chore(taiko-client-rs): several improvments for preconfirmation-driver (#21330)

Author: mskrzypkows

.dockerignore

@@ -0,0 +1,2 @@
+node_modules
+**/target

packages/taiko-client-rs/Dockerfile

@@ -12,7 +12,11 @@ COPY packages/preconfirmation-p2p packages/preconfirmation-p2p
 
 WORKDIR /app/packages/taiko-client-rs
 
-RUN cargo build --release
+RUN --mount=type=cache,target=/usr/local/cargo/registry \
+    --mount=type=cache,target=/usr/local/cargo/git \
+    --mount=type=cache,target=/app/packages/taiko-client-rs/target \
+    cargo build --release && \
+    cp /app/packages/taiko-client-rs/target/release/taiko-client /tmp/taiko-client
 
 FROM ubuntu:22.04
 
@@ -22,6 +26,6 @@ RUN apt-get update && \
 
 WORKDIR /app
 
-COPY --from=build /app/packages/taiko-client-rs/target/release/taiko-client ./
+COPY --from=build /tmp/taiko-client ./taiko-client
 
 ENTRYPOINT ["./taiko-client"]

packages/taiko-client-rs/crates/preconfirmation-driver/src/rpc/server.rs

@@ -201,7 +201,9 @@ fn api_error_to_rpc(err: PreconfirmationClientError) -> ErrorObjectOwned {
             LookaheadError::SystemTime(_) |
             LookaheadError::UnknownChain(_) |
             LookaheadError::MissingLookahead(_) |
-            LookaheadError::CorruptLookaheadCache { .. } => {
+            LookaheadError::CorruptLookaheadCache { .. } |
+            LookaheadError::GetLookaheadStoreConfig(_) |
+            LookaheadError::GetPreconfWhitelistAddress(_) => {
                 PreconfRpcErrorCode::LookaheadUnavailable.code()
             }
         },

packages/taiko-client-rs/crates/preconfirmation-driver/src/runner/mod.rs

@@ -21,6 +21,7 @@ use crate::{
     },
 };
 use protocol::preconfirmation::LookaheadResolver;
+use rpc::beacon::BeaconClient;
 
 use preconf_ingress_sync::PreconfIngressSync;
 
@@ -76,6 +77,9 @@ pub enum RunnerError {
     /// Preconfirmation client error.
     #[error(transparent)]
     Preconfirmation(#[from] PreconfirmationClientError),
+    /// Failed to fetch beacon genesis for lookahead resolver.
+    #[error("beacon genesis fetch failed: {0}")]
+    BeaconGenesis(String),
 }
 
 /// Configuration for the preconfirmation driver runner.
@@ -139,8 +143,13 @@ impl PreconfirmationDriverRunner {
 
         // Build the lookahead resolver and start its background event scanner
         let l1_source = self.config.driver_config.client.l1_provider_source.clone();
+        let beacon_client = BeaconClient::new(self.config.driver_config.l1_beacon_endpoint.clone())
+            .await
+            .map_err(|e| RunnerError::BeaconGenesis(e.to_string()))?;
+        let genesis_timestamp = beacon_client.genesis_time();
+
         let (lookahead_resolver, _scanner_handle) =
-            LookaheadResolver::new(inbox_address, l1_source)
+            LookaheadResolver::new_with_genesis(inbox_address, l1_source, genesis_timestamp)
                 .await
                 .map_err(PreconfirmationClientError::from)?;
 

packages/taiko-client-rs/crates/protocol/src/preconfirmation/lookahead/client.rs

@@ -5,6 +5,7 @@ use bindings::{
 };
 
 use super::{LookaheadData, LookaheadError, ProposerContext, Result};
+use tracing::debug;
 
 /// Thin wrapper around on-chain lookahead contracts resolved via the Inbox configuration.
 #[derive(Clone)]
@@ -19,6 +20,7 @@ impl<P: Provider + Clone> LookaheadClient<P> {
     pub async fn new(inbox_address: Address, provider: P) -> Result<Self> {
         let inbox = InboxInstance::new(inbox_address, provider.clone());
         let config = inbox.getConfig().call().await.map_err(LookaheadError::InboxConfig)?;
+        debug!("Inbox config: {:?}", config);
 
         let lookahead_store = LookaheadStoreInstance::new(config.proposerChecker, provider);
 

packages/taiko-client-rs/crates/protocol/src/preconfirmation/lookahead/mod.rs

@@ -37,6 +37,12 @@ pub enum LookaheadError {
     /// Failure when querying the LookaheadStore.
     #[error("failed to call lookahead store: {0}")]
     Lookahead(alloy_contract::Error),
+    /// Failed to fetch lookahead store config from the LookaheadStore.
+    #[error("failed to get lookahead store config: {0}")]
+    GetLookaheadStoreConfig(alloy_contract::Error),
+    /// Failed to fetch preconf whitelist address from the LookaheadStore.
+    #[error("failed to get preconf whitelist address: {0}")]
+    GetPreconfWhitelistAddress(alloy_contract::Error),
     /// Failure when querying the preconfirmation whitelist.
     #[error("failed to call preconf whitelist: {0}")]
     PreconfWhitelist(alloy_contract::Error),

packages/taiko-client-rs/crates/protocol/src/preconfirmation/lookahead/resolver/core.rs

@@ -99,15 +99,15 @@ impl LookaheadResolver {
             .getLookaheadStoreConfig()
             .call()
             .await
-            .map_err(LookaheadError::Lookahead)?;
+            .map_err(LookaheadError::GetLookaheadStoreConfig)?;
 
         let preconf_whitelist = PreconfWhitelistInstance::new(
             client
                 .lookahead_store()
                 .preconfWhitelist()
                 .call()
                 .await
-                .map_err(LookaheadError::Lookahead)?,
+                .map_err(LookaheadError::GetPreconfWhitelistAddress)?,
             provider.clone(),
         );
 

packages/taiko-client-rs/crates/rpc/src/beacon.rs

@@ -335,6 +335,13 @@ impl BeaconClient {
     pub const fn slots_per_epoch(&self) -> u64 {
         self.slots_per_epoch
     }
+
+    /// Return the beacon genesis timestamp (seconds since UNIX epoch).
+    ///
+    /// Fetched from `/eth/v1/beacon/genesis` during client construction.
+    pub const fn genesis_time(&self) -> u64 {
+        self.genesis_time
+    }
 }
 
 fn parse_blob(value: &str) -> Result<Blob, BlobDataError> {

packages/taiko-client-rs/crates/rpc/src/client.rs

@@ -85,36 +85,49 @@ pub struct ClientConfig {
 impl Client<FillProvider<JoinedRecommendedFillers, RootProvider>> {
     /// Create a new `Client` without a wallet from the given configuration.
     pub async fn new(config: ClientConfig) -> Result<Self> {
-        Self::new_with_l1_provider(config.l1_provider_source.to_provider().await?, config).await
+        let l1_provider = config.l1_provider_source.to_provider().await.map_err(|e| {
+            RpcClientError::Connection(format!("L1 WebSocket (l1.ws) connection failed: {}", e))
+        })?;
+        Self::new_with_l1_provider(l1_provider, config).await
     }
 }
 
 impl Client<FillProvider<JoinedRecommendedFillersWithWallet, RootProvider>> {
     /// Create a new `Client` with a wallet from the given configuration.
     pub async fn new_with_wallet(config: ClientConfig, private_key: B256) -> Result<Self> {
-        Self::new_with_l1_provider(
-            config.l1_provider_source.to_provider_with_wallet(private_key).await?,
-            config,
-        )
-        .await
+        let l1_provider =
+            config.l1_provider_source.to_provider_with_wallet(private_key).await.map_err(|e| {
+                RpcClientError::Connection(format!("L1 WebSocket (l1.ws) connection failed: {}", e))
+            })?;
+        Self::new_with_l1_provider(l1_provider, config).await
     }
 }
 
 impl<P: Provider + Clone> Client<P> {
     /// Create a new `Client` from the given L1 provider and configuration.
     async fn new_with_l1_provider(l1_provider: P, config: ClientConfig) -> Result<Self> {
-        let l2_provider = connect_provider_with_timeout(config.l2_provider_url).await?;
+        let l2_provider =
+            connect_provider_with_timeout(config.l2_provider_url.clone()).await.map_err(|e| {
+                RpcClientError::Connection(format!(
+                    "L2 HTTP RPC (l2.http) connection failed for {}: {}",
+                    config.l2_provider_url, e
+                ))
+            })?;
         let jwt_secret = read_jwt_secret(config.jwt_secret.as_path()).ok_or_else(|| {
             RpcClientError::JwtSecretReadFailed(config.jwt_secret.display().to_string())
         })?;
         let l2_auth_provider =
             build_jwt_http_provider(config.l2_auth_provider_url.clone(), jwt_secret);
 
+        let chain_id = l2_provider.get_chain_id().await.map_err(|e| {
+            RpcClientError::Rpc(format!(
+                "L2 HTTP RPC (l2.http) failed to get chain id from {}: {}",
+                config.l2_provider_url, e
+            ))
+        })?;
+
         let inbox = InboxInstance::new(config.inbox_address, l1_provider.clone());
-        let anchor = AnchorInstance::new(
-            get_treasury_address(l2_provider.get_chain_id().await?),
-            l2_auth_provider.clone(),
-        );
+        let anchor = AnchorInstance::new(get_treasury_address(chain_id), l2_auth_provider.clone());
 
         info!(
             inbox_address = ?config.inbox_address,

packages/taiko-client-rs/crates/test-harness/src/driver/proposal.rs

@@ -59,7 +59,7 @@ pub async fn wait_for_proposal_id(
                 return Err(anyhow!(
                     "timed out waiting for proposal {expected_proposal_id}, current: {}",
                     *rx.borrow()
-                ))
+                ));
             }
         }
     }