fix(fast-inbox): source the checkpoint bucket hint from the streaming cursor (A-1384)

When a checkpoint builds several blocks in one slot and the final sub-slot block fails to
build after earlier blocks already consumed L1-to-L2 messages, no block is held for
broadcast, so the L1 propose bucket hint fell back to genesis bucket 0 while the checkpoint
header committed to a non-genesis rolling hash — L1 rejects this as Rollup__InvalidInboxRollingHash.
Take the hint from the streaming consumption cursor's final bucket reference, which is always
defined and always matches the bucket the header committed to, and carry it through the
broadcast result. Behavior-preserving on the normal held-block path (block bucket refs are
cumulative, so the held last block's ref already equals the cursor's). Adds a regression test
for the no-held-block checkpoint.

Author: spalladino

yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.test.ts

@@ -1493,6 +1493,49 @@ describe('CheckpointProposalJob', () => {
       expect(checkpointBuilder.buildBlockCalls[0].opts.l1ToL2Messages).toEqual(bundle);
       expect(publisher.enqueueProposeCheckpoint).toHaveBeenCalledTimes(1);
     });
+
+    it('carries the consumed bucket hint when the final block fails to build after earlier consumption', async () => {
+      // Two sub-slots. The first block consumes the pending bucket (seq 2) as a message-only block. The final
+      // sub-slot block has no txs and nothing left to consume (the cursor already sits at seq 2), so it fails to
+      // build and is not held for broadcast. The L1 propose bucket hint must still be the bucket the checkpoint
+      // header committed to (seq 2), not fall back to genesis bucket 0 — otherwise L1 rejects the proposal with an
+      // inbox-rolling-hash mismatch (the hint's bucket rolling hash would not match the header's).
+      jest
+        .spyOn(job.getTimetable(), 'selectNextSubslot')
+        .mockReturnValueOnce(subslot(10, 0, false))
+        .mockReturnValueOnce(subslot(18, 1, true))
+        .mockReturnValue(noSubslot());
+
+      const bucket: InboxBucket = {
+        seq: 2n,
+        inboxRollingHash: new Fr(99),
+        totalMsgCount: 5n,
+        timestamp: 0n,
+        msgCount: 2,
+        lastMessageIndex: 4n,
+        isOpen: false,
+      };
+      const bundle = Array.from({ length: 5 }, (_, i) => new Fr(i + 1));
+      l1ToL2MessageSource.getLatestInboxBucketAtOrBefore.mockResolvedValue(bucket);
+      l1ToL2MessageSource.getL1ToL2MessagesBetweenBuckets.mockResolvedValue(bundle);
+
+      // Seed a single message-only block; the second sub-slot has no seeded block, no txs, and no new bucket to
+      // consume, so it fails the min-work threshold and no block is held for broadcast.
+      const { lastBlock } = await setupMultipleBlocks(1, [0]);
+      validatorClient.collectAttestations.mockResolvedValue(getAttestations(lastBlock));
+
+      job.updateConfig({ minTxsPerBlock: 1, buildCheckpointIfEmpty: false });
+      const checkpoint = await job.executeAndAwait();
+
+      expect(checkpoint).toBeDefined();
+      // Only the first (message-only) block built and consumed through bucket 2; the final block did not build.
+      expect(checkpointBuilder.buildBlockCalls).toHaveLength(1);
+      expect(publisher.enqueueProposeCheckpoint).toHaveBeenCalledTimes(1);
+
+      // No held last block, yet the bucket hint (4th positional arg) is the consumed bucket seq 2, matching the
+      // checkpoint header's rolling hash. Before the fix this fell back to genesis bucket 0n.
+      expect(publisher.enqueueProposeCheckpoint.mock.calls[0][3]).toBe(2n);
+    });
   });
 
   describe('build single block', () => {

yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.ts

@@ -97,6 +97,13 @@ type CheckpointProposalBroadcast = {
   checkpoint: Checkpoint;
   proposal: CheckpointProposal;
   blockProposedAt: number;
+  /**
+   * Sequence number of the last Inbox bucket the checkpoint consumed through — the L1 `propose` lookup aid, which
+   * must resolve to the bucket whose rolling hash the checkpoint header committed to. Taken from the streaming
+   * consumption cursor rather than the held last-block proposal, which is absent when the checkpoint's final block
+   * fails to build after earlier blocks already consumed messages.
+   */
+  bucketHint: bigint;
 };
 
 /** Result after attestation collection and signing, ready for L1 submission. */
@@ -310,8 +317,11 @@ export class CheckpointProposalJob implements Traceable {
     votesPromises: Promise<unknown>[],
   ): Promise<void> {
     const { checkpoint } = broadcast;
-    // The checkpoint's consumed Inbox bucket is the last block's bucket reference (undefined ⇒ genesis bucket 0).
-    const bucketHint = broadcast.proposal.lastBlock?.bucketRef?.bucketSeq ?? 0n;
+    // The bucket the checkpoint consumed through, from the streaming cursor. Sourcing it from the held last-block
+    // proposal is wrong: when the checkpoint's final block fails to build after earlier blocks already consumed
+    // messages, no block is held, so the hint would fall back to genesis bucket 0 while the header commits to a
+    // non-genesis rolling hash, which L1 rejects with Rollup__InvalidInboxRollingHash.
+    const bucketHint = broadcast.bucketHint;
 
     try {
       // Wait for all votes actions, enqueued at the beginning, to resolve
@@ -834,7 +844,12 @@ export class CheckpointProposalJob implements Traceable {
         );
         this.metrics.recordCheckpointSuccess();
         // Return a broadcast result with a dummy proposal — fisherman mode skips attestation collection
-        return { checkpoint, proposal: undefined!, blockProposedAt: this.dateProvider.now() };
+        return {
+          checkpoint,
+          proposal: undefined!,
+          blockProposedAt: this.dateProvider.now(),
+          bucketHint: streamingState.lastBucketRef.bucketSeq,
+        };
       }
 
       // Validate the header against L1 state before broadcasting.
@@ -888,8 +903,10 @@ export class CheckpointProposalJob implements Traceable {
         this.checkpointMetrics.noteCheckpointBroadcast(this.dateProvider.now());
       }
 
-      // Return immediately after broadcast — attestation collection happens in the background
-      return { checkpoint, proposal, blockProposedAt };
+      // Return immediately after broadcast — attestation collection happens in the background. The bucket hint is
+      // the streaming cursor's final consumed bucket, which matches the header's rolling hash whether or not a last
+      // block was held for broadcast.
+      return { checkpoint, proposal, blockProposedAt, bucketHint: streamingState.lastBucketRef.bucketSeq };
     } catch (err) {
       if (err && (err instanceof DutyAlreadySignedError || err instanceof SlashingProtectionError)) {
         // swallow this error. It's already been logged by a function deeper in the stack