log -> tracing

Author: nhtyy

.env.example

@@ -1,11 +1,17 @@
 # Example configuration for Sepolia + Celestia Mocha.
 TENDERMINT_RPC_URL=https://rpc.celestia-mocha.com/
-CHAIN_ID=11155111
-RPC_URL=https://ethereum-sepolia.publicnode.com/
-CONTRACT_ADDRESS=
+
 # Key for relaying to the contract.
 PRIVATE_KEY=
 
-NETWORK_PRIVATE_KEY=
 # Optional: Set if you're using a custom RPC URL.
-NETWORK_RPC_URL=
+NETWORK_RPC_URL=
+NETWORK_PRIVATE_KEY=
+
+BLOCK_UPDATE_INTERVAL=
+LOOP_INTERVAL_MINS=
+
+# Optional: Set if you're using the KMS relayer.
+SECURE_RELAYER_API_KEY=
+SECURE_RELAYER_ENDPOINT=
+USE_KMS_RELAYER=

.gitignore

@@ -19,4 +19,6 @@ pgo-data.profdata
 .idea
 
 filtered_transactions/**.csv
-filtered_transactions
+filtered_transactions
+
+chains.json

Cargo.lock

@@ -20,10 +20,8 @@ dotenv = "0.15.0"
 subtle-encoding = "0.5.1"
 anyhow = "1.0.82"
 clap = { version = "4.0", features = ["derive", "env"] }
-log = "0.4.21"
 hex = "0.4.3"
 futures = "0.3.30"
-env_logger = "0.11.3"
 serde_json = "1"
 chrono = "0.4.38"
 csv = "1.3.1"

Cargo.toml

@@ -39,14 +39,14 @@ dotenv = { workspace = true }
 subtle-encoding = { workspace = true }
 anyhow.workspace = true
 clap = { workspace = true }
-log = { workspace = true }
 hex = { workspace = true }
 futures = { workspace = true }
-env_logger = { workspace = true }
 serde_json = { workspace = true }
 chrono = { workspace = true }
 csv = { workspace = true }
 async-trait = "0.1.86"
+tracing = "0.1.41"
+tracing-subscriber = "0.3.19"
 
 [build-dependencies]
 sp1-build = "4.0.0-rc.8"

script/Cargo.toml

@@ -15,6 +15,7 @@ use clap::Parser;
 use futures::StreamExt;
 use reqwest::Url;
 use std::{cmp::Ordering, collections::HashMap, env, fs, str::FromStr};
+use tracing_subscriber::EnvFilter;
 
 #[derive(Parser, Debug, Clone)]
 #[command(about = "Get transaction costs for an address in a given month")]
@@ -153,7 +154,11 @@ async fn get_receipts_for_chain(
 async fn main() -> Result<()> {
     env::set_var("RUST_LOG", "info");
     dotenv::dotenv().ok();
-    env_logger::init();
+
+    // Setup tracing.
+    tracing_subscriber::fmt::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .init();
 
     let args = CostScriptArgs::parse();
 

script/bin/costs.rs

@@ -8,11 +8,12 @@
 //!
 
 use clap::Parser;
-use log::info;
 use sp1_blobstream_script::util::*;
 use sp1_blobstream_script::TendermintRPCClient;
 use sp1_sdk::{HashableKey, Prover, ProverClient};
 use std::env;
+use tracing::info;
+use tracing_subscriber::EnvFilter;
 const BLOBSTREAMX_ELF: &[u8] = include_bytes!("../../elf/blobstream-elf");
 
 #[derive(Parser, Debug, Clone)]
@@ -26,7 +27,12 @@ pub struct GenesisArgs {
 pub async fn main() {
     env::set_var("RUST_LOG", "info");
     dotenv::dotenv().ok();
-    env_logger::init();
+
+    // Setup tracing.
+    tracing_subscriber::fmt::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .init();
+
     let data_fetcher = TendermintRPCClient::default();
     let args = GenesisArgs::parse();
 

script/bin/genesis.rs

@@ -1,14 +1,12 @@
 use alloy::{
-    consensus::SignableTransaction,
-    network::{EthereumWallet, Network, ReceiptResponse, TxSigner},
+    network::{EthereumWallet, Network, ReceiptResponse},
     primitives::{Address, B256},
     providers::{Provider, ProviderBuilder},
-    signers::{local::PrivateKeySigner, Signer},
+    signers::local::PrivateKeySigner,
     sol,
     transports::Transport,
 };
 use anyhow::Result;
-use log::{error, info};
 use sp1_blobstream_primitives::get_header_update_verdict;
 use sp1_blobstream_script::util::{
     fetch_input_for_blobstream_proof, find_block_to_request, get_latest_block_height,
@@ -22,8 +20,10 @@ use sp1_sdk::{
 use std::{env, sync::Arc};
 use std::{marker::PhantomData, time::Duration};
 use tendermint_light_client_verifier::Verdict;
+use tracing::{error, info, Instrument};
+use tracing_subscriber::EnvFilter;
 
-use signer::MaybeSigner;
+use sp1_blobstream_script::util::signer::MaybeWallet;
 
 sol! {
     #[allow(missing_docs)]
@@ -69,7 +69,6 @@ impl<P: Provider<T, N>, T: Transport + Clone, N: Network> SP1BlobstreamOperator<
     ///
     /// # Panics
     /// - If the chain id cannot be retrieved from the provider.
-    /// - If the signer is not provided and were not using the KMS relayer.
     pub async fn new(
         provider: P,
         contract_address: Address,
@@ -288,7 +287,7 @@ impl ChainConfig {
     ///
     /// If neither are set, it will try to use [`Self::from_env`].
     fn fetch() -> Result<Vec<Self>> {
-        const DEFAULT_PATH: &str = "../chains.json";
+        const DEFAULT_PATH: &str = "chains.json";
 
         let path = env::var("CHAINS_PATH").unwrap_or(DEFAULT_PATH.to_string());
 
@@ -297,13 +296,16 @@ impl ChainConfig {
 
     /// Tries to read from the `CHAINS` environment variable.
     fn from_env() -> Result<Vec<Self>> {
-        let chains = env::var("CHAINS").expect("CHAINS not set.");
+        let chains = env::var("CHAINS")?;
 
         Ok(serde_json::from_str(&chains)?)
     }
 
     fn from_file(path: &str) -> Result<Vec<Self>> {
-        let file = std::fs::read_to_string(path)?;
+        tracing::debug!("Reading chains from file: {}", path);
+
+        let file = std::fs::read_to_string(path)
+            .inspect_err(|e| println!("Error reading file: {:?}", e))?;
 
         Ok(serde_json::from_str(&file)?)
     }
@@ -312,29 +314,35 @@ impl ChainConfig {
 #[tokio::main]
 async fn main() {
     dotenv::dotenv().ok();
-    env_logger::init();
 
-    let prover = ProverClient::builder().cpu().build();
-    let (pk, vk) = prover.setup(TENDERMINT_ELF);
-    let pk = Arc::new(pk);
+    // Setup tracing.
+    tracing_subscriber::fmt::fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .init();
 
     // Succinct deployments use the `CHAINS` environment variable.
-    let config = ChainConfig::from_env().expect("Failed to fetch chain config.");
+    let config = ChainConfig::fetch().expect("Failed to fetch chain config");
     let maybe_private_key: Option<PrivateKeySigner> = env::var("PRIVATE_KEY")
         .ok()
         .map(|s| s.parse().expect("Failed to parse PRIVATE_KEY"));
 
+    // Setup the KMS relayer config.
     let use_kms_relayer: bool = env::var("USE_KMS_RELAYER")
         .map(|s| s.parse().expect("USE_KMS_RELAYER failed to parse"))
-        .expect("USE_KMS_RELAYER not set.");
+        .expect("USE_KMS_RELAYER not set");
 
     // Ensure we have a signer if we're not using the KMS relayer.
     if !use_kms_relayer && maybe_private_key.is_none() {
         panic!("PRIVATE_KEY is not set but USE_KMS_RELAYER is false.");
     }
 
     // Setup our signer.
-    let signer = EthereumWallet::new(MaybeSigner::new(maybe_private_key));
+    let signer = MaybeWallet::new(maybe_private_key.map(EthereumWallet::new));
+
+    // Setup the prover and program keys.
+    let prover = ProverClient::builder().cpu().build();
+    let (pk, vk) = prover.setup(TENDERMINT_ELF);
+    let pk = Arc::new(pk);
 
     // Setup all the tasks.
     // These futures should never resolve, so we just await them in the main thread.
@@ -348,6 +356,8 @@ async fn main() {
             let vk = vk.clone();
 
             tokio::task::spawn(async move {
+                tracing::info!("Starting operator for chain {}", c.name);
+
                 let operator = SP1BlobstreamOperator::new(
                     provider,
                     c.blobstream_address,
@@ -359,12 +369,13 @@ async fn main() {
 
                 loop {
                     let request_interval_mins = get_loop_interval_mins();
+
                     tokio::select! {
                         _ = tokio::time::sleep(tokio::time::Duration::from_secs(60 * LOOP_TIMEOUT_MINS)) => {
-                            log::error!("Operator took longer than {} minutes to run.", LOOP_TIMEOUT_MINS);
+                            tracing::error!("Operator took longer than {} minutes to run.", LOOP_TIMEOUT_MINS);
                             continue;
                         }
-                        e = operator.run() => {
+                        e = operator.run().instrument(tracing::span!(tracing::Level::INFO, "operator", chain = c.name)) => {
                             if let Err(e) = e {
                                 // Sleep for less time on errors.
                                 error!("Error running operator: {:?}", e);
@@ -383,50 +394,5 @@ async fn main() {
     // Run all the tasks.
     futures::future::try_join_all(handles).await.unwrap();
 
-    error!("All operators finished.");
-}
-
-mod signer {
-    use alloy::{consensus::SignableTransaction, network::TxSigner, primitives::Address};
-    use std::marker::PhantomData;
-
-    /// A signer than panics if called and not set.
-    pub struct MaybeSigner<Sig, S> {
-        signer: Option<S>,
-        _phantom: PhantomData<Sig>,
-    }
-
-    impl<Sig, S> MaybeSigner<Sig, S> {
-        pub fn new(signer: Option<S>) -> Self {
-            Self {
-                signer,
-                _phantom: PhantomData,
-            }
-        }
-    }
-
-    #[async_trait::async_trait]
-    impl<Sig, S> TxSigner<Sig> for MaybeSigner<Sig, S>
-    where
-        S: TxSigner<Sig> + Send + Sync,
-        Sig: Send + Sync,
-    {
-        fn address(&self) -> Address {
-            self.signer
-                .as_ref()
-                .expect("Signer should be set")
-                .address()
-        }
-
-        async fn sign_transaction(
-            &self,
-            tx: &mut dyn SignableTransaction<Sig>,
-        ) -> alloy::signers::Result<Sig> {
-            self.signer
-                .as_ref()
-                .expect("Signer should be set")
-                .sign_transaction(tx)
-                .await
-        }
-    }
+    info!("All operators finished.");
 }

script/bin/operator.rs

@@ -1,9 +1,9 @@
 use clap::Parser;
-use log::debug;
 use sp1_blobstream_script::util::fetch_input_for_blobstream_proof;
 use sp1_blobstream_script::{TendermintRPCClient, TENDERMINT_ELF};
 use sp1_sdk::{ProverClient, SP1Stdin};
 use tokio::runtime;
+use tracing::debug;
 
 #[derive(Parser, Debug)]
 #[clap(author, version, about, long_about = None)]

script/bin/test.rs

@@ -1,8 +1,8 @@
 use alloy::primitives::B256;
 use anyhow::Result;
-use log::info;
 use serde::{Deserialize, Serialize};
 use std::{env, str::FromStr, time::Duration};
+use tracing::info;
 
 #[derive(Serialize, Deserialize)]
 pub enum KMSRelayStatus {
@@ -48,7 +48,7 @@ pub async fn relay_with_kms(args: &KMSRelayRequest, num_retries: u32) -> Result<
                 let error_message = response
                     .message
                     .expect("KMS request always returns a message");
-                log::warn!("KMS relay attempt {} failed: {}", attempt, error_message);
+                tracing::warn!("KMS relay attempt {} failed: {}", attempt, error_message);
                 if attempt == num_retries {
                     return Err(anyhow::anyhow!(
                         "Failed to relay transaction: {}",