@aztec/stdlib 0.0.1-commit.5daedc8 → 0.0.1-commit.6201a7b05

package/dest/tests/mocks.js

@@ -1,16 +1,21 @@
-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 } from '@aztec/constants';
+import { MAX_ENQUEUED_CALLS_PER_TX, 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 { 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 { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
+import { hashTypedData } from 'viem';
+import { PublicTxEffect } from '../avm/avm.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 } from '../block/index.js';
-import { L2Block } from '../block/l2_block.js';
-import { PublishedL2Block } from '../block/published_l2_block.js';
+import { CheckpointedL2Block, CommitteeAttestation, L2Block } from '../block/index.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';
@@ -25,27 +30,39 @@ import { PartialPrivateTailPublicInputsForPublic, PrivateKernelTailCircuitPublic
 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 { getHashedSignaturePayloadTypedData } 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 { GlobalVariables, HashedValues, PrivateCallExecutionResult, PrivateExecutionResult, Tx, TxConstantData, makeProcessedTxFromPrivateOnlyTx, makeProcessedTxFromTxWithPublicCalls } from '../tx/index.js';
+import { BlockHeader, GlobalVariables, HashedValues, PrivateCallExecutionResult, PrivateExecutionResult, Tx, TxConstantData, makeProcessedTxFromPrivateOnlyTx, makeProcessedTxFromTxWithPublicCalls } from '../tx/index.js';
 import { NestedProcessReturnValues, PublicSimulationOutput } from '../tx/public_simulation_output.js';
 import { TxSimulationResult } from '../tx/simulated_tx.js';
 import { TxEffect } from '../tx/tx_effect.js';
 import { TxHash } from '../tx/tx_hash.js';
-import { makeAvmCircuitInputs, makeAztecAddress, makeBlockHeader, makeGas, makeGlobalVariables, makeL2BlockHeader, makePrivateToPublicAccumulatedData, makePrivateToRollupAccumulatedData, makeProtocolContracts, makePublicCallRequest, makePublicDataWrite } from './factories.js';
+import { makeAvmCircuitInputs, makeAztecAddress, makeBlockHeader, makeCheckpointHeader, makeGas, makeGlobalVariables, makePrivateToPublicAccumulatedData, makePrivateToRollupAccumulatedData, makeProtocolContracts, makePublicCallRequest, makePublicDataWrite } from './factories.js';
+export const TEST_COORDINATION_SIGNATURE_CONTEXT = {
+    chainId: 31337,
+    rollupAddress: EthAddress.fromNumber(1)
+};
+function signTypedData(signer, typedData) {
+    return signer.sign(Buffer32.fromString(hashTypedData(typedData)));
+}
 export const randomTxHash = ()=>TxHash.random();
-export const mockTx = async (seed = 1, { numberOfNonRevertiblePublicCallRequests = MAX_ENQUEUED_CALLS_PER_TX / 2, numberOfRevertiblePublicCallRequests = MAX_ENQUEUED_CALLS_PER_TX / 2, numberOfRevertibleNullifiers = 0, hasPublicTeardownCallRequest = false, publicCalldataSize = 2, feePayer, chonkProof = ChonkProof.random(), maxPriorityFeesPerGas, gasUsed = Gas.empty(), chainId = Fr.ZERO, version = Fr.ZERO, vkTreeRoot = Fr.ZERO, protocolContractsHash = Fr.ZERO } = {})=>{
+export const mockTx = async (seed = 1, { numberOfNonRevertiblePublicCallRequests = MAX_ENQUEUED_CALLS_PER_TX / 2, numberOfRevertiblePublicCallRequests = MAX_ENQUEUED_CALLS_PER_TX / 2, numberOfRevertibleNullifiers = 0, hasPublicTeardownCallRequest = false, publicCalldataSize = 2, feePayer, chonkProof = ChonkProof.random(), gasLimits, maxFeesPerGas = new GasFees(10, 10), maxPriorityFeesPerGas, gasUsed = Gas.empty(), chainId = Fr.ZERO, version = Fr.ZERO, vkTreeRoot = Fr.ZERO, protocolContractsHash = Fr.ZERO, anchorBlockHeader = BlockHeader.empty() } = {})=>{
     const totalPublicCallRequests = numberOfNonRevertiblePublicCallRequests + numberOfRevertiblePublicCallRequests + (hasPublicTeardownCallRequest ? 1 : 0);
     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),
+    data.constants.anchorBlockHeader = anchorBlockHeader;
+    data.constants.txContext.gasSettings = GasSettings.fallback({
+        gasLimits,
+        maxFeesPerGas,
         maxPriorityFeesPerGas
     });
     data.feePayer = feePayer ?? await AztecAddress.random();
@@ -54,8 +71,8 @@ export const mockTx = async (seed = 1, { numberOfNonRevertiblePublicCallRequests
     data.constants.txContext.version = version;
     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 = [];
     if (!isForPublic) {
         data.forRollup.end.nullifiers[0] = firstNullifier.value;
@@ -93,13 +110,13 @@ export const mockTxForRollup = (seed = 1, opts = {})=>mockTx(seed, {
         numberOfNonRevertiblePublicCallRequests: 0,
         numberOfRevertiblePublicCallRequests: 0
     });
-/** Mock a processed tx for testing purposes. */ export async function mockProcessedTx({ seed = 1, anchorBlockHeader, db, chainId = Fr.ZERO, version = Fr.ZERO, gasSettings = GasSettings.default({
+/** Mock a processed tx for testing purposes. */ export async function mockProcessedTx({ seed = 1, anchorBlockHeader, db, chainId = Fr.ZERO, version = Fr.ZERO, gasSettings = GasSettings.fallback({
     maxFeesPerGas: new GasFees(10, 10)
 }), vkTreeRoot = Fr.ZERO, protocolContracts = makeProtocolContracts(seed + 0x100), globalVariables = GlobalVariables.empty(), newL1ToL2Snapshot = AppendOnlyTreeSnapshot.empty(), feePayer, feePaymentPublicDataWrite, // The default gasUsed is the tx overhead.
-gasUsed = Gas.from({
-    daGas: FIXED_DA_GAS,
-    l2Gas: FIXED_L2_GAS
-}), privateOnly = false, ...mockTxOpts } = {}) {
+privateOnly = false, gasUsed = Gas.from({
+    daGas: TX_DA_GAS_OVERHEAD,
+    l2Gas: privateOnly ? PRIVATE_TX_L2_GAS_OVERHEAD : PUBLIC_TX_L2_GAS_OVERHEAD
+}), avmAccumulatedData, ...mockTxOpts } = {}) {
     seed *= 0x1000; // Avoid clashing with the previous mock values if seed only increases by 1.
     anchorBlockHeader ??= db?.getInitialHeader() ?? makeBlockHeader(seed);
     feePayer ??= makeAztecAddress(seed + 0x100);
@@ -161,11 +178,10 @@ gasUsed = Gas.from({
         avmOutput.previousRevertibleAccumulatedData = new PrivateToAvmAccumulatedData(dataFromPrivate.revertibleAccumulatedData.noteHashes, dataFromPrivate.revertibleAccumulatedData.nullifiers, dataFromPrivate.revertibleAccumulatedData.l2ToL1Msgs);
         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
@@ -182,13 +198,14 @@ gasUsed = Gas.from({
             billedGas: Gas.empty()
         };
         await tx.recomputeHash();
-        return makeProcessedTxFromTxWithPublicCalls(tx, {
+        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
-        }, gasUsed, RevertCode.OK, undefined /* revertReason */ );
+        }, publicTxEffect, gasUsed, RevertCode.OK, undefined /* revertReason */ );
     }
 }
-const emptyPrivateCallExecutionResult = ()=>new PrivateCallExecutionResult(Buffer.from(''), Buffer.from(''), new Map(), PrivateCircuitPublicInputs.empty(), new Map(), [], new Map(), [], [], [], [], []);
+const emptyPrivateCallExecutionResult = ()=>new PrivateCallExecutionResult(Buffer.from(''), Buffer.from(''), new Map(), PrivateCircuitPublicInputs.empty(), [], new Map(), [], [], [], [], []);
 const emptyPrivateExecutionResult = ()=>new PrivateExecutionResult(emptyPrivateCallExecutionResult(), Fr.zero(), []);
 export const mockSimulatedTx = async (seed = 1)=>{
     const privateExecutionResult = emptyPrivateExecutionResult();
@@ -201,6 +218,69 @@ export const mockSimulatedTx = async (seed = 1)=>{
     });
     return new TxSimulationResult(privateExecutionResult, tx.data, output);
 };
+export function mockL1ToL2Messages(numL1ToL2Messages) {
+    return Array.from({
+        length: numL1ToL2Messages
+    }, ()=>Fr.random());
+}
+export async function mockCheckpointAndMessages(checkpointNumber, { startBlockNumber = BlockNumber(1), numBlocks = 1, blocks, numTxsPerBlock = 1, numL1ToL2Messages = 1, makeBlockOptions = ()=>({}), previousArchive, maxEffects, ...options } = {}) {
+    const slotNumber = options.slotNumber ?? SlotNumber(Number(checkpointNumber) * 10);
+    const globals = GlobalVariables.random({
+        slotNumber,
+        ...options
+    });
+    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 = 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, {
+                ...globals,
+                checkpointNumber,
+                indexWithinCheckpoint: IndexWithinCheckpoint(i),
+                txsPerBlock: numTxsPerBlock,
+                txOptions,
+                ...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 firstBlockLastArchive = blocksAndMessages[0].block.header.lastArchive;
+    const checkpoint = await Checkpoint.random(checkpointNumber, {
+        numBlocks: 0,
+        inHash,
+        ...options,
+        ...globals,
+        lastArchive: firstBlockLastArchive,
+        lastArchiveRoot: firstBlockLastArchive.root,
+        archive: lastArchive
+    });
+    checkpoint.blocks = blocksAndMessages.map(({ block })=>block);
+    // Return lastArchive so callers can chain it across multiple checkpoints
+    return {
+        checkpoint,
+        messages,
+        lastArchive
+    };
+}
 export const randomContractArtifact = ()=>({
         name: randomBytes(4).toString('hex'),
         functions: [],
@@ -229,27 +309,33 @@ export const randomDeployedContract = async ()=>{
         })
     };
 };
-const makeAndSignConsensusPayload = (domainSeparator, options)=>{
-    const header = options?.header ?? makeL2BlockHeader(1);
-    const { signer = Secp256k1Signer.random(), archive = Fr.random() } = options ?? {};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const makeAndSignConsensusPayload = (options)=>{
+    const header = options?.header ?? makeCheckpointHeader(1);
+    const { signer = Secp256k1Signer.random(), archive = Fr.random(), feeAssetPriceModifier = 0n } = options ?? {};
     const payload = ConsensusPayload.fromFields({
-        header: header.toCheckpointHeader(),
-        archive
+        header,
+        archive,
+        feeAssetPriceModifier,
+        signatureContext: TEST_COORDINATION_SIGNATURE_CONTEXT
     });
-    const hash = getHashedSignaturePayloadEthSignedMessage(payload, domainSeparator);
+    const hash = getHashedSignaturePayloadTypedData(payload);
     const signature = signer.sign(hash);
     return {
-        blockNumber: header.globalVariables.blockNumber,
+        blockNumber: header.slotNumber,
         payload,
         signature
     };
 };
 export const makeAndSignCommitteeAttestationsAndSigners = (attestationsAndSigners, signer = Secp256k1Signer.random())=>{
-    const hash = getHashedSignaturePayloadEthSignedMessage(attestationsAndSigners, SignatureDomainSeparator.attestationsAndSigners);
+    const hash = getHashedSignaturePayloadTypedData(attestationsAndSigners);
     return signer.sign(hash);
 };
 export const makeBlockProposal = (options)=>{
-    const { payload, signature } = makeAndSignConsensusPayload(SignatureDomainSeparator.blockProposal, options);
+    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,
@@ -258,56 +344,114 @@ export const makeBlockProposal = (options)=>{
         4,
         5
     ].map(()=>TxHash.random());
-    return new BlockProposal(payload, signature, txHashes, options?.txs ?? []);
+    const txs = options?.txs;
+    const signer = options?.signer ?? Secp256k1Signer.random();
+    const signatureContext = options?.signatureContext ?? TEST_COORDINATION_SIGNATURE_CONTEXT;
+    return BlockProposal.createProposalFromSigner(blockHeader, CheckpointNumber(1), indexWithinCheckpoint, inHash, archiveRoot, txHashes, txs, signatureContext, (typedData, _context)=>Promise.resolve(signTypedData(signer, typedData)), (typedData, _context)=>Promise.resolve(signTypedData(signer, typedData)));
 };
-// TODO(https://github.com/AztecProtocol/aztec-packages/issues/8028)
-export const makeBlockAttestation = (options = {})=>{
-    const header = options.header ?? makeL2BlockHeader(1);
-    const { signer, attesterSigner = signer, proposerSigner = signer, archive = Fr.random() } = options;
-    const payload = ConsensusPayload.fromFields({
-        header: header.toCheckpointHeader(),
-        archive
-    });
-    return makeBlockAttestationFromPayload(payload, attesterSigner, proposerSigner);
+export const makeCheckpointProposal = async (options)=>{
+    const checkpointHeader = options?.checkpointHeader ?? makeCheckpointHeader(1);
+    const archiveRoot = options?.archiveRoot ?? Fr.random();
+    const feeAssetPriceModifier = options?.feeAssetPriceModifier ?? 0n;
+    const signer = options?.signer ?? Secp256k1Signer.random();
+    const signatureContext = options?.signatureContext ?? TEST_COORDINATION_SIGNATURE_CONTEXT;
+    // Build a signed block proposal if lastBlock options are provided
+    const lastBlockProposal = options?.lastBlock ? await makeBlockProposal({
+        blockHeader: options.lastBlock.blockHeader,
+        indexWithinCheckpoint: options.lastBlock.indexWithinCheckpoint ?? IndexWithinCheckpoint(4),
+        inHash: checkpointHeader.inHash,
+        archiveRoot,
+        txHashes: options.lastBlock.txHashes,
+        txs: options.lastBlock.txs,
+        signer,
+        signatureContext
+    }) : undefined;
+    return CheckpointProposal.createProposalFromSigner(checkpointHeader, archiveRoot, CheckpointNumber(1), feeAssetPriceModifier, lastBlockProposal, signatureContext, (typedData)=>Promise.resolve(signTypedData(signer, typedData)));
 };
-export const makeAttestationFromCheckpoint = (checkpoint, attesterSigner, proposerSigner)=>{
+/**
+ * Create a checkpoint attestation for testing
+ */ export const makeCheckpointAttestation = (options = {})=>{
+    const header = options.header ?? makeCheckpointHeader(1);
+    const archive = options.archive ?? Fr.random();
+    const feeAssetPriceModifier = options.feeAssetPriceModifier ?? 0n;
+    const signatureContext = options.signatureContext ?? TEST_COORDINATION_SIGNATURE_CONTEXT;
+    const { signer, attesterSigner = signer, proposerSigner = signer } = options;
+    const payload = new ConsensusPayload(header, archive, feeAssetPriceModifier, signatureContext);
+    // Sign as attester
+    const attestationHash = getHashedSignaturePayloadTypedData(payload);
+    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, feeAssetPriceModifier, Signature.empty(), signatureContext);
+    const proposalHash = getHashedSignaturePayloadTypedData(tempProposal);
+    const proposerSignature = proposalSignerToUse.sign(proposalHash);
+    return new CheckpointAttestation(payload, attestationSignature, proposerSignature);
+};
+/**
+ * Create a checkpoint attestation from a checkpoint proposal
+ */ export const makeCheckpointAttestationFromProposal = (proposal, attesterSigner)=>{
+    const payload = new ConsensusPayload(proposal.checkpointHeader, proposal.archive, proposal.feeAssetPriceModifier, proposal.signatureContext);
+    // Sign as attester
+    const attestationHash = getHashedSignaturePayloadTypedData(payload);
+    const attestationSigner = attesterSigner ?? Secp256k1Signer.random();
+    const attestationSignature = attestationSigner.sign(attestationHash);
+    // Use the proposal's signature as the proposer signature
+    return new CheckpointAttestation(payload, attestationSignature, proposal.signature);
+};
+/**
+ * Create a checkpoint attestation from a checkpoint
+ */ export const makeCheckpointAttestationFromCheckpoint = (checkpoint, attesterSigner, proposerSigner)=>{
     const header = checkpoint.header;
     const archive = checkpoint.archive.root;
-    const payload = ConsensusPayload.fromFields({
+    const feeAssetPriceModifier = checkpoint.feeAssetPriceModifier;
+    return makeCheckpointAttestation({
         header,
-        archive
+        archive,
+        feeAssetPriceModifier,
+        attesterSigner,
+        proposerSigner
     });
-    return makeBlockAttestationFromPayload(payload, attesterSigner, proposerSigner);
 };
-export const makeBlockAttestationFromBlock = (block, attesterSigner, proposerSigner)=>{
-    const header = block.header;
+/**
+ * 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, attesterSigner, proposerSigner)=>{
+    // 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
+    });
     const archive = block.archive.root;
-    const payload = ConsensusPayload.fromFields({
-        header: header.toCheckpointHeader(),
-        archive
+    return makeCheckpointAttestation({
+        header,
+        archive,
+        attesterSigner,
+        proposerSigner
     });
-    return makeBlockAttestationFromPayload(payload, attesterSigner, proposerSigner);
-};
-export const makeBlockAttestationFromPayload = (payload, attesterSigner, proposerSigner)=>{
-    // 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);
-    return new BlockAttestation(payload, attestationSignature, proposerSignature);
 };
 export async function randomPublishedL2Block(l2BlockNumber, opts = {}) {
-    const block = await L2Block.random(l2BlockNumber);
+    const block = await L2Block.random(BlockNumber(l2BlockNumber));
     const l1 = L1PublishedData.fromFields({
         blockNumber: BigInt(block.number),
         timestamp: block.header.globalVariables.timestamp,
         blockHash: Buffer32.random().toString()
     });
     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/dest/timetable/index.d.ts

@@ -0,0 +1,87 @@
+/**
+ * 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 declare const CHECKPOINT_INITIALIZATION_TIME = 1;
+/** Time budget for assembling a checkpoint after building the last block in seconds */
+export declare const CHECKPOINT_ASSEMBLE_TIME = 1;
+/** Default one-way P2P propagation time for proposals and attestations in seconds */
+export declare const DEFAULT_P2P_PROPAGATION_TIME = 2;
+/** Default L1 publishing time (matches Ethereum slot duration on mainnet) in seconds */
+export declare const DEFAULT_L1_PUBLISHING_TIME = 12;
+/** Minimum execution time for building a block in seconds */
+export declare const MIN_EXECUTION_TIME = 2;
+export type CheckpointTimingConfig = {
+    aztecSlotDuration: number;
+    ethereumSlotDuration?: number;
+    blockDuration?: number;
+    checkpointAssembleTime?: number;
+    checkpointInitializationTime?: number;
+    l1PublishingTime?: number;
+    minExecutionTime?: number;
+    p2pPropagationTime?: number;
+    pipelining?: boolean;
+};
+export interface CheckpointTiming {
+    readonly aztecSlotDuration: number;
+    readonly blockDuration: number | undefined;
+    readonly checkpointAssembleTime: number;
+    readonly checkpointInitializationTime: number;
+    readonly l1PublishingTime: number;
+    readonly minExecutionTime: number;
+    readonly p2pPropagationTime: number;
+    readonly checkpointFinalizationTime: number;
+    readonly pipeliningAttestationGracePeriod: number;
+    readonly timeReservedAtEnd: number;
+    readonly minimumBuildSlotWork: number;
+    readonly initializeDeadline: number;
+    readonly checkpointAssemblyDeadline: number;
+    readonly checkpointAttestationStartDeadline: number;
+    readonly checkpointAttestationDeadline: number;
+    readonly checkpointPublishingDeadline: number;
+    calculateMaxBlocksPerSlot(): number;
+}
+export interface PipelinedCheckpointTiming extends CheckpointTiming {
+    readonly proposalWindowIntoTargetSlot: number;
+    readonly attestationWindowIntoTargetSlot: number;
+}
+/**
+ * Creates a checkpoint timing model for the requested scheduling mode.
+ *
+ * Most callers should use this factory and depend only on the shared
+ * `CheckpointTiming` interface. The returned implementation is selected from
+ * `opts.pipelining`.
+ */
+export declare function createCheckpointTimingModel(opts: CheckpointTimingConfig): CheckpointTiming;
+/**
+ * Creates a pipelined checkpoint timing model with target-slot window accessors.
+ *
+ * Use this when the caller specifically needs the pipelined-only timing surface,
+ * such as proposal or attestation acceptance windows into the target slot.
+ */
+export declare function createPipelinedCheckpointTimingModel(opts: Omit<CheckpointTimingConfig, 'pipelining'>): PipelinedCheckpointTiming;
+/**
+ * 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 declare function calculateMaxBlocksPerSlot(aztecSlotDurationSec: number, blockDurationSec: number | undefined, opts?: {
+    checkpointInitializationTime?: number;
+    checkpointAssembleTime?: number;
+    p2pPropagationTime?: number;
+    l1PublishingTime?: number;
+    pipelining?: boolean;
+}): number;
+//# sourceMappingURL=data:application/json;base64,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

package/dest/timetable/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/timetable/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,mFAAmF;AACnF,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAEhD,uFAAuF;AACvF,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,qFAAqF;AACrF,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAE9C,wFAAwF;AACxF,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAE7C,6DAA6D;AAC7D,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAEpC,MAAM,MAAM,sBAAsB,GAAG;IACnC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,4BAA4B,CAAC,EAAE,MAAM,CAAC;IACtC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3C,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC,QAAQ,CAAC,4BAA4B,EAAE,MAAM,CAAC;IAC9C,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,0BAA0B,EAAE,MAAM,CAAC;IAC5C,QAAQ,CAAC,gCAAgC,EAAE,MAAM,CAAC;IAClD,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;IACtC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,0BAA0B,EAAE,MAAM,CAAC;IAC5C,QAAQ,CAAC,kCAAkC,EAAE,MAAM,CAAC;IACpD,QAAQ,CAAC,6BAA6B,EAAE,MAAM,CAAC;IAC/C,QAAQ,CAAC,4BAA4B,EAAE,MAAM,CAAC;IAE9C,yBAAyB,IAAI,MAAM,CAAC;CACrC;AAED,MAAM,WAAW,yBAA0B,SAAQ,gBAAgB;IACjE,QAAQ,CAAC,4BAA4B,EAAE,MAAM,CAAC;IAC9C,QAAQ,CAAC,+BAA+B,EAAE,MAAM,CAAC;CAClD;AA6JD;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,sBAAsB,GAAG,gBAAgB,CAS1F;AAED;;;;;GAKG;AACH,wBAAgB,oCAAoC,CAClD,IAAI,EAAE,IAAI,CAAC,sBAAsB,EAAE,YAAY,CAAC,GAC/C,yBAAyB,CAO3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,oBAAoB,EAAE,MAAM,EAC5B,gBAAgB,EAAE,MAAM,GAAG,SAAS,EACpC,IAAI,GAAE;IACJ,4BAA4B,CAAC,EAAE,MAAM,CAAC;IACtC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,OAAO,CAAC;CACjB,GACL,MAAM,CAUR"}