@aztec/stdlib 4.0.0-nightly.20260112 → 4.0.0-nightly.20260113

package/dest/tx/private_execution_result.js

@@ -96,7 +96,6 @@ export class PrivateExecutionResult {
     vk;
     partialWitness;
     publicInputs;
-    noteHashLeafIndexMap;
     newNotes;
     noteHashNullifierCounterMap;
     returnValues;
@@ -107,7 +106,7 @@ export class PrivateExecutionResult {
     profileResult;
     constructor(// Needed for prover
     /** The ACIR bytecode. */ acir, /** The verification key. */ vk, /** The partial witness. */ partialWitness, // Needed for the verifier (kernel)
-    /** The call stack item. */ publicInputs, /** Mapping of note hash to its index in the note hash tree. Used for building hints for note hash read requests. */ noteHashLeafIndexMap, /** The notes created in the executed function. */ newNotes, /** Mapping of note hash counter to the counter of its nullifier. */ noteHashNullifierCounterMap, /** The raw return values of the executed function. */ returnValues, /** The offchain effects emitted during execution of this function call via the `emit_offchain_effect` oracle. */ offchainEffects, /** The pre-tags used in this tx to compute tags for private logs */ preTags, /** The nested executions. */ nestedExecutionResults, /**
+    /** The call stack item. */ publicInputs, /** The notes created in the executed function. */ newNotes, /** Mapping of note hash counter to the counter of its nullifier. */ noteHashNullifierCounterMap, /** The raw return values of the executed function. */ returnValues, /** The offchain effects emitted during execution of this function call via the `emit_offchain_effect` oracle. */ offchainEffects, /** The pre-tags used in this tx to compute tags for private logs */ preTags, /** The nested executions. */ nestedExecutionResults, /**
      * Contract class logs emitted during execution of this function call.
      * Note: We only need to collect the ContractClassLogFields as preimages for the tx.
      * But keep them as ContractClassLog so that we can verify the log hashes before submitting the tx (TODO).
@@ -116,7 +115,6 @@ export class PrivateExecutionResult {
         this.vk = vk;
         this.partialWitness = partialWitness;
         this.publicInputs = publicInputs;
-        this.noteHashLeafIndexMap = noteHashLeafIndexMap;
         this.newNotes = newNotes;
         this.noteHashNullifierCounterMap = noteHashNullifierCounterMap;
         this.returnValues = returnValues;
@@ -132,7 +130,6 @@ export class PrivateExecutionResult {
             vk: schemas.Buffer,
             partialWitness: mapSchema(z.coerce.number(), z.string()),
             publicInputs: PrivateCircuitPublicInputs.schema,
-            noteHashLeafIndexMap: mapSchema(schemas.BigInt, schemas.BigInt),
             newNotes: z.array(NoteAndSlot.schema),
             noteHashNullifierCounterMap: mapSchema(z.coerce.number(), z.number()),
             returnValues: z.array(schemas.Fr),
@@ -145,7 +142,7 @@ export class PrivateExecutionResult {
         }).transform(PrivateCallExecutionResult.from);
     }
     static from(fields) {
-        return new PrivateCallExecutionResult(fields.acir, fields.vk, fields.partialWitness, fields.publicInputs, fields.noteHashLeafIndexMap, fields.newNotes, fields.noteHashNullifierCounterMap, fields.returnValues, fields.offchainEffects, fields.preTags, fields.nestedExecutionResults, fields.contractClassLogs);
+        return new PrivateCallExecutionResult(fields.acir, fields.vk, fields.partialWitness, fields.publicInputs, fields.newNotes, fields.noteHashNullifierCounterMap, fields.returnValues, fields.offchainEffects, fields.preTags, fields.nestedExecutionResults, fields.contractClassLogs);
     }
     static async random(nested = 1) {
         return new PrivateCallExecutionResult(randomBytes(4), randomBytes(4), new Map([
@@ -153,12 +150,7 @@ export class PrivateExecutionResult {
                 1,
                 'one'
             ]
-        ]), PrivateCircuitPublicInputs.empty(), new Map([
-            [
-                1n,
-                1n
-            ]
-        ]), [
+        ]), PrivateCircuitPublicInputs.empty(), [
             NoteAndSlot.random()
         ], new Map([
             [
@@ -178,15 +170,6 @@ export class PrivateExecutionResult {
         ]);
     }
 }
-export function collectNoteHashLeafIndexMap(execResult) {
-    const accum = new Map();
-    const collectNoteHashLeafIndexMapRecursive = (callResult, accum)=>{
-        callResult.noteHashLeafIndexMap.forEach((value, key)=>accum.set(key, value));
-        callResult.nestedExecutionResults.forEach((nested)=>collectNoteHashLeafIndexMapRecursive(nested, accum));
-    };
-    collectNoteHashLeafIndexMapRecursive(execResult.entrypoint, accum);
-    return accum;
-}
 export function collectNoteHashNullifierCounterMap(execResult) {
     const accum = new Map();
     const collectNoteHashNullifierCounterMapRecursive = (callResult, accum)=>{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/stdlib",
-  "version": "4.0.0-nightly.20260112",
+  "version": "4.0.0-nightly.20260113",
   "type": "module",
   "inherits": [
     "../package.common.json",
@@ -77,13 +77,13 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.892.0",
-    "@aztec/bb.js": "4.0.0-nightly.20260112",
-    "@aztec/blob-lib": "4.0.0-nightly.20260112",
-    "@aztec/constants": "4.0.0-nightly.20260112",
-    "@aztec/ethereum": "4.0.0-nightly.20260112",
-    "@aztec/foundation": "4.0.0-nightly.20260112",
-    "@aztec/l1-artifacts": "4.0.0-nightly.20260112",
-    "@aztec/noir-noirc_abi": "4.0.0-nightly.20260112",
+    "@aztec/bb.js": "4.0.0-nightly.20260113",
+    "@aztec/blob-lib": "4.0.0-nightly.20260113",
+    "@aztec/constants": "4.0.0-nightly.20260113",
+    "@aztec/ethereum": "4.0.0-nightly.20260113",
+    "@aztec/foundation": "4.0.0-nightly.20260113",
+    "@aztec/l1-artifacts": "4.0.0-nightly.20260113",
+    "@aztec/noir-noirc_abi": "4.0.0-nightly.20260113",
     "@google-cloud/storage": "^7.15.0",
     "axios": "^1.12.0",
     "json-stringify-deterministic": "1.0.12",

package/src/block/attestation_info.ts

@@ -1,9 +1,9 @@
 import { recoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 
+import { Checkpoint } from '../checkpoint/checkpoint.js';
 import { ConsensusPayload } from '../p2p/consensus_payload.js';
 import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from '../p2p/signature_utils.js';
-import type { L2Block } from './l2_block.js';
 import type { CommitteeAttestation } from './proposal/committee_attestation.js';
 
 /**
@@ -29,14 +29,14 @@ export type AttestationInfo =
     };
 
 /**
- * Extracts attestation information from a published L2 block.
+ * Extracts attestation information from a published checkpoint.
  * Returns info for each attestation, preserving array indices.
  */
-export function getAttestationInfoFromPublishedL2Block(block: {
+export function getAttestationInfoFromPublishedCheckpoint(block: {
   attestations: CommitteeAttestation[];
-  block: L2Block;
+  checkpoint: Checkpoint;
 }): AttestationInfo[] {
-  const payload = ConsensusPayload.fromBlock(block.block);
+  const payload = ConsensusPayload.fromCheckpoint(block.checkpoint);
   return getAttestationInfoFromPayload(payload, block.attestations);
 }
 
@@ -44,7 +44,10 @@ export function getAttestationInfoFromPayload(
   payload: ConsensusPayload,
   attestations: CommitteeAttestation[],
 ): AttestationInfo[] {
-  const hashedPayload = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
+  const hashedPayload = getHashedSignaturePayloadEthSignedMessage(
+    payload,
+    SignatureDomainSeparator.checkpointAttestation,
+  );
 
   return attestations.map(attestation => {
     // If signature is empty, check if we have an address directly

package/src/block/l2_block.ts

@@ -151,13 +151,13 @@ export class L2Block {
     return this.header.toBlockHeader();
   }
 
-  public toL2Block() {
+  public toL2Block(args: { checkpointNumber?: CheckpointNumber; indexWithinCheckpoint?: number } = {}): L2BlockNew {
     return new L2BlockNew(
       this.archive,
       this.getBlockHeader(),
       this.body,
-      CheckpointNumber.fromBlockNumber(this.number),
-      0, // indexWithinCheckpoint
+      args?.checkpointNumber ?? CheckpointNumber.fromBlockNumber(this.number),
+      args?.indexWithinCheckpoint ?? 0,
     );
   }
 

package/src/block/l2_block_new.ts

@@ -11,9 +11,13 @@ import { BlockHeader } from '../tx/block_header.js';
 import { Body } from './body.js';
 import type { L2BlockInfo } from './l2_block_info.js';
 
+// TODO(palla/mbps): Delete the existing `L2Block` class and rename this to `L2Block`.
+// TODO(palla/mbps): Consider moving the checkpointNumber and indexWithinCheckpoint to the header:
+// if the blockNumber is there, why not these as well? Consider whether they should be part of the
+// circuits structs though.
+
 /**
  * An L2 block with a header and a body.
- * TODO: Delete the existing `L2Block` class and rename this to `L2Block`.
  */
 export class L2BlockNew {
   constructor(

package/src/block/l2_block_source.ts

@@ -2,6 +2,7 @@ import {
   BlockNumber,
   BlockNumberSchema,
   CheckpointNumber,
+  CheckpointNumberSchema,
   type EpochNumber,
   type SlotNumber,
 } from '@aztec/foundation/branded-types';
@@ -14,6 +15,7 @@ import { z } from 'zod';
 import type { Checkpoint } from '../checkpoint/checkpoint.js';
 import type { PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
 import type { L1RollupConstants } from '../epoch-helpers/index.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
 import type { BlockHeader } from '../tx/block_header.js';
 import type { IndexedTxEffect } from '../tx/indexed_tx_effect.js';
 import type { TxHash } from '../tx/tx_hash.js';
@@ -21,7 +23,7 @@ import type { TxReceipt } from '../tx/tx_receipt.js';
 import { type CheckpointedL2Block, PublishedL2Block } from './checkpointed_l2_block.js';
 import type { L2Block } from './l2_block.js';
 import type { L2BlockNew } from './l2_block_new.js';
-import type { ValidateBlockNegativeResult, ValidateBlockResult } from './validate_block_result.js';
+import type { ValidateCheckpointNegativeResult, ValidateCheckpointResult } from './validate_block_result.js';
 
 /**
  * Interface of classes allowing for the retrieval of L2 blocks.
@@ -66,6 +68,8 @@ export interface L2BlockSource {
    */
   getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined>;
 
+  getCheckpointedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<CheckpointedL2Block[]>;
+
   /**
    * Retrieves a collection of published checkpoints
    * @param checkpointNumber The first checkpoint to be retrieved
@@ -161,10 +165,10 @@ export interface L2BlockSource {
   isPendingChainInvalid(): Promise<boolean>;
 
   /**
-   * Returns the status of the pending chain validation. If the chain is invalid, reports the earliest consecutive block
-   * that is invalid, along with the reason for being invalid, which can be used to trigger an invalidation.
+   * Returns the status of the pending chain validation. If the chain is invalid, reports the earliest consecutive
+   * checkpoint that is invalid, along with the reason for being invalid, which can be used to trigger an invalidation.
    */
-  getPendingChainValidationStatus(): Promise<ValidateBlockResult>;
+  getPendingChainValidationStatus(): Promise<ValidateCheckpointResult>;
 
   /** Force a sync. */
   syncImmediate(): Promise<void>;
@@ -179,6 +183,10 @@ export interface L2BlockSource {
    */
   getBlock(number: BlockNumber): Promise<L2Block | undefined>;
 
+  getL2BlockNew(number: BlockNumber): Promise<L2BlockNew | undefined>;
+
+  getL2BlocksNew(from: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]>;
+
   /**
    * Returns all blocks for a given epoch.
    * @dev Use this method only with recent epochs, since it walks the block list backwards.
@@ -232,24 +240,44 @@ export interface L2BlockSink {
 export type ArchiverEmitter = TypedEventEmitter<{
   [L2BlockSourceEvents.L2PruneDetected]: (args: L2BlockPruneEvent) => void;
   [L2BlockSourceEvents.L2BlockProven]: (args: L2BlockProvenEvent) => void;
-  [L2BlockSourceEvents.InvalidAttestationsBlockDetected]: (args: InvalidBlockDetectedEvent) => void;
+  [L2BlockSourceEvents.InvalidAttestationsCheckpointDetected]: (args: InvalidCheckpointDetectedEvent) => void;
+  [L2BlockSourceEvents.L2BlocksCheckpointed]: (args: L2CheckpointEvent) => void;
 }>;
 export interface L2BlockSourceEventEmitter extends L2BlockSource, ArchiverEmitter {}
 
 /**
  * Identifier for L2 block tags.
- * - latest: Latest block pushed to L1.
+ * - proposed: Latest block proposed on L2.
+ * - checkpointed: Checkpointed block on L1.
  * - proven: Proven block on L1.
  * - finalized: Proven block on a finalized L1 block (not implemented, set to proven for now).
  */
-export type L2BlockTag = 'latest' | 'proven' | 'finalized';
+export type L2BlockTag = 'proposed' | 'checkpointed' | 'proven' | 'finalized';
+
+/**
+ * Reason for L2 block prune.
+ * - uncheckpointed: L2 blocks were pruned due to a failure to checkpoint.
+ * - unproven: L2 blocks were pruned due to a failure to prove.
+ */
+export type L2BlockPruneReason = 'uncheckpointed' | 'unproven';
 
 /** Tips of the L2 chain. */
-export type L2Tips = Record<L2BlockTag, L2BlockId>;
+export type L2Tips = {
+  proposed: L2BlockId;
+  checkpointed: L2TipId;
+  proven: L2TipId;
+  finalized: L2TipId;
+};
+
+export const GENESIS_CHECKPOINT_HEADER_HASH = CheckpointHeader.empty().hash();
 
 /** Identifies a block by number and hash. */
 export type L2BlockId = { number: BlockNumber; hash: string };
 
+export type CheckpointId = { number: CheckpointNumber; hash: string };
+
+export type L2TipId = { block: L2BlockId; checkpoint: CheckpointId };
+
 /** Creates an L2 block id */
 export function makeL2BlockId(number: BlockNumber, hash?: string): L2BlockId {
   if (number !== 0 && !hash) {
@@ -258,21 +286,38 @@ export function makeL2BlockId(number: BlockNumber, hash?: string): L2BlockId {
   return { number, hash: hash! };
 }
 
+/** Creates an L2 checkpoint id */
+export function makeL2CheckpointId(number: CheckpointNumber, hash: string): CheckpointId {
+  return { number, hash };
+}
+
 const L2BlockIdSchema = z.object({
   number: BlockNumberSchema,
   hash: z.string(),
 });
 
+const L2CheckpointIdSchema = z.object({
+  number: CheckpointNumberSchema,
+  hash: z.string(),
+});
+
+const L2TipIdSchema = z.object({
+  block: L2BlockIdSchema,
+  checkpoint: L2CheckpointIdSchema,
+});
+
 export const L2TipsSchema = z.object({
-  latest: L2BlockIdSchema,
-  proven: L2BlockIdSchema,
-  finalized: L2BlockIdSchema,
+  proposed: L2BlockIdSchema,
+  checkpointed: L2TipIdSchema,
+  proven: L2TipIdSchema,
+  finalized: L2TipIdSchema,
 });
 
 export enum L2BlockSourceEvents {
   L2PruneDetected = 'l2PruneDetected',
   L2BlockProven = 'l2BlockProven',
-  InvalidAttestationsBlockDetected = 'invalidBlockDetected',
+  L2BlocksCheckpointed = 'l2BlocksCheckpointed',
+  InvalidAttestationsCheckpointDetected = 'invalidCheckpointDetected',
 }
 
 export type L2BlockProvenEvent = {
@@ -285,10 +330,15 @@ export type L2BlockProvenEvent = {
 export type L2BlockPruneEvent = {
   type: 'l2PruneDetected';
   epochNumber: EpochNumber;
-  blocks: L2Block[];
+  blocks: L2BlockNew[];
+};
+
+export type L2CheckpointEvent = {
+  type: 'l2BlocksCheckpointed';
+  checkpoint: PublishedCheckpoint;
 };
 
-export type InvalidBlockDetectedEvent = {
-  type: 'invalidBlockDetected';
-  validationResult: ValidateBlockNegativeResult;
+export type InvalidCheckpointDetectedEvent = {
+  type: 'invalidCheckpointDetected';
+  validationResult: ValidateCheckpointNegativeResult;
 };

package/src/block/l2_block_stream/index.ts

@@ -1,3 +1,4 @@
 export * from './interfaces.js';
 export * from './l2_block_stream.js';
 export * from './l2_tips_memory_store.js';
+export * from './l2_tips_store_base.js';

package/src/block/l2_block_stream/interfaces.ts

@@ -1,5 +1,6 @@
-import type { PublishedL2Block } from '../checkpointed_l2_block.js';
-import type { L2BlockId, L2Tips } from '../l2_block_source.js';
+import type { PublishedCheckpoint } from '../../checkpoint/published_checkpoint.js';
+import type { L2BlockNew } from '../l2_block_new.js';
+import type { CheckpointId, L2BlockId, L2BlockPruneReason, L2Tips } from '../l2_block_source.js';
 
 /** Interface to the local view of the chain. Implemented by world-state and l2-tips-store. */
 export interface L2BlockStreamLocalDataProvider {
@@ -15,11 +16,22 @@ export interface L2BlockStreamEventHandler {
 export type L2BlockStreamEvent =
   | /** Emits blocks added to the chain. */ {
       type: 'blocks-added';
-      blocks: PublishedL2Block[];
+      blocks: L2BlockNew[];
     }
-  | /** Reports last correct block (new tip of the unproven chain). */ {
+  | /** Emits checkpoints published to L1. */ {
+      type: 'chain-checkpointed';
+      checkpoint: PublishedCheckpoint;
+      block: L2BlockId;
+    }
+  | /**
+   * Reports last correct block (new tip of the proposed chain). Note that this is not necessarily the anchor block
+   * that will be used in the transaction - if the chain has already moved past the reorg, we'll also see blocks-added
+   * events that will push the anchor block forward.
+   */ {
       type: 'chain-pruned';
+      reason: L2BlockPruneReason;
       block: L2BlockId;
+      checkpoint: CheckpointId;
     }
   | /** Reports new proven block. */ {
       type: 'chain-proven';

package/src/block/l2_block_stream/l2_block_stream.ts

@@ -1,9 +1,10 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import { AbortError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 
-import { type L2BlockId, type L2BlockSource, makeL2BlockId } from '../l2_block_source.js';
+import type { PublishedCheckpoint } from '../../checkpoint/published_checkpoint.js';
+import { type L2BlockId, type L2BlockPruneReason, type L2BlockSource, makeL2BlockId } from '../l2_block_source.js';
 import type { L2BlockStreamEvent, L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider } from './interfaces.js';
 
 /** Creates a stream of events for new blocks, chain tips updates, and reorgs, out of polling an archiver or a node. */
@@ -13,7 +14,10 @@ export class L2BlockStream {
   private hasStarted = false;
 
   constructor(
-    private l2BlockSource: Pick<L2BlockSource, 'getPublishedBlocks' | 'getBlockHeader' | 'getL2Tips'>,
+    private l2BlockSource: Pick<
+      L2BlockSource,
+      'getL2BlocksNew' | 'getBlockHeader' | 'getL2Tips' | 'getPublishedCheckpoints' | 'getCheckpointedBlocks'
+    >,
     private localData: L2BlockStreamLocalDataProvider,
     private handler: L2BlockStreamEventHandler,
     private readonly log = createLogger('types:block_stream'),
@@ -24,6 +28,8 @@ export class L2BlockStream {
       startingBlock?: number;
       /** Instead of downloading all blocks, only fetch the smallest subset that results in reliable reorg detection. */
       skipFinalized?: boolean;
+      /** When true, checkpoint events will not be emitted. Blocks are still fetched via checkpoints but only blocks-added events are emitted. */
+      ignoreCheckpoints?: boolean;
     } = {},
   ) {
     // Note that RunningPromise is in stopped state by default. This promise won't run until someone invokes `start`,
@@ -61,36 +67,38 @@ export class L2BlockStream {
     try {
       const sourceTips = await this.l2BlockSource.getL2Tips();
       const localTips = await this.localData.getL2Tips();
-      this.log.trace(`Running L2 block stream`, {
-        sourceLatest: sourceTips.latest.number,
-        localLatest: localTips.latest.number,
-        sourceFinalized: sourceTips.finalized.number,
-        localFinalized: localTips.finalized.number,
-        sourceProven: sourceTips.proven.number,
-        localProven: localTips.proven.number,
-        sourceLatestHash: sourceTips.latest.hash,
-        localLatestHash: localTips.latest.hash,
-        sourceProvenHash: sourceTips.proven.hash,
-        localProvenHash: localTips.proven.hash,
-        sourceFinalizedHash: sourceTips.finalized.hash,
-        localFinalizedHash: localTips.finalized.hash,
-      });
+      this.log.trace(`Running L2 block stream`, { sourceTips, localTips });
 
       // Check if there was a reorg and emit a chain-pruned event if so.
-      let latestBlockNumber = localTips.latest.number;
-      const sourceCache = new BlockHashCache([sourceTips.latest]);
+      let latestBlockNumber = localTips.proposed.number;
+      const sourceCache = new BlockHashCache([sourceTips.proposed]);
       while (!(await this.areBlockHashesEqualAt(latestBlockNumber, { sourceCache }))) {
         latestBlockNumber--;
       }
 
-      if (latestBlockNumber < localTips.latest.number) {
-        latestBlockNumber = BlockNumber(Math.min(latestBlockNumber, sourceTips.latest.number)); // see #13471
+      if (latestBlockNumber < localTips.proposed.number) {
+        latestBlockNumber = BlockNumber(Math.min(latestBlockNumber, sourceTips.proposed.number)); // see #13471
         const hash = sourceCache.get(latestBlockNumber) ?? (await this.getBlockHashFromSource(latestBlockNumber));
         if (latestBlockNumber !== 0 && !hash) {
           throw new Error(`Block hash not found in block source for block number ${latestBlockNumber}`);
         }
-        this.log.verbose(`Reorg detected. Pruning blocks from ${latestBlockNumber + 1} to ${localTips.latest.number}.`);
-        await this.emitEvent({ type: 'chain-pruned', block: makeL2BlockId(latestBlockNumber, hash) });
+        this.log.verbose(
+          `Reorg detected. Pruning blocks from ${latestBlockNumber + 1} to ${localTips.proposed.number}.`,
+        );
+        // This check is not 100% accurate
+        // If the local tips are sufficiently behind the source tips, such that we are missing at least one checkpoint
+        // that has now been re-orged due to a proof failure then this will indicate a failure to checkpoint rather than a failure to prove
+        // TODO: (mbps/PhilWindle): Improve re-org detection accuracy when we come to do re-orgs
+        let reason: L2BlockPruneReason = 'unproven';
+        if (latestBlockNumber === localTips.checkpointed.block.number && !this.opts.ignoreCheckpoints) {
+          reason = 'uncheckpointed';
+        }
+        await this.emitEvent({
+          type: 'chain-pruned',
+          block: makeL2BlockId(latestBlockNumber, hash),
+          reason,
+          checkpoint: sourceTips.checkpointed.checkpoint,
+        });
       }
 
       // If we are just starting, use the starting block number from the options.
@@ -105,40 +113,115 @@ export class L2BlockStream {
       }
 
       let nextBlockNumber = latestBlockNumber + 1;
+      let nextCheckpointToEmit = CheckpointNumber(localTips.checkpointed.checkpoint.number + 1);
       if (this.opts.skipFinalized) {
         // When skipping finalized blocks we need to provide reliable reorg detection while fetching as few blocks as
         // possible. Finalized blocks cannot be reorged by definition, so we can skip most of them. We do need the very
         // last finalized block however in order to guarantee that we will eventually find a block in which our local
         // store matches the source.
         // If the last finalized block is behind our local tip, there is nothing to skip.
-        nextBlockNumber = Math.max(sourceTips.finalized.number, nextBlockNumber);
+        nextBlockNumber = Math.max(sourceTips.finalized.block.number, nextBlockNumber);
+        // If the next checkpoint to emit is behind the finalized tip then skip forward
+        nextCheckpointToEmit = CheckpointNumber(Math.max(nextCheckpointToEmit, sourceTips.finalized.checkpoint.number));
       }
 
-      // Request new blocks from the source.
-      while (nextBlockNumber <= sourceTips.latest.number) {
-        const limit = Math.min(this.opts.batchSize ?? 50, sourceTips.latest.number - nextBlockNumber + 1);
+      // Loop 1: Emit checkpoint events for checkpoints whose blocks are already in local storage.
+      // This handles the case where blocks were synced as uncheckpointed and later became checkpointed.
+      // The guard `lastBlockInCheckpoint.number > localTips.proposed.number` ensures we don't emit
+      // checkpoints for blocks we don't have (e.g., when startingBlock skips earlier blocks).
+      // Since only one checkpoint can ever be uncheckpointed, this loop should iterate at most once.
+      if (!this.opts.ignoreCheckpoints) {
+        let loop1Iterations = 0;
+        while (nextCheckpointToEmit <= sourceTips.checkpointed.checkpoint.number) {
+          const checkpoints = await this.l2BlockSource.getPublishedCheckpoints(nextCheckpointToEmit, 1);
+          if (checkpoints.length === 0) {
+            break;
+          }
+          const lastBlockInCheckpoint = checkpoints[0].checkpoint.blocks.at(-1)!;
+          // If this checkpoint has blocks we haven't seen yet, stop - they need to be fetched first
+          if (lastBlockInCheckpoint.number > localTips.proposed.number) {
+            break;
+          }
+          loop1Iterations++;
+          if (loop1Iterations > 1) {
+            this.log.warn(
+              `Emitting multiple checkpoints (${loop1Iterations}) for already-local blocks. ` +
+                `Next checkpoint: ${nextCheckpointToEmit}, source checkpointed: ${sourceTips.checkpointed.checkpoint.number}`,
+            );
+          }
+          const lastBlockHash = await lastBlockInCheckpoint.hash();
+          await this.emitEvent({
+            type: 'chain-checkpointed',
+            checkpoint: checkpoints[0],
+            block: makeL2BlockId(lastBlockInCheckpoint.number, lastBlockHash.toString()),
+          });
+          nextCheckpointToEmit = CheckpointNumber(nextCheckpointToEmit + 1);
+        }
+      }
+
+      // Loop 2: Fetch new checkpointed blocks. For each block, get its checkpoint, emit all blocks
+      // from that checkpoint that we need, then emit the checkpoint event.
+      // We cache the current checkpoint to avoid redundant fetches when batchSize < checkpoint size.
+      let checkpoint: PublishedCheckpoint | undefined;
+      while (nextBlockNumber <= sourceTips.checkpointed.block.number) {
+        const limit = Math.min(this.opts.batchSize ?? 50, sourceTips.checkpointed.block.number - nextBlockNumber + 1);
+
+        // Check if we need to fetch a new checkpoint (nextBlockNumber is beyond the cached one)
+        if (!checkpoint || nextBlockNumber > checkpoint.checkpoint.blocks.at(-1)!.number) {
+          const blocks = await this.l2BlockSource.getCheckpointedBlocks(BlockNumber(nextBlockNumber), 1);
+          if (blocks.length === 0) {
+            break;
+          }
+          const checkpoints = await this.l2BlockSource.getPublishedCheckpoints(blocks[0].checkpointNumber, 1);
+          if (checkpoints.length === 0) {
+            break;
+          }
+          checkpoint = checkpoints[0];
+        }
+
+        // Get all blocks from this checkpoint that we need, respecting batchSize
+        const blocksForCheckpoint = checkpoint.checkpoint.blocks
+          .filter(b => b.number >= nextBlockNumber)
+          .slice(0, limit);
+        if (blocksForCheckpoint.length === 0) {
+          break;
+        }
+        await this.emitEvent({ type: 'blocks-added', blocks: blocksForCheckpoint });
+        nextBlockNumber = blocksForCheckpoint.at(-1)!.number + 1;
+
+        // If we've reached the end of this checkpoint, emit the checkpoint event
+        const lastBlockInCheckpoint = checkpoint.checkpoint.blocks.at(-1)!;
+        if (!this.opts.ignoreCheckpoints && nextBlockNumber > lastBlockInCheckpoint.number) {
+          const lastBlockHash = await lastBlockInCheckpoint.hash();
+          await this.emitEvent({
+            type: 'chain-checkpointed',
+            checkpoint,
+            block: makeL2BlockId(lastBlockInCheckpoint.number, lastBlockHash.toString()),
+          });
+        }
+      }
+
+      // Loop 3: Fetch any remaining uncheckpointed (proposed) blocks.
+      while (nextBlockNumber <= sourceTips.proposed.number) {
+        const limit = Math.min(this.opts.batchSize ?? 50, sourceTips.proposed.number - nextBlockNumber + 1);
         this.log.trace(`Requesting blocks from ${nextBlockNumber} limit ${limit} proven=${this.opts.proven}`);
-        const blocks = await this.l2BlockSource.getPublishedBlocks(
-          BlockNumber(nextBlockNumber),
-          limit,
-          this.opts.proven,
-        );
+        const blocks = await this.l2BlockSource.getL2BlocksNew(BlockNumber(nextBlockNumber), limit, this.opts.proven);
         if (blocks.length === 0) {
           break;
         }
         await this.emitEvent({ type: 'blocks-added', blocks });
-        nextBlockNumber = blocks.at(-1)!.block.number + 1;
+        nextBlockNumber = blocks.at(-1)!.number + 1;
       }
 
       // Update the proven and finalized tips.
-      if (localTips.proven !== undefined && sourceTips.proven.number !== localTips.proven.number) {
+      if (localTips.proven !== undefined && sourceTips.proven.block.number !== localTips.proven.block.number) {
         await this.emitEvent({
           type: 'chain-proven',
-          block: sourceTips.proven,
+          block: sourceTips.proven.block,
         });
       }
-      if (localTips.finalized !== undefined && sourceTips.finalized.number !== localTips.finalized.number) {
-        await this.emitEvent({ type: 'chain-finalized', block: sourceTips.finalized });
+      if (localTips.finalized !== undefined && sourceTips.finalized.block.number !== localTips.finalized.block.number) {
+        await this.emitEvent({ type: 'chain-finalized', block: sourceTips.finalized.block });
       }
     } catch (err: any) {
       if (err.name === 'AbortError') {
@@ -186,7 +269,7 @@ export class L2BlockStream {
 
   private async emitEvent(event: L2BlockStreamEvent) {
     this.log.debug(
-      `Emitting ${event.type} (${event.type === 'blocks-added' ? event.blocks.length : event.block.number})`,
+      `Emitting ${event.type} (${event.type === 'blocks-added' ? event.blocks.length : event.type === 'chain-checkpointed' ? event.checkpoint.checkpoint.number : event.block.number})`,
     );
     await this.handler.handleBlockStreamEvent(event);
     if (!this.isRunning() && !this.isSyncing) {