@aztec/stdlib 0.0.1-commit.3469e52 → 0.0.1-commit.3895657bc

package/src/block/block_data.ts

@@ -0,0 +1,26 @@
+import { CheckpointNumberSchema, IndexWithinCheckpointSchema } from '@aztec/foundation/branded-types';
+import type { CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { schemas } from '@aztec/foundation/schemas';
+
+import { z } from 'zod';
+
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { BlockHeader } from '../tx/block_header.js';
+
+/** L2Block metadata. Equivalent to L2Block but without block body containing tx data. */
+export type BlockData = {
+  header: BlockHeader;
+  archive: AppendOnlyTreeSnapshot;
+  blockHash: Fr;
+  checkpointNumber: CheckpointNumber;
+  indexWithinCheckpoint: IndexWithinCheckpoint;
+};
+
+export const BlockDataSchema = z.object({
+  header: BlockHeader.schema,
+  archive: AppendOnlyTreeSnapshot.schema,
+  blockHash: schemas.Fr,
+  checkpointNumber: CheckpointNumberSchema,
+  indexWithinCheckpoint: IndexWithinCheckpointSchema,
+});

package/src/block/block_hash.ts

@@ -1,66 +1,45 @@
-import { Buffer32 } from '@aztec/foundation/buffer';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { BufferReader } from '@aztec/foundation/serialize';
+import type { ZodFor } from '@aztec/foundation/schemas';
 
-import { schemas } from '../schemas/schemas.js';
+import { inspect } from 'util';
 
-/** Hash of an L2 block. */
-export class L2BlockHash extends Buffer32 {
-  constructor(
-    /** The buffer containing the hash. */
-    hash: Buffer,
-  ) {
-    super(hash);
-  }
+import { hexSchemaFor } from '../schemas/schemas.js';
 
-  /**
-   * Type guard that checks if a value is an L2BlockHash instance.
-   * Uses duck typing to handle cases where instanceof fails due to module duplication.
-   * Checks for Buffer32-like structure with a 32-byte buffer.
-   */
-  static isL2BlockHash(value: unknown): value is L2BlockHash {
-    if (value instanceof L2BlockHash) {
-      return true;
-    }
-    // Duck typing fallback: check if it looks like a Buffer32 with a 32-byte buffer
-    // This helps when instanceof fails due to module duplication
-    return (
-      typeof value === 'object' &&
-      value !== null &&
-      'buffer' in value &&
-      Buffer.isBuffer((value as Buffer32).buffer) &&
-      (value as Buffer32).buffer.length === 32 &&
-      'toBuffer' in value &&
-      typeof (value as Buffer32).toBuffer === 'function'
-    );
-  }
+const BLOCK_HASH_BRAND = Symbol.for('aztec.BlockHash');
 
-  static override random() {
-    return new L2BlockHash(Fr.random().toBuffer());
+/** Hash of an L2 block. */
+export class BlockHash extends Fr {
+  readonly [BLOCK_HASH_BRAND] = true as const;
+
+  constructor(hash: Fr) {
+    super(hash);
   }
 
-  static override fromNumber(num: number): L2BlockHash {
-    return new L2BlockHash(super.fromNumber(num).toBuffer());
+  override [inspect.custom]() {
+    return `BlockHash<${this.toString()}>`;
   }
 
-  static override fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new L2BlockHash(reader.readBytes(L2BlockHash.SIZE));
+  toFr(): Fr {
+    return new Fr(this.toBigInt());
   }
 
-  static override fromString(str: string): Buffer32 {
-    return new L2BlockHash(super.fromString(str).toBuffer());
+  /**
+   * Type guard that checks if a value is a BlockHash instance.
+   * Uses Symbol.for to ensure cross-module compatibility.
+   */
+  static isBlockHash(value: unknown): value is BlockHash {
+    return typeof value === 'object' && value !== null && BLOCK_HASH_BRAND in value;
   }
 
-  static get schema() {
-    return schemas.BufferHex.transform(value => new L2BlockHash(value));
+  static override random() {
+    return new BlockHash(Fr.random());
   }
 
-  static zero() {
-    return new L2BlockHash(Buffer32.ZERO.toBuffer());
+  static override fromString(str: string): BlockHash {
+    return new BlockHash(Fr.fromString(str));
   }
 
-  static override fromField(hash: Fr) {
-    return new L2BlockHash(hash.toBuffer());
+  static override get schema() {
+    return hexSchemaFor(BlockHash) as ZodFor<BlockHash>;
   }
 }

package/src/block/block_parameter.ts

@@ -2,9 +2,9 @@ import { BlockNumberSchema } from '@aztec/foundation/branded-types';
 
 import { z } from 'zod';
 
-import { L2BlockHash } from './block_hash.js';
+import { BlockHash } from './block_hash.js';
 
-export const BlockParameterSchema = z.union([L2BlockHash.schema, BlockNumberSchema, z.literal('latest')]);
+export const BlockParameterSchema = z.union([BlockHash.schema, BlockNumberSchema, z.literal('latest')]);
 
-/** Block parameter - either a specific BlockNumber, block hash (L2BlockHash), or 'latest' */
+/** Block parameter - either a specific BlockNumber, block hash (BlockHash), or 'latest' */
 export type BlockParameter = z.infer<typeof BlockParameterSchema>;

package/src/block/checkpointed_l2_block.ts

@@ -7,7 +7,7 @@ import { z } from 'zod';
 
 import { L1PublishedData } from '../checkpoint/published_checkpoint.js';
 import { MAX_BLOCK_HASH_STRING_LENGTH, MAX_COMMITTEE_SIZE } from '../deserialization/index.js';
-import { L2BlockNew } from './l2_block_new.js';
+import { L2Block } from './l2_block.js';
 import { CommitteeAttestation } from './proposal/committee_attestation.js';
 
 /**
@@ -16,7 +16,7 @@ import { CommitteeAttestation } from './proposal/committee_attestation.js';
 export class CheckpointedL2Block {
   constructor(
     public checkpointNumber: CheckpointNumber,
-    public block: L2BlockNew,
+    public block: L2Block,
     public l1: L1PublishedData,
     public attestations: CommitteeAttestation[],
   ) {}
@@ -24,7 +24,7 @@ export class CheckpointedL2Block {
     return z
       .object({
         checkpointNumber: CheckpointNumberSchema,
-        block: L2BlockNew.schema,
+        block: L2Block.schema,
         l1: L1PublishedData.schema,
         attestations: z.array(CommitteeAttestation.schema),
       })
@@ -34,7 +34,7 @@ export class CheckpointedL2Block {
   static fromBuffer(bufferOrReader: Buffer | BufferReader): CheckpointedL2Block {
     const reader = BufferReader.asReader(bufferOrReader);
     const checkpointNumber = reader.readNumber();
-    const block = reader.readObject(L2BlockNew);
+    const block = reader.readObject(L2Block);
     const l1BlockNumber = reader.readBigInt();
     const l1BlockHash = reader.readString(MAX_BLOCK_HASH_STRING_LENGTH);
     const l1Timestamp = reader.readBigInt();

package/src/block/in_block.ts

@@ -2,12 +2,12 @@ import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types'
 
 import { type ZodTypeAny, z } from 'zod';
 
-import { L2BlockHash } from './block_hash.js';
-import type { L2BlockNew } from './l2_block_new.js';
+import { BlockHash } from './block_hash.js';
+import type { L2Block } from './l2_block.js';
 
 export type InBlock = {
   l2BlockNumber: BlockNumber;
-  l2BlockHash: L2BlockHash;
+  l2BlockHash: BlockHash;
 };
 
 // Note: If you expand this type with indexInBlock, then delete `IndexedTxEffect` and use this type instead.
@@ -17,8 +17,8 @@ export type DataInBlock<T> = {
 
 export function randomInBlock(): InBlock {
   return {
-    l2BlockNumber: BlockNumber(Math.floor(Math.random() * 1000)),
-    l2BlockHash: L2BlockHash.random(),
+    l2BlockNumber: BlockNumber(Math.floor(Math.random() * 1000) + 1),
+    l2BlockHash: BlockHash.random(),
   };
 }
 
@@ -29,18 +29,18 @@ export function randomDataInBlock<T>(data: T): DataInBlock<T> {
   };
 }
 
-export async function wrapDataInBlock<T>(data: T, block: L2BlockNew): Promise<DataInBlock<T>> {
+export async function wrapDataInBlock<T>(data: T, block: L2Block): Promise<DataInBlock<T>> {
   return {
     data,
     l2BlockNumber: block.number,
-    l2BlockHash: L2BlockHash.fromField(await block.hash()),
+    l2BlockHash: await block.hash(),
   };
 }
 
 export function inBlockSchema() {
   return z.object({
     l2BlockNumber: BlockNumberSchema,
-    l2BlockHash: L2BlockHash.schema,
+    l2BlockHash: BlockHash.schema,
   });
 }
 

package/src/block/index.ts

@@ -1,4 +1,5 @@
-export * from './l2_block_new.js';
+export * from './block_data.js';
+export * from './l2_block.js';
 export * from './l2_block_stream/index.js';
 export * from './in_block.js';
 export * from './body.js';

package/src/block/{l2_block_new.ts → l2_block.ts}

@@ -1,4 +1,5 @@
 import { type BlockBlobData, encodeBlockBlobData } from '@aztec/blob-lib/encoding';
+import { DA_GAS_PER_FIELD } from '@aztec/constants';
 import {
   BlockNumber,
   CheckpointNumber,
@@ -15,18 +16,14 @@ import { z } from 'zod';
 import type { PrivateLog } from '../logs/private_log.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { BlockHeader } from '../tx/block_header.js';
+import type { BlockHash } from './block_hash.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.
  */
-export class L2BlockNew {
+export class L2Block {
   constructor(
     /** Snapshot of archive tree after the block is applied. */
     public archive: AppendOnlyTreeSnapshot,
@@ -63,7 +60,7 @@ export class L2BlockNew {
       })
       .transform(
         ({ archive, header, body, checkpointNumber, indexWithinCheckpoint }) =>
-          new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint),
+          new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint),
       );
   }
 
@@ -79,7 +76,7 @@ export class L2BlockNew {
     const checkpointNumber = CheckpointNumber(reader.readNumber());
     const indexWithinCheckpoint = IndexWithinCheckpoint(reader.readNumber());
 
-    return new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint);
+    return new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint);
   }
 
   /**
@@ -94,7 +91,7 @@ export class L2BlockNew {
    * Returns the block's hash (hash of block header).
    * @returns The block's hash.
    */
-  public hash(): Promise<Fr> {
+  public hash(): Promise<BlockHash> {
     return this.header.hash();
   }
 
@@ -143,7 +140,7 @@ export class L2BlockNew {
   }
 
   static empty(header?: BlockHeader) {
-    return new L2BlockNew(
+    return new L2Block(
       AppendOnlyTreeSnapshot.empty(),
       header ?? BlockHeader.empty(),
       Body.empty(),
@@ -177,11 +174,11 @@ export class L2BlockNew {
       txOptions?: Partial<Parameters<typeof Body.random>[0]>;
       makeTxOptions?: (txIndex: number) => Partial<Parameters<typeof Body.random>[0]>;
     } & Partial<Parameters<typeof BlockHeader.random>[0]> = {},
-  ): Promise<L2BlockNew> {
+  ): Promise<L2Block> {
     const archive = new AppendOnlyTreeSnapshot(Fr.random(), blockNumber + 1);
-    const header = BlockHeader.random({ blockNumber, ...blockHeaderOverrides });
+    const header = BlockHeader.random({ ...blockHeaderOverrides, blockNumber });
     const body = await Body.random({ txsPerBlock, makeTxOptions, ...txOptions });
-    return new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint);
+    return new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint);
   }
 
   /**
@@ -225,4 +222,15 @@ export class L2BlockNew {
       timestamp: this.header.globalVariables.timestamp,
     };
   }
+
+  /**
+   * Compute how much DA gas this block uses.
+   *
+   * @remarks This assumes DA gas is computed solely based on the number of blob fields in transactions.
+   * This may change in the future, but we cannot access the actual DA gas used in a block since it's not exposed
+   * in the L2BlockHeader, so we have to rely on recomputing it.
+   */
+  computeDAGasUsed(): number {
+    return this.body.txEffects.reduce((total, txEffect) => total + txEffect.getNumBlobFields(), 0) * DA_GAS_PER_FIELD;
+  }
 }

package/src/block/l2_block_source.ts

@@ -13,6 +13,7 @@ import type { TypedEventEmitter } from '@aztec/foundation/types';
 import { z } from 'zod';
 
 import type { Checkpoint } from '../checkpoint/checkpoint.js';
+import type { CheckpointData } from '../checkpoint/checkpoint_data.js';
 import type { PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
 import type { L1RollupConstants } from '../epoch-helpers/index.js';
 import { CheckpointHeader } from '../rollup/checkpoint_header.js';
@@ -20,8 +21,10 @@ 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';
 import type { TxReceipt } from '../tx/tx_receipt.js';
+import type { BlockData } from './block_data.js';
+import type { BlockHash } from './block_hash.js';
 import type { CheckpointedL2Block } from './checkpointed_l2_block.js';
-import type { L2BlockNew } from './l2_block_new.js';
+import type { L2Block } from './l2_block.js';
 import type { ValidateCheckpointNegativeResult, ValidateCheckpointResult } from './validate_block_result.js';
 
 /**
@@ -46,12 +49,32 @@ export interface L2BlockSource {
    */
   getBlockNumber(): Promise<BlockNumber>;
 
+  /**
+   * Gets the number of the latest L2 checkpoint processed by the block source implementation.
+   * @returns The number of the latest L2 checkpoint processed by the block source implementation.
+   */
+  getCheckpointNumber(): Promise<CheckpointNumber>;
+
   /**
    * Gets the number of the latest L2 block proven seen by the block source implementation.
    * @returns The number of the latest L2 block proven seen by the block source implementation.
    */
   getProvenBlockNumber(): Promise<BlockNumber>;
 
+  /**
+   * Gets the number of the latest L2 block checkpointed seen by the block source implementation.
+   * @returns The number of the latest L2 block checkpointed seen by the block source implementation.
+   */
+  getCheckpointedL2BlockNumber(): Promise<BlockNumber>;
+
+  /**
+   * Computes the finalized block number based on the proven block number.
+   * A block is considered finalized when it's 2 epochs behind the proven block.
+   * TODO(#13569): Compute proper finalized block number based on L1 finalized block.
+   * @returns The finalized block number.
+   */
+  getFinalizedL2BlockNumber(): Promise<BlockNumber>;
+
   /**
    * Gets an l2 block header.
    * @param number - The block number to return or 'latest' for the most recent one.
@@ -67,15 +90,15 @@ export interface L2BlockSource {
    */
   getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined>;
 
-  getCheckpointedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<CheckpointedL2Block[]>;
+  getCheckpointedBlocks(from: BlockNumber, limit: number): Promise<CheckpointedL2Block[]>;
 
   /**
-   * Retrieves a collection of published checkpoints
-   * @param checkpointNumber The first checkpoint to be retrieved
-   * @param limit The number of checkpoints to be retrieved
-   * @returns The collection of complete checkpoints
+   * Retrieves a collection of checkpoints.
+   * @param checkpointNumber The first checkpoint to be retrieved.
+   * @param limit The number of checkpoints to be retrieved.
+   * @returns The collection of complete checkpoints.
    */
-  getPublishedCheckpoints(checkpointNumber: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]>;
+  getCheckpoints(checkpointNumber: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]>;
 
   /**
    * Gets the checkpoints for a given epoch
@@ -83,12 +106,18 @@ export interface L2BlockSource {
    */
   getCheckpointsForEpoch(epochNumber: EpochNumber): Promise<Checkpoint[]>;
 
+  /**
+   * Gets lightweight checkpoint metadata for a given epoch, without fetching full block data.
+   * @param epochNumber - Epoch for which we want checkpoint data
+   */
+  getCheckpointsDataForEpoch(epochNumber: EpochNumber): Promise<CheckpointData[]>;
+
   /**
    * Gets a block header by its hash.
    * @param blockHash - The block hash to retrieve.
    * @returns The requested block header (or undefined if not found).
    */
-  getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined>;
+  getBlockHeaderByHash(blockHash: BlockHash): Promise<BlockHeader | undefined>;
 
   /**
    * Gets a block header by its archive root.
@@ -97,26 +126,40 @@ export interface L2BlockSource {
    */
   getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined>;
 
+  /**
+   * Gets block metadata (without tx data) by block number.
+   * @param number - The block number to retrieve.
+   * @returns The requested block data (or undefined if not found).
+   */
+  getBlockData(number: BlockNumber): Promise<BlockData | undefined>;
+
+  /**
+   * Gets block metadata (without tx data) by archive root.
+   * @param archive - The archive root to retrieve.
+   * @returns The requested block data (or undefined if not found).
+   */
+  getBlockDataByArchive(archive: Fr): Promise<BlockData | undefined>;
+
   /**
    * Gets an L2 block by block number.
    * @param number - The block number to return.
    * @returns The requested L2 block (or undefined if not found).
    */
-  getL2BlockNew(number: BlockNumber): Promise<L2BlockNew | undefined>;
+  getL2Block(number: BlockNumber): Promise<L2Block | undefined>;
 
   /**
    * Gets an L2 block by its hash.
    * @param blockHash - The block hash to retrieve.
    * @returns The requested L2 block (or undefined if not found).
    */
-  getL2BlockNewByHash(blockHash: Fr): Promise<L2BlockNew | undefined>;
+  getL2BlockByHash(blockHash: BlockHash): Promise<L2Block | undefined>;
 
   /**
    * Gets an L2 block by its archive root.
    * @param archive - The archive root to retrieve.
    * @returns The requested L2 block (or undefined if not found).
    */
-  getL2BlockNewByArchive(archive: Fr): Promise<L2BlockNew | undefined>;
+  getL2BlockByArchive(archive: Fr): Promise<L2Block | undefined>;
 
   /**
    * Gets a tx effect.
@@ -143,11 +186,11 @@ export interface L2BlockSource {
   getL2EpochNumber(): Promise<EpochNumber | undefined>;
 
   /**
-   * Returns all block headers for a given epoch.
+   * Returns all checkpointed block headers for a given epoch.
    * @dev Use this method only with recent epochs, since it walks the block list backwards.
    * @param epochNumber - The epoch number to return headers for.
    */
-  getBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]>;
+  getCheckpointedBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]>;
 
   /**
    * Returns whether the given epoch is completed on L1, based on the current L1 and L2 block numbers.
@@ -193,49 +236,43 @@ export interface L2BlockSource {
    * @param number - The block number to return (inclusive).
    * @returns The requested L2 block.
    */
-  getBlock(number: BlockNumber): Promise<L2BlockNew | undefined>;
-
-  getL2BlocksNew(from: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]>;
+  getBlock(number: BlockNumber): Promise<L2Block | undefined>;
 
   /**
-   * Returns all blocks for a given epoch.
+   * Returns all checkpointed blocks for a given epoch.
    * @dev Use this method only with recent epochs, since it walks the block list backwards.
    * @param epochNumber - The epoch number to return blocks for.
    */
-  getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2BlockNew[]>;
+  getCheckpointedBlocksForEpoch(epochNumber: EpochNumber): Promise<CheckpointedL2Block[]>;
 
   /**
    * Returns all blocks for a given slot.
    * @dev Use this method only with recent slots, since it walks the block list backwards.
    * @param slotNumber - The slot number to return blocks for.
    */
-  getBlocksForSlot(slotNumber: SlotNumber): Promise<L2BlockNew[]>;
+  getBlocksForSlot(slotNumber: SlotNumber): Promise<L2Block[]>;
 
   /**
-   * Gets a published block by its block hash.
+   * Gets a checkpointed block by its block hash.
    * @param blockHash - The block hash to retrieve.
    * @returns The requested block (or undefined if not found).
    */
-  getPublishedBlockByHash(blockHash: Fr): Promise<CheckpointedL2Block | undefined>;
+  getCheckpointedBlockByHash(blockHash: BlockHash): Promise<CheckpointedL2Block | undefined>;
 
   /**
-   * Gets a published block by its archive root.
+   * Gets a checkpointed block by its archive root.
    * @param archive - The archive root to retrieve.
    * @returns The requested block (or undefined if not found).
    */
-  getPublishedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined>;
+  getCheckpointedBlockByArchive(archive: Fr): Promise<CheckpointedL2Block | undefined>;
 
   /**
    * Gets up to `limit` amount of L2 blocks starting from `from`.
    * @param from - Number of the first block to return (inclusive).
    * @param limit - The maximum number of blocks to return.
-   * @param proven - If true, only return blocks that have been proven.
    * @returns The requested L2 blocks.
    */
-  getBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]>;
-
-  /** Equivalent to getBlocks but includes publish data. */
-  getPublishedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<CheckpointedL2Block[]>;
+  getBlocks(from: BlockNumber, limit: number): Promise<L2Block[]>;
 }
 
 /**
@@ -247,7 +284,7 @@ export interface L2BlockSink {
    * @param block - The L2 block to add.
    * @throws If block number is not incremental (i.e., not exactly one more than the last stored block).
    */
-  addBlock(block: L2BlockNew): Promise<void>;
+  addBlock(block: L2Block): Promise<void>;
 }
 
 /**
@@ -344,13 +381,13 @@ export type L2BlockProvenEvent = {
 export type L2PruneUnprovenEvent = {
   type: 'l2PruneUnproven';
   epochNumber: EpochNumber;
-  blocks: L2BlockNew[];
+  blocks: L2Block[];
 };
 
 export type L2PruneUncheckpointedEvent = {
   type: 'l2PruneUncheckpointed';
   slotNumber: SlotNumber;
-  blocks: L2BlockNew[];
+  blocks: L2Block[];
 };
 
 export type L2CheckpointEvent = {

package/src/block/l2_block_stream/interfaces.ts

@@ -1,5 +1,5 @@
 import type { PublishedCheckpoint } from '../../checkpoint/published_checkpoint.js';
-import type { L2BlockNew } from '../l2_block_new.js';
+import type { L2Block } from '../l2_block.js';
 import type { CheckpointId, L2BlockId, L2Tips } from '../l2_block_source.js';
 
 /** Interface to the local view of the chain. Implemented by world-state and l2-tips-store. */
@@ -16,7 +16,7 @@ export interface L2BlockStreamEventHandler {
 export type L2BlockStreamEvent =
   | /** Emits blocks added to the chain. */ {
       type: 'blocks-added';
-      blocks: L2BlockNew[];
+      blocks: L2Block[];
     }
   | /** Emits checkpoints published to L1. */ {
       type: 'chain-checkpointed';

package/src/block/l2_block_stream/l2_block_stream.ts

@@ -19,13 +19,12 @@ export class L2BlockStream {
   constructor(
     private l2BlockSource: Pick<
       L2BlockSource,
-      'getL2BlocksNew' | 'getBlockHeader' | 'getL2Tips' | 'getPublishedCheckpoints' | 'getCheckpointedBlocks'
+      'getBlocks' | 'getBlockHeader' | 'getL2Tips' | 'getCheckpoints' | 'getCheckpointedBlocks'
     >,
     private localData: L2BlockStreamLocalDataProvider,
     private handler: L2BlockStreamEventHandler,
     private readonly log = createLogger('types:block_stream'),
     private opts: {
-      proven?: boolean;
       pollIntervalMS?: number;
       batchSize?: number;
       startingBlock?: number;
@@ -110,6 +109,27 @@ export class L2BlockStream {
 
       let nextBlockNumber = latestBlockNumber + 1;
       let nextCheckpointToEmit = CheckpointNumber(localTips.checkpointed.checkpoint.number + 1);
+
+      // When startingBlock is set, also skip ahead for checkpoints.
+      if (
+        this.opts.startingBlock !== undefined &&
+        this.opts.startingBlock >= 1 &&
+        nextCheckpointToEmit <= sourceTips.checkpointed.checkpoint.number
+      ) {
+        const startingBlockCheckpoints = await this.l2BlockSource.getCheckpointedBlocks(
+          BlockNumber(this.opts.startingBlock),
+          1,
+        );
+        if (startingBlockCheckpoints.length > 0) {
+          nextCheckpointToEmit = CheckpointNumber(
+            Math.max(nextCheckpointToEmit, startingBlockCheckpoints[0].checkpointNumber),
+          );
+        } else {
+          // startingBlock is past all checkpointed blocks; skip Loop 1 entirely.
+          nextCheckpointToEmit = CheckpointNumber(sourceTips.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
@@ -129,7 +149,7 @@ export class L2BlockStream {
       if (!this.opts.ignoreCheckpoints) {
         let loop1Iterations = 0;
         while (nextCheckpointToEmit <= sourceTips.checkpointed.checkpoint.number) {
-          const checkpoints = await this.l2BlockSource.getPublishedCheckpoints(nextCheckpointToEmit, 1);
+          const checkpoints = await this.l2BlockSource.getCheckpoints(nextCheckpointToEmit, 1);
           if (checkpoints.length === 0) {
             break;
           }
@@ -174,7 +194,7 @@ export class L2BlockStream {
         // Refill the prefetch buffer when exhausted
         if (prefetchIdx >= prefetchedCheckpoints.length) {
           const prefetchLimit = this.opts.checkpointPrefetchLimit ?? CHECKPOINT_PREFETCH_LIMIT;
-          prefetchedCheckpoints = await this.l2BlockSource.getPublishedCheckpoints(nextCheckpointNumber, prefetchLimit);
+          prefetchedCheckpoints = await this.l2BlockSource.getCheckpoints(nextCheckpointNumber, prefetchLimit);
           prefetchIdx = 0;
           if (prefetchedCheckpoints.length === 0) {
             break;
@@ -213,8 +233,8 @@ export class L2BlockStream {
       // 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.getL2BlocksNew(BlockNumber(nextBlockNumber), limit, this.opts.proven);
+        this.log.trace(`Requesting blocks from ${nextBlockNumber} limit ${limit}`);
+        const blocks = await this.l2BlockSource.getBlocks(BlockNumber(nextBlockNumber), BlockNumber(limit));
         if (blocks.length === 0) {
           break;
         }

package/src/block/l2_block_stream/l2_tips_store_base.ts

@@ -2,7 +2,7 @@ import { GENESIS_BLOCK_HEADER_HASH } from '@aztec/constants';
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 
 import type { PublishedCheckpoint } from '../../checkpoint/published_checkpoint.js';
-import type { L2BlockNew } from '../l2_block_new.js';
+import type { L2Block } from '../l2_block.js';
 import {
   type CheckpointId,
   GENESIS_CHECKPOINT_HEADER_HASH,
@@ -109,7 +109,7 @@ export abstract class L2TipsStoreBase implements L2BlockStreamEventHandler, L2Bl
   }
 
   // Protected helper that subclasses can override for block hash computation
-  protected computeBlockHash(block: L2BlockNew): Promise<string> {
+  protected computeBlockHash(block: L2Block): Promise<string> {
     return block.hash().then(hash => hash.toString());
   }