@aztec/stdlib 0.0.1-commit.6230efd → 0.0.1-commit.64b6bbb

package/src/block/l2_block.ts

@@ -1,44 +1,66 @@
-import { type BlockBlobData, encodeBlockBlobData, encodeCheckpointBlobDataFromBlocks } from '@aztec/blob-lib/encoding';
-import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { type BlockBlobData, encodeBlockBlobData } from '@aztec/blob-lib/encoding';
+import {
+  BlockNumber,
+  CheckpointNumber,
+  CheckpointNumberSchema,
+  IndexWithinCheckpoint,
+  IndexWithinCheckpointSchema,
+  SlotNumber,
+} from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { z } from 'zod';
 
-import { Checkpoint } from '../checkpoint/checkpoint.js';
+import type { PrivateLog } from '../logs/private_log.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
-import type { BlockHeader } from '../tx/block_header.js';
+import { BlockHeader } from '../tx/block_header.js';
+import type { BlockHash } from './block_hash.js';
 import { Body } from './body.js';
-import { makeAppendOnlyTreeSnapshot, makeL2BlockHeader } from './l2_block_code_to_purge.js';
-import { L2BlockHeader } from './l2_block_header.js';
 import type { L2BlockInfo } from './l2_block_info.js';
-import { L2BlockNew } from './l2_block_new.js';
 
 /**
- * The data that makes up the rollup proof, with encoder decoder functions.
- *
- * @deprecated Use `L2BlockNew` instead.
+ * An L2 block with a header and a body.
  */
 export class L2Block {
   constructor(
     /** Snapshot of archive tree after the block is applied. */
     public archive: AppendOnlyTreeSnapshot,
-    /** L2 block header. */
-    public header: L2BlockHeader,
+    /** Header of the block. */
+    public header: BlockHeader,
     /** L2 block body. */
     public body: Body,
-    private blockHash: Fr | undefined = undefined,
+    /** Number of the checkpoint that the block belongs to. */
+    public checkpointNumber: CheckpointNumber,
+    /** Index of the block within the checkpoint. */
+    public indexWithinCheckpoint: IndexWithinCheckpoint,
   ) {}
 
+  get number(): BlockNumber {
+    return this.header.globalVariables.blockNumber;
+  }
+
+  get slot(): SlotNumber {
+    return this.header.globalVariables.slotNumber;
+  }
+
+  get timestamp(): bigint {
+    return this.header.globalVariables.timestamp;
+  }
+
   static get schema() {
     return z
       .object({
         archive: AppendOnlyTreeSnapshot.schema,
-        header: L2BlockHeader.schema,
+        header: BlockHeader.schema,
         body: Body.schema,
+        checkpointNumber: CheckpointNumberSchema,
+        indexWithinCheckpoint: IndexWithinCheckpointSchema,
       })
-      .transform(({ archive, header, body }) => new L2Block(archive, header, body));
+      .transform(
+        ({ archive, header, body, checkpointNumber, indexWithinCheckpoint }) =>
+          new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint),
+      );
   }
 
   /**
@@ -47,11 +69,13 @@ export class L2Block {
    */
   static fromBuffer(buf: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buf);
-    const header = reader.readObject(L2BlockHeader);
+    const header = reader.readObject(BlockHeader);
     const archive = reader.readObject(AppendOnlyTreeSnapshot);
     const body = reader.readObject(Body);
+    const checkpointNumber = CheckpointNumber(reader.readNumber());
+    const indexWithinCheckpoint = IndexWithinCheckpoint(reader.readNumber());
 
