Revert "intense logging for cis"

This reverts commit e187a5c.

Author: dev-jodee

.github/actions/run-test-runner/action.yml

@@ -17,14 +17,6 @@ inputs:
     description: "Force refresh of test accounts"
     required: false
     default: "false"
-  capture-kora-logs:
-    description: "Capture and display Kora RPC server logs during test execution"
-    required: false
-    default: "true"
-  verbose-kora-logs:
-    description: "Enable maximum verbosity for Kora logs (requires capture-kora-logs)"
-    required: false
-    default: "false"
 
 runs:
   using: "composite"
@@ -45,12 +37,6 @@ runs:
         if [ "${{ inputs.rpc-url }}" != "http://127.0.0.1:8899" ]; then
           ARGS="$ARGS --rpc-url ${{ inputs.rpc-url }}"
         fi
-        if [ "${{ inputs.capture-kora-logs }}" = "true" ]; then
-          ARGS="$ARGS --capture-kora-logs"
-        fi
-        if [ "${{ inputs.verbose-kora-logs }}" = "true" ]; then
-          ARGS="$ARGS --verbose-kora-logs"
-        fi
 
         # Add filters
         ARGS="$ARGS ${{ inputs.filters }}"

.github/workflows/rust.yml

@@ -26,7 +26,7 @@ on:
 
 env:
   CARGO_TERM_COLOR: always
-  RUST_LOG: error
+  RUST_LOG: info
   CI: true
 
 jobs:

crates/lib/src/rpc_server/method/estimate_transaction_fee.rs

