Add tracing and spans

Author: dcompoze

Cargo.lock

@@ -38,5 +38,6 @@ log = { version = "0.4.27" }
 num = "0.4.3"
 rand = "0.8.0"
 tokio = { version = "1.43.0", features = ["full"] }
+tracing = "0.1.41"
 
 mantis-sdk = { path = "mantis-sdk" }

Cargo.toml

@@ -27,11 +27,7 @@ alloy = { workspace = true }
 anyhow = { workspace = true }
 base64 = { workspace = true }
 chrono = { workspace = true }
-env_logger = { workspace = true }
-log = { workspace = true }
 num = { workspace = true }
 rand = { workspace = true }
 tokio = { workspace = true }
-
-[lints.clippy]
-obfuscated_if_else = "allow"
+tracing = { workspace = true }

mantis-sdk/Cargo.toml

@@ -6,7 +6,7 @@ use alloy::sol;
 use alloy::transports::Transport;
 use anyhow::{anyhow, Result};
 use chrono::Utc;
-use log::info;
+use tracing::{info, instrument};
 use Escrow::NewIntent;
 
 use crate::{random_intent_id, retry};
@@ -34,6 +34,7 @@ pub struct GasFees {
     pub max_priority_fee_per_gas: u128,
 }
 
+#[instrument(skip_all)]
 pub async fn escrow_funds<P, T>(
     provider: P,
     escrow_address: Address,
@@ -114,6 +115,7 @@ where
     Ok(receipt)
 }
 
+#[instrument(skip_all)]
 pub async fn solve_intent_remote<P, T>(
     provider: P,
     escrow_address: Address,
@@ -163,6 +165,7 @@ where
     Ok(receipt)
 }
 
+#[instrument(skip_all)]
 pub async fn solve_intent_local<P, T>(
     provider: P,
     escrow_address: Address,
@@ -208,6 +211,7 @@ where
     Ok(receipt)
 }
 
+#[instrument(skip_all)]
 pub async fn cancel_intent<P, T>(
     provider: P,
     escrow_address: Address,
@@ -243,6 +247,7 @@ where
     Ok(receipt)
 }
 
+#[instrument(skip_all)]
 pub async fn approve_erc20<P, T>(
     provider: P,
     token: Address,
@@ -279,6 +284,7 @@ where
     Ok(receipt)
 }
 
+#[instrument(skip_all)]
 pub async fn send_raw_tx<P, T>(
     provider: P,
     to: Address,

mantis-sdk/src/ethereum.rs

@@ -2,9 +2,9 @@ use std::fmt::Display;
 use std::future::Future;
 use std::time::Duration;
 
-use log::{error, warn};
 use rand::Rng;
 use tokio::time::sleep;
+use tracing::{error, warn};
 
 pub mod auction;
 pub mod ethereum;

mantis-sdk/src/lib.rs

@@ -5,7 +5,6 @@ use anchor_lang::prelude::declare_program;
 use anchor_spl::associated_token;
 use anyhow::{anyhow, Context, Result};
 use chrono::Utc;
-use log::info;
 use num::BigUint;
 use solana_client::nonblocking::rpc_client::RpcClient;
 use solana_client::rpc_config::RpcTransactionConfig;
@@ -25,6 +24,7 @@ use solana_transaction_status::EncodedConfirmedTransactionWithStatusMeta;
 use spl_associated_token_account::get_associated_token_address_with_program_id;
 use spl_associated_token_account::instruction::create_associated_token_account_idempotent;
 use spl_token::instruction::transfer;
+use tracing::{info, instrument};
 
 use crate::{random_intent_id, retry};
 
@@ -54,6 +54,7 @@ impl TxInstructions {
     }
 }
 