-    return new L2Block(archive, header, body);
+    return new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint);
   }
 
   /**
@@ -59,151 +83,39 @@ export class L2Block {
    * @returns A serialized L2 block as a Buffer.
    */
   toBuffer() {
-    return serializeToBuffer(this.header, this.archive, this.body);
-  }
-
-  /**
-   * Deserializes L2 block from a buffer.
-   * @param str - A serialized L2 block.
-   * @returns Deserialized L2 block.
-   */
-  static fromString(str: string): L2Block {
-    return L2Block.fromBuffer(hexToBuffer(str));
-  }
-
-  /**
-   * Serializes a block to a string.
-   * @returns A serialized L2 block as a string.
-   */
-  toString(): string {
-    return bufferToHex(this.toBuffer());
-  }
-
-  /**
-   * Creates an L2 block containing random data.
-   * @param l2BlockNum - The number of the L2 block.
-   * @param txsPerBlock - The number of transactions to include in the block.
-   * @param numPublicCallsPerTx - The number of public function calls to include in each transaction.
-   * @param numPublicLogsPerCall - The number of public logs per 1 public function invocation.
-   * @param inHash - The hash of the L1 to L2 messages subtree which got inserted in this block.
-   * @returns The L2 block.
-   */
-  static async random(
-    l2BlockNum: BlockNumber,
-    txsPerBlock = 4,
-    numPublicCallsPerTx = 3,
-    numPublicLogsPerCall = 1,
-    inHash: Fr | undefined = undefined,
-    slotNumber: number | undefined = undefined,
-    maxEffects: number | undefined = undefined,
-  ): Promise<L2Block> {
-    const body = await Body.random({ txsPerBlock, numPublicCallsPerTx, numPublicLogsPerCall, maxEffects });
-
-    return new L2Block(
-      makeAppendOnlyTreeSnapshot(l2BlockNum + 1),
-      makeL2BlockHeader(0, l2BlockNum, slotNumber ?? l2BlockNum, {}, inHash),
-      body,
-    );
-  }
-
-  /**
-   * Creates an L2 block containing empty data.
-   * @returns The L2 block.
-   */
-  static empty(): L2Block {
-    return new L2Block(AppendOnlyTreeSnapshot.empty(), L2BlockHeader.empty(), Body.empty());
-  }
-
-  get number(): BlockNumber {
-    return this.header.getBlockNumber();
-  }
-
-  get slot(): SlotNumber {
-    return this.header.getSlot();
-  }
-
-  get timestamp(): bigint {
-    return this.header.globalVariables.timestamp;
+    return serializeToBuffer(this.header, this.archive, this.body, this.checkpointNumber, this.indexWithinCheckpoint);
   }
 
   /**
    * Returns the block's hash (hash of block header).
    * @returns The block's hash.
    */
