@aztec/stdlib 0.0.1-commit.d3ec352c → 0.0.1-commit.d6f2b3f94

package/src/tests/mocks.ts

@@ -6,23 +6,25 @@ import {
   MAX_NULLIFIERS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
 } from '@aztec/constants';
-import { makeTuple } from '@aztec/foundation/array';
-import { BlockNumber } from '@aztec/foundation/branded-types';
+import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
+import { BlockNumber, CheckpointNumber, IndexWithinCheckpoint, SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { padArrayEnd, times } from '@aztec/foundation/collection';
-import { Secp256k1Signer, randomBytes } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { randomBytes } from '@aztec/foundation/crypto/random';
+import { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Signature } from '@aztec/foundation/eth-signature';
 
 import type { ContractArtifact } from '../abi/abi.js';
+import { PublicTxEffect } from '../avm/avm.js';
+import type { AvmAccumulatedData } from '../avm/avm_accumulated_data.js';
 import { AvmCircuitPublicInputs } from '../avm/avm_circuit_public_inputs.js';
 import { PublicDataWrite } from '../avm/public_data_write.js';
 import { RevertCode } from '../avm/revert_code.js';
 import { AztecAddress } from '../aztec-address/index.js';
-import { CommitteeAttestation, L2BlockHeader } from '../block/index.js';
-import { L2Block } from '../block/l2_block.js';
+import { CheckpointedL2Block, CommitteeAttestation, L2Block } from '../block/index.js';
 import type { CommitteeAttestationsAndSigners } from '../block/proposal/attestations_and_signers.js';
-import { PublishedL2Block } from '../block/published_l2_block.js';
-import type { Checkpoint } from '../checkpoint/checkpoint.js';
+import { Checkpoint } from '../checkpoint/checkpoint.js';
 import { L1PublishedData } from '../checkpoint/published_checkpoint.js';
 import { computeContractAddressFromInstance } from '../contract/contract_address.js';
 import { getContractClassFromArtifact } from '../contract/contract_class.js';
@@ -43,12 +45,15 @@ import {
 import { PrivateToAvmAccumulatedData } from '../kernel/private_to_avm_accumulated_data.js';
 import { PrivateToPublicAccumulatedDataBuilder } from '../kernel/private_to_public_accumulated_data_builder.js';
 import { PublicCallRequestArrayLengths } from '../kernel/public_call_request.js';
-import { BlockAttestation } from '../p2p/block_attestation.js';
+import { computeInHashFromL1ToL2Messages } from '../messaging/in_hash.js';
 import { BlockProposal } from '../p2p/block_proposal.js';
+import { CheckpointAttestation } from '../p2p/checkpoint_attestation.js';
+import { CheckpointProposal } from '../p2p/checkpoint_proposal.js';
 import { ConsensusPayload } from '../p2p/consensus_payload.js';
 import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from '../p2p/signature_utils.js';
 import { ChonkProof } from '../proofs/chonk_proof.js';
 import { ProvingRequestType } from '../proofs/proving_request_type.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import {
   BlockHeader,
@@ -70,9 +75,9 @@ import {
   makeAvmCircuitInputs,
   makeAztecAddress,
   makeBlockHeader,
+  makeCheckpointHeader,
   makeGas,
   makeGlobalVariables,
-  makeL2BlockHeader,
   makePrivateToPublicAccumulatedData,
   makePrivateToRollupAccumulatedData,
   makeProtocolContracts,
@@ -92,12 +97,14 @@ export const mockTx = async (
     publicCalldataSize = 2,
     feePayer,
     chonkProof = ChonkProof.random(),
+    maxFeesPerGas = new GasFees(10, 10),
     maxPriorityFeesPerGas,
     gasUsed = Gas.empty(),
     chainId = Fr.ZERO,
     version = Fr.ZERO,
     vkTreeRoot = Fr.ZERO,
     protocolContractsHash = Fr.ZERO,
+    anchorBlockHeader = BlockHeader.empty(),
   }: {
     numberOfNonRevertiblePublicCallRequests?: number;
     numberOfRevertiblePublicCallRequests?: number;
@@ -106,12 +113,14 @@ export const mockTx = async (
     publicCalldataSize?: number;
     feePayer?: AztecAddress;
     chonkProof?: ChonkProof;
+    maxFeesPerGas?: GasFees;
     maxPriorityFeesPerGas?: GasFees;
     gasUsed?: Gas;
     chainId?: Fr;
     version?: Fr;
     vkTreeRoot?: Fr;
     protocolContractsHash?: Fr;
+    anchorBlockHeader?: BlockHeader;
   } = {},
 ) => {
   const totalPublicCallRequests =
@@ -121,10 +130,8 @@ export const mockTx = async (
   const isForPublic = totalPublicCallRequests > 0;
   const data = PrivateKernelTailCircuitPublicInputs.empty();
   const firstNullifier = new Nullifier(new Fr(seed + 1), Fr.ZERO, 0);
-  data.constants.txContext.gasSettings = GasSettings.default({
-    maxFeesPerGas: new GasFees(10, 10),
-    maxPriorityFeesPerGas,
-  });
+  data.constants.anchorBlockHeader = anchorBlockHeader;
+  data.constants.txContext.gasSettings = GasSettings.default({ maxFeesPerGas, maxPriorityFeesPerGas });
   data.feePayer = feePayer ?? (await AztecAddress.random());
   data.gasUsed = gasUsed;
   data.constants.txContext.chainId = chainId;
@@ -200,6 +207,7 @@ export async function mockProcessedTx({
   // The default gasUsed is the tx overhead.
   gasUsed = Gas.from({ daGas: FIXED_DA_GAS, l2Gas: FIXED_L2_GAS }),
   privateOnly = false,
+  avmAccumulatedData,
   ...mockTxOpts
 }: {
   seed?: number;
@@ -211,6 +219,7 @@ export async function mockProcessedTx({
   protocolContracts?: ProtocolContracts;
   feePaymentPublicDataWrite?: PublicDataWrite;
   privateOnly?: boolean;
+  avmAccumulatedData?: Partial<FieldsOf<AvmAccumulatedData>>;
 } & Parameters<typeof mockTx>[1] = {}) {
   seed *= 0x1000; // Avoid clashing with the previous mock values if seed only increases by 1.
   anchorBlockHeader ??= db?.getInitialHeader() ?? makeBlockHeader(seed);
@@ -290,19 +299,22 @@ export async function mockProcessedTx({
     avmOutput.previousRevertibleAccumulatedDataArrayLengths =
       avmOutput.previousRevertibleAccumulatedData.getArrayLengths();
     // Assign final data emitted from avm.
-    avmOutput.accumulatedData.noteHashes = revertibleData.noteHashes;
-    avmOutput.accumulatedData.nullifiers = padArrayEnd(
-      nonRevertibleData.nullifiers.concat(revertibleData.nullifiers).filter(n => !n.isEmpty()),
-      Fr.ZERO,
-      MAX_NULLIFIERS_PER_TX,
-    );
-    avmOutput.accumulatedData.l2ToL1Msgs = revertibleData.l2ToL1Msgs;
-    avmOutput.accumulatedData.publicDataWrites = makeTuple(
-      MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-      i => new PublicDataWrite(new Fr(i), new Fr(i + 10)),
-      seed + 0x2000,
-    );
-    avmOutput.accumulatedData.publicDataWrites[0] = feePaymentPublicDataWrite;
+    avmOutput.accumulatedData.noteHashes = avmAccumulatedData?.noteHashes ?? revertibleData.noteHashes;
+    avmOutput.accumulatedData.nullifiers =
+      avmAccumulatedData?.nullifiers ??
+      padArrayEnd(
+        nonRevertibleData.nullifiers.concat(revertibleData.nullifiers).filter(n => !n.isEmpty()),
+        Fr.ZERO,
+        MAX_NULLIFIERS_PER_TX,
+      );
+    avmOutput.accumulatedData.l2ToL1Msgs = avmAccumulatedData?.l2ToL1Msgs ?? revertibleData.l2ToL1Msgs;
+    avmOutput.accumulatedData.publicDataWrites =
+      avmAccumulatedData?.publicDataWrites ??
+      makeTuple(
+        MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+        i => (i === 0 ? feePaymentPublicDataWrite : new PublicDataWrite(new Fr(i), new Fr(i + 10))),
+        seed + 0x2000,
+      );
     avmOutput.accumulatedDataArrayLengths = avmOutput.accumulatedData.getArrayLengths();
     avmOutput.gasSettings = gasSettings;
     // Note: The fee is computed from the tx's gas used, which only includes the gas used in private. But this shouldn't
@@ -320,12 +332,24 @@ export async function mockProcessedTx({
     } satisfies GasUsed;
 
     await tx.recomputeHash();
+
+    const publicTxEffect = new PublicTxEffect(
+      avmOutput.transactionFee,
+      avmOutput.accumulatedData.noteHashes.filter(h => !h.isZero()),
+      avmOutput.accumulatedData.nullifiers.filter(h => !h.isZero()),
+      avmOutput.accumulatedData.l2ToL1Msgs.filter(h => !h.isEmpty()),
+      avmOutput.accumulatedData.publicLogs.toLogs(),
+      avmOutput.accumulatedData.publicDataWrites.filter(h => !h.isEmpty()),
+    );
+
     return makeProcessedTxFromTxWithPublicCalls(
       tx,
+      globalVariables,
       {
         type: ProvingRequestType.PUBLIC_VM,
         inputs: avmCircuitInputs,
       },
+      publicTxEffect,
       gasUsed,
       RevertCode.OK,
       undefined /* revertReason */,
@@ -339,7 +363,6 @@ const emptyPrivateCallExecutionResult = () =>
     Buffer.from(''),
     new Map(),
     PrivateCircuitPublicInputs.empty(),
-    new Map(),
     [],
     new Map(),
     [],
@@ -369,6 +392,76 @@ export const mockSimulatedTx = async (seed = 1) => {
   return new TxSimulationResult(privateExecutionResult, tx.data, output);
 };
 
+export function mockL1ToL2Messages(numL1ToL2Messages: number): Fr[] {
+  return Array.from({ length: numL1ToL2Messages }, () => Fr.random());
+}
+
+export async function mockCheckpointAndMessages(
+  checkpointNumber: CheckpointNumber,
+  {
+    startBlockNumber = BlockNumber(1),
+    numBlocks = 1,
+    blocks,
+    numTxsPerBlock = 1,
+    numL1ToL2Messages = 1,
+    makeBlockOptions = () => ({}),
+    previousArchive,
+    maxEffects,
+    ...options
+  }: {
+    startBlockNumber?: BlockNumber;
+    numBlocks?: number;
+    numTxsPerBlock?: number;
+    numL1ToL2Messages?: number;
+    makeBlockOptions?: (blockNumber: BlockNumber) => Partial<Parameters<typeof L2Block.random>[1]>;
+    previousArchive?: AppendOnlyTreeSnapshot;
+    blocks?: L2Block[];
+    maxEffects?: number;
+  } & Partial<Parameters<typeof Checkpoint.random>[1]> &
+    Partial<Parameters<typeof L2Block.random>[1]> = {},
+) {
+  const slotNumber = options.slotNumber ?? SlotNumber(Number(checkpointNumber) * 10);
+  const blocksAndMessages = [];
+  // Track the previous block's archive to ensure consecutive blocks have consistent archive roots.
+  // The current block's header.lastArchive must equal the previous block's archive.
+  let lastArchive: AppendOnlyTreeSnapshot | undefined = previousArchive;
+  // Pass maxEffects via txOptions so it reaches TxEffect.random
+  const txOptions = maxEffects !== undefined ? { maxEffects } : {};
+  for (let i = 0; i < (blocks?.length ?? numBlocks); i++) {
+    const blockNumber = BlockNumber(startBlockNumber + i);
+    const { block, messages } = {
+      block:
+        blocks?.[i] ??
+        (await L2Block.random(blockNumber, {
+          checkpointNumber,
+          indexWithinCheckpoint: IndexWithinCheckpoint(i),
+          txsPerBlock: numTxsPerBlock,
+          txOptions,
+          slotNumber,
+          ...options,
+          ...makeBlockOptions(blockNumber),
+          ...(lastArchive ? { lastArchive } : {}),
+        })),
+      messages: mockL1ToL2Messages(numL1ToL2Messages),
+    };
+    // Update lastArchive for the next block
+    lastArchive = block.archive;
+    blocksAndMessages.push({ block, messages });
+  }
+
+  const messages = blocksAndMessages[0].messages;
+  const inHash = computeInHashFromL1ToL2Messages(messages);
+  const checkpoint = await Checkpoint.random(checkpointNumber, { numBlocks: 0, slotNumber, inHash, ...options });
+  checkpoint.blocks = blocksAndMessages.map(({ block }) => block);
+  // Set the checkpoint's archive to match the last block's archive for proper chaining.
+  // When the archiver reconstructs checkpoints from L1, it uses the checkpoint's archive root
+  // from the L1 event to set the last block's archive. Without this, the archive chain breaks.
+  checkpoint.archive = lastArchive!;
+
+  // Return lastArchive so callers can chain it across multiple checkpoints
+  return { checkpoint, messages, lastArchive };
+}
+
 export const randomContractArtifact = (): ContractArtifact => ({
   name: randomBytes(4).toString('hex'),
   functions: [],
@@ -406,28 +499,52 @@ export interface MakeConsensusPayloadOptions {
   signer?: Secp256k1Signer;
   attesterSigner?: Secp256k1Signer;
   proposerSigner?: Secp256k1Signer;
-  header?: L2BlockHeader;
+  header?: CheckpointHeader;
   archive?: Fr;
   txHashes?: TxHash[];
   txs?: Tx[];
 }
 
+export interface MakeBlockProposalOptions {
+  signer?: Secp256k1Signer;
+  blockHeader?: BlockHeader;
+  indexWithinCheckpoint?: IndexWithinCheckpoint;
+  inHash?: Fr;
+  archiveRoot?: Fr;
+  txHashes?: TxHash[];
+  txs?: Tx[];
+}
+
+export interface MakeCheckpointProposalOptions {
+  signer?: Secp256k1Signer;
+  checkpointHeader?: CheckpointHeader;
+  archiveRoot?: Fr;
+  /** Options for the lastBlock - if undefined, no lastBlock is included */
+  lastBlock?: {
+    blockHeader?: BlockHeader;
+    indexWithinCheckpoint?: IndexWithinCheckpoint;
+    txHashes?: TxHash[];
+    txs?: Tx[];
+  };
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 const makeAndSignConsensusPayload = (
   domainSeparator: SignatureDomainSeparator,
   options?: MakeConsensusPayloadOptions,
 ) => {
-  const header = options?.header ?? makeL2BlockHeader(1);
+  const header = options?.header ?? makeCheckpointHeader(1);
   const { signer = Secp256k1Signer.random(), archive = Fr.random() } = options ?? {};
 
   const payload = ConsensusPayload.fromFields({
-    header: header.toCheckpointHeader(),
+    header,
     archive,
   });
 
   const hash = getHashedSignaturePayloadEthSignedMessage(payload, domainSeparator);
   const signature = signer.sign(hash);
 
-  return { blockNumber: header.globalVariables.blockNumber, payload, signature };
+  return { blockNumber: header.slotNumber, payload, signature };
 };
 
 export const makeAndSignCommitteeAttestationsAndSigners = (
@@ -441,79 +558,149 @@ export const makeAndSignCommitteeAttestationsAndSigners = (
   return signer.sign(hash);
 };
 
-export const makeBlockProposal = (options?: MakeConsensusPayloadOptions): BlockProposal => {
-  const { payload, signature } = makeAndSignConsensusPayload(SignatureDomainSeparator.blockProposal, options);
+export const makeBlockProposal = (options?: MakeBlockProposalOptions): Promise<BlockProposal> => {
+  const blockHeader = options?.blockHeader ?? makeBlockHeader(1);
+  const indexWithinCheckpoint = options?.indexWithinCheckpoint ?? IndexWithinCheckpoint(0);
+  const inHash = options?.inHash ?? Fr.random();
+  const archiveRoot = options?.archiveRoot ?? Fr.random();
   const txHashes = options?.txHashes ?? [0, 1, 2, 3, 4, 5].map(() => TxHash.random());
-  return new BlockProposal(payload, signature, txHashes, options?.txs ?? []);
+  const txs = options?.txs;
+  const signer = options?.signer ?? Secp256k1Signer.random();
+
+  return BlockProposal.createProposalFromSigner(
+    blockHeader,
+    indexWithinCheckpoint,
+    inHash,
+    archiveRoot,
+    txHashes,
+    txs,
+    (_payload, _context) => Promise.resolve(signer.signMessage(_payload)),
+  );
 };
 
-// TODO(https://github.com/AztecProtocol/aztec-packages/issues/8028)
-export const makeBlockAttestation = (options: MakeConsensusPayloadOptions = {}): BlockAttestation => {
-  const header = options.header ?? makeL2BlockHeader(1);
-  const { signer, attesterSigner = signer, proposerSigner = signer, archive = Fr.random() } = options;
+export const makeCheckpointProposal = (options?: MakeCheckpointProposalOptions): Promise<CheckpointProposal> => {
+  const blockHeader = options?.lastBlock?.blockHeader ?? makeBlockHeader(1);
+  const checkpointHeader = options?.checkpointHeader ?? makeCheckpointHeader(1);
+  const archiveRoot = options?.archiveRoot ?? Fr.random();
+  const signer = options?.signer ?? Secp256k1Signer.random();
+
+  // Build lastBlock info if provided
+  const lastBlockInfo = options?.lastBlock
+    ? {
+        blockHeader,
+        indexWithinCheckpoint: options.lastBlock.indexWithinCheckpoint ?? IndexWithinCheckpoint(4), // Last block in a 5-block checkpoint
+        txHashes: options.lastBlock.txHashes ?? [0, 1, 2, 3, 4, 5].map(() => TxHash.random()),
+        txs: options.lastBlock.txs,
+      }
+    : undefined;
+
+  return CheckpointProposal.createProposalFromSigner(checkpointHeader, archiveRoot, lastBlockInfo, payload =>
+    Promise.resolve(signer.signMessage(payload)),
+  );
+};
 
-  const payload = ConsensusPayload.fromFields({
-    header: header.toCheckpointHeader(),
-    archive,
-  });
+/**
+ * Options for creating a checkpoint attestation
+ */
+export type MakeCheckpointAttestationOptions = {
+  header?: CheckpointHeader;
+  archive?: Fr;
+  attesterSigner?: Secp256k1Signer;
+  proposerSigner?: Secp256k1Signer;
+  signer?: Secp256k1Signer;
+};
+
+/**
+ * Create a checkpoint attestation for testing
+ */
+export const makeCheckpointAttestation = (options: MakeCheckpointAttestationOptions = {}): CheckpointAttestation => {
+  const header = options.header ?? makeCheckpointHeader(1);
+  const archive = options.archive ?? Fr.random();
+  const { signer, attesterSigner = signer, proposerSigner = signer } = options;
+
+  const payload = new ConsensusPayload(header, archive);
 
-  return makeBlockAttestationFromPayload(payload, attesterSigner, proposerSigner);
+  // Sign as attester
+  const attestationHash = getHashedSignaturePayloadEthSignedMessage(
+    payload,
+    SignatureDomainSeparator.checkpointAttestation,
+  );
+  const attestationSigner = attesterSigner ?? Secp256k1Signer.random();
+  const attestationSignature = attestationSigner.sign(attestationHash);
+
+  // Sign as proposer - use CheckpointProposal's payload format (serializeToBuffer)
+  // This is different from ConsensusPayload's format (ABI encoding)
+  const proposalSignerToUse = proposerSigner ?? Secp256k1Signer.random();
+  const tempProposal = new CheckpointProposal(header, archive, Signature.empty());
+  const proposalHash = getHashedSignaturePayloadEthSignedMessage(
+    tempProposal,
+    SignatureDomainSeparator.checkpointProposal,
+  );
+  const proposerSignature = proposalSignerToUse.sign(proposalHash);
+
+  return new CheckpointAttestation(payload, attestationSignature, proposerSignature);
 };
 
-export const makeAttestationFromCheckpoint = (
-  checkpoint: Checkpoint,
+/**
+ * Create a checkpoint attestation from a checkpoint proposal
+ */
+export const makeCheckpointAttestationFromProposal = (
+  proposal: CheckpointProposal,
   attesterSigner?: Secp256k1Signer,
-  proposerSigner?: Secp256k1Signer,
-): BlockAttestation => {
-  const header = checkpoint.header;
-  const archive = checkpoint.archive.root;
+): CheckpointAttestation => {
+  const payload = new ConsensusPayload(proposal.checkpointHeader, proposal.archive);
 
-  const payload = ConsensusPayload.fromFields({
-    header,
-    archive,
-  });
+  // Sign as attester
+  const attestationHash = getHashedSignaturePayloadEthSignedMessage(
+    payload,
+    SignatureDomainSeparator.checkpointAttestation,
+  );
+  const attestationSigner = attesterSigner ?? Secp256k1Signer.random();
+  const attestationSignature = attestationSigner.sign(attestationHash);
 
-  return makeBlockAttestationFromPayload(payload, attesterSigner, proposerSigner);
+  // Use the proposal's signature as the proposer signature
+  return new CheckpointAttestation(payload, attestationSignature, proposal.signature);
 };
 
-export const makeBlockAttestationFromBlock = (
-  block: L2Block,
+/**
+ * Create a checkpoint attestation from a checkpoint
+ */
+export const makeCheckpointAttestationFromCheckpoint = (
+  checkpoint: Checkpoint,
   attesterSigner?: Secp256k1Signer,
   proposerSigner?: Secp256k1Signer,
-): BlockAttestation => {
-  const header = block.header;
-  const archive = block.archive.root;
-
-  const payload = ConsensusPayload.fromFields({
-    header: header.toCheckpointHeader(),
-    archive,
-  });
+): CheckpointAttestation => {
+  const header = checkpoint.header;
+  const archive = checkpoint.archive.root;
 
-  return makeBlockAttestationFromPayload(payload, attesterSigner, proposerSigner);
+  return makeCheckpointAttestation({ header, archive, attesterSigner, proposerSigner });
 };
 
-export const makeBlockAttestationFromPayload = (
-  payload: ConsensusPayload,
+/**
+ * Create a checkpoint attestation from an L2Block
+ * Note: This is a compatibility function for tests. L2Block doesn't have a checkpoint header directly.
+ */
+export const makeCheckpointAttestationFromBlock = (
+  block: L2Block,
   attesterSigner?: Secp256k1Signer,
   proposerSigner?: Secp256k1Signer,
-): BlockAttestation => {
-  // Sign as attester
-  const attestationHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
-  const attestationSigner = attesterSigner ?? Secp256k1Signer.random();
-  const attestationSignature = attestationSigner.sign(attestationHash);
-
-  // Sign as proposer
-  const proposalHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockProposal);
-  const proposalSignerToUse = proposerSigner ?? Secp256k1Signer.random();
-  const proposerSignature = proposalSignerToUse.sign(proposalHash);
+): CheckpointAttestation => {
+  // For L2Block, we create a minimal checkpoint header for testing purposes
+  const header = CheckpointHeader.empty({
+    lastArchiveRoot: block.header.lastArchive.root,
+    slotNumber: block.slot,
+    timestamp: block.timestamp,
+    blockHeadersHash: Fr.ZERO, // Would need to compute from block header hash
+  });
+  const archive = block.archive.root;
 
-  return new BlockAttestation(payload, attestationSignature, proposerSignature);
+  return makeCheckpointAttestation({ header, archive, attesterSigner, proposerSigner });
 };
 
 export async function randomPublishedL2Block(
   l2BlockNumber: number,
   opts: { signers?: Secp256k1Signer[] } = {},
-): Promise<PublishedL2Block> {
+): Promise<CheckpointedL2Block> {
   const block = await L2Block.random(BlockNumber(l2BlockNumber));
   const l1 = L1PublishedData.fromFields({
     blockNumber: BigInt(block.number),
@@ -522,9 +709,19 @@ export async function randomPublishedL2Block(
   });
 
   const signers = opts.signers ?? times(3, () => Secp256k1Signer.random());
-  const atts = await Promise.all(signers.map(signer => makeBlockAttestationFromBlock(block, signer)));
+  const checkpoint = await Checkpoint.random(CheckpointNumber.fromBlockNumber(BlockNumber(l2BlockNumber)), {
+    numBlocks: 0,
+  });
+  checkpoint.blocks = [block];
+  const atts = signers.map(signer =>
+    makeCheckpointAttestation({
+      signer,
+      archive: block.archive.root,
+      header: checkpoint.header,
+    }),
+  );
   const attestations = atts.map(
     (attestation, i) => new CommitteeAttestation(signers[i].address, attestation.signature),
   );
-  return new PublishedL2Block(block, l1, attestations);
+  return new CheckpointedL2Block(CheckpointNumber.fromBlockNumber(BlockNumber(l2BlockNumber)), block, l1, attestations);
 }

package/src/timetable/index.ts

@@ -0,0 +1,66 @@
+/**
+ * Timetable constants used for sequencer timing calculations.
+ * These define the time budgets for various phases of block production.
+ *
+ * The sequencer slot is divided into phases:
+ * 1. Checkpoint initialization (sync + proposer check)
+ * 2. Block building (execution)
+ * 3. Checkpoint assembly
+ * 4. P2P propagation for proposal and attestations (round-trip)
+ * 5. L1 publishing
+ */
+
+/** Time budget for checkpoint initialization (sync + proposer check) in seconds */
+export const CHECKPOINT_INITIALIZATION_TIME = 1;
+
+/** Time budget for assembling a checkpoint after building the last block in seconds */
+export const CHECKPOINT_ASSEMBLE_TIME = 1;
+
+/** Default one-way P2P propagation time for proposals and attestations in seconds */
+export const DEFAULT_P2P_PROPAGATION_TIME = 2;
+
+/** Default L1 publishing time (matches Ethereum slot duration on mainnet) in seconds */
+export const DEFAULT_L1_PUBLISHING_TIME = 12;
+
+/** Minimum execution time for building a block in seconds */
+export const MIN_EXECUTION_TIME = 2;
+
+/**
+ * Calculates the maximum number of blocks that can be built in a slot.
+ * Used by both the sequencer timetable and p2p gossipsub scoring.
+ *
+ * @param aztecSlotDurationSec - Aztec slot duration in seconds
+ * @param blockDurationSec - Duration per block in seconds (undefined = single block mode)
+ * @param opts - Optional overrides for timing constants
+ * @returns Maximum number of blocks per slot
+ */
+export function calculateMaxBlocksPerSlot(
+  aztecSlotDurationSec: number,
+  blockDurationSec: number | undefined,
+  opts: {
+    checkpointInitializationTime?: number;
+    checkpointAssembleTime?: number;
+    p2pPropagationTime?: number;
+    l1PublishingTime?: number;
+  } = {},
+): number {
+  if (!blockDurationSec) {
+    return 1; // Single block per slot
+  }
+
+  const initOffset = opts.checkpointInitializationTime ?? CHECKPOINT_INITIALIZATION_TIME;
+  const assembleTime = opts.checkpointAssembleTime ?? CHECKPOINT_ASSEMBLE_TIME;
+  const p2pTime = opts.p2pPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME;
+  const l1Time = opts.l1PublishingTime ?? DEFAULT_L1_PUBLISHING_TIME;
+
+  // Calculate checkpoint finalization time (assembly + round-trip propagation + L1 publishing)
+  const checkpointFinalizationTime = assembleTime + p2pTime * 2 + l1Time;
+
+  // Time reserved at end for last sub-slot (validator re-execution) + finalization
+  const timeReservedAtEnd = blockDurationSec + checkpointFinalizationTime;
+
+  // Time available for building blocks
+  const timeAvailableForBlocks = aztecSlotDurationSec - initOffset - timeReservedAtEnd;
+
+  return Math.max(1, Math.floor(timeAvailableForBlocks / blockDurationSec));
+}

package/src/trees/append_only_tree_snapshot.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';

package/src/trees/database_public_state_source.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { AztecAddress } from '../aztec-address/index.js';
 import { computePublicDataTreeLeafSlot } from '../hash/hash.js';

package/src/trees/nullifier_leaf.ts

@@ -1,5 +1,5 @@
 import { toBigIntBE, toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader } from '@aztec/foundation/serialize';
 import type { IndexedTreeLeaf, IndexedTreeLeafPreimage } from '@aztec/foundation/trees';

package/src/trees/nullifier_membership_witness.ts

@@ -1,5 +1,5 @@
 import { NULLIFIER_TREE_HEIGHT } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { MembershipWitness, SiblingPath } from '@aztec/foundation/trees';
 
 import { z } from 'zod';

package/src/trees/public_data_leaf.ts

@@ -1,5 +1,5 @@
 import { toBigIntBE, toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { IndexedTreeLeaf, IndexedTreeLeafPreimage } from '@aztec/foundation/trees';

package/src/trees/public_data_witness.ts

@@ -1,6 +1,6 @@
 import { PUBLIC_DATA_TREE_HEIGHT } from '@aztec/constants';
 import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import { MembershipWitness, SiblingPath } from '@aztec/foundation/trees';