fix(hubble): arbitrum consensus height tracking

Author: qlp

hubble/src/arb.rs

@@ -11,7 +11,7 @@ use alloy::{
 };
 use backon::{ConstantBuilder, ExponentialBuilder, Retryable};
 use color_eyre::eyre::{eyre, ContextCompat, Result, WrapErr};
-use tracing::{debug, info};
+use tracing::{debug, info, trace};
 use unionlabs::{bounded::BoundedU32, hash::H160, uint::U256};
 
 use crate::{
@@ -86,6 +86,8 @@ impl Config {
         .retry(&ExponentialBuilder::default())
         .await?;
 
+        info!("fetched db chain_id for chain {l2_chain_id} => {chain_id:?}");
+
         let querier = Arb {
             l1_client: ProviderBuilder::new().on_http(self.l1_url),
             l2_client,
@@ -102,8 +104,13 @@ impl Config {
 impl Arb {
     // NOTE: Copied from chain_utils
     async fn execution_height_of_beacon_slot(&self, slot: u64) -> Result<u64> {
+        trace!("find execution height of beacon slot {slot}");
+
         // read the next_node_num at l1.execution_height(beacon_slot), then from there filter for `NodeCreated`
         let next_node_num = self.next_node_num_at_beacon_slot(slot).await?;
+
+        trace!("find execution height of beacon slot {slot}. next node num: {next_node_num}");
+
         let [event] = self
             .l1_client
             .get_logs(
@@ -123,24 +130,38 @@ impl Arb {
             .await
             .wrap_err("error fetching `NodeCreated` log from l1")?
             .try_into()
-            .map_err(|e| eyre!("too many logs found? there should only be one `NodeCreated event`, but found: {e:?}"))?;
-        debug!("next node num: {next_node_num}: {event:?}");
+            .map_err(|e| eyre!("too many logs or no found? there should only be one `NodeCreated event`, but found: {e:?}"))?;
+
+        trace!("find execution height of beacon slot {slot}. event: {event:?}");
+
         let event = NodeCreated::decode_log(&event.inner, true).unwrap();
+
+        trace!("find execution height of beacon slot {slot}. event(decoded): {event:?}");
         let block_id = BlockId::Hash(RpcBlockHash {
             block_hash: FixedBytes::from_slice(event.assertion.0 .0 .0[0].as_ref()),
             require_canonical: None,
         });
+
+        trace!("find execution height of beacon slot {slot}. block-id: {block_id}");
+
         let block = self
             .l2_client
-            .get_block(block_id, BlockTransactionsKind::Full)
+            .get_block(block_id, BlockTransactionsKind::Hashes)
             .await
             .wrap_err("error fetching l2 block")?
             .expect("block should exist if it is finalized on the l1");
 
+        trace!(
+            "find execution height of beacon slot {slot}. block-number: {}",
+            block.header.number
+        );
+
         Ok(block.header.number)
     }
 
     pub async fn next_node_num_at_beacon_slot(&self, slot: u64) -> Result<u64> {
+        trace!("find next node num at beacon slot {slot}");
+
         let l1_height = self
             .beacon
             .get_height_at_skip_missing(slot.try_into().expect("negative slot?"))
@@ -151,12 +172,15 @@ impl Arb {
             .execution_payload
             .block_number;
 
+        trace!("find next node num at beacon slot {slot}: l1-height: {l1_height}");
+
         let slot_offset_bytes = self
             .rollup_finalization_config
             .l1_next_node_num_slot_offset_bytes
             .inner()
             .try_into()
             .unwrap();
+
         let raw_slot = self
             .l1_client
             .get_storage_at(
@@ -171,27 +195,41 @@ impl Arb {
             )
             .await?;
 
+        trace!("find next node num at beacon slot {slot}: l1-height: {l1_height}: raw_slow: {raw_slot}");
+
         let raw_slot: B256 = raw_slot.into();
         let latest_confirmed = u64::from_be_bytes(
             raw_slot.0[slot_offset_bytes..slot_offset_bytes + 8]
                 .try_into()
                 .expect("size is correct; qed;"),
         );
 
+        trace!("find next node num at beacon slot {slot}: l1-height: {l1_height}: latest_confirmed: {latest_confirmed}");
+
         debug!("l1_height {l1_height} is next node num {latest_confirmed}",);
         Ok(latest_confirmed)
     }
 }
 
 impl Querier for Arb {
     async fn get_execution_height(&self, slot: i64) -> Result<(i64, i64)> {
+        trace!("get execution height of beacon slot {slot}");
+
         let height = (|| self.execution_height_of_beacon_slot(slot.try_into().unwrap()))
             .retry(
                 &ConstantBuilder::default()
                     .with_delay(Duration::from_millis(500))
                     .with_max_times(60),
             )
+            .notify(|err, duration| {
+                trace!(
+                    "get execution height of beacon slot {slot} => error: {err:?}. retry after {}s",
+                    duration.as_secs()
+                );
+            })
             .await?;
+
+        trace!("get execution height of beacon slot {slot}, found: {height}");
         Ok((slot, height.try_into().unwrap()))
     }
 }