@aztec/stdlib 3.0.0-devnet.2 → 3.0.0-devnet.2-patch.1

package/src/block/l2_block_source.ts

@@ -1,9 +1,18 @@
+import {
+  BlockNumber,
+  BlockNumberSchema,
+  type CheckpointNumber,
+  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 { PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
 import type { L1RollupConstants } from '../epoch-helpers/index.js';
 import type { BlockHeader } from '../tx/block_header.js';
 import type { IndexedTxEffect } from '../tx/indexed_tx_effect.js';
@@ -33,27 +42,27 @@ 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 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.
    */
-  getBlock(number: number): Promise<L2Block | undefined>;
+  getBlock(number: BlockNumber): Promise<L2Block | undefined>;
 
   /**
    * 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`.
@@ -62,10 +71,20 @@ export interface L2BlockSource {
    * @param proven - If true, only return blocks that have been proven.
    * @returns The requested L2 blocks.
    */
-  getBlocks(from: number, limit: number, proven?: boolean): Promise<L2Block[]>;
+  getBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<L2Block[]>;
+
+  getPublishedCheckpoints(from: CheckpointNumber, limit: number): Promise<PublishedCheckpoint[]>;
+
+  /**
+   * Gets a checkpoint by the archive root, which should be the root of the archive tree after the requested checkpoint
+   * is applied.
+   * @param archive - The new archive root of the checkpoint.
+   * @returns The requested checkpoint (or undefined if not found).
+   */
+  getCheckpointByArchive(archive: Fr): Promise<Checkpoint | undefined>;
 
   /** Equivalent to getBlocks but includes publish data. */
-  getPublishedBlocks(from: number, limit: number, proven?: boolean): Promise<PublishedL2Block[]>;
+  getPublishedBlocks(from: BlockNumber, limit: number, proven?: boolean): Promise<PublishedL2Block[]>;
 
   /**
    * Gets a published block by its hash.
@@ -110,34 +129,41 @@ export interface L2BlockSource {
   getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined>;
 
   /**
-   * Returns the current L2 slot number based on the current L1 timestamp.
+   * 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.
    */
-  getL2SlotNumber(): Promise<bigint>;
+  getL2EpochNumber(): Promise<EpochNumber | undefined>;
 
   /**
-   * Returns the current L2 epoch number based on the current L1 timestamp.
+   * Returns all checkpoints for a given epoch.
+   * @dev Use this method only with recent epochs, since it walks the checkpoint list backwards.
+   * @param epochNumber - The epoch number to return checkpoints for.
    */
-  getL2EpochNumber(): Promise<bigint>;
+  getCheckpointsForEpoch(epochNumber: EpochNumber): Promise<Checkpoint[]>;
 
   /**
    * 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.
    */
-  getBlocksForEpoch(epochNumber: bigint): Promise<L2Block[]>;
+  getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2Block[]>;
 
   /**
    * Returns all 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: bigint): Promise<BlockHeader[]>;
+  getBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]>;
 
   /**
    * Returns whether the given epoch is completed on L1, based on the current L1 and L2 block numbers.
    * @param epochNumber - The epoch number to check.
    */
-  isEpochComplete(epochNumber: bigint): Promise<boolean>;
+  isEpochComplete(epochNumber: EpochNumber): Promise<boolean>;
 
   /**
    * Returns the tips of the L2 chain.
@@ -153,7 +179,7 @@ export interface L2BlockSource {
   getGenesisValues(): Promise<{ genesisArchiveRoot: Fr }>;
 
   /** Latest synced L1 timestamp. */
-  getL1Timestamp(): Promise<bigint>;
+  getL1Timestamp(): Promise<bigint | undefined>;
 
   /**
    * Returns whether the latest block in the pending chain on L1 is invalid (ie its attestations are incorrect).
@@ -194,33 +220,26 @@ export type L2BlockTag = 'latest' | 'proven' | 'finalized';
 export type L2Tips = Record<L2BlockTag, L2BlockId>;
 
 /** Identifies a block by number and hash. */
-export type L2BlockId = z.infer<typeof L2BlockIdSchema>;
+export type L2BlockId = { number: BlockNumber; hash: string };
 
 /** 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(),
-  }),
-]);
+const L2BlockIdSchema = z.object({
+  number: BlockNumberSchema,
+  hash: z.string(),
+});
 
 export const L2TipsSchema = z.object({
   latest: L2BlockIdSchema,
   proven: L2BlockIdSchema,
   finalized: L2BlockIdSchema,
-}) satisfies z.ZodType<L2Tips>;
+});
 
 export enum L2BlockSourceEvents {
   L2PruneDetected = 'l2PruneDetected',
@@ -230,14 +249,14 @@ export enum L2BlockSourceEvents {
 
 export type L2BlockProvenEvent = {
   type: 'l2BlockProven';
-  blockNumber: bigint;
-  slotNumber: bigint;
-  epochNumber: bigint;
+  blockNumber: BlockNumber;
+  slotNumber: SlotNumber;
+  epochNumber: EpochNumber;
 };
 
 export type L2BlockPruneEvent = {
   type: 'l2PruneDetected';
-  epochNumber: bigint;
+  epochNumber: EpochNumber;
   blocks: L2Block[];
 };
 

package/src/block/l2_block_stream/l2_block_stream.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { AbortError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
@@ -74,7 +75,7 @@ export class L2BlockStream {
       }
 
       if (latestBlockNumber < localTips.latest.number) {
-        latestBlockNumber = Math.min(latestBlockNumber, sourceTips.latest.number); // see #13471
+        latestBlockNumber = BlockNumber(Math.min(latestBlockNumber, sourceTips.latest.number)); // see #13471
         const hash = sourceCache.get(latestBlockNumber) ?? (await this.getBlockHashFromSource(latestBlockNumber));
         if (latestBlockNumber !== 0 && !hash) {
           throw new Error(`Block hash not found in block source for block number ${latestBlockNumber}`);
@@ -85,7 +86,7 @@ export class L2BlockStream {
 
       // If we are just starting, use the starting block number from the options.
       if (latestBlockNumber === 0 && this.opts.startingBlock !== undefined) {
-        latestBlockNumber = Math.max(this.opts.startingBlock - 1, 0);
+        latestBlockNumber = BlockNumber(Math.max(this.opts.startingBlock - 1, 0));
       }
 
       // Only log this entry once (for sanity)
@@ -108,7 +109,11 @@ export class L2BlockStream {
       while (nextBlockNumber <= sourceTips.latest.number) {
         const limit = Math.min(this.opts.batchSize ?? 50, sourceTips.latest.number - nextBlockNumber + 1);
         this.log.trace(`Requesting blocks from ${nextBlockNumber} limit ${limit} proven=${this.opts.proven}`);
-        const blocks = await this.l2BlockSource.getPublishedBlocks(nextBlockNumber, limit, this.opts.proven);
+        const blocks = await this.l2BlockSource.getPublishedBlocks(
+          BlockNumber(nextBlockNumber),
+          limit,
+          this.opts.proven,
+        );
         if (blocks.length === 0) {
           break;
         }
@@ -139,7 +144,7 @@ export class L2BlockStream {
    * @param blockNumber - The block number to test.
    * @param args - A cache of data already requested from source, to avoid re-requesting it.
    */
-  private async areBlockHashesEqualAt(blockNumber: number, args: { sourceCache: BlockHashCache }) {
+  private async areBlockHashesEqualAt(blockNumber: BlockNumber, args: { sourceCache: BlockHashCache }) {
     if (blockNumber === 0) {
       return true;
     }
@@ -163,7 +168,7 @@ export class L2BlockStream {
     return localBlockHash === sourceBlockHash;
   }
 
-  private getBlockHashFromSource(blockNumber: number) {
+  private getBlockHashFromSource(blockNumber: BlockNumber) {
     return this.l2BlockSource
       .getBlockHeader(blockNumber)
       .then(h => h?.hash())

package/src/block/l2_block_stream/l2_tips_memory_store.ts

@@ -1,3 +1,6 @@
+import { GENESIS_BLOCK_HEADER_HASH } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+
 import type { L2Block } from '../l2_block.js';
 import type { L2BlockId, L2BlockTag, L2Tips } from '../l2_block_source.js';
 import type { L2BlockStreamEvent, L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider } from './interfaces.js';
@@ -7,7 +10,7 @@ import type { L2BlockStreamEvent, L2BlockStreamEventHandler, L2BlockStreamLocalD
  * @dev tests in kv-store/src/stores/l2_tips_memory_store.test.ts
  */
 export class L2TipsMemoryStore implements L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider {
-  protected readonly l2TipsStore: Map<L2BlockTag, number> = new Map();
+  protected readonly l2TipsStore: Map<L2BlockTag, BlockNumber> = new Map();
   protected readonly l2BlockHashesStore: Map<number, string> = new Map();
 
   public getL2BlockHash(number: number): Promise<string | undefined> {
@@ -25,7 +28,7 @@ export class L2TipsMemoryStore implements L2BlockStreamEventHandler, L2BlockStre
   private getL2Tip(tag: L2BlockTag): L2BlockId {
     const blockNumber = this.l2TipsStore.get(tag);
     if (blockNumber === undefined || blockNumber === 0) {
-      return { number: 0, hash: undefined };
+      return { number: BlockNumber.ZERO, hash: GENESIS_BLOCK_HEADER_HASH.toString() };
     }
     const blockHash = this.l2BlockHashesStore.get(blockNumber);
     if (!blockHash) {

package/src/block/proposal/attestations_and_signers.ts

@@ -1,11 +1,11 @@
-import type { ViemCommitteeAttestations } from '@aztec/ethereum';
+import type { ViemCommitteeAttestations } from '@aztec/ethereum/contracts';
 import { hexToBuffer } from '@aztec/foundation/string';
 
 import { encodeAbiParameters, parseAbiParameters } from 'viem';
 import { z } from 'zod';
 
 import type { Signable, SignatureDomainSeparator } from '../../p2p/signature_utils.js';
-import { CommitteeAttestation } from './committee_attestation.js';
+import { CommitteeAttestation, EthAddress } from './committee_attestation.js';
 
 export class CommitteeAttestationsAndSigners implements Signable {
   constructor(public attestations: CommitteeAttestation[]) {}
@@ -119,3 +119,22 @@ export class CommitteeAttestationsAndSigners implements Signable {
     };
   }
 }
+
+/**
+ * Malicious extension of CommitteeAttestationsAndSigners that keeps separate attestations and
+ * signers. Used for tricking the L1 contract into accepting attestations by reconstructing
+ * the correct committee commitment (which relies on the signers, ignoring the signatures)
+ * with an invalid set of attestation signatures.
+ */
+export class MaliciousCommitteeAttestationsAndSigners extends CommitteeAttestationsAndSigners {
+  constructor(
+    attestations: CommitteeAttestation[],
+    private signers: EthAddress[],
+  ) {
+    super(attestations);
+  }
+
+  override getSigners(): EthAddress[] {
+    return this.signers;
+  }
+}

package/src/block/proposal/committee_attestation.ts

@@ -1,4 +1,4 @@
-import type { ViemCommitteeAttestation, ViemCommitteeAttestations } from '@aztec/ethereum';
+import type { ViemCommitteeAttestation, ViemCommitteeAttestations } from '@aztec/ethereum/contracts';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';

package/src/block/published_l2_block.ts

@@ -1,43 +1,18 @@
 // Ignoring import issue to fix portable inferred type issue in zod schema
-import { Buffer32 } from '@aztec/foundation/buffer';
-import { randomBigInt } from '@aztec/foundation/crypto';
-import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
+import { L1PublishedData, PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
 import { L2Block } from './l2_block.js';
 import { CommitteeAttestation } from './proposal/committee_attestation.js';
 
-export class L1PublishedData {
-  constructor(
-    public blockNumber: bigint,
-    public timestamp: bigint,
-    public blockHash: string,
-  ) {}
-
-  static get schema() {
-    return z.object({
-      blockNumber: schemas.BigInt,
-      timestamp: schemas.BigInt,
-      blockHash: z.string(),
-    });
-  }
-
-  static random() {
-    return new L1PublishedData(
-      randomBigInt(1000n) + 1n,
-      BigInt(Math.floor(Date.now() / 1000)),
-      Buffer32.random().toString(),
-    );
-  }
-
-  static fromFields(fields: FieldsOf<L1PublishedData>) {
-    return new L1PublishedData(fields.blockNumber, fields.timestamp, fields.blockHash);
-  }
-}
-
+/**
+ * @deprecated `PublishedCheckpoint` is what will be retrieved from L1.
+ * L2 blocks do not need to link to L1PublishedData directly.
+ * TODO: Create another type (AttestedL2Block?) for an L2 block and its attestations.
+ */
 export class PublishedL2Block {
   constructor(
     public block: L2Block,
@@ -79,4 +54,12 @@ export class PublishedL2Block {
       this.attestations,
     );
   }
+
+  public toPublishedCheckpoint() {
+    return new PublishedCheckpoint(this.block.toCheckpoint(), this.l1, this.attestations);
+  }
+
+  static fromPublishedCheckpoint(checkpoint: PublishedCheckpoint) {
+    return new PublishedL2Block(L2Block.fromCheckpoint(checkpoint.checkpoint), checkpoint.l1, checkpoint.attestations);
+  }
 }

package/src/block/test/l2_tips_store_test_suite.ts

@@ -1,5 +1,7 @@
+import { GENESIS_BLOCK_HEADER_HASH } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { times } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type L2Block, type L2BlockId, PublishedL2Block } from '@aztec/stdlib/block';
 
 import { jestExpect as expect } from '@jest/expect';
@@ -15,17 +17,20 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
 
   const makeBlock = (number: number): PublishedL2Block =>
     PublishedL2Block.fromFields({
-      block: { number, hash: () => Promise.resolve(new Fr(number)) } as L2Block,
+      block: { number: BlockNumber(number), hash: () => Promise.resolve(new Fr(number)) } as L2Block,
       l1: { blockNumber: BigInt(number), blockHash: `0x${number}`, timestamp: BigInt(number) },
       attestations: [],
     });
 
   const makeBlockId = (number: number): L2BlockId => ({
-    number,
+    number: BlockNumber(number),
     hash: new Fr(number).toString(),
   });
 
-  const makeTip = (number: number) => ({ number, hash: number === 0 ? undefined : new Fr(number).toString() });
+  const makeTip = (number: number): L2BlockId => ({
+    number: BlockNumber(number),
+    hash: number === 0 ? GENESIS_BLOCK_HEADER_HASH.toString() : new Fr(number).toString(),
+  });
 
   const makeTips = (latest: number, proven: number, finalized: number) => ({
     latest: makeTip(latest),

package/src/block/validate_block_result.ts

@@ -1,3 +1,4 @@
+import { EpochNumber, EpochNumberSchema } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
@@ -16,7 +17,7 @@ export type ValidateBlockNegativeResult =
       /** Committee members at the epoch this block was proposed */
       committee: EthAddress[];
       /** Epoch in which this block was proposed */
-      epoch: bigint;
+      epoch: EpochNumber;
       /** Proposer selection seed for the epoch */
       seed: bigint;
       /** List of committee members who signed this block proposal */
@@ -33,7 +34,7 @@ export type ValidateBlockNegativeResult =
       /** Committee members at the epoch this block was proposed */
       committee: EthAddress[];
       /** Epoch in which this block was proposed */
-      epoch: bigint;
+      epoch: EpochNumber;
       /** Proposer selection seed for the epoch */
       seed: bigint;
       /** List of committee members who signed this block proposal */
@@ -46,16 +47,17 @@ export type ValidateBlockNegativeResult =
       invalidIndex: number;
     };
 
+// TODO: Rename to ValidateAttestationsResult
 /** Result type for validating a block attestations */
 export type ValidateBlockResult = { valid: true } | ValidateBlockNegativeResult;
 
-export const ValidateBlockResultSchema = z.union([
+export const ValidateBlockResultSchema: ZodFor<ValidateBlockResult> = z.union([
   z.object({ valid: z.literal(true) }),
   z.object({
     valid: z.literal(false),
     block: BlockInfoSchema,
     committee: z.array(schemas.EthAddress),
-    epoch: schemas.BigInt,
+    epoch: EpochNumberSchema,
     seed: schemas.BigInt,
     attestors: z.array(schemas.EthAddress),
     attestations: z.array(CommitteeAttestation.schema),
@@ -65,14 +67,14 @@ export const ValidateBlockResultSchema = z.union([
     valid: z.literal(false),
     block: BlockInfoSchema,
     committee: z.array(schemas.EthAddress),
-    epoch: schemas.BigInt,
+    epoch: EpochNumberSchema,
     seed: schemas.BigInt,
     attestors: z.array(schemas.EthAddress),
     attestations: z.array(CommitteeAttestation.schema),
     reason: z.literal('invalid-attestation'),
     invalidIndex: z.number(),
   }),
-]) satisfies ZodFor<ValidateBlockResult>;
+]);
 
 export function serializeValidateBlockResult(result: ValidateBlockResult): Buffer {
   if (result.valid) {
@@ -106,7 +108,7 @@ export function deserializeValidateBlockResult(bufferOrReader: Buffer | BufferRe
   const reason = reader.readString() as 'insufficient-attestations' | 'invalid-attestation';
   const block = deserializeBlockInfo(reader.readBuffer());
   const committee = reader.readVector(EthAddress);
-  const epoch = reader.readBigInt();
+  const epoch = EpochNumber(reader.readNumber());
   const seed = reader.readBigInt();
   const attestors = reader.readVector(EthAddress);
   const attestations = reader.readVector(CommitteeAttestation);

package/src/checkpoint/checkpoint.ts

@@ -0,0 +1,88 @@
+import { encodeCheckpointBlobDataFromBlocks } from '@aztec/blob-lib/encoding';
+import { BlockNumber, CheckpointNumber, CheckpointNumberSchema } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, 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 { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+
+export class Checkpoint {
+  constructor(
+    /** Snapshot of archive tree after the checkpoint is added. */
+    public archive: AppendOnlyTreeSnapshot,
+    /** Header of the checkpoint. */
+    public header: CheckpointHeader,
+    /** L2 blocks in the checkpoint. */
+    public blocks: L2BlockNew[],
+    /** Number of the checkpoint. */
+    public number: CheckpointNumber,
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        archive: AppendOnlyTreeSnapshot.schema,
+        header: CheckpointHeader.schema,
+        blocks: z.array(L2BlockNew.schema),
+        number: CheckpointNumberSchema,
+      })
+      .transform(({ archive, header, blocks, number }) => new Checkpoint(archive, header, blocks, number));
+  }
+
+  static from(fields: FieldsOf<Checkpoint>) {
+    return new Checkpoint(...Checkpoint.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<Checkpoint>) {
+    return [fields.archive, fields.header, fields.blocks, fields.number] as const;
+  }
+
+  static fromBuffer(buf: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buf);
+    return new Checkpoint(
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(CheckpointHeader),
+      reader.readVector(L2BlockNew),
+      CheckpointNumber(reader.readNumber()),
+    );
+  }
+
+  public toBuffer() {
+    return serializeToBuffer(this.archive, this.header, this.blocks.length, this.blocks, this.number);
+  }
+
+  public toBlobFields(): Fr[] {
+    const blocks = this.blocks.map(block => block.toBlockBlobData());
+    return encodeCheckpointBlobDataFromBlocks(blocks);
+  }
+
+  public hash(): Fr {
+    return this.header.hash();
+  }
+
+  public getState() {
+    return this.blocks.at(-1)!.header.state;
+  }
+
+  static async random(
+    checkpointNumber = CheckpointNumber(1),
+    {
+      numBlocks = 1,
+      startBlockNumber = 1,
+      ...options
+    }: { numBlocks?: number; startBlockNumber?: number } & Partial<Parameters<typeof CheckpointHeader.random>[0]> &
+      Partial<Parameters<typeof L2BlockNew.random>[1]> = {},
+  ) {
+    const header = CheckpointHeader.random(options);
+
+    const blocks = await Promise.all(
+      Array.from({ length: numBlocks }, (_, i) => L2BlockNew.random(BlockNumber(startBlockNumber + i), options)),
+    );
+
+    return new Checkpoint(AppendOnlyTreeSnapshot.random(), header, blocks, checkpointNumber);
+  }
+}

package/src/checkpoint/index.ts

@@ -1 +1,2 @@
-export * from './checkpoint_body.js';
+export * from './checkpoint.js';
+export * from './published_checkpoint.js';

package/src/checkpoint/published_checkpoint.ts

@@ -0,0 +1,91 @@
+// Ignoring import issue to fix portable inferred type issue in zod schema
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { randomBigInt } from '@aztec/foundation/crypto/random';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { z } from 'zod';
+
+import { CommitteeAttestation } from '../block/proposal/committee_attestation.js';
+import { Checkpoint } from './checkpoint.js';
+
+export class L1PublishedData {
+  constructor(
+    public blockNumber: bigint,
+    public timestamp: bigint,
+    public blockHash: string,
+  ) {}
+
+  static get schema() {
+    return z.object({
+      blockNumber: schemas.BigInt,
+      timestamp: schemas.BigInt,
+      blockHash: z.string(),
+    });
+  }
+
+  static random() {
+    return new L1PublishedData(
+      randomBigInt(1000n) + 1n,
+      BigInt(Math.floor(Date.now() / 1000)),
+      Buffer32.random().toString(),
+    );
+  }
+
+  static fromFields(fields: FieldsOf<L1PublishedData>) {
+    return new L1PublishedData(fields.blockNumber, fields.timestamp, fields.blockHash);
+  }
+}
+
+export class PublishedCheckpoint {
+  constructor(
+    public checkpoint: Checkpoint,
+    public l1: L1PublishedData,
+    // The attestations for the last block in the checkpoint.
+    public attestations: CommitteeAttestation[],
+  ) {}
+
+  static get schema() {
+    return z
+      .object({
+        checkpoint: Checkpoint.schema,
+        l1: L1PublishedData.schema,
+        attestations: z.array(CommitteeAttestation.schema),
+      })
+      .transform(obj => PublishedCheckpoint.from(obj));
+  }
+
+  static getFields(fields: FieldsOf<PublishedCheckpoint>) {
+    return [fields.checkpoint, fields.l1, fields.attestations] as const;
+  }
+
+  static from(fields: FieldsOf<PublishedCheckpoint>) {
+    return new PublishedCheckpoint(...PublishedCheckpoint.getFields(fields));
+  }
+
+  static fromBuffer(bufferOrReader: Buffer | BufferReader): PublishedCheckpoint {
+    const reader = BufferReader.asReader(bufferOrReader);
+    const checkpoint = reader.readObject(Checkpoint);
+    const l1BlockNumber = reader.readBigInt();
+    const l1BlockHash = reader.readString();
+    const l1Timestamp = reader.readBigInt();
+    const attestations = reader.readVector(CommitteeAttestation);
+    return new PublishedCheckpoint(
+      checkpoint,
+      new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash),
+      attestations,
+    );
+  }
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(
+      this.checkpoint,
+      this.l1.blockNumber,
+      this.l1.blockHash,
+      this.l1.timestamp,
+      this.attestations.length,
+      this.attestations,
+    );
+  }
+}

package/src/contract/artifact_hash.ts

@@ -1,5 +1,5 @@
-import { sha256 } from '@aztec/foundation/crypto';
-import { Fr, reduceFn } from '@aztec/foundation/fields';
+import { sha256 } from '@aztec/foundation/crypto/sha256';
+import { Fr, reduceFn } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { numToUInt8 } from '@aztec/foundation/serialize';
 import { MerkleTree, MerkleTreeCalculator } from '@aztec/foundation/trees';