remove txn limit

Author: lukeiannucci

justfile

@@ -110,7 +110,7 @@ mkconfig_docker_full NUM_NODES RPC_URL PARENT_CHAIN_ID PARENT_INBOX_ADDRESS *ARG
     --mode "increment-address" {{ARGS}} | jq
 
 verify_blocks:
-  cargo run --bin block_verifier
+  cargo run --release --bin block_verifier
 
 ####################
 ####TEST COMMANDS###

tests/block-verifier/src/main.rs

@@ -10,10 +10,13 @@ use futures::future::join_all;
 use timeboost_utils::types::logging::init_logging;
 use tracing::{error, info};
 
+/// Max. Difference between l2 block heights for potential race conditions when heights are fetched
+/// from the sequencers
+const MAX_BLOCK_HEIGHT_DIFF: u64 = 2;
+
 #[derive(Parser, Debug)]
 struct Cli {
-    /// Nitro node URLs used for gas estimations and getting nonce when sending transactions
-    /// Can be specified multiple times: --nitro-url url1 --nitro-url url2
+    /// Nitro node URLs use to check state for different sequencers to ensure consistency
     #[clap(
         long,
         default_value = "http://localhost:8547;http://localhost:8647",
@@ -23,7 +26,7 @@ struct Cli {
     nitro_urls: Vec<String>,
 }
 
-async fn connect_to_chain<N: Network>(urls: &[String]) -> Result<Vec<RootProvider<N>>> {
+async fn connect_to_nitro<N: Network>(urls: &[String]) -> Result<Vec<RootProvider<N>>> {
     let mut p = Vec::new();
     for url in urls {
         p.push(RootProvider::<N>::connect(url).await?)
@@ -36,23 +39,34 @@ async fn main() -> Result<()> {
     init_logging();
     let cli = Cli::parse();
 
-    let providers = connect_to_chain::<Ethereum>(&cli.nitro_urls).await?;
+    let providers = connect_to_nitro::<Ethereum>(&cli.nitro_urls).await?;
 
-    // take the minimum block in to avoid race conditions
-    let min_block = join_all(providers.iter().map(|p| async {
+    let block_numbers = join_all(providers.iter().map(|p| async {
         p.get_block_number()
             .await
             .context("provider request failed")
     }))
     .await
     .into_iter()
-    .collect::<Result<Vec<u64>>>()?
-    .into_iter()
-    .min()
-    .context("failed to get min block")?;
+    .collect::<Result<Vec<u64>>>()?;
+
+    let min = *block_numbers.iter().min().context("no blocks received")?;
+    let max = *block_numbers.iter().max().context("no blocks received")?;
+    let diff = max - min;
+
+    // ensure the max - min is within MAX_BLOCK_HEIGHT_DIFF
+    if diff > MAX_BLOCK_HEIGHT_DIFF {
+        error!(%max, %min, %diff, max_diff = %MAX_BLOCK_HEIGHT_DIFF, "❌ block numbers too far apart");
+        anyhow::bail!(
+            "block numbers too far apart (min: {}, max: {}, diff: {})",
+            min,
+            max,
+            diff
+        );
+    }
 
-    for i in 0..=min_block {
-        info!(num = %i, "getting block number");
+    // use minimum block in to avoid race conditions
+    for i in 0..=min {
         let blocks = join_all(providers.iter().map(|p| async {
             p.get_block_by_number(BlockNumberOrTag::Number(i))
                 .await
@@ -71,6 +85,7 @@ async fn main() -> Result<()> {
                 .ok_or_else(|| anyhow::anyhow!("provider returned no block"))?;
             if b != first_block {
                 error!(
+                    num = %b.number(),
                     block_a = ?b,
                     block_b = ?first_block,
                     "❌ block mismatch between state"
@@ -82,7 +97,7 @@ async fn main() -> Result<()> {
                 );
             }
             if i == blocks.len() - 1 {
-                info!(block_hash = %b.hash(), txns = ?b.transactions, "✅ verified block");
+                info!(num = %b.number(), block_hash = %b.hash(), txns = ?b.transactions, "✅ verified block");
             }
         }
     }

yapper/src/config.rs

@@ -11,8 +11,6 @@ pub(crate) struct YapperConfig {
     pub(crate) nitro_integration: bool,
     /// URL of nitro chain that is configured
     pub(crate) nitro_url: String,
-    /// Limit on the number of transactions we want to send
-    pub(crate) txn_limit: u64,
     /// Chain id for l2 chain
     pub(crate) chain_id: u64,
 }

yapper/src/main.rs

@@ -45,10 +45,6 @@ struct Cli {
     #[clap(long, default_value_t = false)]
     nitro_integration: bool,
 
-    /// How many txns to send before terminating yapper
-    #[clap(long, default_value_t = 20)]
-    nitro_txn_limit: u64,
-
     /// Chain id for l2 chain
     /// default: https://docs.arbitrum.io/run-arbitrum-node/run-local-full-chain-simulation#default-endpoints-and-addresses
     #[clap(long, default_value_t = 412346)]
@@ -85,7 +81,6 @@ async fn main() -> Result<()> {
         .addresses(addresses)
         .nitro_integration(cli.nitro_integration)
         .tps(cli.tps)
-        .txn_limit(cli.nitro_txn_limit)
         .nitro_url(cli.nitro_url)
         .chain_id(cli.chain_id)
         .build();

yapper/src/yapper.rs

@@ -41,7 +41,6 @@ pub(crate) struct Yapper {
     interval: Duration,
     chain_id: u64,
     provider: Option<RootProvider>,
-    txn_limit: Option<u64>,
 }
 
 impl Yapper {
@@ -63,23 +62,16 @@ impl Yapper {
             });
         }
         let client = Client::builder().timeout(Duration::from_secs(1)).build()?;
-        let (provider, interval, txn_limit) = if cfg.nitro_integration {
-            (
-                Some(RootProvider::<Ethereum>::connect(&cfg.nitro_url).await?),
-                Duration::from_secs(1),
-                // For nitro running in ci, avoid race conditions with block height by setting txn
-                // limit
-                Some(cfg.txn_limit),
-            )
+        let provider = if cfg.nitro_integration {
+            Some(RootProvider::<Ethereum>::connect(&cfg.nitro_url).await?)
         } else {
-            (None, Duration::from_millis(tps_to_millis(cfg.tps)), None)
+            None
         };
         Ok(Self {
             urls,
-            interval,
+            interval: Duration::from_millis(tps_to_millis(cfg.tps)),
             client,
             provider,
-            txn_limit,
             chain_id: cfg.chain_id,
         })
     }
@@ -93,7 +85,6 @@ impl Yapper {
             self.urls.iter().map(|url| url.enckey_url.clone()),
         );
 
-        let mut txn_sent = 0;
         loop {
             let b = if let Some(ref p) = self.provider {
                 // For testing just send from the dev account to the validator address
@@ -119,11 +110,6 @@ impl Yapper {
                     .await
             }))
             .await;
-            txn_sent += 1;
-            if self.txn_limit == Some(txn_sent) {
-                warn!("hit txn limit, terminating yapper");
-                return Ok(());
-            }
 
             interval.tick().await;
         }