@@ -45,124 +45,40 @@ pub async fn estimate_transaction_fee(
     rpc_client: &Arc<RpcClient>,
     request: EstimateTransactionFeeRequest,
 ) -> Result<EstimateTransactionFeeResponse, KoraError> {
-    log::error!("RPC Method: estimateTransactionFee - Entry: transaction_len={}, fee_token={:?}, signer_key={:?}, sig_verify={}",
-        request.transaction.len(), request.fee_token, request.signer_key, request.sig_verify);
-
-    let transaction = match TransactionUtil::decode_b64_transaction(&request.transaction) {
-        Ok(tx) => {
-            log::error!("Transaction decoded successfully: signatures={}", tx.signatures.len());
-            tx
-        }
-        Err(e) => {
-            log::error!("Transaction decode failed: {e}");
-            return Err(e);
-        }
-    };
-
-    let signer = match get_request_signer_with_signer_key(request.signer_key.as_deref()) {
-        Ok(s) => {
-            log::error!("Signer obtained: pubkey={}", s.solana_pubkey());
-            s
-        }
-        Err(e) => {
-            log::error!("Failed to get signer: {e}");
-            return Err(e);
-        }
-    };
+    let transaction = TransactionUtil::decode_b64_transaction(&request.transaction)?;
 
-    let config = match get_config() {
-        Ok(c) => {
-            log::error!("Config loaded successfully");
-            c
-        }
-        Err(e) => {
-            log::error!("Failed to get config: {e}");
-            return Err(e);
-        }
-    };
-
-    let fee_payer = signer.solana_pubkey();
-    let payment_destination = match config.kora.get_payment_address(&fee_payer) {
-        Ok(addr) => {
-            log::error!("Payment destination: {addr}");
-            addr
-        }
-        Err(e) => {
-            log::error!("Failed to get payment destination: {e}");
-            return Err(e);
-        }
-    };
+    let signer = get_request_signer_with_signer_key(request.signer_key.as_deref())?;
+    let config = get_config()?;
+    let payment_destination = config.kora.get_payment_address(&signer.solana_pubkey())?;
 
     let validation_config = &config.validation;
-    log::error!(
-        "Validation config: payment_required={}, price_source={:?}",
-        validation_config.is_payment_required(),
-        validation_config.price_source
-    );
+    let fee_payer = signer.solana_pubkey();
 
-    log::error!("Resolving transaction with lookup tables");
-    let mut resolved_transaction = match VersionedTransactionResolved::from_transaction(
+    let mut resolved_transaction = VersionedTransactionResolved::from_transaction(
         &transaction,
         rpc_client,
         request.sig_verify,
     )
-    .await
-    {
-        Ok(resolved) => {
-            log::error!(
-                "Transaction resolved successfully: total_accounts={}, total_instructions={}",
-                resolved.all_account_keys.len(),
-                resolved.all_instructions.len()
-            );
-            resolved
-        }
-        Err(e) => {
-            log::error!("Transaction resolution failed: {e}");
-            return Err(e);
-        }
-    };
+    .await?;
 
-    log::error!("Estimating Kora fee");
-    let fee_calculation = match FeeConfigUtil::estimate_kora_fee(
+    let fee_calculation = FeeConfigUtil::estimate_kora_fee(
         rpc_client,
         &mut resolved_transaction,
         &fee_payer,
         validation_config.is_payment_required(),
         Some(validation_config.price_source.clone()),
     )
-    .await
-    {
-        Ok(calc) => {
-            log::error!("Fee estimation complete: total_fee_lamports={}", calc.total_fee_lamports);
-            calc
-        }
-        Err(e) => {
-            log::error!("Fee estimation failed: {e}");
-            return Err(e);
-        }
-    };
+    .await?;
 
     let fee_in_lamports = fee_calculation.total_fee_lamports;
 
-    log::error!("Calculating fee in token if requested");
-    let fee_in_token = match FeeConfigUtil::calculate_fee_in_token(
+    // Calculate fee in token if requested
+    let fee_in_token = FeeConfigUtil::calculate_fee_in_token(
         rpc_client,
         fee_in_lamports,
         request.fee_token.as_deref(),
     )
-    .await
-    {
-        Ok(token_fee) => {
-            log::error!("Token fee calculation result: {token_fee:?}");
-            token_fee
-        }
-        Err(e) => {
-            log::error!("Token fee calculation failed: {e}");
-            return Err(e);
-        }
-    };
-
-    log::error!("RPC Method: estimateTransactionFee - Success: fee_in_lamports={fee_in_lamports}, fee_in_token={fee_in_token:?}");
+    .await?;
 
     Ok(EstimateTransactionFeeResponse {
         fee_in_lamports,

crates/lib/src/rpc_server/method/get_blockhash.rs

@@ -11,27 +11,10 @@ pub struct GetBlockhashResponse {
 }
 
 pub async fn get_blockhash(rpc_client: &RpcClient) -> Result<GetBlockhashResponse, KoraError> {
-    log::error!("RPC Method: getBlockhash - Entry: commitment=confirmed");
-
-    let blockhash = match rpc_client
+    let blockhash = rpc_client
         .get_latest_blockhash_with_commitment(CommitmentConfig::confirmed())
         .await
-    {
-        Ok(result) => {
-            log::error!(
-                "Blockhash retrieved successfully: {}, context_slot={}",
-                result.0,
-                result.1
-            );
-            result
-        }
-        Err(e) => {
-            log::error!("Failed to get blockhash: {e}");
-            return Err(KoraError::RpcError(e.to_string()));
-        }
-    };
-
-    log::error!("RPC Method: getBlockhash - Success: blockhash={}", blockhash.0);
+        .map_err(|e| KoraError::RpcError(e.to_string()))?;
     Ok(GetBlockhashResponse { blockhash: blockhash.0.to_string() })
 }
 

crates/lib/src/rpc_server/method/sign_and_send_transaction.rs

@@ -33,78 +33,22 @@ pub async fn sign_and_send_transaction(
     rpc_client: &Arc<RpcClient>,
     request: SignAndSendTransactionRequest,
 ) -> Result<SignAndSendTransactionResponse, KoraError> {
-    log::error!("RPC Method: signAndSendTransaction - Entry: transaction_len={}, signer_key={:?}, sig_verify={}",
-        request.transaction.len(), request.signer_key, request.sig_verify);
-
-    let transaction = match TransactionUtil::decode_b64_transaction(&request.transaction) {
-        Ok(tx) => {
-            log::error!("Transaction decoded successfully: signatures={}", tx.signatures.len());
-            tx
-        }
-        Err(e) => {
-            log::error!("Transaction decode failed: {e}");
-            return Err(e);
-        }
-    };
+    let transaction = TransactionUtil::decode_b64_transaction(&request.transaction)?;
 
-    log::error!("Checking usage limit for transaction sender");
-    if let Err(e) = UsageTracker::check_transaction_usage_limit(&transaction).await {
-        log::error!("Usage limit check failed: {e}");
-        return Err(e);
-    }
-    log::error!("Usage limit check passed");
-
-    let signer = match get_request_signer_with_signer_key(request.signer_key.as_deref()) {
-        Ok(s) => {
-            log::error!("Signer obtained: pubkey={}", s.solana_pubkey());
-            s
-        }
-        Err(e) => {
-            log::error!("Failed to get signer: {e}");
-            return Err(e);
-        }
-    };
+    // Check usage limit for transaction sender
+    UsageTracker::check_transaction_usage_limit(&transaction).await?;
+
+    let signer = get_request_signer_with_signer_key(request.signer_key.as_deref())?;
 
-    log::error!("Resolving transaction with lookup tables");
-    let mut resolved_transaction = match VersionedTransactionResolved::from_transaction(
+    let mut resolved_transaction = VersionedTransactionResolved::from_transaction(
         &transaction,
         rpc_client,
         request.sig_verify,
     )
-    .await
-    {
-        Ok(resolved) => {
-            log::error!(
-                "Transaction resolved successfully: total_accounts={}, total_instructions={}",
-                resolved.all_account_keys.len(),
-                resolved.all_instructions.len()
-            );
-            resolved
-        }
-        Err(e) => {
-            log::error!("Transaction resolution failed: {e}");
-            return Err(e);
-        }
-    };
+    .await?;
 
-    log::error!("Signing and sending transaction");
     let (signature, signed_transaction) =
-        match resolved_transaction.sign_and_send_transaction(&signer, rpc_client).await {
-            Ok((sig, tx)) => {
-                log::error!("Transaction signed and sent successfully: signature={sig}");
-                (sig, tx)
-            }
-            Err(e) => {
-                log::error!("Sign and send transaction failed: {e}");
-                return Err(e);
-            }
-        };
-
-    log::error!(
-        "RPC Method: signAndSendTransaction - Success: signature={}, signer_pubkey={}",
-        signature,
-        signer.solana_pubkey()
-    );
+        resolved_transaction.sign_and_send_transaction(&signer, rpc_client).await?;
 
     Ok(SignAndSendTransactionResponse {
         signature,

crates/lib/src/rpc_server/method/sign_transaction.rs

@@ -33,88 +33,27 @@ pub async fn sign_transaction(
     rpc_client: &Arc<RpcClient>,
     request: SignTransactionRequest,
 ) -> Result<SignTransactionResponse, KoraError> {
-    log::error!(
-        "RPC Method: signTransaction - Entry: transaction_len={}, signer_key={:?}, sig_verify={}",
-        request.transaction.len(),
-        request.signer_key,
-        request.sig_verify
-    );
-
-    let transaction = match TransactionUtil::decode_b64_transaction(&request.transaction) {
-        Ok(tx) => {
-            log::error!("Transaction decoded successfully: signatures={}", tx.signatures.len());
-            tx
-        }
-        Err(e) => {
-            log::error!("Transaction decode failed: {e}");
-            return Err(e);
-        }
-    };
+    let transaction = TransactionUtil::decode_b64_transaction(&request.transaction)?;
 
-    log::error!("Checking usage limit for transaction sender");
-    if let Err(e) = UsageTracker::check_transaction_usage_limit(&transaction).await {
-        log::error!("Usage limit check failed: {e}");
-        return Err(e);
-    }
-    log::error!("Usage limit check passed");
-
-    let signer = match get_request_signer_with_signer_key(request.signer_key.as_deref()) {
-        Ok(s) => {
-            log::error!("Signer obtained: pubkey={}", s.solana_pubkey());
-            s
-        }
-        Err(e) => {
-            log::error!("Failed to get signer: {e}");
-            return Err(e);
-        }
-    };
+    // Check usage limit for transaction sender
+    UsageTracker::check_transaction_usage_limit(&transaction).await?;
+
+    let signer = get_request_signer_with_signer_key(request.signer_key.as_deref())?;
 
-    log::error!("Resolving transaction with lookup tables");
-    let mut resolved_transaction = match VersionedTransactionResolved::from_transaction(
+    let mut resolved_transaction = VersionedTransactionResolved::from_transaction(
         &transaction,
         rpc_client,
         request.sig_verify,
     )
-    .await
-    {
-        Ok(resolved) => {
-            log::error!(
-                "Transaction resolved successfully: total_accounts={}, total_instructions={}",
-                resolved.all_account_keys.len(),
-                resolved.all_instructions.len()
-            );
-            resolved
-        }
-        Err(e) => {
-            log::error!("Transaction resolution failed: {e}");
-            return Err(e);
-        }
-    };
+    .await?;
 
-    log::error!("Signing transaction (without sending)");
-    let (signed_transaction, signature_str) =
-        match resolved_transaction.sign_transaction(&signer, rpc_client).await {
-            Ok((tx, sig)) => {
-                log::error!("Transaction signed successfully: signature={sig}");
-                (tx, sig)
-            }
-            Err(e) => {
-                log::error!("Transaction signing failed: {e}");
-                return Err(e);
-            }
-        };
+    let (signed_transaction, _) =
+        resolved_transaction.sign_transaction(&signer, rpc_client).await?;
 
-    log::error!("Encoding signed transaction to base64");
     let encoded = TransactionUtil::encode_versioned_transaction(&signed_transaction);
 
-    log::error!(
-        "RPC Method: signTransaction - Success: signature={}, signer_pubkey={}",
-        signature_str,
-        signer.solana_pubkey()
-    );
-
     Ok(SignTransactionResponse {
-        signature: signature_str,
+        signature: transaction.signatures[0].to_string(),
         signed_transaction: encoded,
         signer_pubkey: signer.solana_pubkey().to_string(),
     })