@aztec/stdlib 0.0.1-commit.1142ef1 → 0.0.1-commit.18ccd8f0

package/src/p2p/checkpoint_proposal.ts

@@ -1,4 +1,4 @@
-import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, IndexWithinCheckpoint, SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { keccak256 } from '@aztec/foundation/crypto/keccak';
 import { tryRecoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
@@ -6,8 +6,10 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { DutyType, type SigningContext } from '@aztec/validator-ha-signer/types';
 
 import type { L2BlockInfo } from '../block/l2_block_info.js';
+import { MAX_TXS_PER_BLOCK } from '../deserialization/index.js';
 import { CheckpointHeader } from '../rollup/checkpoint_header.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { TxHash } from '../tx/index.js';
@@ -30,8 +32,15 @@ export class CheckpointProposalHash extends Buffer32 {
 }
 
 export type CheckpointProposalOptions = {
-  publishFullTxs: boolean;
-  /** Whether to generate an invalid checkpoint proposal for broadcasting. Use only for testing. */
+  /**
+   * Whether to include the tx objects along with the block proposal.
+   * Dramatically increases size of the payload but eliminates failed reexecutions due to missing txs.
+   */
+  publishFullTxs?: boolean;
+  /**
+   * Whether to generate an invalid checkpoint proposal for broadcasting.
+   * Use only for testing.
+   */
   broadcastInvalidCheckpointProposal?: boolean;
 };
 
@@ -40,7 +49,7 @@ export type CheckpointLastBlockData = {
   /** The per-block header for the last block in the checkpoint */
   blockHeader: BlockHeader;
   /** Index of this block within the checkpoint (should be the last index, e.g., numBlocks - 1) */
-  indexWithinCheckpoint: number; // REFACTOR(palla): Use branded type
+  indexWithinCheckpoint: IndexWithinCheckpoint;
   /** The sequence of transactions in the last block */
   txHashes: TxHash[];
   /** The tx in the last block (optional, for DA guarantees) */
@@ -151,13 +160,18 @@ export class CheckpointProposal extends Gossipable {
     checkpointHeader: CheckpointHeader,
     archiveRoot: Fr,
     lastBlockInfo: CheckpointLastBlockData | undefined,
-    payloadSigner: (payload: Buffer32) => Promise<Signature>,
+    payloadSigner: (payload: Buffer32, context: SigningContext) => Promise<Signature>,
   ): Promise<CheckpointProposal> {
-    // Sign the checkpoint payload
+    // Sign the checkpoint payload with CHECKPOINT_PROPOSAL duty type
     const tempProposal = new CheckpointProposal(checkpointHeader, archiveRoot, Signature.empty(), undefined);
-
     const checkpointHash = getHashedSignaturePayload(tempProposal, SignatureDomainSeparator.checkpointProposal);
-    const checkpointSignature = await payloadSigner(checkpointHash);
+
+    const checkpointContext: SigningContext = {
+      slot: checkpointHeader.slotNumber,
+      blockNumber: lastBlockInfo?.blockHeader?.globalVariables.blockNumber ?? BlockNumber(0),
+      dutyType: DutyType.CHECKPOINT_PROPOSAL,
+    };
+    const checkpointSignature = await payloadSigner(checkpointHash, checkpointContext);
 
     if (!lastBlockInfo) {
       return new CheckpointProposal(checkpointHeader, archiveRoot, checkpointSignature);
@@ -246,9 +260,13 @@ export class CheckpointProposal extends Gossipable {
 
     if (hasLastBlock) {
       const blockHeader = reader.readObject(BlockHeader);
-      const indexWithinCheckpoint = reader.readNumber();
+      const indexWithinCheckpoint = IndexWithinCheckpoint(reader.readNumber());
       const blockSignature = reader.readObject(Signature);
-      const txHashes = reader.readArray(reader.readNumber(), TxHash);
+      const txHashCount = reader.readNumber();
+      if (txHashCount > MAX_TXS_PER_BLOCK) {
+        throw new Error(`txHashes count ${txHashCount} exceeds maximum ${MAX_TXS_PER_BLOCK}`);
+      }
+      const txHashes = reader.readArray(txHashCount, TxHash);
 
       let signedTxs: SignedTxs | undefined;
       if (!reader.isEmpty()) {
@@ -298,7 +316,7 @@ export class CheckpointProposal extends Gossipable {
   static random(): CheckpointProposal {
     return new CheckpointProposal(CheckpointHeader.random(), Fr.random(), Signature.random(), {
       blockHeader: BlockHeader.random(),
-      indexWithinCheckpoint: Math.floor(Math.random() * 5),
+      indexWithinCheckpoint: IndexWithinCheckpoint(Math.floor(Math.random() * 5)),
       txHashes: [TxHash.random(), TxHash.random()],
       signature: Signature.random(),
     });

package/src/p2p/consensus_payload.ts

@@ -7,7 +7,6 @@ import type { FieldsOf } from '@aztec/foundation/types';
 import { encodeAbiParameters, parseAbiParameters } from 'viem';
 import { z } from 'zod';
 
-import type { L2Block } from '../block/l2_block.js';
 import type { Checkpoint } from '../checkpoint/checkpoint.js';
 import { CheckpointHeader } from '../rollup/checkpoint_header.js';
 import type { CheckpointProposal, CheckpointProposalCore } from './checkpoint_proposal.js';
@@ -76,10 +75,6 @@ export class ConsensusPayload implements Signable {
     return new ConsensusPayload(fields.header, fields.archive);
   }
 
-  static fromBlock(block: L2Block): ConsensusPayload {
-    return new ConsensusPayload(block.header.toCheckpointHeader(), block.archive.root);
-  }
-
   static fromCheckpoint(checkpoint: Checkpoint): ConsensusPayload {
     return new ConsensusPayload(checkpoint.header, checkpoint.archive.root);
   }

package/src/p2p/constants.ts

@@ -0,0 +1,3 @@
+export const MAX_TX_SIZE_KB: number = 512;
+
+export const MAX_MESSAGE_SIZE_KB: number = 10 * 1024;

package/src/p2p/index.ts

@@ -11,3 +11,4 @@ export * from './topic_type.js';
 export * from './client_type.js';
 export * from './message_validator.js';
 export * from './peer_error.js';
+export * from './constants.js';

package/src/p2p/message_validator.ts

@@ -1,10 +1,22 @@
 import type { PeerErrorSeverity } from './peer_error.js';
 
+/**
+ * Result of validating a P2P message.
+ * - 'accept': Message is valid and should be accepted and processed
+ * - 'ignore': Message should be ignored (not propagated or processed, but sender not penalized)
+ * - 'reject': Message is invalid (rejected and sender penalized)
+ */
+export type ValidationResult =
+  | { result: 'accept' }
+  | { result: 'ignore' }
+  | { result: 'reject'; severity: PeerErrorSeverity };
+
 /**
  * P2PValidator
  *
- * A validator for P2P messages, which returns a severity of error to be applied to the peer
+ * A validator for P2P messages, which returns a ValidationResult indicating
+ * whether to accept, ignore, or reject the message
  */
 export interface P2PValidator<T> {
-  validate(message: T): Promise<PeerErrorSeverity | undefined>;
+  validate(message: T): Promise<ValidationResult>;
 }

package/src/p2p/signed_txs.ts

@@ -4,6 +4,7 @@ import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
+import { MAX_TXS_PER_BLOCK } from '../deserialization/index.js';
 import { Tx } from '../tx/tx.js';
 import {
   SignatureDomainSeparator,
@@ -64,7 +65,11 @@ export class SignedTxs {
 
   static fromBuffer(buf: Buffer | BufferReader): SignedTxs {
     const reader = BufferReader.asReader(buf);
-    const txs = reader.readArray(reader.readNumber(), Tx);
+    const txCount = reader.readNumber();
+    if (txCount > MAX_TXS_PER_BLOCK) {
+      throw new Error(`txs count ${txCount} exceeds maximum ${MAX_TXS_PER_BLOCK}`);
+    }
+    const txs = reader.readArray(txCount, Tx);
     const signature = reader.readObject(Signature);
     return new SignedTxs(txs, signature);
   }

package/src/p2p/topic_type.ts

@@ -31,7 +31,7 @@ export function getTopicTypeForClientType(clientType: P2PClientType) {
   if (clientType === P2PClientType.Full) {
     return [TopicType.tx, TopicType.block_proposal, TopicType.checkpoint_proposal, TopicType.checkpoint_attestation];
   } else if (clientType === P2PClientType.Prover) {
-    return [TopicType.tx, TopicType.block_proposal];
+    return [TopicType.tx, TopicType.block_proposal, TopicType.checkpoint_proposal];
   } else {
     const _: never = clientType;
     return [TopicType.tx];

package/src/proofs/chonk_proof.ts

@@ -1,4 +1,5 @@
 import { CHONK_PROOF_LENGTH } from '@aztec/constants';
+import { times } from '@aztec/foundation/collection';
 import { randomBytes } from '@aztec/foundation/crypto/random';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
@@ -31,12 +32,15 @@ export class ChonkProof {
 
   static random() {
     // NB: Not using Fr.random here because it slows down some tests that require a large number of txs significantly.
+    // NB2: generate one fewer random bytes to not have to deal with buffers representing numbers greater than the field modulus
+    // NB3: a chonk proof can be compressed. Simulate this by filling 1/4 of the proof with zero data
     const reducedFrSize = Fr.SIZE_IN_BYTES - 1;
-    const randomFields = randomBytes(CHONK_PROOF_LENGTH * reducedFrSize);
-    const proof = Array.from(
-      { length: CHONK_PROOF_LENGTH },
-      (_, i) => new Fr(randomFields.subarray(i * reducedFrSize, (i + 1) * reducedFrSize)),
-    );
+    const nonZeroFields = Math.floor((3 * CHONK_PROOF_LENGTH) / 4);
+    const randomFields = randomBytes(nonZeroFields * Fr.SIZE_IN_BYTES);
+    const proof = [
+      ...times(nonZeroFields, i => new Fr(randomFields.subarray(i * reducedFrSize, (i + 1) * reducedFrSize))),
+      ...times(CHONK_PROOF_LENGTH - nonZeroFields, () => Fr.ZERO),
+    ];
     return new ChonkProof(proof);
   }
 

package/src/rollup/block_headers_hash.ts

@@ -5,7 +5,7 @@ import type { BlockHeader } from '../tx/block_header.js';
 
 export async function computeBlockHeadersHash(blockHeaders: BlockHeader[]): Promise<Fr> {
   const blockHeaderHashes = await Promise.all(blockHeaders.map(header => header.hash()));
-  // Must match the implementation in merge_block_rollups.nr, with the **wonky** rollup structure
+  // Must match the implementation in merge_block_rollups.nr, with the **unbalanced** rollup structure
   // (see validate_consecutive_block_rollups.nr > assert_rollups_filled_greedily.nr).
   const blockHeadersHash = await computeUnbalancedPoseidonRoot(blockHeaderHashes.map(hash => hash.toBuffer()));
   return Fr.fromBuffer(blockHeadersHash);

package/src/rollup/block_rollup_public_inputs.ts

@@ -48,8 +48,8 @@ export class BlockRollupPublicInputs {
     public timestamp: UInt64,
     /**
      * Hash of the headers of all blocks in this block range. It will be combined with the `blockHeadersHash` from
-     * other blocks in the same checkpoint to form a wonky tree. The root of that tree becomes the final hash stored in
-     * the checkpoint header, enabling validation of the blocks included in a checkpoint given their headers.
+     * other blocks in the same checkpoint to form an unbalanced tree. The root of that tree becomes the final hash
+     * stored in the checkpoint header, enabling validation of the blocks included in a checkpoint given their headers.
      */
     public blockHeadersHash: Fr,
     /**

package/src/rollup/checkpoint_header.ts

@@ -32,6 +32,14 @@ export class CheckpointHeader {
     public blobsHash: Fr,
     /** Root of the l1 to l2 messages subtree. */
     public inHash: Fr,
+    /**
+     * The root of the epoch out hash balanced tree. The out hash of the first checkpoint in the epoch is inserted at
+     * index 0, the second at index 1, and so on.
+     * Note: This is not necessarily the final epoch out hash. It includes only the out hashes of checkpoints up to and
+     * including the current checkpoint. Any subsequent checkpoints added to the same epoch are not reflected in this
+     * value.
+     */
+    public epochOutHash: Fr,
     /** Slot number of the L2 block */
     public slotNumber: SlotNumber,
     /** Timestamp of the L2 block. */
@@ -53,6 +61,7 @@ export class CheckpointHeader {
         blockHeadersHash: schemas.Fr,
         blobsHash: schemas.Fr,
         inHash: schemas.Fr,
+        epochOutHash: schemas.Fr,
         slotNumber: schemas.SlotNumber,
         timestamp: schemas.BigInt,
         coinbase: schemas.EthAddress,
@@ -69,6 +78,7 @@ export class CheckpointHeader {
       fields.blockHeadersHash,
       fields.blobsHash,
       fields.inHash,
+      fields.epochOutHash,
       fields.slotNumber,
       fields.timestamp,
       fields.coinbase,
@@ -90,6 +100,7 @@ export class CheckpointHeader {
       reader.readObject(Fr),
       reader.readObject(Fr),
       reader.readObject(Fr),
+      reader.readObject(Fr),
       SlotNumber(Fr.fromBuffer(reader).toNumber()),
       reader.readUInt64(),
       reader.readObject(EthAddress),
@@ -105,6 +116,7 @@ export class CheckpointHeader {
       this.blockHeadersHash.equals(other.blockHeadersHash) &&
       this.blobsHash.equals(other.blobsHash) &&
       this.inHash.equals(other.inHash) &&
+      this.epochOutHash.equals(other.epochOutHash) &&
       this.slotNumber === other.slotNumber &&
       this.timestamp === other.timestamp &&
       this.coinbase.equals(other.coinbase) &&
@@ -132,6 +144,7 @@ export class CheckpointHeader {
       this.blockHeadersHash,
       this.blobsHash,
       this.inHash,
+      this.epochOutHash,
       new Fr(this.slotNumber),
       bigintToUInt64BE(this.timestamp),
       this.coinbase,
@@ -151,6 +164,7 @@ export class CheckpointHeader {
       blockHeadersHash: Fr.ZERO,
       blobsHash: Fr.ZERO,
       inHash: Fr.ZERO,
+      epochOutHash: Fr.ZERO,
       slotNumber: SlotNumber.ZERO,
       timestamp: 0n,
       coinbase: EthAddress.ZERO,
@@ -167,6 +181,7 @@ export class CheckpointHeader {
       blockHeadersHash: Fr.random(),
       blobsHash: Fr.random(),
       inHash: Fr.random(),
+      epochOutHash: Fr.random(),
       slotNumber: SlotNumber(Math.floor(Math.random() * 1000) + 1),
       timestamp: BigInt(Math.floor(Date.now() / 1000)),
       coinbase: EthAddress.random(),
@@ -183,6 +198,7 @@ export class CheckpointHeader {
       this.blockHeadersHash.isZero() &&
       this.blobsHash.isZero() &&
       this.inHash.isZero() &&
+      this.epochOutHash.isZero() &&
       this.slotNumber === 0 &&
       this.timestamp === 0n &&
       this.coinbase.isZero() &&
@@ -210,6 +226,7 @@ export class CheckpointHeader {
       Fr.fromString(header.blockHeadersHash),
       Fr.fromString(header.blobsHash),
       Fr.fromString(header.inHash),
+      Fr.fromString(header.outHash),
       SlotNumber.fromBigInt(header.slotNumber),
       header.timestamp,
       new EthAddress(hexToBuffer(header.coinbase)),
@@ -233,6 +250,7 @@ export class CheckpointHeader {
       blockHeadersHash: this.blockHeadersHash.toString(),
       blobsHash: this.blobsHash.toString(),
       inHash: this.inHash.toString(),
+      outHash: this.epochOutHash.toString(),
       slotNumber: BigInt(this.slotNumber),
       timestamp: this.timestamp,
       coinbase: this.coinbase.toString(),
@@ -251,6 +269,7 @@ export class CheckpointHeader {
       blockHeadersHash: this.blockHeadersHash.toString(),
       blobsHash: this.blobsHash.toString(),
       inHash: this.inHash.toString(),
+      epochOutHash: this.epochOutHash.toString(),
       slotNumber: this.slotNumber,
       timestamp: this.timestamp,
       coinbase: this.coinbase.toString(),
@@ -266,6 +285,7 @@ export class CheckpointHeader {
   blockHeadersHash: ${this.blockHeadersHash.toString()},
   blobsHash: ${inspect(this.blobsHash)},
   inHash: ${inspect(this.inHash)},
+  epochOutHash: ${inspect(this.epochOutHash)},
   slotNumber: ${this.slotNumber},
   timestamp: ${this.timestamp},
   coinbase: ${this.coinbase.toString()},

package/src/rollup/checkpoint_rollup_public_inputs.ts

@@ -28,13 +28,17 @@ export class CheckpointRollupPublicInputs {
      */
     public newArchive: AppendOnlyTreeSnapshot,
     /**
-     * The hashes of the headers of the constituent checkpoints.
+     * The out hash tree snapshot immediately before this checkpoint range.
      */
-    public checkpointHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public previousOutHash: AppendOnlyTreeSnapshot,
     /**
-     * The `out_hash` values from all checkpoints in this checkpoint range.
+     * The out hash tree snapshot after applying this checkpoint range.
      */
-    public outHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public newOutHash: AppendOnlyTreeSnapshot,
+    /**
+     * The hashes of the headers of the constituent checkpoints.
+     */
+    public checkpointHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
     /**
      * The summed transaction fees and recipients of the constituent checkpoints.
      */
@@ -59,7 +63,8 @@ export class CheckpointRollupPublicInputs {
       reader.readObject(EpochConstantData),
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readObject(AppendOnlyTreeSnapshot),
-      reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(AppendOnlyTreeSnapshot),
       reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
       reader.readArray(AZTEC_MAX_EPOCH_DURATION, FeeRecipient),
       reader.readObject(BlobAccumulator),
@@ -73,8 +78,9 @@ export class CheckpointRollupPublicInputs {
       this.constants,
       this.previousArchive,
       this.newArchive,
+      this.previousOutHash,
+      this.newOutHash,
       this.checkpointHeaderHashes,
-      this.outHashes,
       this.fees,
       this.startBlobAccumulator,
       this.endBlobAccumulator,

package/src/rollup/checkpoint_root_rollup_private_inputs.ts

@@ -1,5 +1,5 @@
 import { BlobAccumulator, FinalBlobBatchingChallenges } from '@aztec/blob-lib/types';
-import { ARCHIVE_HEIGHT, BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB } from '@aztec/constants';
+import { ARCHIVE_HEIGHT, BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB, OUT_HASH_TREE_HEIGHT } from '@aztec/constants';
 import { BLS12Point } from '@aztec/foundation/curves/bls12';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
@@ -8,6 +8,7 @@ import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { BlockRollupPublicInputs } from './block_rollup_public_inputs.js';
 
@@ -21,6 +22,14 @@ export class CheckpointRootRollupHints {
      * Hint for checking the hash of previous_block_header is the last leaf of the previous archive.
      */
     public previousArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
+    /**
+     * The out hash tree snapshot immediately before this checkpoint.
+     */
+    public previousOutHash: AppendOnlyTreeSnapshot,
+    /**
+     * Hint for inserting the new out hash into the out hash tree.
+     */
+    public newOutHashSiblingPath: Tuple<Fr, typeof OUT_HASH_TREE_HEIGHT>,
     /**
      * The current blob accumulation state across the epoch.
      */
@@ -54,6 +63,8 @@ export class CheckpointRootRollupHints {
     return [
       fields.previousBlockHeader,
       fields.previousArchiveSiblingPath,
+      fields.previousOutHash,
+      fields.newOutHashSiblingPath,
       fields.startBlobAccumulator,
       fields.finalBlobChallenges,
       fields.blobFields,
@@ -71,6 +82,8 @@ export class CheckpointRootRollupHints {
     return new CheckpointRootRollupHints(
       BlockHeader.fromBuffer(reader),
       reader.readArray(ARCHIVE_HEIGHT, Fr),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readArray(OUT_HASH_TREE_HEIGHT, Fr),
       reader.readObject(BlobAccumulator),
       reader.readObject(FinalBlobBatchingChallenges),
       // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'

package/src/rollup/root_rollup_public_inputs.ts

@@ -21,7 +21,10 @@ export class RootRollupPublicInputs {
     public previousArchiveRoot: Fr,
     /** Root of the archive tree after this rollup is processed */
     public endArchiveRoot: Fr,
-    /** Root of the unbalanced merkle tree consisting of the `out_hash` values from all checkpoints in this rollup. */
+    /**
+     * Root of the balanced merkle tree consisting of the out hashes of all checkpoints in this epoch.
+     * The out hash of the first checkpoint in the epoch is inserted at index 0, the second at index 1, and so on.
+     */
     public outHash: Fr,
     /** Hashes of checkpoint headers for this rollup. */
     public checkpointHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,

package/src/tests/factories.ts

@@ -87,7 +87,6 @@ import {
 import { PublicDataRead } from '../avm/public_data_read.js';
 import { PublicDataWrite } from '../avm/public_data_write.js';
 import { AztecAddress } from '../aztec-address/index.js';
-import { L2BlockHeader } from '../block/l2_block_header.js';
 import type { L2Tips } from '../block/l2_block_source.js';
 import {
   type ContractClassPublic,
@@ -850,7 +849,8 @@ export function makeCheckpointRollupPublicInputs(seed = 0) {
     makeEpochConstantData(seed),
     makeAppendOnlyTreeSnapshot(seed + 0x100),
     makeAppendOnlyTreeSnapshot(seed + 0x200),
-    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => fr(seed), 0x300),
+    makeAppendOnlyTreeSnapshot(seed + 0x300),
+    makeAppendOnlyTreeSnapshot(seed + 0x350),
     makeTuple(AZTEC_MAX_EPOCH_DURATION, () => fr(seed), 0x400),
     makeTuple(AZTEC_MAX_EPOCH_DURATION, () => makeFeeRecipient(seed), 0x500),
     makeBlobAccumulator(seed + 0x600),
@@ -910,40 +910,20 @@ export function makeBlockHeader(
   });
 }
 
-export function makeL2BlockHeader(
-  seed = 0,
-  blockNumber?: number,
-  slotNumber?: number,
-  overrides: Partial<FieldsOf<L2BlockHeader>> = {},
-) {
-  return new L2BlockHeader(
-    makeAppendOnlyTreeSnapshot(seed + 0x100),
-    overrides?.blobsHash ?? fr(seed + 0x200),
-    overrides?.inHash ?? fr(seed + 0x300),
-    overrides?.state ?? makeStateReference(seed + 0x600),
-    makeGlobalVariables((seed += 0x700), {
-      ...(blockNumber !== undefined ? { blockNumber: BlockNumber(blockNumber) } : {}),
-      ...(slotNumber !== undefined ? { slotNumber: SlotNumber(slotNumber) } : {}),
-    }),
-    new Fr(seed + 0x800),
-    new Fr(seed + 0x900),
-    new Fr(seed + 0xa00),
-    new Fr(seed + 0xb00),
-  );
-}
-
-export function makeCheckpointHeader(seed = 0) {
+export function makeCheckpointHeader(seed = 0, overrides: Partial<FieldsOf<CheckpointHeader>> = {}) {
   return CheckpointHeader.from({
     lastArchiveRoot: fr(seed + 0x100),
     blockHeadersHash: fr(seed + 0x150),
     blobsHash: fr(seed + 0x200),
     inHash: fr(seed + 0x210),
+    epochOutHash: fr(seed + 0x220),
     slotNumber: SlotNumber(seed + 0x300),
     timestamp: BigInt(seed + 0x400),
     coinbase: makeEthAddress(seed + 0x500),
     feeRecipient: makeAztecAddress(seed + 0x600),
     gasFees: makeGasFees(seed + 0x700),
     totalManaUsed: fr(seed + 0x800),
+    ...overrides,
   });
 }
 
@@ -1759,7 +1739,7 @@ export function makeL2Tips(
       ? typeof checkpointNumber === 'number'
         ? CheckpointNumber(checkpointNumber)
         : checkpointNumber
-      : CheckpointNumber(bn);
+      : CheckpointNumber.fromBlockNumber(bn);
   const cph = checkpointHash ?? hash;
   return {
     proposed: { number: bn, hash },

package/src/tests/jest.ts

@@ -20,7 +20,7 @@ export function equalL2Blocks(a: any, b: any) {
     // use a custom comparator because the blockHash property is lazily computed and one instance might not have it
     return aAsL2Block.toBuffer().equals(bAsL2Block.toBuffer());
   } else if (aAsL2Block || bAsL2Block) {
-    // one value is an L2block and the other isn't. Definitely not equal.
+    // one value is an L2Block and the other isn't. Definitely not equal.
     return false;
   } else {
     // we don't know what they are, tell Jest to keep looking