+#[instrument(skip_all)]
 pub async fn escrow_funds(
     client: &RpcClient,
     payer: Arc<Keypair>,
@@ -76,9 +77,11 @@ pub async fn escrow_funds(
     let timeout = timestamp + timeout_sec;
     let intent_id = random_intent_id();
 
-    let token_in_mint = (token_in == Pubkey::default())
-        .then_some(spl_token::native_mint::ID)
-        .unwrap_or(token_in);
+    let token_in_mint = if token_in == Pubkey::default() {
+        spl_token::native_mint::ID
+    } else {
+        token_in
+    };
 
     let (escrow_pda, _) = Pubkey::find_program_address(&[ESCROW_SEED], &program_id);
     let (escrow_sol_pda, _) = Pubkey::find_program_address(&[ESCROW_SEED, SOL_SEED], &program_id);
@@ -139,7 +142,11 @@ pub async fn escrow_funds(
         .args(escrow_args)
         .instructions()?;
 
-    let recent_blockhash = retry(|| client.get_latest_blockhash(), 3).await?;
+    let recent_blockhash = retry(
+        || client.get_latest_blockhash(),
+        3,
+    )
+    .await?;
 
     let escrow_transaction = Transaction::new_signed_with_payer(
         &escrow_instructions,
@@ -148,10 +155,15 @@ pub async fn escrow_funds(
         recent_blockhash,
     );
 
-    let signature = retry(|| client.send_and_confirm_transaction(&escrow_transaction), 3).await?;
+    let signature = retry(
+        || client.send_and_confirm_transaction(&escrow_transaction),
+        3,
+    )
+    .await?;
     Ok(signature)
 }
 
+#[instrument(skip_all)]
 pub async fn cancel_intent(
     client: &RpcClient,
     payer: Arc<Keypair>,
@@ -202,7 +214,11 @@ pub async fn cancel_intent(
         .args(cancel_args)
         .instructions()?;
 
-    let recent_blockhash = retry(|| client.get_latest_blockhash(), 3).await?;
+    let recent_blockhash = retry(
+        || client.get_latest_blockhash(),
+        3,
+    )
+    .await?;
 
     let cancel_transaction = Transaction::new_signed_with_payer(
         &cancel_instructions,
@@ -211,10 +227,15 @@ pub async fn cancel_intent(
         recent_blockhash,
     );
 
-    let signature = retry(|| client.send_and_confirm_transaction(&cancel_transaction), 3).await?;
+    let signature = retry(
+        || client.send_and_confirm_transaction(&cancel_transaction),
+        3,
+    )
+    .await?;
     Ok(signature)
 }
 
+#[instrument(skip_all)]
 pub async fn initialize(client: &RpcClient, payer: Arc<Keypair>, program_id: Pubkey) -> Result<Signature> {
     let cluster = Cluster::Custom(client.url(), String::default());
     let client_anchor = Client::new_with_options(cluster, payer.clone(), CommitmentConfig::processed());
@@ -243,7 +264,11 @@ pub async fn initialize(client: &RpcClient, payer: Arc<Keypair>, program_id: Pub
         .args(initialize_args)
         .instructions()?;
 
-    let recent_blockhash = retry(|| client.get_latest_blockhash(), 3).await?;
+    let recent_blockhash = retry(
+        || client.get_latest_blockhash(),
+        3,
+    )
+    .await?;
 
     let initialize_tx = Transaction::new_signed_with_payer(
         &initialize_ix,
@@ -252,10 +277,15 @@ pub async fn initialize(client: &RpcClient, payer: Arc<Keypair>, program_id: Pub
         recent_blockhash,
     );
 
-    let signature = retry(|| client.send_and_confirm_transaction(&initialize_tx), 3).await?;
+    let signature = retry(
+        || client.send_and_confirm_transaction(&initialize_tx),
+        3,
+    )
+    .await?;
     Ok(signature)
 }
 
+#[instrument(skip_all)]
 pub async fn create_associated_token_account(
     client: &RpcClient,
     payer: Arc<Keypair>,
@@ -265,7 +295,11 @@ pub async fn create_associated_token_account(
     let (create_associated_account_ix, ata) =
         create_associated_token_account_ix(client, payer.clone(), user, token_mint).await?;
 
-    let recent_blockhash = retry(|| client.get_latest_blockhash(), 3).await?;
+    let recent_blockhash = retry(
+        || client.get_latest_blockhash(),
+        3,
+    )
+    .await?;
 
     let create_associated_account_tx = Transaction::new_signed_with_payer(
         &[create_associated_account_ix],
@@ -299,6 +333,7 @@ pub async fn create_associated_token_account_ix(
     Ok((instructions, ata))
 }
 
+#[instrument(skip_all)]
 pub async fn get_transaction_info(
     client: &RpcClient,
     signature: Signature,
@@ -308,16 +343,25 @@ pub async fn get_transaction_info(
         commitment: Some(CommitmentConfig::confirmed()),
         max_supported_transaction_version: Some(0),
     };
-    let transaction_info = retry(|| client.get_transaction_with_config(&signature, config), 3).await?;
+    let transaction_info = retry(
+        || client.get_transaction_with_config(&signature, config),
+        3,
+    )
+    .await?;
 
     Ok(transaction_info)
 }
 
+#[instrument(skip_all)]
 pub async fn get_lookup_table_accounts(
     client: &RpcClient,
     lookup_table_addresses: &[Pubkey],
 ) -> Result<Vec<AddressLookupTableAccount>> {
-    let lookup_table_accounts = retry(|| client.get_multiple_accounts(lookup_table_addresses), 3).await?;
+    let lookup_table_accounts = retry(
+        || client.get_multiple_accounts(lookup_table_addresses),
+        3,
+    )
+    .await?;
 
     lookup_table_addresses
         .iter()
@@ -334,6 +378,7 @@ pub async fn get_lookup_table_accounts(
         .collect()
 }
 
+#[instrument(skip_all)]
 pub async fn transfer_spl_token(
     client: &RpcClient,
     sender: Arc<Keypair>,
@@ -344,7 +389,11 @@ pub async fn transfer_spl_token(
     let transfer_spl_token_ix =
         transfer_spl_token_ix(client, sender.clone(), recipient, token_mint, amount).await?;
 
-    let recent_blockhash = retry(|| client.get_latest_blockhash(), 3).await?;
+    let recent_blockhash = retry(
+        || client.get_latest_blockhash(),
+        3,
+    )
+    .await?;
 
     let transfer_spl_token_tx = Transaction::new_signed_with_payer(
         &transfer_spl_token_ix,
@@ -353,7 +402,11 @@ pub async fn transfer_spl_token(
         recent_blockhash,
     );
 
-    let signature = retry(|| client.send_and_confirm_transaction(&transfer_spl_token_tx), 3).await?;
+    let signature = retry(
+        || client.send_and_confirm_transaction(&transfer_spl_token_tx),
+        3,
+    )
+    .await?;
     Ok(signature)
 }
 
@@ -393,6 +446,7 @@ pub async fn transfer_spl_token_ix(
     Ok(transfer_instructions)
 }
 
+#[instrument(skip_all)]
 pub async fn submit_through_rpc(
     client: &RpcClient,
     payer: Arc<Keypair>,
@@ -404,25 +458,40 @@ pub async fn submit_through_rpc(
             &transaction.instructions,
             Some(&payer.pubkey()),
             &[&*payer],
-            retry(|| client.get_latest_blockhash(), 3).await?,
+            retry(
+                || client.get_latest_blockhash(),
+                3,
+            )
+            .await?,
         );
-        retry(|| client.send_and_confirm_transaction(&transaction), 3)
-            .await
-            .context("Failed to send legacy transaction")
+        retry(
+            || client.send_and_confirm_transaction(&transaction),
+            3,
+        )
+        .await
+        .context("Failed to send legacy transaction")
     } else {
         let message = v0::Message::try_compile(
             &payer.pubkey(),
             &transaction.instructions,
             &transaction.address_lookup_table,
-            retry(|| client.get_latest_blockhash(), 3).await?,
+            retry(
+                || client.get_latest_blockhash(),
+                3,
+            )
+            .await?,
         )?;
         let transaction = VersionedTransaction::try_new(VersionedMessage::V0(message), &[&payer])?;
-        retry(|| client.send_and_confirm_transaction(&transaction), 3)
-            .await
-            .context("Failed to send versioned transaction")
+        retry(
+            || client.send_and_confirm_transaction(&transaction),
+            3,
+        )
+        .await
+        .context("Failed to send versioned transaction")
     }
 }
 
+#[instrument(skip_all)]
 pub async fn submit_through_rpc_multiple(
     client: &RpcClient,
     payer: Arc<Keypair>,
@@ -446,8 +515,14 @@ pub async fn submit_through_rpc_multiple(
     Ok(signatures)
 }
 
+#[instrument(skip_all)]
 pub async fn get_token_program_id(client: &RpcClient, token_mint: &Pubkey) -> Result<Pubkey> {
-    match retry(|| client.get_account(token_mint), 3).await? {
+    match retry(
+        || client.get_account(token_mint),
+        3,
+    )
+    .await?
+    {
         account if account.owner == spl_token_2022::ID => Ok(spl_token_2022::ID),
         account if account.owner == spl_token::ID => Ok(spl_token::ID),
         _ => Err(anyhow!("Failed to get token program ID for token {}", token_mint)),