@aztec/stdlib 0.0.1-commit.f504929 → 0.0.1-commit.f5a9928

package/dest/tests/mocks.js

@@ -1,4 +1,4 @@
-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 { MAX_ENQUEUED_CALLS_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_PROCESSABLE_L2_GAS, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, MAX_TX_DA_GAS, 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';
@@ -6,15 +6,16 @@ import { padArrayEnd, times } from '@aztec/foundation/collection';
 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 { CheckpointedL2Block, CommitteeAttestation, L2Block } from '../block/index.js';
+import { 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';
 import { SerializableContractInstance } from '../contract/contract_instance.js';
@@ -33,7 +34,7 @@ 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';
@@ -43,15 +44,24 @@ import { NestedProcessReturnValues, PublicSimulationOutput } from '../tx/public_
 import { TxSimulationResult } from '../tx/simulated_tx.js';
 import { TxEffect } from '../tx/tx_effect.js';
 import { TxHash } from '../tx/tx_hash.js';
+import { DEV_VERSION } from '../update-checker/dev_version.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(), maxFeesPerGas = new GasFees(10, 10), maxPriorityFeesPerGas, gasUsed = Gas.empty(), chainId = Fr.ZERO, version = Fr.ZERO, vkTreeRoot = Fr.ZERO, protocolContractsHash = Fr.ZERO, anchorBlockHeader = BlockHeader.empty() } = {})=>{
+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 = new Gas(MAX_TX_DA_GAS, MAX_PROCESSABLE_L2_GAS), 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.anchorBlockHeader = anchorBlockHeader;
-    data.constants.txContext.gasSettings = GasSettings.default({
+    data.constants.txContext.gasSettings = GasSettings.fallback({
+        gasLimits,
         maxFeesPerGas,
         maxPriorityFeesPerGas
     });
@@ -100,7 +110,8 @@ 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({
+    gasLimits: new Gas(MAX_TX_DA_GAS, MAX_PROCESSABLE_L2_GAS),
     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.
 privateOnly = false, gasUsed = Gas.from({
@@ -215,6 +226,10 @@ export function mockL1ToL2Messages(numL1ToL2Messages) {
 }
 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.
@@ -227,11 +242,11 @@ export async function mockCheckpointAndMessages(checkpointNumber, { startBlockNu
         const blockNumber = BlockNumber(startBlockNumber + i);
         const { block, messages } = {
             block: blocks?.[i] ?? await L2Block.random(blockNumber, {
+                ...globals,
                 checkpointNumber,
                 indexWithinCheckpoint: IndexWithinCheckpoint(i),
                 txsPerBlock: numTxsPerBlock,
                 txOptions,
-                slotNumber,
                 ...options,
                 ...makeBlockOptions(blockNumber),
                 ...lastArchive ? {
@@ -249,17 +264,17 @@ export async function mockCheckpointAndMessages(checkpointNumber, { startBlockNu
     }
     const messages = blocksAndMessages[0].messages;
     const inHash = computeInHashFromL1ToL2Messages(messages);
+    const firstBlockLastArchive = blocksAndMessages[0].block.header.lastArchive;
     const checkpoint = await Checkpoint.random(checkpointNumber, {
         numBlocks: 0,
-        slotNumber,
         inHash,
-        ...options
+        ...options,
+        ...globals,
+        lastArchive: firstBlockLastArchive,
+        lastArchiveRoot: firstBlockLastArchive.root,
+        archive: lastArchive
     });
     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,
@@ -269,6 +284,7 @@ export async function mockCheckpointAndMessages(checkpointNumber, { startBlockNu
 }
 export const randomContractArtifact = ()=>({
         name: randomBytes(4).toString('hex'),
+        aztecVersion: DEV_VERSION,
         functions: [],
         nonDispatchPublicFunctions: [],
         outputs: {
@@ -296,15 +312,16 @@ export const randomDeployedContract = async ()=>{
     };
 };
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-const makeAndSignConsensusPayload = (domainSeparator, options)=>{
+const makeAndSignConsensusPayload = (options)=>{
     const header = options?.header ?? makeCheckpointHeader(1);
     const { signer = Secp256k1Signer.random(), archive = Fr.random(), feeAssetPriceModifier = 0n } = options ?? {};
     const payload = ConsensusPayload.fromFields({
         header,
         archive,
-        feeAssetPriceModifier
+        feeAssetPriceModifier,
+        signatureContext: TEST_COORDINATION_SIGNATURE_CONTEXT
     });
-    const hash = getHashedSignaturePayloadEthSignedMessage(payload, domainSeparator);
+    const hash = getHashedSignaturePayloadTypedData(payload);
     const signature = signer.sign(hash);
     return {
         blockNumber: header.slotNumber,
@@ -313,7 +330,7 @@ const makeAndSignConsensusPayload = (domainSeparator, options)=>{
     };
 };
 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)=>{
@@ -331,29 +348,27 @@ export const makeBlockProposal = (options)=>{
     ].map(()=>TxHash.random());
     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)));
+    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)));
 };
-export const makeCheckpointProposal = (options)=>{
-    const blockHeader = options?.lastBlock?.blockHeader ?? makeBlockHeader(1);
+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();
-    // Build lastBlock info if provided
-    const lastBlockInfo = options?.lastBlock ? {
-        blockHeader,
+    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),
-        txHashes: options.lastBlock.txHashes ?? [
-            0,
-            1,
-            2,
-            3,
-            4,
-            5
-        ].map(()=>TxHash.random()),
-        txs: options.lastBlock.txs
-    } : undefined;
-    return CheckpointProposal.createProposalFromSigner(checkpointHeader, archiveRoot, feeAssetPriceModifier, lastBlockInfo, (payload)=>Promise.resolve(signer.signMessage(payload)));
+        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)));
 };
 /**
  * Create a checkpoint attestation for testing
@@ -361,26 +376,27 @@ export const makeCheckpointProposal = (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);
+    const payload = new ConsensusPayload(header, archive, feeAssetPriceModifier, signatureContext);
     // Sign as attester
-    const attestationHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.checkpointAttestation);
+    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());
-    const proposalHash = getHashedSignaturePayloadEthSignedMessage(tempProposal, SignatureDomainSeparator.checkpointProposal);
+    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);
+    const payload = new ConsensusPayload(proposal.checkpointHeader, proposal.archive, proposal.feeAssetPriceModifier, proposal.signatureContext);
     // Sign as attester
-    const attestationHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.checkpointAttestation);
+    const attestationHash = getHashedSignaturePayloadTypedData(payload);
     const attestationSigner = attesterSigner ?? Secp256k1Signer.random();
     const attestationSignature = attestationSigner.sign(attestationHash);
     // Use the proposal's signature as the proposer signature
@@ -419,25 +435,3 @@ export const makeCheckpointProposal = (options)=>{
         proposerSigner
     });
 };
-export async function randomPublishedL2Block(l2BlockNumber, opts = {}) {
-    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 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 CheckpointedL2Block(CheckpointNumber.fromBlockNumber(BlockNumber(l2BlockNumber)), block, l1, attestations);
-}

package/dest/timetable/budgets.d.ts

@@ -0,0 +1,57 @@
+/** Default block sub-slot duration (`D`) in seconds, used to derive how many blocks fit in a slot. */
+export declare const DEFAULT_BLOCK_DURATION = 3;
+/** Default minimum block-building duration (`min_block_duration`) in seconds. */
+export declare const DEFAULT_MIN_BLOCK_DURATION = 2;
+/** Default one-way P2P propagation time (`p2p_propagation_time`) for proposals and attestations in seconds. */
+export declare const DEFAULT_P2P_PROPAGATION_TIME = 2;
+/** Default local checkpoint proposal preparation time (`checkpoint_proposal_prepare_time`) in seconds. */
+export declare const DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME = 1;
+/** Default local tolerance for archiver orphan-prune checks when no checkpoint proposal was received. */
+export declare const DEFAULT_ORPHAN_PRUNE_NO_PROPOSAL_TOLERANCE = 1;
+/**
+ * Default proposer initialization time (`checkpoint_proposal_init_time`) in seconds: the budget reserved at
+ * the start of the build frame for sync, the proposer check, and checkpoint initialization before the first
+ * block sub-slot opens. The proposer rarely starts building exactly at `build_frame_start`; this offset
+ * shifts the sub-slot grid so the first sub-slot still has its full duration once the prologue completes.
+ */
+export declare const DEFAULT_CHECKPOINT_PROPOSAL_INIT_TIME = 1;
+/**
+ * Ethereum slot duration (seconds) below which a network is treated as a fast local/e2e profile with mocked
+ * p2p. Profiles at or above this keep the production operational budgets. Mainnet is 12s; fast anvil-style
+ * local profiles run at 4s.
+ */
+export declare const FAST_PROFILE_ETHEREUM_SLOT_DURATION = 8;
+/**
+ * Operational timing budgets for the fast local/e2e profile (mocked p2p), per the README's "Local e2e with
+ * mocked p2p" section. When `ethereum_slot_duration < FAST_PROFILE_ETHEREUM_SLOT_DURATION`, these cap the
+ * proposer's operational budgets so a fast network does not inherit the conservative production budgets,
+ * which would shrink the per-checkpoint build window and under-pack checkpoints. Explicitly configured
+ * budgets below these caps are kept as-is (the budgets are clamped down, never raised).
+ */
+export declare const FAST_PROFILE_P2P_PROPAGATION_TIME = 0.5;
+/** Fast-profile checkpoint proposal preparation budget (seconds). See {@link FAST_PROFILE_P2P_PROPAGATION_TIME}. */
+export declare const FAST_PROFILE_CHECKPOINT_PROPOSAL_PREPARE_TIME = 0.5;
+/** Fast-profile minimum block-building budget (seconds). See {@link FAST_PROFILE_P2P_PROPAGATION_TIME}. */
+export declare const FAST_PROFILE_MIN_BLOCK_DURATION = 1;
+/** Resolved operational timing budgets used to size the proposer build window. */
+export type ResolvedTimingBudgets = {
+    minBlockDuration: number;
+    p2pPropagationTime: number;
+    checkpointProposalPrepareTime: number;
+    checkpointProposalInitTime: number;
+};
+/** Default consensus grace for received checkpoint proposals to materialize locally. */
+export declare function getDefaultCheckpointProposalSyncGrace(blockDuration: number): number;
+/**
+ * Resolves the operational timing budgets, applying the fast local/e2e profile when
+ * `ethereumSlotDuration < FAST_PROFILE_ETHEREUM_SLOT_DURATION`.
+ *
+ * Production profiles (`ethereumSlotDuration >= FAST_PROFILE_ETHEREUM_SLOT_DURATION`) use the configured
+ * budgets verbatim. Fast profiles clamp `p2pPropagationTime`, `checkpointProposalPrepareTime`, and
+ * `minBlockDuration` down to the fast-profile caps so a fast network (mocked p2p) gets a build window sized
+ * for local timing rather than the conservative production budgets. The clamp only lowers budgets, so an
+ * operator that explicitly configured a smaller value keeps it. `checkpointProposalInitTime` is unchanged by
+ * the profile: it is a proposer prologue budget, not a propagation/preparation budget.
+ */
+export declare function resolveTimingBudgets(ethereumSlotDuration: number, opts: ResolvedTimingBudgets): ResolvedTimingBudgets;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVkZ2V0cy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3RpbWV0YWJsZS9idWRnZXRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHNHQUFzRztBQUN0RyxlQUFPLE1BQU0sc0JBQXNCLElBQUksQ0FBQztBQUV4QyxpRkFBaUY7QUFDakYsZUFBTyxNQUFNLDBCQUEwQixJQUFJLENBQUM7QUFFNUMsK0dBQStHO0FBQy9HLGVBQU8sTUFBTSw0QkFBNEIsSUFBSSxDQUFDO0FBRTlDLDBHQUEwRztBQUMxRyxlQUFPLE1BQU0sd0NBQXdDLElBQUksQ0FBQztBQUUxRCx5R0FBeUc7QUFDekcsZUFBTyxNQUFNLDBDQUEwQyxJQUFJLENBQUM7QUFFNUQ7Ozs7O0dBS0c7QUFDSCxlQUFPLE1BQU0scUNBQXFDLElBQUksQ0FBQztBQUV2RDs7OztHQUlHO0FBQ0gsZUFBTyxNQUFNLG1DQUFtQyxJQUFJLENBQUM7QUFFckQ7Ozs7OztHQU1HO0FBQ0gsZUFBTyxNQUFNLGlDQUFpQyxNQUFNLENBQUM7QUFFckQsb0hBQW9IO0FBQ3BILGVBQU8sTUFBTSw2Q0FBNkMsTUFBTSxDQUFDO0FBRWpFLDJHQUEyRztBQUMzRyxlQUFPLE1BQU0sK0JBQStCLElBQUksQ0FBQztBQUVqRCxrRkFBa0Y7QUFDbEYsTUFBTSxNQUFNLHFCQUFxQixHQUFHO0lBQ2xDLGdCQUFnQixFQUFFLE1BQU0sQ0FBQztJQUN6QixrQkFBa0IsRUFBRSxNQUFNLENBQUM7SUFDM0IsNkJBQTZCLEVBQUUsTUFBTSxDQUFDO0lBQ3RDLDBCQUEwQixFQUFFLE1BQU0sQ0FBQztDQUNwQyxDQUFDO0FBRUYsd0ZBQXdGO0FBQ3hGLHdCQUFnQixxQ0FBcUMsQ0FBQyxhQUFhLEVBQUUsTUFBTSxHQUFHLE1BQU0sQ0FFbkY7QUFFRDs7Ozs7Ozs7OztHQVVHO0FBQ0gsd0JBQWdCLG9CQUFvQixDQUFDLG9CQUFvQixFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUscUJBQXFCLEdBQUcscUJBQXFCLENBaUJySCJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"budgets.d.ts","sourceRoot":"","sources":["../../src/timetable/budgets.ts"],"names":[],"mappings":"AAAA,sGAAsG;AACtG,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC,iFAAiF;AACjF,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C,+GAA+G;AAC/G,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAE9C,0GAA0G;AAC1G,eAAO,MAAM,wCAAwC,IAAI,CAAC;AAE1D,yGAAyG;AACzG,eAAO,MAAM,0CAA0C,IAAI,CAAC;AAE5D;;;;;GAKG;AACH,eAAO,MAAM,qCAAqC,IAAI,CAAC;AAEvD;;;;GAIG;AACH,eAAO,MAAM,mCAAmC,IAAI,CAAC;AAErD;;;;;;GAMG;AACH,eAAO,MAAM,iCAAiC,MAAM,CAAC;AAErD,oHAAoH;AACpH,eAAO,MAAM,6CAA6C,MAAM,CAAC;AAEjE,2GAA2G;AAC3G,eAAO,MAAM,+BAA+B,IAAI,CAAC;AAEjD,kFAAkF;AAClF,MAAM,MAAM,qBAAqB,GAAG;IAClC,gBAAgB,EAAE,MAAM,CAAC;IACzB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,6BAA6B,EAAE,MAAM,CAAC;IACtC,0BAA0B,EAAE,MAAM,CAAC;CACpC,CAAC;AAEF,wFAAwF;AACxF,wBAAgB,qCAAqC,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAEnF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,oBAAoB,EAAE,MAAM,EAAE,IAAI,EAAE,qBAAqB,GAAG,qBAAqB,CAiBrH"}

package/dest/timetable/budgets.js

@@ -0,0 +1,56 @@
+/** Default block sub-slot duration (`D`) in seconds, used to derive how many blocks fit in a slot. */ export const DEFAULT_BLOCK_DURATION = 3;
+/** Default minimum block-building duration (`min_block_duration`) in seconds. */ export const DEFAULT_MIN_BLOCK_DURATION = 2;
+/** Default one-way P2P propagation time (`p2p_propagation_time`) for proposals and attestations in seconds. */ export const DEFAULT_P2P_PROPAGATION_TIME = 2;
+/** Default local checkpoint proposal preparation time (`checkpoint_proposal_prepare_time`) in seconds. */ export const DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME = 1;
+/** Default local tolerance for archiver orphan-prune checks when no checkpoint proposal was received. */ export const DEFAULT_ORPHAN_PRUNE_NO_PROPOSAL_TOLERANCE = 1;
+/**
+ * Default proposer initialization time (`checkpoint_proposal_init_time`) in seconds: the budget reserved at
+ * the start of the build frame for sync, the proposer check, and checkpoint initialization before the first
+ * block sub-slot opens. The proposer rarely starts building exactly at `build_frame_start`; this offset
+ * shifts the sub-slot grid so the first sub-slot still has its full duration once the prologue completes.
+ */ export const DEFAULT_CHECKPOINT_PROPOSAL_INIT_TIME = 1;
+/**
+ * Ethereum slot duration (seconds) below which a network is treated as a fast local/e2e profile with mocked
+ * p2p. Profiles at or above this keep the production operational budgets. Mainnet is 12s; fast anvil-style
+ * local profiles run at 4s.
+ */ export const FAST_PROFILE_ETHEREUM_SLOT_DURATION = 8;
+/**
+ * Operational timing budgets for the fast local/e2e profile (mocked p2p), per the README's "Local e2e with
+ * mocked p2p" section. When `ethereum_slot_duration < FAST_PROFILE_ETHEREUM_SLOT_DURATION`, these cap the
+ * proposer's operational budgets so a fast network does not inherit the conservative production budgets,
+ * which would shrink the per-checkpoint build window and under-pack checkpoints. Explicitly configured
+ * budgets below these caps are kept as-is (the budgets are clamped down, never raised).
+ */ export const FAST_PROFILE_P2P_PROPAGATION_TIME = 0.5;
+/** Fast-profile checkpoint proposal preparation budget (seconds). See {@link FAST_PROFILE_P2P_PROPAGATION_TIME}. */ export const FAST_PROFILE_CHECKPOINT_PROPOSAL_PREPARE_TIME = 0.5;
+/** Fast-profile minimum block-building budget (seconds). See {@link FAST_PROFILE_P2P_PROPAGATION_TIME}. */ export const FAST_PROFILE_MIN_BLOCK_DURATION = 1;
+/** Default consensus grace for received checkpoint proposals to materialize locally. */ export function getDefaultCheckpointProposalSyncGrace(blockDuration) {
+    return 2 * blockDuration;
+}
+/**
+ * Resolves the operational timing budgets, applying the fast local/e2e profile when
+ * `ethereumSlotDuration < FAST_PROFILE_ETHEREUM_SLOT_DURATION`.
+ *
+ * Production profiles (`ethereumSlotDuration >= FAST_PROFILE_ETHEREUM_SLOT_DURATION`) use the configured
+ * budgets verbatim. Fast profiles clamp `p2pPropagationTime`, `checkpointProposalPrepareTime`, and
+ * `minBlockDuration` down to the fast-profile caps so a fast network (mocked p2p) gets a build window sized
+ * for local timing rather than the conservative production budgets. The clamp only lowers budgets, so an
+ * operator that explicitly configured a smaller value keeps it. `checkpointProposalInitTime` is unchanged by
+ * the profile: it is a proposer prologue budget, not a propagation/preparation budget.
+ */ export function resolveTimingBudgets(ethereumSlotDuration, opts) {
+    const { minBlockDuration, p2pPropagationTime, checkpointProposalPrepareTime, checkpointProposalInitTime } = opts;
+    const isFastProfile = ethereumSlotDuration < FAST_PROFILE_ETHEREUM_SLOT_DURATION;
+    if (!isFastProfile) {
+        return {
+            minBlockDuration,
+            p2pPropagationTime,
+            checkpointProposalPrepareTime,
+            checkpointProposalInitTime
+        };
+    }
+    return {
+        minBlockDuration: Math.min(minBlockDuration, FAST_PROFILE_MIN_BLOCK_DURATION),
+        p2pPropagationTime: Math.min(p2pPropagationTime, FAST_PROFILE_P2P_PROPAGATION_TIME),
+        checkpointProposalPrepareTime: Math.min(checkpointProposalPrepareTime, FAST_PROFILE_CHECKPOINT_PROPOSAL_PREPARE_TIME),
+        checkpointProposalInitTime
+    };
+}

package/dest/timetable/build_proposer_timetable.d.ts

@@ -0,0 +1,21 @@
+import type { SlotTimingConstants } from './consensus_timetable.js';
+import { ProposerTimetable } from './proposer_timetable.js';
+/**
+ * Subset of the sequencer/p2p config the proposer timetable derives its operational budgets from. Both
+ * {@link SequencerConfig} and {@link P2PConfig} structurally satisfy this, so the same builder is used by
+ * the sequencer, the p2p layer, and the node's `getNodeInfo`.
+ */
+export type ProposerTimetableConfig = {
+    blockDurationMs?: number;
+    minBlockDuration?: number;
+    attestationPropagationTime?: number;
+    checkpointProposalPrepareTime?: number;
+    checkpointProposalSyncGraceSeconds?: number;
+};
+/**
+ * Builds the proposer timetable from a sequencer/p2p config and the slot-timing protocol constants,
+ * applying the shared stdlib budget defaults. Single source of truth shared by the sequencer, the p2p
+ * layer, and the node's `getNodeInfo` so they all derive the same `maxBlocksPerCheckpoint`.
+ */
+export declare function buildProposerTimetable(config: ProposerTimetableConfig, l1Constants: SlotTimingConstants): ProposerTimetable;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVpbGRfcHJvcG9zZXJfdGltZXRhYmxlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGltZXRhYmxlL2J1aWxkX3Byb3Bvc2VyX3RpbWV0YWJsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFPQSxPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3BFLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRTVEOzs7O0dBSUc7QUFDSCxNQUFNLE1BQU0sdUJBQXVCLEdBQUc7SUFDcEMsZUFBZSxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ3pCLGdCQUFnQixDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQzFCLDBCQUEwQixDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ3BDLDZCQUE2QixDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ3ZDLGtDQUFrQyxDQUFDLEVBQUUsTUFBTSxDQUFDO0NBQzdDLENBQUM7QUFFRjs7OztHQUlHO0FBQ0gsd0JBQWdCLHNCQUFzQixDQUNwQyxNQUFNLEVBQUUsdUJBQXVCLEVBQy9CLFdBQVcsRUFBRSxtQkFBbUIsR0FDL0IsaUJBQWlCLENBVW5CIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"build_proposer_timetable.d.ts","sourceRoot":"","sources":["../../src/timetable/build_proposer_timetable.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAE5D;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACpC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,0BAA0B,CAAC,EAAE,MAAM,CAAC;IACpC,6BAA6B,CAAC,EAAE,MAAM,CAAC;IACvC,kCAAkC,CAAC,EAAE,MAAM,CAAC;CAC7C,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,mBAAmB,GAC/B,iBAAiB,CAUnB"}

package/dest/timetable/build_proposer_timetable.js

@@ -0,0 +1,17 @@
+import { DEFAULT_BLOCK_DURATION, DEFAULT_CHECKPOINT_PROPOSAL_INIT_TIME, DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME, DEFAULT_MIN_BLOCK_DURATION, DEFAULT_P2P_PROPAGATION_TIME } from './budgets.js';
+import { ProposerTimetable } from './proposer_timetable.js';
+/**
+ * Builds the proposer timetable from a sequencer/p2p config and the slot-timing protocol constants,
+ * applying the shared stdlib budget defaults. Single source of truth shared by the sequencer, the p2p
+ * layer, and the node's `getNodeInfo` so they all derive the same `maxBlocksPerCheckpoint`.
+ */ export function buildProposerTimetable(config, l1Constants) {
+    return new ProposerTimetable({
+        l1Constants,
+        blockDuration: config.blockDurationMs !== undefined ? config.blockDurationMs / 1000 : DEFAULT_BLOCK_DURATION,
+        minBlockDuration: config.minBlockDuration ?? DEFAULT_MIN_BLOCK_DURATION,
+        p2pPropagationTime: config.attestationPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME,
+        checkpointProposalPrepareTime: config.checkpointProposalPrepareTime ?? DEFAULT_CHECKPOINT_PROPOSAL_PREPARE_TIME,
+        checkpointProposalInitTime: DEFAULT_CHECKPOINT_PROPOSAL_INIT_TIME,
+        checkpointProposalSyncGrace: config.checkpointProposalSyncGraceSeconds
+    });
+}

package/dest/timetable/consensus_timetable.d.ts

@@ -0,0 +1,70 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+import { type L1RollupConstants } from '../epoch-helpers/index.js';
+/** Slot-timing protocol constants the timetables derive wall-clock times from. */
+export type SlotTimingConstants = Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration' | 'ethereumSlotDuration'>;
+/**
+ * Consensus acceptance bounds for the pipelined timetable.
+ *
+ * Returns the deadlines and matching receive-window lower bounds that validators and p2p use to decide
+ * whether a proposal or attestation is acceptable for a given target slot. All getters take a target slot
+ * and return an absolute wall-clock timestamp in seconds.
+ *
+ * Inputs are protocol slot-timing constants only (`genesis`, `aztec_slot_duration`,
+ * `ethereum_slot_duration`, `block_duration`, `checkpoint_proposal_sync_grace`); no operational budgets, so every
+ * node agrees on these bounds. See `stdlib/src/timetable/README.md` for the timing model.
+ */
+export declare class ConsensusTimetable {
+    /** Aztec slot duration (`S`) in seconds. */
+    readonly aztecSlotDuration: number;
+    /** Ethereum slot duration (`E`) in seconds. */
+    readonly ethereumSlotDuration: number;
+    /** Block sub-slot duration (`D`) in seconds. */
+    readonly blockDuration: number;
+    /** L1 genesis timestamp in seconds (`genesis`), the anchor all slot timings derive from. */
+    readonly genesisTime: bigint;
+    /** Consensus grace for received checkpoint proposals to materialize into local proposed state. */
+    readonly checkpointProposalSyncGrace: number;
+    constructor(opts: {
+        l1Constants: SlotTimingConstants;
+        blockDuration: number;
+        checkpointProposalSyncGrace?: number;
+    });
+    /**
+     * Build-frame start for the target slot: `target_slot_start - S - E`. Anchors all sub-slot timings.
+     * Computed directly (not via a `slot - 1` hop) so it is well-defined for slot 0, whose build frame
+     * predates genesis; p2p validators evaluate acceptance windows for arbitrary peer-supplied slots.
+     */
+    getBuildFrameStart(slot: SlotNumber): number;
+    /** Start of the target slot: `genesis + slot * S`. */
+    getTargetSlotStart(slot: SlotNumber): number;
+    /**
+     * Earliest acceptable arrival for a checkpoint proposal: `target_slot_start - S - E` (the build frame
+     * opening). Nothing legitimate for this slot exists before its build frame opens.
+     */
+    getCheckpointProposalReceiveStart(slot: SlotNumber): number;
+    /**
+     * Hard consensus receive deadline for a checkpoint proposal: `target_slot_start - E - D`. Validators
+     * reject proposals arriving after this, and the next proposer does not build on them.
+     */
+    getCheckpointProposalReceiveDeadline(slot: SlotNumber): number;
+    /**
+     * Wall-clock deadline by which a received checkpoint proposal should have materialized into local proposed
+     * state. This is `next_proposer_build_frame_start + checkpointProposalSyncGrace`, rounded up to the next
+     * integer second because L1 timestamps and archiver comparisons are second-granularity.
+     */
+    getCheckpointProposalSyncedDeadline(slot: SlotNumber): number;
+    /**
+     * Earliest acceptable arrival for an attestation: `target_slot_start - S - E` (the build frame
+     * opening). Deliberately liberal; attestations are attributed by content, not timing.
+     */
+    getAttestationReceiveStart(slot: SlotNumber): number;
+    /**
+     * Single hard consensus deadline: `target_slot_start + S - 2E`. The latest the checkpoint can still
+     * land on L1 in the target slot, and the cutoff by which every block and the checkpoint must be
+     * re-executed, validated, and signed. Consensus-driven (used for inactivity/slashing decisions).
+     */
+    getAttestationDeadline(slot: SlotNumber): number;
+    /** Slot-timing protocol constants this timetable derives wall-clock times from. */
+    getL1Constants(): SlotTimingConstants;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc2Vuc3VzX3RpbWV0YWJsZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3RpbWV0YWJsZS9jb25zZW5zdXNfdGltZXRhYmxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRWxFLE9BQU8sRUFBRSxLQUFLLGlCQUFpQixFQUF1QixNQUFNLDJCQUEyQixDQUFDO0FBR3hGLGtGQUFrRjtBQUNsRixNQUFNLE1BQU0sbUJBQW1CLEdBQUcsSUFBSSxDQUFDLGlCQUFpQixFQUFFLGVBQWUsR0FBRyxjQUFjLEdBQUcsc0JBQXNCLENBQUMsQ0FBQztBQUVySDs7Ozs7Ozs7OztHQVVHO0FBQ0gscUJBQWEsa0JBQWtCO0lBQzdCLDRDQUE0QztJQUM1QyxTQUFnQixpQkFBaUIsRUFBRSxNQUFNLENBQUM7SUFFMUMsK0NBQStDO0lBQy9DLFNBQWdCLG9CQUFvQixFQUFFLE1BQU0sQ0FBQztJQUU3QyxnREFBZ0Q7SUFDaEQsU0FBZ0IsYUFBYSxFQUFFLE1BQU0sQ0FBQztJQUV0Qyw0RkFBNEY7SUFDNUYsU0FBZ0IsV0FBVyxFQUFFLE1BQU0sQ0FBQztJQUVwQyxrR0FBa0c7SUFDbEcsU0FBZ0IsMkJBQTJCLEVBQUUsTUFBTSxDQUFDO0lBRXBELFlBQVksSUFBSSxFQUFFO1FBQUUsV0FBVyxFQUFFLG1CQUFtQixDQUFDO1FBQUMsYUFBYSxFQUFFLE1BQU0sQ0FBQztRQUFDLDJCQUEyQixDQUFDLEVBQUUsTUFBTSxDQUFBO0tBQUUsRUFzQmxIO0lBRUQ7Ozs7T0FJRztJQUNJLGtCQUFrQixDQUFDLElBQUksRUFBRSxVQUFVLEdBQUcsTUFBTSxDQUVsRDtJQUVELHNEQUFzRDtJQUMvQyxrQkFBa0IsQ0FBQyxJQUFJLEVBQUUsVUFBVSxHQUFHLE1BQU0sQ0FFbEQ7SUFFRDs7O09BR0c7SUFDSSxpQ0FBaUMsQ0FBQyxJQUFJLEVBQUUsVUFBVSxHQUFHLE1BQU0sQ0FFakU7SUFFRDs7O09BR0c7SUFDSSxvQ0FBb0MsQ0FBQyxJQUFJLEVBQUUsVUFBVSxHQUFHLE1BQU0sQ0FFcEU7SUFFRDs7OztPQUlHO0lBQ0ksbUNBQW1DLENBQUMsSUFBSSxFQUFFLFVBQVUsR0FBRyxNQUFNLENBSW5FO0lBRUQ7OztPQUdHO0lBQ0ksMEJBQTBCLENBQUMsSUFBSSxFQUFFLFVBQVUsR0FBRyxNQUFNLENBRTFEO0lBRUQ7Ozs7T0FJRztJQUNJLHNCQUFzQixDQUFDLElBQUksRUFBRSxVQUFVLEdBQUcsTUFBTSxDQUV0RDtJQUVELG1GQUFtRjtJQUM1RSxjQUFjLElBQUksbUJBQW1CLENBTTNDO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"consensus_timetable.d.ts","sourceRoot":"","sources":["../../src/timetable/consensus_timetable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAElE,OAAO,EAAE,KAAK,iBAAiB,EAAuB,MAAM,2BAA2B,CAAC;AAGxF,kFAAkF;AAClF,MAAM,MAAM,mBAAmB,GAAG,IAAI,CAAC,iBAAiB,EAAE,eAAe,GAAG,cAAc,GAAG,sBAAsB,CAAC,CAAC;AAErH;;;;;;;;;;GAUG;AACH,qBAAa,kBAAkB;IAC7B,4CAA4C;IAC5C,SAAgB,iBAAiB,EAAE,MAAM,CAAC;IAE1C,+CAA+C;IAC/C,SAAgB,oBAAoB,EAAE,MAAM,CAAC;IAE7C,gDAAgD;IAChD,SAAgB,aAAa,EAAE,MAAM,CAAC;IAEtC,4FAA4F;IAC5F,SAAgB,WAAW,EAAE,MAAM,CAAC;IAEpC,kGAAkG;IAClG,SAAgB,2BAA2B,EAAE,MAAM,CAAC;IAEpD,YAAY,IAAI,EAAE;QAAE,WAAW,EAAE,mBAAmB,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,2BAA2B,CAAC,EAAE,MAAM,CAAA;KAAE,EAsBlH;IAED;;;;OAIG;IACI,kBAAkB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAElD;IAED,sDAAsD;IAC/C,kBAAkB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAElD;IAED;;;OAGG;IACI,iCAAiC,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAEjE;IAED;;;OAGG;IACI,oCAAoC,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAEpE;IAED;;;;OAIG;IACI,mCAAmC,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAInE;IAED;;;OAGG;IACI,0BAA0B,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAE1D;IAED;;;;OAIG;IACI,sBAAsB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAEtD;IAED,mFAAmF;IAC5E,cAAc,IAAI,mBAAmB,CAM3C;CACF"}

package/dest/timetable/consensus_timetable.js

@@ -0,0 +1,89 @@
+import { getTimestampForSlot } from '../epoch-helpers/index.js';
+import { getDefaultCheckpointProposalSyncGrace } from './budgets.js';
+/**
+ * Consensus acceptance bounds for the pipelined timetable.
+ *
+ * Returns the deadlines and matching receive-window lower bounds that validators and p2p use to decide
+ * whether a proposal or attestation is acceptable for a given target slot. All getters take a target slot
+ * and return an absolute wall-clock timestamp in seconds.
+ *
+ * Inputs are protocol slot-timing constants only (`genesis`, `aztec_slot_duration`,
+ * `ethereum_slot_duration`, `block_duration`, `checkpoint_proposal_sync_grace`); no operational budgets, so every
+ * node agrees on these bounds. See `stdlib/src/timetable/README.md` for the timing model.
+ */ export class ConsensusTimetable {
+    /** Aztec slot duration (`S`) in seconds. */ aztecSlotDuration;
+    /** Ethereum slot duration (`E`) in seconds. */ ethereumSlotDuration;
+    /** Block sub-slot duration (`D`) in seconds. */ blockDuration;
+    /** L1 genesis timestamp in seconds (`genesis`), the anchor all slot timings derive from. */ genesisTime;
+    /** Consensus grace for received checkpoint proposals to materialize into local proposed state. */ checkpointProposalSyncGrace;
+    constructor(opts){
+        const { l1Constants, blockDuration } = opts;
+        const checkpointProposalSyncGrace = opts.checkpointProposalSyncGrace ?? getDefaultCheckpointProposalSyncGrace(blockDuration);
+        if (l1Constants.slotDuration <= 0) {
+            throw new Error(`aztecSlotDuration must be positive (got ${l1Constants.slotDuration})`);
+        }
+        if (l1Constants.ethereumSlotDuration <= 0) {
+            throw new Error(`ethereumSlotDuration must be positive (got ${l1Constants.ethereumSlotDuration})`);
+        }
+        if (blockDuration <= 0) {
+            throw new Error(`blockDuration must be positive (got ${blockDuration})`);
+        }
+        if (checkpointProposalSyncGrace < 0) {
+            throw new Error(`checkpointProposalSyncGrace must be non-negative (got ${checkpointProposalSyncGrace})`);
+        }
+        this.aztecSlotDuration = l1Constants.slotDuration;
+        this.ethereumSlotDuration = l1Constants.ethereumSlotDuration;
+        this.blockDuration = blockDuration;
+        this.genesisTime = l1Constants.l1GenesisTime;
+        this.checkpointProposalSyncGrace = checkpointProposalSyncGrace;
+    }
+    /**
+   * Build-frame start for the target slot: `target_slot_start - S - E`. Anchors all sub-slot timings.
+   * Computed directly (not via a `slot - 1` hop) so it is well-defined for slot 0, whose build frame
+   * predates genesis; p2p validators evaluate acceptance windows for arbitrary peer-supplied slots.
+   */ getBuildFrameStart(slot) {
+        return this.getTargetSlotStart(slot) - this.aztecSlotDuration - this.ethereumSlotDuration;
+    }
+    /** Start of the target slot: `genesis + slot * S`. */ getTargetSlotStart(slot) {
+        return Number(getTimestampForSlot(slot, this.getL1Constants()));
+    }
+    /**
+   * Earliest acceptable arrival for a checkpoint proposal: `target_slot_start - S - E` (the build frame
+   * opening). Nothing legitimate for this slot exists before its build frame opens.
+   */ getCheckpointProposalReceiveStart(slot) {
+        return this.getBuildFrameStart(slot);
+    }
+    /**
+   * Hard consensus receive deadline for a checkpoint proposal: `target_slot_start - E - D`. Validators
+   * reject proposals arriving after this, and the next proposer does not build on them.
+   */ getCheckpointProposalReceiveDeadline(slot) {
+        return this.getTargetSlotStart(slot) - this.ethereumSlotDuration - this.blockDuration;
+    }
+    /**
+   * Wall-clock deadline by which a received checkpoint proposal should have materialized into local proposed
+   * state. This is `next_proposer_build_frame_start + checkpointProposalSyncGrace`, rounded up to the next
+   * integer second because L1 timestamps and archiver comparisons are second-granularity.
+   */ getCheckpointProposalSyncedDeadline(slot) {
+        return Math.ceil(this.getCheckpointProposalReceiveDeadline(slot) + this.blockDuration + this.checkpointProposalSyncGrace);
+    }
+    /**
+   * Earliest acceptable arrival for an attestation: `target_slot_start - S - E` (the build frame
+   * opening). Deliberately liberal; attestations are attributed by content, not timing.
+   */ getAttestationReceiveStart(slot) {
+        return this.getBuildFrameStart(slot);
+    }
+    /**
+   * Single hard consensus deadline: `target_slot_start + S - 2E`. The latest the checkpoint can still
+   * land on L1 in the target slot, and the cutoff by which every block and the checkpoint must be
+   * re-executed, validated, and signed. Consensus-driven (used for inactivity/slashing decisions).
+   */ getAttestationDeadline(slot) {
+        return this.getTargetSlotStart(slot) + this.aztecSlotDuration - 2 * this.ethereumSlotDuration;
+    }
+    /** Slot-timing protocol constants this timetable derives wall-clock times from. */ getL1Constants() {
+        return {
+            l1GenesisTime: this.genesisTime,
+            slotDuration: this.aztecSlotDuration,
+            ethereumSlotDuration: this.ethereumSlotDuration
+        };
+    }
+}