From 479a85bda800259f78ac49718eb1f0309a04c42d Mon Sep 17 00:00:00 2001 From: evalir Date: Thu, 30 Apr 2026 18:03:13 +0200 Subject: [PATCH 1/2] rename host references in BlockWatcher to rollup --- src/utils/block_watcher.rs | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/src/utils/block_watcher.rs b/src/utils/block_watcher.rs index 9eb6727..4189250 100644 --- a/src/utils/block_watcher.rs +++ b/src/utils/block_watcher.rs @@ -1,5 +1,5 @@ -//! Host chain block watcher that subscribes to new blocks and tracks the -//! current host block number. +//! Rollup chain block watcher that subscribes to new blocks and tracks the +//! current rollup block number. use alloy::{ network::Ethereum, @@ -12,33 +12,33 @@ use tokio::{ }; use tracing::{debug, error, trace}; -/// Host chain block watcher that subscribes to new blocks and broadcasts +/// Rollup chain block watcher that subscribes to new blocks and broadcasts /// updates via a watch channel. #[derive(Debug)] pub struct BlockWatcher { /// Watch channel responsible for broadcasting block number updates. block_number: watch::Sender, - /// Host chain provider. - host_provider: RootProvider, + /// Rollup chain provider. + rollup_provider: RootProvider, } impl BlockWatcher { /// Creates a new [`BlockWatcher`] with the given provider and initial /// block number. - pub fn new(host_provider: RootProvider, initial: u64) -> Self { + pub fn new(rollup_provider: RootProvider, initial: u64) -> Self { Self { block_number: watch::channel(initial).0, - host_provider, + rollup_provider, } } /// Creates a new [`BlockWatcher`], fetching the current block number first. pub async fn with_current_block( - host_provider: RootProvider, + rollup_provider: RootProvider, ) -> Result { - let block_number = host_provider.get_block_number().await?; - Ok(Self::new(host_provider, block_number)) + let block_number = rollup_provider.get_block_number().await?; + Ok(Self::new(rollup_provider, block_number)) } /// Subscribe to block number updates. @@ -52,7 +52,7 @@ impl BlockWatcher { } async fn task_future(self) { - let mut sub = match self.host_provider.subscribe_blocks().await { + let mut sub = match self.rollup_provider.subscribe_blocks().await { Ok(sub) => sub, Err(error) => { error!(%error); @@ -60,14 +60,14 @@ impl BlockWatcher { } }; - debug!("subscribed to host chain blocks"); + debug!("subscribed to rollup chain blocks"); loop { match sub.recv().await { Ok(header) => { let block_number = header.number; self.block_number.send_replace(block_number); - trace!(block_number, "updated host block number"); + trace!(block_number, "updated rollup block number"); } Err(RecvError::Lagged(missed)) => { debug!(%missed, "block subscription lagged"); From bb753c04e95919b5620b74a4de12188ec6e51a17 Mon Sep 17 00:00:00 2001 From: evalir Date: Mon, 4 May 2026 15:30:04 +0200 Subject: [PATCH 2/2] make BlockWatcher chain-agnostic Drop host/rollup naming from BlockWatcher; it just watches blocks on whatever chain its provider is connected to. Co-Authored-By: Claude Opus 4.7 (1M context) --- src/utils/block_watcher.rs | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/src/utils/block_watcher.rs b/src/utils/block_watcher.rs index 4189250..741bb3c 100644 --- a/src/utils/block_watcher.rs +++ b/src/utils/block_watcher.rs @@ -1,5 +1,5 @@ -//! Rollup chain block watcher that subscribes to new blocks and tracks the -//! current rollup block number. +//! Block watcher that subscribes to new blocks and tracks the current block +//! number for any chain. use alloy::{ network::Ethereum, @@ -12,33 +12,33 @@ use tokio::{ }; use tracing::{debug, error, trace}; -/// Rollup chain block watcher that subscribes to new blocks and broadcasts -/// updates via a watch channel. +/// Block watcher that subscribes to new blocks and broadcasts updates via a +/// watch channel. #[derive(Debug)] pub struct BlockWatcher { /// Watch channel responsible for broadcasting block number updates. block_number: watch::Sender, - /// Rollup chain provider. - rollup_provider: RootProvider, + /// Provider for the chain being watched. + provider: RootProvider, } impl BlockWatcher { /// Creates a new [`BlockWatcher`] with the given provider and initial /// block number. - pub fn new(rollup_provider: RootProvider, initial: u64) -> Self { + pub fn new(provider: RootProvider, initial: u64) -> Self { Self { block_number: watch::channel(initial).0, - rollup_provider, + provider, } } /// Creates a new [`BlockWatcher`], fetching the current block number first. pub async fn with_current_block( - rollup_provider: RootProvider, + provider: RootProvider, ) -> Result { - let block_number = rollup_provider.get_block_number().await?; - Ok(Self::new(rollup_provider, block_number)) + let block_number = provider.get_block_number().await?; + Ok(Self::new(provider, block_number)) } /// Subscribe to block number updates. @@ -52,7 +52,7 @@ impl BlockWatcher { } async fn task_future(self) { - let mut sub = match self.rollup_provider.subscribe_blocks().await { + let mut sub = match self.provider.subscribe_blocks().await { Ok(sub) => sub, Err(error) => { error!(%error); @@ -60,14 +60,14 @@ impl BlockWatcher { } }; - debug!("subscribed to rollup chain blocks"); + debug!("subscribed to blocks"); loop { match sub.recv().await { Ok(header) => { let block_number = header.number; self.block_number.send_replace(block_number); - trace!(block_number, "updated rollup block number"); + trace!(block_number, "updated block number"); } Err(RecvError::Lagged(missed)) => { debug!(%missed, "block subscription lagged");