-  public async hash(): Promise<Fr> {
-    if (this.blockHash === undefined) {
-      this.blockHash = await this.getBlockHeader().hash();
-    }
-    return this.blockHash;
+  public hash(): Promise<BlockHash> {
+    return this.header.hash();
   }
 
   /**
-   * @deprecated
-   * This only works when there's one block per checkpoint.
-   * TODO(#17027): Remove this method from L2Block and create a dedicated Checkpoint class.
+   * Checks if this block equals another block.
+   * @param other - The other block to compare with.
+   * @returns True if both blocks are equal.
    */
-  public getCheckpointHeader() {
-    return this.header.toCheckpointHeader();
-  }
-
-  // Temporary helper to get the actual block header.
-  public getBlockHeader(): BlockHeader {
-    return this.header.toBlockHeader();
-  }
-
-  public toL2Block() {
-    return new L2BlockNew(
-      this.archive,
-      this.getBlockHeader(),
-      this.body,
-      CheckpointNumber.fromBlockNumber(this.number),
-      0, // indexWithinCheckpoint
+  public equals(other: this): boolean {
+    return (
+      this.archive.equals(other.archive) &&
+      this.header.equals(other.header) &&
+      this.body.equals(other.body) &&
+      this.checkpointNumber === other.checkpointNumber &&
+      this.indexWithinCheckpoint === other.indexWithinCheckpoint
     );
   }
 
-  public toCheckpoint() {
-    return new Checkpoint(
-      this.archive,
-      this.getCheckpointHeader(),
-      [this.toL2Block()],
-      CheckpointNumber.fromBlockNumber(this.number),
-    );
-  }
-
-  static fromCheckpoint(checkpoint: Checkpoint) {
-    const checkpointHeader = checkpoint.header;
-    const block = checkpoint.blocks.at(-1)!;
-    const header = new L2BlockHeader(
-      new AppendOnlyTreeSnapshot(checkpointHeader.lastArchiveRoot, block.number),
-      checkpointHeader.contentCommitment,
-      block.header.state,
-      block.header.globalVariables,
-      block.header.totalFees,
-      checkpointHeader.totalManaUsed,
-      block.header.spongeBlobHash,
-      checkpointHeader.blockHeadersHash,
-    );
-    return new L2Block(checkpoint.archive, header, block.body);
-  }
-
-  /**
-   * @deprecated
-   * This only works when there's one block per checkpoint.
-   * TODO(#17027): Remove this method from L2Block and create a dedicated Checkpoint class.
-   */
-  public getCheckpointBlobFields() {
-    const blockBlobData = this.toBlockBlobData();
-    return encodeCheckpointBlobDataFromBlocks([blockBlobData]);
-  }
-
   public toBlobFields(): Fr[] {
     const blockBlobData = this.toBlockBlobData();
     return encodeBlockBlobData(blockBlobData);
   }
 
   public toBlockBlobData(): BlockBlobData {
-    // There's only one L2Block per checkpoint, so it's always the first block in the checkpoint.
-    const isFirstBlock = true;
+    const isFirstBlock = this.indexWithinCheckpoint === 0;
     return {
       blockEndMarker: {
         numTxs: this.body.txEffects.length,
@@ -226,6 +138,48 @@ export class L2Block {
     };
   }
 
+  static empty(header?: BlockHeader) {
+    return new L2Block(
+      AppendOnlyTreeSnapshot.empty(),
+      header ?? BlockHeader.empty(),
+      Body.empty(),
+      CheckpointNumber(0),
+      IndexWithinCheckpoint(0),
+    );
+  }
+
+  /**
+   * Creates an L2 block containing random data.
+   * @param l2BlockNum - The number of the L2 block.
+   * @param txsPerBlock - The number of transactions to include in the block.
+   * @param numPublicCallsPerTx - The number of public function calls to include in each transaction.
+   * @param numPublicLogsPerCall - The number of public logs per 1 public function invocation.
+   * @param inHash - The hash of the L1 to L2 messages subtree which got inserted in this block.
+   * @returns The L2 block.
+   */
+  static async random(
+    blockNumber: BlockNumber,
+    {
+      checkpointNumber = CheckpointNumber(Number(blockNumber)),
+      indexWithinCheckpoint = IndexWithinCheckpoint(0),
+      txsPerBlock = 1,
+      txOptions = {},
+      makeTxOptions,
+      ...blockHeaderOverrides
+    }: {
+      checkpointNumber?: CheckpointNumber;
+      indexWithinCheckpoint?: IndexWithinCheckpoint;
+      txsPerBlock?: number;
+      txOptions?: Partial<Parameters<typeof Body.random>[0]>;
+      makeTxOptions?: (txIndex: number) => Partial<Parameters<typeof Body.random>[0]>;
+    } & Partial<Parameters<typeof BlockHeader.random>[0]> = {},
+  ): Promise<L2Block> {
+    const archive = new AppendOnlyTreeSnapshot(Fr.random(), blockNumber + 1);
+    const header = BlockHeader.random({ blockNumber, ...blockHeaderOverrides });
+    const body = await Body.random({ txsPerBlock, makeTxOptions, ...txOptions });
+    return new L2Block(archive, header, body, checkpointNumber, indexWithinCheckpoint);
+  }
+
   /**
    * Returns stats used for logging.
    * @returns Stats on tx count, number, and log size and count.
@@ -253,9 +207,12 @@ export class L2Block {
     };
   }
 
+  getPrivateLogs(): PrivateLog[] {
+    return this.body.txEffects.map(txEffect => txEffect.privateLogs).flat();
+  }
+
   toBlockInfo(): L2BlockInfo {
     return {
-      blockHash: this.blockHash,
       archive: this.archive.root,
       lastArchive: this.header.lastArchive.root,
       blockNumber: this.number,
@@ -264,8 +221,4 @@ export class L2Block {
       timestamp: this.header.globalVariables.timestamp,
     };
   }
-
-  equals(other: L2Block) {
-    return this.archive.equals(other.archive) && this.header.equals(other.header) && this.body.equals(other.body);
-  }
 }

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,14 +15,15 @@ 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';
 import type { TxReceipt } from '../tx/tx_receipt.js';
-import { type CheckpointedL2Block, PublishedL2Block } from './checkpointed_l2_block.js';
+import type { BlockHash } from './block_hash.js';
+import type { CheckpointedL2Block } 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.
@@ -51,6 +53,20 @@ export interface L2BlockSource {
    */
   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.
@@ -66,13 +82,15 @@ export interface L2BlockSource {
    */
   getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined>;
 
+  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
@@ -85,7 +103,7 @@ export interface L2BlockSource {
    * @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.
@@ -99,7 +117,21 @@ export interface L2BlockSource {
    * @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).
+   */
+  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.
@@ -126,11 +158,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.
@@ -161,10 +193,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>;
@@ -175,42 +207,44 @@ export interface L2BlockSource {
    * 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.
-   * @deprecated Use getL2BlockNew instead.
    */
   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<L2Block[]>;
+  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 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<PublishedL2Block | 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<PublishedL2Block | 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<L2Block[]>;
-
-  /** Equivalent to getBlocks but includes publish data. */
-  getPublishedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<PublishedL2Block[]>;
+  getBlocks(from: BlockNumber, limit: number): Promise<L2Block[]>;
 }
 
 /**
@@ -222,7 +256,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>;
 }
 
 /**
@@ -230,26 +264,42 @@ export interface L2BlockSink {
  * 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' | 'checkpointed' | 'proven' | 'finalized';
 
 /** 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 +308,39 @@ 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',
+  L2PruneUnproven = 'l2PruneUnproven',
+  L2PruneUncheckpointed = 'l2PruneUncheckpointed',
   L2BlockProven = 'l2BlockProven',
-  InvalidAttestationsBlockDetected = 'invalidBlockDetected',
+  L2BlocksCheckpointed = 'l2BlocksCheckpointed',
+  InvalidAttestationsCheckpointDetected = 'invalidCheckpointDetected',
 }
 
 export type L2BlockProvenEvent = {
@@ -282,13 +350,24 @@ export type L2BlockProvenEvent = {
   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';