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};
+use tracing_subscriber::EnvFilter;
 
-use signer::MaybeSigner;
+use 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.
@@ -357,11 +365,14 @@ async fn main() {
                 )
                 .await;
 
+                let span = tracing::span!(tracing::Level::INFO, "operator", chain = c.name);
+                let _guard = span.enter();
+
                 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() => {
@@ -383,49 +394,61 @@ async fn main() {
     // Run all the tasks.
     futures::future::try_join_all(handles).await.unwrap();
 
-    error!("All operators finished.");
+    info!("All operators finished.");
 }
 
+/// We want our operators to be generic over a single provider (which is generic over a signer).
+/// Using this signer, we get one concrete type as a provider, even if we dont have a private key.
 mod signer {
-    use alloy::{consensus::SignableTransaction, network::TxSigner, primitives::Address};
-    use std::marker::PhantomData;
+    use alloy::{
+        consensus::{TxEnvelope, TypedTransaction},
+        network::{Network, NetworkWallet},
+        primitives::Address,
+    };
 
     /// A signer than panics if called and not set.
-    pub struct MaybeSigner<Sig, S> {
-        signer: Option<S>,
-        _phantom: PhantomData<Sig>,
-    }
+    #[derive(Clone, Debug)]
+    pub struct MaybeWallet<W>(Option<W>);
 
-    impl<Sig, S> MaybeSigner<Sig, S> {
-        pub fn new(signer: Option<S>) -> Self {
-            Self {
-                signer,
-                _phantom: PhantomData,
-            }
+    impl<W> MaybeWallet<W> {
+        pub fn new(signer: Option<W>) -> Self {
+            Self(signer)
         }
     }
 
-    #[async_trait::async_trait]
-    impl<Sig, S> TxSigner<Sig> for MaybeSigner<Sig, S>
+    impl<W, N> NetworkWallet<N> for MaybeWallet<W>
     where
-        S: TxSigner<Sig> + Send + Sync,
-        Sig: Send + Sync,
+        W: NetworkWallet<N>,
+        N: Network<UnsignedTx = TypedTransaction, TxEnvelope = TxEnvelope>,
     {
-        fn address(&self) -> Address {
-            self.signer
+        fn default_signer_address(&self) -> Address {
+            self.0
+                .as_ref()
+                .expect("No signer set")
+                .default_signer_address()
+        }
+
+        fn has_signer_for(&self, address: &Address) -> bool {
+            self.0
                 .as_ref()
-                .expect("Signer should be set")
-                .address()
+                .expect("No signer set")
+                .has_signer_for(address)
+        }
+
+        fn signer_addresses(&self) -> impl Iterator<Item = Address> {
+            self.0.as_ref().expect("No signer set").signer_addresses()
         }
 
-        async fn sign_transaction(
+        #[doc(alias = "sign_tx_from")]
+        async fn sign_transaction_from(
             &self,
-            tx: &mut dyn SignableTransaction<Sig>,
-        ) -> alloy::signers::Result<Sig> {
-            self.signer
+            sender: Address,
+            tx: TypedTransaction,
+        ) -> alloy::signers::Result<TxEnvelope> {
+            self.0
                 .as_ref()
-                .expect("Signer should be set")
-                .sign_transaction(tx)
+                .expect("No signer set")
+                .sign_transaction_from(sender, tx)
                 .await
         }
     }

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)]