@aztec/stdlib 0.0.1-commit.3469e52 → 0.0.1-commit.35158ae7e

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,31 @@ 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>;
+
+  /**
+   * 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.
@@ -67,15 +89,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 +105,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 +125,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.
@@ -133,21 +175,25 @@ export interface L2BlockSource {
   getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined>;
 
   /**
-   * Returns the current L2 slot 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.
    */
-  getL2SlotNumber(): Promise<SlotNumber | undefined>;
+  getSyncedL2SlotNumber(): Promise<SlotNumber | undefined>;
 
   /**
-   * Returns the current L2 epoch number based on the currently synced L1 timestamp.
+   * 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.
    */
-  getL2EpochNumber(): Promise<EpochNumber | undefined>;
+  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.
@@ -193,49 +239,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 +287,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 +384,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());
   }
 

package/src/block/test/l2_tips_store_test_suite.ts

@@ -5,8 +5,8 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import {
   type CheckpointId,
   GENESIS_CHECKPOINT_HEADER_HASH,
+  L2Block,
   type L2BlockId,
-  L2BlockNew,
   type L2TipId,
 } from '@aztec/stdlib/block';
 import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
@@ -31,8 +31,8 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
     blockToCheckpoint.clear();
   });
 
-  const makeBlock = async (number: number): Promise<L2BlockNew> => {
-    const block = await L2BlockNew.random(BlockNumber(number));
+  const makeBlock = async (number: number): Promise<L2Block> => {
+    const block = await L2Block.random(BlockNumber(number));
     blockHashes.set(number, (await block.hash()).toString());
     return block;
   };
@@ -74,7 +74,7 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
     checkpointed: makeTipId(checkpointed),
   });
 
