@aztec/stdlib 0.0.1-commit.96bb3f7 → 0.0.1-commit.993d52e

package/src/stats/stats.ts

@@ -202,8 +202,6 @@ export type L2BlockBuiltStats = {
   duration: number;
   /** Time for processing public txs in ms. */
   publicProcessDuration: number;
-  /** Time for running rollup circuits in ms.  */
-  rollupCircuitsDuration: number;
 } & L2BlockStats;
 
 /** Stats for an L2 block processed by the world state synchronizer. */

package/src/tests/factories.ts

@@ -7,11 +7,11 @@ import {
 import {
   ARCHIVE_HEIGHT,
   AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
-  AZTEC_MAX_EPOCH_DURATION,
   CHONK_PROOF_LENGTH,
   CONTRACT_CLASS_LOG_SIZE_IN_FIELDS,
-  GeneratorIndex,
+  DomainSeparator,
   L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
+  MAX_CHECKPOINTS_PER_EPOCH,
   MAX_CONTRACT_CLASS_LOGS_PER_TX,
   MAX_ENQUEUED_CALLS_PER_CALL,
   MAX_ENQUEUED_CALLS_PER_TX,
@@ -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,
@@ -103,7 +102,7 @@ import {
 import { Gas, GasFees, GasSettings } from '../gas/index.js';
 import { computeCalldataHash } from '../hash/hash.js';
 import { KeyValidationRequest } from '../kernel/hints/key_validation_request.js';
-import { KeyValidationRequestAndGenerator } from '../kernel/hints/key_validation_request_and_generator.js';
+import { KeyValidationRequestAndSeparator } from '../kernel/hints/key_validation_request_and_separator.js';
 import { ReadRequest, ScopedReadRequest } from '../kernel/hints/read_request.js';
 import {
   ClaimedLengthArray,
@@ -129,6 +128,7 @@ import {
   PublicCallRequestArrayLengths,
 } from '../kernel/public_call_request.js';
 import { PublicKeys, computeAddress } from '../keys/index.js';
+import { ExtendedDirectionalAppTaggingSecret } from '../logs/extended_directional_app_tagging_secret.js';
 import { ContractClassLog, ContractClassLogFields } from '../logs/index.js';
 import { PrivateLog } from '../logs/private_log.js';
 import { FlatPublicLogs, PublicLog } from '../logs/public_log.js';
@@ -260,12 +260,12 @@ function makeKeyValidationRequests(seed: number): KeyValidationRequest {
 }
 
 /**
- * Creates arbitrary KeyValidationRequestAndGenerator from the given seed.
- * @param seed - The seed to use for generating the KeyValidationRequestAndGenerator.
- * @returns A KeyValidationRequestAndGenerator.
+ * Creates arbitrary KeyValidationRequestAndSeparator from the given seed.
+ * @param seed - The seed to use for generating the KeyValidationRequestAndSeparator.
+ * @returns A KeyValidationRequestAndSeparator.
  */
-function makeKeyValidationRequestAndGenerators(seed: number): KeyValidationRequestAndGenerator {
-  return new KeyValidationRequestAndGenerator(makeKeyValidationRequests(seed), fr(seed + 4));
+function makeKeyValidationRequestAndSeparators(seed: number): KeyValidationRequestAndSeparator {
+  return new KeyValidationRequestAndSeparator(makeKeyValidationRequests(seed), fr(seed + 4));
 }
 
 export function makePublicDataWrite(seed = 1) {
@@ -657,7 +657,7 @@ function makeClaimedLengthArray<T extends Serializable, N extends number>(
  */
 export function makePrivateCircuitPublicInputs(seed = 0): PrivateCircuitPublicInputs {
   return PrivateCircuitPublicInputs.from({
-    includeByTimestamp: BigInt(seed + 0x31415),
+    expirationTimestamp: BigInt(seed + 0x31415),
     callContext: makeCallContext(seed, { isStaticCall: true }),
     argsHash: fr(seed + 0x100),
     returnsHash: fr(seed + 0x200),
@@ -672,9 +672,9 @@ export function makePrivateCircuitPublicInputs(seed = 0): PrivateCircuitPublicIn
       makeScopedReadRequest,
       seed + 0x310,
     ),
-    keyValidationRequestsAndGenerators: makeClaimedLengthArray(
+    keyValidationRequestsAndSeparators: makeClaimedLengthArray(
       MAX_KEY_VALIDATION_REQUESTS_PER_CALL,
-      makeKeyValidationRequestAndGenerators,
+      makeKeyValidationRequestAndSeparators,
       seed + 0x320,
     ),
     noteHashes: makeClaimedLengthArray(MAX_NOTE_HASHES_PER_CALL, makeNoteHash, seed + 0x400),
@@ -850,9 +850,10 @@ export function makeCheckpointRollupPublicInputs(seed = 0) {
     makeEpochConstantData(seed),
     makeAppendOnlyTreeSnapshot(seed + 0x100),
     makeAppendOnlyTreeSnapshot(seed + 0x200),
-    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => fr(seed), 0x300),
-    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => fr(seed), 0x400),
-    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => makeFeeRecipient(seed), 0x500),
+    makeAppendOnlyTreeSnapshot(seed + 0x300),
+    makeAppendOnlyTreeSnapshot(seed + 0x350),
+    makeTuple(MAX_CHECKPOINTS_PER_EPOCH, () => fr(seed), 0x400),
+    makeTuple(MAX_CHECKPOINTS_PER_EPOCH, () => makeFeeRecipient(seed), 0x500),
     makeBlobAccumulator(seed + 0x600),
     makeBlobAccumulator(seed + 0x700),
     makeFinalBlobBatchingChallenges(seed + 0x800),
@@ -888,8 +889,8 @@ export function makeRootRollupPublicInputs(seed = 0): RootRollupPublicInputs {
     fr(seed + 0x100),
     fr(seed + 0x200),
     fr(seed + 0x300),
-    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => fr(seed), 0x400),
-    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => makeFeeRecipient(seed), 0x500),
+    makeTuple(MAX_CHECKPOINTS_PER_EPOCH, () => fr(seed), 0x400),
+    makeTuple(MAX_CHECKPOINTS_PER_EPOCH, () => makeFeeRecipient(seed), 0x500),
     makeEpochConstantData(seed + 0x600),
     makeFinalBlobAccumulator(seed + 0x700),
   );
@@ -910,40 +911,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,
   });
 }
 
@@ -1307,11 +1288,11 @@ export async function makeContractInstanceFromClassId(
 
   const saltedInitializationHash = await poseidon2HashWithSeparator(
     [salt, initializationHash, deployer],
-    GeneratorIndex.PARTIAL_ADDRESS,
+    DomainSeparator.PARTIAL_ADDRESS,
   );
   const partialAddress = await poseidon2HashWithSeparator(
     [classId, saltedInitializationHash],
-    GeneratorIndex.PARTIAL_ADDRESS,
+    DomainSeparator.PARTIAL_ADDRESS,
   );
   const address = await computeAddress(publicKeys, partialAddress);
   return new SerializableContractInstance({
@@ -1759,7 +1740,7 @@ export function makeL2Tips(
       ? typeof checkpointNumber === 'number'
         ? CheckpointNumber(checkpointNumber)
         : checkpointNumber
-      : CheckpointNumber(bn);
+      : CheckpointNumber.fromBlockNumber(bn);
   const cph = checkpointHash ?? hash;
   return {
     proposed: { number: bn, hash },
@@ -1777,3 +1758,11 @@ export function makeL2Tips(
     },
   };
 }
+
+export async function randomExtendedDirectionalAppTaggingSecret(): Promise<ExtendedDirectionalAppTaggingSecret> {
+  const resolvedApp = await AztecAddress.random();
+  // Using the fromString method like this is messy as it leaks the underlying serialization format but I don't want to
+  // expose the type's constructor just for tests since in prod the secret is always constructed via compute. Also this
+  // method is tested in extended_directional_app_tagging_secret.test.ts hence all should be fine.
+  return ExtendedDirectionalAppTaggingSecret.fromString(`${Fr.random().toString()}:${resolvedApp.toString()}`);
+}

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

package/src/tests/mocks.ts

@@ -1,13 +1,14 @@
 import {
-  FIXED_DA_GAS,
-  FIXED_L2_GAS,
   MAX_ENQUEUED_CALLS_PER_TX,
-  MAX_INCLUDE_BY_TIMESTAMP_DURATION,
   MAX_NULLIFIERS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  MAX_TX_LIFETIME,
+  PRIVATE_TX_L2_GAS_OVERHEAD,
+  PUBLIC_TX_L2_GAS_OVERHEAD,
+  TX_DA_GAS_OVERHEAD,
 } from '@aztec/constants';
 import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
-import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, CheckpointNumber, IndexWithinCheckpoint, SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { padArrayEnd, times } from '@aztec/foundation/collection';
 import { randomBytes } from '@aztec/foundation/crypto/random';
@@ -22,8 +23,7 @@ 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, L2BlockNew, PublishedL2Block } 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 { Checkpoint } from '../checkpoint/checkpoint.js';
 import { L1PublishedData } from '../checkpoint/published_checkpoint.js';
@@ -76,9 +76,9 @@ import {
   makeAvmCircuitInputs,
   makeAztecAddress,
   makeBlockHeader,
+  makeCheckpointHeader,
   makeGas,
   makeGlobalVariables,
-  makeL2BlockHeader,
   makePrivateToPublicAccumulatedData,
   makePrivateToRollupAccumulatedData,
   makeProtocolContracts,
@@ -98,12 +98,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;
@@ -112,12 +114,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 =
@@ -127,10 +131,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;
@@ -138,8 +140,8 @@ export const mockTx = async (
   data.constants.vkTreeRoot = vkTreeRoot;
   data.constants.protocolContractsHash = protocolContractsHash;
 
-  // Set includeByTimestamp to the maximum allowed duration from the current time.
-  data.includeByTimestamp = BigInt(Math.floor(Date.now() / 1000) + MAX_INCLUDE_BY_TIMESTAMP_DURATION);
+  // Set expirationTimestamp to the maximum allowed duration from the current time.
+  data.expirationTimestamp = BigInt(Math.floor(Date.now() / 1000) + MAX_TX_LIFETIME);
 
   const publicFunctionCalldata: HashedValues[] = [];
   if (!isForPublic) {
@@ -204,8 +206,11 @@ export async function mockProcessedTx({
   feePayer,
   feePaymentPublicDataWrite,
   // The default gasUsed is the tx overhead.
-  gasUsed = Gas.from({ daGas: FIXED_DA_GAS, l2Gas: FIXED_L2_GAS }),
   privateOnly = false,
+  gasUsed = Gas.from({
+    daGas: TX_DA_GAS_OVERHEAD,
+    l2Gas: privateOnly ? PRIVATE_TX_L2_GAS_OVERHEAD : PUBLIC_TX_L2_GAS_OVERHEAD,
+  }),
   avmAccumulatedData,
   ...mockTxOpts
 }: {
@@ -400,38 +405,47 @@ export async function mockCheckpointAndMessages(
   {
     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 L2BlockNew.random>[1]>;
+    makeBlockOptions?: (blockNumber: BlockNumber) => Partial<Parameters<typeof L2Block.random>[1]>;
     previousArchive?: AppendOnlyTreeSnapshot;
+    blocks?: L2Block[];
+    maxEffects?: number;
   } & Partial<Parameters<typeof Checkpoint.random>[1]> &
-    Partial<Parameters<typeof L2BlockNew.random>[1]> = {},
+    Partial<Parameters<typeof L2Block.random>[1]> = {},
 ) {
-  const slotNumber = options.slotNumber ?? SlotNumber(checkpointNumber * 10);
+  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;
-  for (let i = 0; i < numBlocks; i++) {
+  // 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: await L2BlockNew.random(blockNumber, {
-        checkpointNumber,
-        indexWithinCheckpoint: i,
-        txsPerBlock: numTxsPerBlock,
-        slotNumber,
-        ...options,
-        ...makeBlockOptions(blockNumber),
-        ...(lastArchive ? { lastArchive } : {}),
-      }),
+      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
@@ -489,16 +503,17 @@ export interface MakeConsensusPayloadOptions {
   signer?: Secp256k1Signer;
   attesterSigner?: Secp256k1Signer;
   proposerSigner?: Secp256k1Signer;
-  header?: L2BlockHeader;
+  header?: CheckpointHeader;
   archive?: Fr;
   txHashes?: TxHash[];
   txs?: Tx[];
+  feeAssetPriceModifier?: bigint;
 }
 
 export interface MakeBlockProposalOptions {
   signer?: Secp256k1Signer;
-  blockHeader?: L2BlockHeader;
-  indexWithinCheckpoint?: number;
+  blockHeader?: BlockHeader;
+  indexWithinCheckpoint?: IndexWithinCheckpoint;
   inHash?: Fr;
   archiveRoot?: Fr;
   txHashes?: TxHash[];
@@ -509,10 +524,11 @@ export interface MakeCheckpointProposalOptions {
   signer?: Secp256k1Signer;
   checkpointHeader?: CheckpointHeader;
   archiveRoot?: Fr;
+  feeAssetPriceModifier?: bigint;
   /** Options for the lastBlock - if undefined, no lastBlock is included */
   lastBlock?: {
-    blockHeader?: L2BlockHeader;
-    indexWithinCheckpoint?: number;
+    blockHeader?: BlockHeader;
+    indexWithinCheckpoint?: IndexWithinCheckpoint;
     txHashes?: TxHash[];
     txs?: Tx[];
   };
@@ -523,18 +539,19 @@ const makeAndSignConsensusPayload = (
   domainSeparator: SignatureDomainSeparator,
   options?: MakeConsensusPayloadOptions,
 ) => {
-  const header = options?.header ?? makeL2BlockHeader(1);
-  const { signer = Secp256k1Signer.random(), archive = Fr.random() } = options ?? {};
+  const header = options?.header ?? makeCheckpointHeader(1);
+  const { signer = Secp256k1Signer.random(), archive = Fr.random(), feeAssetPriceModifier = 0n } = options ?? {};
 
   const payload = ConsensusPayload.fromFields({
-    header: header.toCheckpointHeader(),
+    header,
     archive,
+    feeAssetPriceModifier,
   });
 
   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 = (
@@ -549,9 +566,8 @@ export const makeAndSignCommitteeAttestationsAndSigners = (
 };
 
 export const makeBlockProposal = (options?: MakeBlockProposalOptions): Promise<BlockProposal> => {
-  const l2BlockHeader = options?.blockHeader ?? makeL2BlockHeader(1);
-  const blockHeader = l2BlockHeader.toBlockHeader();
-  const indexWithinCheckpoint = options?.indexWithinCheckpoint ?? 0;
+  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());
@@ -565,28 +581,33 @@ export const makeBlockProposal = (options?: MakeBlockProposalOptions): Promise<B
     archiveRoot,
     txHashes,
     txs,
-    payload => Promise.resolve(signer.signMessage(payload)),
+    (_payload, _context) => Promise.resolve(signer.signMessage(_payload)),
   );
 };
 
 export const makeCheckpointProposal = (options?: MakeCheckpointProposalOptions): Promise<CheckpointProposal> => {
-  const l2BlockHeader = options?.lastBlock?.blockHeader ?? makeL2BlockHeader(1);
-  const checkpointHeader = options?.checkpointHeader ?? l2BlockHeader.toCheckpointHeader();
+  const blockHeader = options?.lastBlock?.blockHeader ?? makeBlockHeader(1);
+  const checkpointHeader = options?.checkpointHeader ?? makeCheckpointHeader(1);
   const archiveRoot = options?.archiveRoot ?? Fr.random();
+  const feeAssetPriceModifier = options?.feeAssetPriceModifier ?? 0n;
   const signer = options?.signer ?? Secp256k1Signer.random();
 
   // Build lastBlock info if provided
   const lastBlockInfo = options?.lastBlock
     ? {
-        blockHeader: l2BlockHeader.toBlockHeader(),
-        indexWithinCheckpoint: options.lastBlock.indexWithinCheckpoint ?? 4, // Last block in a 5-block checkpoint
+        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)),
+  return CheckpointProposal.createProposalFromSigner(
+    checkpointHeader,
+    archiveRoot,
+    feeAssetPriceModifier,
+    lastBlockInfo,
+    payload => Promise.resolve(signer.signMessage(payload)),
   );
 };
 
@@ -596,6 +617,7 @@ export const makeCheckpointProposal = (options?: MakeCheckpointProposalOptions):
 export type MakeCheckpointAttestationOptions = {
   header?: CheckpointHeader;
   archive?: Fr;
+  feeAssetPriceModifier?: bigint;
   attesterSigner?: Secp256k1Signer;
   proposerSigner?: Secp256k1Signer;
   signer?: Secp256k1Signer;
@@ -605,11 +627,12 @@ export type MakeCheckpointAttestationOptions = {
  * Create a checkpoint attestation for testing
  */
 export const makeCheckpointAttestation = (options: MakeCheckpointAttestationOptions = {}): CheckpointAttestation => {
-  const header = options.header ?? makeL2BlockHeader(1).toCheckpointHeader();
+  const header = options.header ?? makeCheckpointHeader(1);
   const archive = options.archive ?? Fr.random();
+  const feeAssetPriceModifier = options.feeAssetPriceModifier ?? 0n;
   const { signer, attesterSigner = signer, proposerSigner = signer } = options;
 
-  const payload = new ConsensusPayload(header, archive);
+  const payload = new ConsensusPayload(header, archive, feeAssetPriceModifier);
 
   // Sign as attester
   const attestationHash = getHashedSignaturePayloadEthSignedMessage(
@@ -622,7 +645,7 @@ export const makeCheckpointAttestation = (options: MakeCheckpointAttestationOpti
   // 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 tempProposal = new CheckpointProposal(header, archive, feeAssetPriceModifier, Signature.empty());
   const proposalHash = getHashedSignaturePayloadEthSignedMessage(
     tempProposal,
     SignatureDomainSeparator.checkpointProposal,
@@ -639,7 +662,7 @@ export const makeCheckpointAttestationFromProposal = (
   proposal: CheckpointProposal,
   attesterSigner?: Secp256k1Signer,
 ): CheckpointAttestation => {
-  const payload = new ConsensusPayload(proposal.checkpointHeader, proposal.archive);
+  const payload = new ConsensusPayload(proposal.checkpointHeader, proposal.archive, proposal.feeAssetPriceModifier);
 
   // Sign as attester
   const attestationHash = getHashedSignaturePayloadEthSignedMessage(
@@ -663,19 +686,27 @@ export const makeCheckpointAttestationFromCheckpoint = (
 ): CheckpointAttestation => {
   const header = checkpoint.header;
   const archive = checkpoint.archive.root;
+  const feeAssetPriceModifier = checkpoint.feeAssetPriceModifier;
 
-  return makeCheckpointAttestation({ header, archive, attesterSigner, proposerSigner });
+  return makeCheckpointAttestation({ header, archive, feeAssetPriceModifier, attesterSigner, proposerSigner });
 };
 
 /**
  * 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,
 ): CheckpointAttestation => {
-  const header = block.header.toCheckpointHeader();
+  // 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 makeCheckpointAttestation({ header, archive, attesterSigner, proposerSigner });
@@ -684,7 +715,7 @@ export const makeCheckpointAttestationFromBlock = (
 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),
@@ -693,15 +724,19 @@ export async function randomPublishedL2Block(
   });
 
   const signers = opts.signers ?? times(3, () => Secp256k1Signer.random());
+  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: block.header.toCheckpointHeader(),
+      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));
+}