address comments

Author: lukeiannucci

timeboost-sequencer/src/delayed_inbox.rs

@@ -11,8 +11,12 @@ use tracing::{error, info, warn};
 
 use crate::queue::BundleQueue;
 
+// Polling interval to check for next delayed inbox index
 const INBOX_DELAY: Duration = Duration::from_secs(60);
 
+// Max lookback for `from_block` to `to_block` in our `Filter` request
+const MAX_BLOCK_LOOKBACK: u64 = 300;
+
 sol! {
     event InboxMessageDelivered(uint256 indexed messageNum, bytes data);
     event InboxMessageDeliveredFromOrigin(uint256 indexed messageNum);
@@ -29,12 +33,12 @@ pub struct DelayedInbox<N: Network> {
 impl<N: Network> DelayedInbox<N> {
     pub async fn connect(
         node: PublicKey,
-        url: String,
+        url: &str,
         ibox_addr: Address,
         parent_chain_id: u64,
         queue: BundleQueue,
     ) -> Result<Self, Error> {
-        let provider = RootProvider::<N>::connect(&url)
+        let provider = RootProvider::<N>::connect(url)
             .await
             .map_err(|e| Error::RpcError(e.to_string()))?;
         let rpc_chain_id = provider
@@ -50,13 +54,13 @@ impl<N: Network> DelayedInbox<N> {
             ibox_addr,
             provider,
             queue,
-            url,
+            url: url.to_string(),
         })
     }
 
     pub async fn go(self) {
-        let mut last_finalized = 0;
-        let mut last_delayed_index = 0;
+        let mut prev_finalized = 0;
+        let mut prev_delayed_idx = 0;
         let events = vec![
             InboxMessageDelivered::SIGNATURE,
             InboxMessageDeliveredFromOrigin::SIGNATURE,
@@ -69,22 +73,26 @@ impl<N: Network> DelayedInbox<N> {
                 .await
             {
                 let finalized = b.header().number();
-                if finalized == last_finalized {
+                if finalized == prev_finalized {
+                    // Nothing to do
                     sleep(INBOX_DELAY).await;
                     continue;
                 }
-                if last_finalized == 0 {
-                    last_finalized = finalized.saturating_sub(300);
+                // To prevent large rpc queries go from finalized - MAX_BLOCK_LOOKBACK
+                // This is fine because we only need the latest finalized delayed message to set the
+                // index
+                if finalized.saturating_sub(prev_finalized) > MAX_BLOCK_LOOKBACK {
+                    prev_finalized = finalized.saturating_sub(MAX_BLOCK_LOOKBACK);
                 }
 
                 // Filter for the `InboxMessageDelivered` and `InboxMessageDeliveredFromOrigin`
                 // between our last finalized and current finalized on the L1 contract
                 let filter = Filter::new()
                     .address(self.ibox_addr)
-                    .from_block(last_finalized)
+                    .from_block(prev_finalized)
                     .to_block(finalized)
                     .events(&events);
-                last_finalized = finalized;
+                prev_finalized = finalized;
 
                 if let Ok(mut logs) = self.provider.get_logs(&filter).await {
                     // Make sure event logs are in order, we need highest block number first then
@@ -99,14 +107,14 @@ impl<N: Network> DelayedInbox<N> {
                         .map(|log| (log.transaction_hash, log.topics().get(1)))
                     {
                         // Update delayed index if newer
-                        let delayed_index = U256::from_be_bytes(index.0)
+                        let delayed_idx = U256::from_be_bytes(index.0)
                             .try_into()
                             .expect("valid msg number");
-                        if delayed_index != last_delayed_index {
-                            debug_assert!(delayed_index > last_delayed_index);
-                            info!(node = %self.node, %delayed_index, parent_finalized_block = %finalized, ibox_addr = %self.ibox_addr, %tx_hash, "delayed index updated");
-                            last_delayed_index = delayed_index;
-                            self.queue.set_delayed_inbox_index(delayed_index.into());
+                        if delayed_idx != prev_delayed_idx {
+                            debug_assert!(delayed_idx > prev_delayed_idx);
+                            info!(node = %self.node, %delayed_idx, parent_finalized_block = %finalized, ibox_addr = %self.ibox_addr, %tx_hash, "delayed index updated");
+                            prev_delayed_idx = delayed_idx;
+                            self.queue.set_delayed_inbox_index(delayed_idx.into());
                         }
                     }
                 }

timeboost-sequencer/src/lib.rs

@@ -118,7 +118,7 @@ impl Sequencer {
 
         let ibox = DelayedInbox::<Ethereum>::connect(
             public_key,
-            cfg.chain_config.parent_chain_rpc_url().clone(),
+            cfg.chain_config.parent_chain_rpc_url(),
             cfg.chain_config.parent_ibox_contr_addr(),
             cfg.chain_config.parent_chain_id(),
             queue.clone(),

timeboost-sequencer/src/queue.rs

@@ -61,7 +61,6 @@ impl BundleQueue {
         })))
     }
 
-    #[allow(unused)]
     pub fn set_delayed_inbox_index(&self, idx: DelayedInboxIndex) {
         self.0.lock().index = idx
     }

timeboost-types/src/chain_config.rs

@@ -21,7 +21,7 @@ impl ChainConfig {
         self.parent_chain_id
     }
 
-    pub fn parent_chain_rpc_url(&self) -> &String {
+    pub fn parent_chain_rpc_url(&self) -> &str {
         &self.parent_chain_rpc_url
     }