-  const makeCheckpoint = async (checkpointNumber: number, blocks: L2BlockNew[]): Promise<PublishedCheckpoint> => {
+  const makeCheckpoint = async (checkpointNumber: number, blocks: L2Block[]): Promise<PublishedCheckpoint> => {
     const checkpoint = await Checkpoint.random(CheckpointNumber(checkpointNumber), {
       numBlocks: blocks.length,
       startBlockNumber: blocks[0].number,

package/src/checkpoint/checkpoint.ts

@@ -6,17 +6,18 @@ import {
   IndexWithinCheckpoint,
   SlotNumber,
 } from '@aztec/foundation/branded-types';
-import { sum } from '@aztec/foundation/collection';
+import { pick, sum } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, serializeSignedBigInt, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
-import { L2BlockNew } from '../block/l2_block_new.js';
+import { L2Block } from '../block/l2_block.js';
 import { MAX_BLOCKS_PER_CHECKPOINT } from '../deserialization/index.js';
 import { computeCheckpointOutHash } from '../messaging/out_hash.js';
 import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { schemas } from '../schemas/schemas.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import type { CheckpointInfo } from './checkpoint_info.js';
 
@@ -29,9 +30,11 @@ export class Checkpoint {
     /** Header of the checkpoint. */
     public header: CheckpointHeader,
     /** L2 blocks in the checkpoint. */
-    public blocks: L2BlockNew[],
+    public blocks: L2Block[],
     /** Number of the checkpoint. */
     public number: CheckpointNumber,
+    /** Fee asset price modifier in basis points (from oracle). Defaults to 0 (no change). */
+    public feeAssetPriceModifier: bigint = 0n,
   ) {}
 
   get slot(): SlotNumber {
@@ -43,10 +46,14 @@ export class Checkpoint {
       .object({
         archive: AppendOnlyTreeSnapshot.schema,
         header: CheckpointHeader.schema,
-        blocks: z.array(L2BlockNew.schema),
+        blocks: z.array(L2Block.schema),
         number: CheckpointNumberSchema,
+        feeAssetPriceModifier: schemas.BigInt,
       })
-      .transform(({ archive, header, blocks, number }) => new Checkpoint(archive, header, blocks, number));
+      .transform(
+        ({ archive, header, blocks, number, feeAssetPriceModifier }) =>
+          new Checkpoint(archive, header, blocks, number, feeAssetPriceModifier),
+      );
   }
 
   static from(fields: FieldsOfCheckpoint) {
@@ -54,21 +61,28 @@ export class Checkpoint {
   }
 
   static getFields(fields: FieldsOfCheckpoint) {
-    return [fields.archive, fields.header, fields.blocks, fields.number] as const;
+    return [fields.archive, fields.header, fields.blocks, fields.number, fields.feeAssetPriceModifier] as const;
   }
 
   static fromBuffer(buf: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buf);
-    return new Checkpoint(
-      reader.readObject(AppendOnlyTreeSnapshot),
-      reader.readObject(CheckpointHeader),
-      reader.readVector(L2BlockNew, MAX_BLOCKS_PER_CHECKPOINT),
-      CheckpointNumber(reader.readNumber()),
-    );
+    const archive = reader.readObject(AppendOnlyTreeSnapshot);
+    const header = reader.readObject(CheckpointHeader);
+    const blocks = reader.readVector(L2Block, MAX_BLOCKS_PER_CHECKPOINT);
+    const number = CheckpointNumber(reader.readNumber());
+    const feeAssetPriceModifier = reader.readInt256();
+    return new Checkpoint(archive, header, blocks, number, feeAssetPriceModifier);
   }
 
   public toBuffer() {
-    return serializeToBuffer(this.archive, this.header, this.blocks.length, this.blocks, this.number);
+    return serializeToBuffer(
+      this.archive,
+      this.header,
+      this.blocks.length,
+      this.blocks,
+      this.number,
+      serializeSignedBigInt(this.feeAssetPriceModifier),
+    );
   }
 
   public toBlobFields(): Fr[] {
@@ -80,9 +94,11 @@ export class Checkpoint {
     return this.header.hash();
   }
 
-  // Returns the out hash computed from all l2-to-l1 messages in this checkpoint.
-  // Note: This value is different from the out hash in the header, which is the **accumulated** out hash over all
-  // checkpoints up to and including this one in the epoch.
+  /**
+   * Returns the out hash computed from all l2-to-l1 messages in this checkpoint.
+   * Note: This value is different from the out hash in the header, which is the **accumulated** out hash over all
+   * checkpoints up to and including this one in the epoch.
+   */
   public getCheckpointOutHash(): Fr {
     const msgs = this.blocks.map(block => block.body.txEffects.map(txEffect => txEffect.l2ToL1Msgs));
     return computeCheckpointOutHash(msgs);
@@ -129,30 +145,41 @@ export class Checkpoint {
       numBlocks = 1,
       startBlockNumber = 1,
       previousArchive,
+      feeAssetPriceModifier = 0n,
       ...options
     }: {
       numBlocks?: number;
       startBlockNumber?: number;
       previousArchive?: AppendOnlyTreeSnapshot;
+      feeAssetPriceModifier?: bigint;
+      archive?: AppendOnlyTreeSnapshot;
     } & Partial<Parameters<typeof CheckpointHeader.random>[0]> &
-      Partial<Parameters<typeof L2BlockNew.random>[1]> = {},
+      Partial<Parameters<typeof L2Block.random>[1]> = {},
   ) {
-    const header = CheckpointHeader.random(options);
+    const headerOptions = previousArchive ? { lastArchiveRoot: previousArchive.root, ...options } : options;
+    const header = CheckpointHeader.random(headerOptions);
 
     // Create blocks sequentially to chain archive roots properly.
     // Each block's header.lastArchive must equal the previous block's archive.
-    const blocks: L2BlockNew[] = [];
+    const blocks: L2Block[] = [];
     let lastArchive = previousArchive;
     for (let i = 0; i < numBlocks; i++) {
-      const block = await L2BlockNew.random(BlockNumber(startBlockNumber + i), {
+      const block = await L2Block.random(BlockNumber(startBlockNumber + i), {
         indexWithinCheckpoint: IndexWithinCheckpoint(i),
         ...options,
         ...(lastArchive ? { lastArchive } : {}),
+        ...pick(header, 'slotNumber', 'timestamp', 'coinbase', 'feeRecipient', 'gasFees'),
       });
       lastArchive = block.archive;
       blocks.push(block);
     }
 
-    return new Checkpoint(AppendOnlyTreeSnapshot.random(), header, blocks, checkpointNumber);
+    return new Checkpoint(
+      options.archive ?? AppendOnlyTreeSnapshot.random(),
+      header,
+      blocks,
+      checkpointNumber,
+      feeAssetPriceModifier,
+    );
   }
 }

package/src/checkpoint/checkpoint_data.ts

@@ -0,0 +1,51 @@
+import {
+  BlockNumber,
+  BlockNumberSchema,
+  CheckpointNumber,
+  CheckpointNumberSchema,
+} from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { schemas } from '@aztec/foundation/schemas';
+
+import { z } from 'zod';
+
+import { CommitteeAttestation } from '../block/proposal/committee_attestation.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { L1PublishedData } from './published_checkpoint.js';
+
+/** Lightweight checkpoint metadata without full block data. */
+export type CheckpointData = {
+  checkpointNumber: CheckpointNumber;
+  header: CheckpointHeader;
+  archive: AppendOnlyTreeSnapshot;
+  checkpointOutHash: Fr;
+  startBlock: BlockNumber;
+  blockCount: number;
+  attestations: CommitteeAttestation[];
+  l1: L1PublishedData;
+};
+
+export const CheckpointDataSchema = z
+  .object({
+    checkpointNumber: CheckpointNumberSchema,
+    header: CheckpointHeader.schema,
+    archive: AppendOnlyTreeSnapshot.schema,
+    checkpointOutHash: schemas.Fr,
+    startBlock: BlockNumberSchema,
+    blockCount: schemas.Integer,
+    attestations: z.array(CommitteeAttestation.schema),
+    l1: L1PublishedData.schema,
+  })
+  .transform(
+    (obj): CheckpointData => ({
+      checkpointNumber: obj.checkpointNumber,
+      header: obj.header,
+      archive: obj.archive,
+      checkpointOutHash: obj.checkpointOutHash,
+      startBlock: obj.startBlock,
+      blockCount: obj.blockCount,
+      attestations: obj.attestations,
+      l1: obj.l1,
+    }),
+  );

package/src/checkpoint/index.ts

@@ -1,3 +1,5 @@
 export * from './checkpoint.js';
+export * from './checkpoint_data.js';
 export * from './checkpoint_info.js';
 export * from './published_checkpoint.js';
+export * from './validate.js';

package/src/checkpoint/published_checkpoint.ts

@@ -55,9 +55,11 @@ export class L1PublishedData {
 
 export class PublishedCheckpoint {
   constructor(
+    /** The checkpoint itself. */
     public checkpoint: Checkpoint,
+    /** Info on when this checkpoint was published on L1. */
     public l1: L1PublishedData,
-    // The attestations for the last block in the checkpoint.
+    /** The attestations for the last block in the checkpoint. */
     public attestations: CommitteeAttestation[],
   ) {}