@aztec/stdlib 0.0.1-commit.5daedc8 → 0.0.1-commit.6201a7b05

package/src/block/l2_block_source.ts

@@ -1,18 +1,40 @@
-import type { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import {
+  BlockNumber,
+  BlockNumberSchema,
+  CheckpointNumber,
+  CheckpointNumberSchema,
+  type EpochNumber,
+  type SlotNumber,
+} from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { Fr } from '@aztec/foundation/fields';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
+import type { Checkpoint } from '../checkpoint/checkpoint.js';
+import type { CheckpointData, CommonCheckpointData, ProposedCheckpointData } from '../checkpoint/checkpoint_data.js';
+import type { L1PublishedData, 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';
 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 { L2Block } from './l2_block.js';
-import { PublishedL2Block } from './published_l2_block.js';
-import type { ValidateBlockNegativeResult, ValidateBlockResult } from './validate_block_result.js';
+import type { CommitteeAttestation } from './proposal/committee_attestation.js';
+import type { ValidateCheckpointNegativeResult, ValidateCheckpointResult } from './validate_block_result.js';
+
+/** Block metadata plus checkpoint-derived context (L1 publish info, attestations). */
+export type BlockDataWithCheckpointContext = {
+  data: BlockData;
+  checkpoint?: CheckpointData;
+  l1?: L1PublishedData;
+  attestations: CommitteeAttestation[];
+};
 
 /**
  * Interface of classes allowing for the retrieval of L2 blocks.
@@ -34,60 +56,107 @@ export interface L2BlockSource {
    * Gets the number of the latest L2 block processed by the block source implementation.
    * @returns The number of the latest L2 block processed by the block source implementation.
    */
-  getBlockNumber(): Promise<number>;
+  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<number>;
+  getProvenBlockNumber(): Promise<BlockNumber>;
 
   /**
-   * Gets an l2 block. If a negative number is passed, the block returned is the most recent.
-   * @param number - The block number to return (inclusive).
-   * @returns The requested L2 block.
+   * 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.
    */
-  getBlock(number: number): Promise<L2Block | undefined>;
+  getCheckpointedL2BlockNumber(): Promise<BlockNumber>;
+
+  /**
+   * Returns the finalized L2 block number. A block is finalized when it was proven
+   * in an L1 block that has itself been finalized on Ethereum.
+   * @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.
    * @returns The requested L2 block header.
    */
-  getBlockHeader(number: number | 'latest'): Promise<BlockHeader | undefined>;
+  getBlockHeader(number: BlockNumber | 'latest'): Promise<BlockHeader | 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.
+   * Gets a checkpointed L2 block by block number.
+   * Returns undefined if the block doesn't exist or hasn't been checkpointed yet.
+   * @param number - The block number to retrieve.
+   * @returns The requested checkpointed L2 block (or undefined if not found or not checkpointed).
    */
-  getBlocks(from: number, limit: number, proven?: boolean): Promise<L2Block[]>;
+  getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined>;
 
-  /** Equivalent to getBlocks but includes publish data. */
-  getPublishedBlocks(from: number, limit: number, proven?: boolean): Promise<PublishedL2Block[]>;
+  getCheckpointedBlocks(from: BlockNumber, limit: number): Promise<CheckpointedL2Block[]>;
 
   /**
-   * Gets a published block by its hash.
-   * @param blockHash - The block hash to retrieve.
-   * @returns The requested published block (or undefined if not found).
+   * 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.
    */
-  getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined>;
+  getCheckpoints(checkpointNumber: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]>;
 
   /**
-   * Gets a published block by its archive root.
-   * @param archive - The archive root to retrieve.
-   * @returns The requested published block (or undefined if not found).
+   * Gets the checkpoints for a given epoch
+   * @param epochNumber - Epoch for which we want checkpoint data
+   */
+  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 lightweight checkpoint metadata for a single checkpoint.
+   * Cheap passthrough for metadata-only queries (no block body reads).
+   * @param checkpointNumber - The checkpoint number to retrieve.
+   * @returns The requested checkpoint data (or undefined if not found).
+   */
+  getCheckpointData(checkpointNumber: CheckpointNumber): Promise<CheckpointData | undefined>;
+
+  /**
+   * Gets up to `limit` amount of checkpoint metadata entries starting from `from`.
+   * Cheap passthrough for metadata-only queries (no block body reads).
+   * @param from - The first checkpoint number to return (inclusive).
+   * @param limit - The maximum number of checkpoints to return.
+   */
+  getCheckpointDataRange(from: CheckpointNumber, limit: number): Promise<CheckpointData[]>;
+
+  /**
+   * Looks up the checkpoint number that contains the given slot.
+   * @param slot - The slot number to look up.
+   * @returns The checkpoint number (or undefined if not found).
+   */
+  getCheckpointNumberBySlot(slot: SlotNumber): Promise<CheckpointNumber | undefined>;
+
+  /**
+   * Gets block metadata plus checkpoint-derived context (L1 publish info, attestations)
+   * without deserializing tx bodies. Uses checkpoint-level values when the block is
+   * checkpointed; otherwise returns `l1: undefined` and empty attestations.
+   * @param number - The block number to retrieve.
    */
-  getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined>;
+  getBlockDataWithCheckpointContext(number: BlockNumber): Promise<BlockDataWithCheckpointContext | undefined>;
 
   /**
    * 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.
@@ -96,6 +165,41 @@ 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).
+   */
+  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).
+   */
+  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).
+   */
+  getL2BlockByArchive(archive: Fr): Promise<L2Block | undefined>;
+
   /**
    * Gets a tx effect.
    * @param txHash - The hash of the tx corresponding to the tx effect.
@@ -111,28 +215,25 @@ export interface L2BlockSource {
   getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined>;
 
   /**
-   * Returns the current L2 slot number based on the currently synced L1 timestamp.
-   */
-  getL2SlotNumber(): Promise<SlotNumber | undefined>;
-
-  /**
-   * Returns the current L2 epoch number based on the currently synced L1 timestamp.
+   * Returns the last L2 slot number for which we have all L1 data needed to build the next checkpoint.
+   * Determined by the max of two signals: L1 block sync progress and latest synced checkpoint slot.
+   * The checkpoint signal handles missed L1 blocks, since a published checkpoint seals the message tree
+   * for the next checkpoint via the inbox LAG mechanism.
    */
