duty_tracker: track finalized block

Author: prajwolrg

crates/consensus-logic/src/duties.rs

@@ -58,6 +58,7 @@ impl BlockSigningDuty {
 pub struct DutyTracker {
     next_id: u64,
     duties: Vec<DutyEntry>,
+    finalized_block: Option<L2BlockId>,
 }
 
 impl DutyTracker {
@@ -66,6 +67,7 @@ impl DutyTracker {
         Self {
             next_id: 1,
             duties: Vec::new(),
+            finalized_block: None,
         }
     }
 
@@ -78,6 +80,10 @@ impl DutyTracker {
     pub fn update(&mut self, update: &StateUpdate) -> usize {
         let mut kept_duties = Vec::new();
 
+        if update.latest_finalized_block.is_some() {
+            self.set_finalized_block(update.latest_finalized_block);
+        }
+
         for d in self.duties.drain(..) {
             match d.duty.expiry() {
                 Expiry::NextBlock => {
@@ -120,6 +126,14 @@ impl DutyTracker {
         }));
     }
 
+    pub fn set_finalized_block(&mut self, blkid: Option<L2BlockId>) {
+        self.finalized_block = blkid;
+    }
+
+    pub fn get_finalized_block(&self) -> Option<L2BlockId> {
+        self.finalized_block
+    }
+
     /// Returns the slice of duties we're keeping around.
     pub fn duties(&self) -> &[DutyEntry] {
         &self.duties
@@ -162,6 +176,9 @@ pub struct StateUpdate {
 
     /// Newly finalized blocks, must be sorted.
     newly_finalized_blocks: Vec<L2BlockId>,
+
+    /// Latest finalized block.
+    latest_finalized_block: Option<L2BlockId>,
 }
 
 impl StateUpdate {
@@ -170,11 +187,16 @@ impl StateUpdate {
         cur_timestamp: time::Instant,
         mut newly_finalized_blocks: Vec<L2BlockId>,
     ) -> Self {
+        // Extract latest finalized block before sorting
+        let latest_finalized_block = newly_finalized_blocks.first().cloned();
+
         newly_finalized_blocks.sort();
+
         Self {
             last_block_slot,
             cur_timestamp,
             newly_finalized_blocks,
+            latest_finalized_block,
         }
     }
 

crates/consensus-logic/src/duty_executor.rs

@@ -59,10 +59,11 @@ pub fn duty_tracker_task<D: Database>(
 
     let idx = database.client_state_provider().get_last_checkpoint_idx()?;
     let last_checkpoint_state = database.client_state_provider().get_state_checkpoint(idx)?;
-    let mut last_finalized_blk = match last_checkpoint_state {
+    let last_finalized_blk = match last_checkpoint_state {
         Some(state) => state.sync().map(|sync| *sync.finalized_blkid()),
         None => None,
     };
+    duties_tracker.set_finalized_block(last_finalized_blk);
 
     loop {
         let update = match cupdate_rx.blocking_recv() {
@@ -82,13 +83,7 @@ pub fn duty_tracker_task<D: Database>(
         trace!(%ev_idx, "new consensus state, updating duties");
         trace!("STATE: {new_state:#?}");
 
-        if let Err(e) = update_tracker(
-            &mut duties_tracker,
-            new_state,
-            &ident,
-            database.as_ref(),
-            &mut last_finalized_blk,
-        ) {
+        if let Err(e) = update_tracker(&mut duties_tracker, new_state, &ident, database.as_ref()) {
             error!(err = %e, "failed to update duties tracker");
         }
 
@@ -109,7 +104,6 @@ fn update_tracker<D: Database>(
     state: &ClientState,
     ident: &Identity,
     database: &D,
-    last_finalized_block: &mut Option<L2BlockId>,
 ) -> Result<(), Error> {
     let Some(ss) = state.sync() else {
         return Ok(());
@@ -129,8 +123,11 @@ fn update_tracker<D: Database>(
 
     // Figure out which blocks were finalized
     let new_finalized = state.sync().map(|sync| *sync.finalized_blkid());
-    let newly_finalized_blocks: Vec<L2BlockId> =
-        get_finalized_blocks(new_finalized, l2prov.as_ref(), last_finalized_block)?;
+    let newly_finalized_blocks: Vec<L2BlockId> = get_finalized_blocks(
+        tracker.get_finalized_block(),
+        l2prov.as_ref(),
+        new_finalized,
+    )?;
 
     let tracker_update = duties::StateUpdate::new(block_idx, ts, newly_finalized_blocks);
     let n_evicted = tracker.update(&tracker_update);
@@ -143,36 +140,30 @@ fn update_tracker<D: Database>(
 }
 
 fn get_finalized_blocks(
-    finalized: Option<L2BlockId>,
+    last_finalized_block: Option<L2BlockId>,
     l2prov: &impl L2DataProvider,
-    last_finalized_block: &mut Option<L2BlockId>,
+    finalized: Option<L2BlockId>,
 ) -> Result<Vec<L2BlockId>, Error> {
     // Figure out which blocks were finalized
     let mut newly_finalized_blocks: Vec<L2BlockId> = Vec::new();
     let mut new_finalized = finalized;
 
-    loop {
-        if let Some(finalized) = new_finalized {
-            // If the last finalized block is equal to the new finalized block,
-            // it means that no new blocks are finalized
-            if *last_finalized_block == Some(finalized) {
-                break;
-            }
-
-            // else loop till we reach to the last finalized block or go all the way
-            // as long as we get some block data
-            // TODO: verify if this works as expected
-            newly_finalized_blocks.push(finalized);
+    while let Some(finalized) = new_finalized {
+        // If the last finalized block is equal to the new finalized block,
+        // it means that no new blocks are finalized
+        if last_finalized_block == Some(finalized) {
+            break;
+        }
 
-            match l2prov.get_block_data(finalized)? {
-                Some(block) => new_finalized = Some(*block.header().parent()),
-                None => break,
-            }
+        // else loop till we reach to the last finalized block or go all the way
+        // as long as we get some block data
+        match l2prov.get_block_data(finalized)? {
+            Some(block) => new_finalized = Some(*block.header().parent()),
+            None => break,
         }
-    }
 
-    // Update the last_finalized_block with the new_finalized value
-    *last_finalized_block = finalized;
+        newly_finalized_blocks.push(finalized);
+    }
 
     Ok(newly_finalized_blocks)
 }
@@ -455,18 +446,50 @@ mod tests {
 
         let block_ids: Vec<_> = chain.iter().map(|b| b.header().get_blockid()).collect();
 
-        let mut last_finalized_block = Some(block_ids[0]);
-        let new_finalized = Some(block_ids[4]);
-        let finalized_blocks = get_finalized_blocks(
-            new_finalized,
-            db.l2_provider().as_ref(),
-            &mut last_finalized_block,
-        )
-        .unwrap();
+        {
+            let last_finalized_block = Some(block_ids[0]);
+            let new_finalized = Some(block_ids[4]);
+            let finalized_blocks = get_finalized_blocks(
+                last_finalized_block,
+                db.l2_provider().as_ref(),
+                new_finalized,
+            )
+            .unwrap();
+
+            let expected_finalized_blocks: Vec<_> =
+                block_ids[1..=4].iter().rev().cloned().collect();
+
+            assert_eq!(finalized_blocks, expected_finalized_blocks);
+        }
 
-        let expected_finalized_blocks: Vec<_> = block_ids[1..=4].iter().rev().cloned().collect();
+        {
+            let last_finalized_block = None;
+            let new_finalized = Some(block_ids[4]);
+            let finalized_blocks = get_finalized_blocks(
+                last_finalized_block,
+                db.l2_provider().as_ref(),
+                new_finalized,
+            )
+            .unwrap();
 
-        assert_eq!(finalized_blocks, expected_finalized_blocks);
-        assert_eq!(last_finalized_block, new_finalized);
+            let expected_finalized_blocks: Vec<_> =
+                block_ids[0..=4].iter().rev().cloned().collect();
+
+            assert_eq!(finalized_blocks, expected_finalized_blocks);
+        }
+
+        {
+            let last_finalized_block = None;
+            let new_finalized = None;
+            let finalized_blocks = get_finalized_blocks(
+                last_finalized_block,
+                db.l2_provider().as_ref(),
+                new_finalized,
+            )
+            .unwrap();
+
+            let expected_finalized_blocks: Vec<_> = vec![];
+            assert_eq!(finalized_blocks, expected_finalized_blocks);
+        }
     }
 }

crates/test-utils/src/l2.rs

@@ -14,11 +14,10 @@ pub fn gen_block(parent: Option<&SignedL2BlockHeader>) -> L2BlockBundle {
     let body: L2BlockBody = arb.generate();
     let accessory: L2BlockAccessory = arb.generate();
 
-    let start = SystemTime::now();
-    let since_the_epoch = start
+    let current_timestamp = SystemTime::now()
         .duration_since(UNIX_EPOCH)
-        .expect("Time went backwards");
-    let current_timestamp = since_the_epoch.as_millis() as u64;
+        .unwrap()
+        .as_millis() as u64;
 
     let block_idx = parent.map(|h| h.blockidx() + 1).unwrap_or(0);
     let prev_block = parent.map(|h| h.get_blockid()).unwrap_or_default();