-  getL2EpochNumber(): Promise<EpochNumber | undefined>;
+  getSyncedL2SlotNumber(): Promise<SlotNumber | undefined>;
 
   /**
-   * Returns all 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.
+   * Returns the last L2 epoch number that has been fully synchronized from L1.
+   * An epoch is fully synced when all its L2 slots have been fully synced.
    */
-  getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2Block[]>;
+  getSyncedL2EpochNumber(): 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.
@@ -163,13 +264,76 @@ 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>;
+
+  /** Returns the checkpoint at the proposed chain tip. */
+  getLastCheckpoint(): Promise<CommonCheckpointData | undefined>;
+
+  /** Returns proposed checkpoint, if set, undefined if not*/
+  getLastProposedCheckpoint(): Promise<ProposedCheckpointData | undefined>;
 
   /** Force a sync. */
   syncImmediate(): Promise<void>;
+
+  /* Legacy APIS */
+
+  /**
+   * Gets an l2 block. If a negative number is passed, the block returned is the most recent.
+   * @param number - The block number to return (inclusive).
+   * @returns The requested L2 block.
+   */
+  getBlock(number: BlockNumber): Promise<L2Block | undefined>;
+
+  /**
+   * 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.
+   */
+  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<L2Block[]>;
+
+  /**
+   * Gets a checkpointed block by its block hash.
+   * @param blockHash - The block hash to retrieve.
+   * @returns The requested block (or undefined if not found).
+   */
+  getCheckpointedBlockByHash(blockHash: BlockHash): Promise<CheckpointedL2Block | undefined>;
+
+  /**
+   * Gets a checkpointed block by its archive root.
+   * @param archive - The archive root to retrieve.
+   * @returns The requested block (or undefined if not found).
+   */
+  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.
+   * @returns The requested L2 blocks.
+   */
+  getBlocks(from: BlockNumber, limit: number): Promise<L2Block[]>;
+}
+
+/**
+ * Interface for classes that can receive and store L2 blocks.
+ */
+export interface L2BlockSink {
+  /**
+   * Adds a block to the store.
+   * @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: L2Block): Promise<void>;
 }
 
 /**
@@ -177,72 +341,112 @@ export interface L2BlockSource {
  * see L2BlockSourceEvents for the events emitted.
  */
 export type ArchiverEmitter = TypedEventEmitter<{
-  [L2BlockSourceEvents.L2PruneDetected]: (args: L2BlockPruneEvent) => void;
+  [L2BlockSourceEvents.L2PruneUnproven]: (args: L2PruneUnprovenEvent) => void;
+  [L2BlockSourceEvents.L2PruneUncheckpointed]: (args: L2PruneUncheckpointedEvent) => 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 {}
+export interface L2BlockSourceEventEmitter extends L2BlockSource {
+  events: 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' | 'proposedCheckpoint' | 'checkpointed' | 'proven' | 'finalized';
 
 /** Tips of the L2 chain. */
-export type L2Tips = Record<L2BlockTag, L2BlockId>;
+export type L2Tips = {
+  proposed: L2BlockId;
+  checkpointed: L2TipId;
+  proposedCheckpoint: L2TipId;
+  proven: L2TipId;
+  finalized: L2TipId;
+};
+
+export const GENESIS_CHECKPOINT_HEADER_HASH = CheckpointHeader.empty().hash();
 
 /** Identifies a block by number and hash. */
-export type L2BlockId = z.infer<typeof L2BlockIdSchema>;
+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: number, hash?: string): L2BlockId {
+export function makeL2BlockId(number: BlockNumber, hash?: string): L2BlockId {
   if (number !== 0 && !hash) {
     throw new Error(`Hash is required for non-genesis blocks (got block number ${number})`);
   }
   return { number, hash: hash! };
 }
 
-// TODO(palla/schemas): This package should know what is the block hash of the genesis block 0.
-const L2BlockIdSchema = z.union([
-  z.object({
-    number: z.literal(0),
-    hash: z.undefined(),
-  }),
-  z.object({
-    number: z.number(),
-    hash: z.string(),
-  }),
-]);
+/** 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,
-}) satisfies z.ZodType<L2Tips>;
+  proposed: L2BlockIdSchema,
+  checkpointed: L2TipIdSchema,
+  proposedCheckpoint: L2TipIdSchema,
+  proven: L2TipIdSchema,
+  finalized: L2TipIdSchema,
+});
 
 export enum L2BlockSourceEvents {
-  L2PruneDetected = 'l2PruneDetected',
+  L2PruneUnproven = 'l2PruneUnproven',
+  L2PruneUncheckpointed = 'l2PruneUncheckpointed',
   L2BlockProven = 'l2BlockProven',
-  InvalidAttestationsBlockDetected = 'invalidBlockDetected',
+  L2BlocksCheckpointed = 'l2BlocksCheckpointed',
+  InvalidAttestationsCheckpointDetected = 'invalidCheckpointDetected',
 }
 
 export type L2BlockProvenEvent = {
   type: 'l2BlockProven';
-  blockNumber: bigint;
+  blockNumber: BlockNumber;
   slotNumber: SlotNumber;
   epochNumber: EpochNumber;
 };
 
-export type L2BlockPruneEvent = {
-  type: 'l2PruneDetected';
+export type L2PruneUnprovenEvent = {
+  type: 'l2PruneUnproven';
   epochNumber: EpochNumber;
   blocks: L2Block[];
 };
 
-export type InvalidBlockDetectedEvent = {
-  type: 'invalidBlockDetected';
-  validationResult: ValidateBlockNegativeResult;
+export type L2PruneUncheckpointedEvent = {
+  type: 'l2PruneUncheckpointed';
+  slotNumber: SlotNumber;
+  blocks: L2Block[];
+};
+
+export type L2CheckpointEvent = {
+  type: 'l2BlocksCheckpointed';
+  checkpoint: PublishedCheckpoint;
+};
+
+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,10 +1,15 @@
-import type { L2BlockId, L2Tips } from '../l2_block_source.js';
-import type { PublishedL2Block } from '../published_l2_block.js';
+import type { PublishedCheckpoint } from '../../checkpoint/published_checkpoint.js';
+import type { L2Block } from '../l2_block.js';
+import type { CheckpointId, L2BlockId, L2Tips } from '../l2_block_source.js';
+
+/** Provides the current chain tips. Implemented by world-state, l2-tips-store, and AztecNode. */
+export interface L2TipsProvider {
+  getL2Tips(): Promise<L2Tips>;
+}
 
 /** Interface to the local view of the chain. Implemented by world-state and l2-tips-store. */
-export interface L2BlockStreamLocalDataProvider {
+export interface L2BlockStreamLocalDataProvider extends L2TipsProvider {
   getL2BlockHash(number: number): Promise<string | undefined>;
-  getL2Tips(): Promise<L2Tips>;
 }
 
 /** Interface to a handler of events emitted. */
@@ -15,11 +20,21 @@ export interface L2BlockStreamEventHandler {
 export type L2BlockStreamEvent =
   | /** Emits blocks added to the chain. */ {
       type: 'blocks-added';
-      blocks: PublishedL2Block[];
+      blocks: L2Block[];
+    }
+  | /** Emits checkpoints published to L1. */ {
+      type: 'chain-checkpointed';
+      checkpoint: PublishedCheckpoint;
+      block: L2BlockId;
     }
-  | /** Reports last correct block (new tip of the unproven chain). */ {
+  | /**
+   * 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';
       block: L2BlockId;
+      checkpoint: CheckpointId;
     }
   | /** Reports new proven block. */ {
       type: 'chain-proven';