@aztec/stdlib 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/dest/tests/mocks.js

@@ -1,46 +1,68 @@
-import { MAX_ENQUEUED_CALLS_PER_TX, MAX_INCLUDE_BY_TIMESTAMP_DURATION } 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';
-import { times } from '@aztec/foundation/collection';
-import { Secp256k1Signer, randomBytes } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+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 { CommitteeAttestation, L1PublishedData } from '../block/index.js';
-import { L2Block } from '../block/l2_block.js';
-import { PublishedL2Block } from '../block/published_l2_block.js';
+import { L2Block } from '../block/index.js';
+import { Checkpoint } from '../checkpoint/checkpoint.js';
 import { computeContractAddressFromInstance } from '../contract/contract_address.js';
 import { getContractClassFromArtifact } from '../contract/contract_class.js';
 import { SerializableContractInstance } from '../contract/contract_instance.js';
+import { computeEffectiveGasFees } from '../fees/transaction_fee.js';
 import { Gas } from '../gas/gas.js';
 import { GasFees } from '../gas/gas_fees.js';
 import { GasSettings } from '../gas/gas_settings.js';
 import { Nullifier } from '../kernel/nullifier.js';
 import { PrivateCircuitPublicInputs } from '../kernel/private_circuit_public_inputs.js';
 import { PartialPrivateTailPublicInputsForPublic, PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
+import { PrivateToAvmAccumulatedData } from '../kernel/private_to_avm_accumulated_data.js';
 import { PrivateToPublicAccumulatedDataBuilder } from '../kernel/private_to_public_accumulated_data_builder.js';
-import { Note } from '../note/note.js';
-import { UniqueNote } from '../note/unique_note.js';
-import { BlockAttestation } from '../p2p/block_attestation.js';
+import { PublicCallRequestArrayLengths } from '../kernel/public_call_request.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 { HashedValues, PrivateCallExecutionResult, PrivateExecutionResult, Tx } from '../tx/index.js';
-import { PublicSimulationOutput } from '../tx/public_simulation_output.js';
-import { TxSimulationResult, accumulatePrivateReturnValues } from '../tx/simulated_tx.js';
+import { ProvingRequestType } from '../proofs/proving_request_type.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { BlockHeader, 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 { makeGas, makeGlobalVariables, makeL2BlockHeader, makePublicCallRequest } from './factories.js';
-export const randomTxHash = ()=>TxHash.random();
-export const randomUniqueNote = async ({ note = Note.random(), recipient = undefined, contractAddress = undefined, txHash = randomTxHash(), storageSlot = Fr.random(), noteNonce = Fr.random() } = {})=>{
-    return new UniqueNote(note, recipient ?? await AztecAddress.random(), contractAddress ?? await AztecAddress.random(), storageSlot, txHash, noteNonce);
+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)
 };
-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 } = {})=>{
+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(), 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.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();
@@ -49,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;
@@ -88,14 +110,108 @@ export const mockTxForRollup = (seed = 1, opts = {})=>mockTx(seed, {
         numberOfNonRevertiblePublicCallRequests: 0,
         numberOfRevertiblePublicCallRequests: 0
     });
-const emptyPrivateCallExecutionResult = ()=>new PrivateCallExecutionResult(Buffer.from(''), Buffer.from(''), new Map(), PrivateCircuitPublicInputs.empty(), new Map(), [], new Map(), [], [], [], [], []);
+/** 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({
+    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);
+    feePaymentPublicDataWrite ??= makePublicDataWrite(seed + 0x200);
+    const txConstantData = TxConstantData.empty();
+    txConstantData.anchorBlockHeader = anchorBlockHeader;
+    txConstantData.txContext.chainId = chainId;
+    txConstantData.txContext.version = version;
+    txConstantData.txContext.gasSettings = gasSettings;
+    txConstantData.vkTreeRoot = vkTreeRoot;
+    txConstantData.protocolContractsHash = await protocolContracts.hash();
+    const tx = !privateOnly ? await mockTx(seed, {
+        feePayer,
+        gasUsed,
+        ...mockTxOpts
+    }) : await mockTx(seed, {
+        numberOfNonRevertiblePublicCallRequests: 0,
+        numberOfRevertiblePublicCallRequests: 0,
+        feePayer,
+        gasUsed,
+        ...mockTxOpts
+    });
+    tx.data.constants = txConstantData;
+    const transactionFee = tx.data.gasUsed.computeFee(globalVariables.gasFees);
+    if (privateOnly) {
+        const data = makePrivateToRollupAccumulatedData(seed + 0x1000, {
+            numContractClassLogs: 0
+        });
+        tx.data.forRollup.end = data;
+        await tx.recomputeHash();
+        return makeProcessedTxFromPrivateOnlyTx(tx, transactionFee, feePaymentPublicDataWrite, globalVariables);
+    } else {
+        const dataFromPrivate = tx.data.forPublic;
+        const nonRevertibleData = dataFromPrivate.nonRevertibleAccumulatedData;
+        // Create revertible data.
+        const revertibleData = makePrivateToPublicAccumulatedData(seed + 0x1000, {
+            numContractClassLogs: 0
+        });
+        revertibleData.nullifiers[MAX_NULLIFIERS_PER_TX - 1] = Fr.ZERO; // Leave one space for the tx hash nullifier in nonRevertibleAccumulatedData.
+        dataFromPrivate.revertibleAccumulatedData = revertibleData;
+        // Create avm output.
+        const avmOutput = AvmCircuitPublicInputs.empty();
+        // Assign data from hints.
+        avmOutput.protocolContracts = protocolContracts;
+        avmOutput.startTreeSnapshots.l1ToL2MessageTree = newL1ToL2Snapshot;
+        avmOutput.endTreeSnapshots.l1ToL2MessageTree = newL1ToL2Snapshot;
+        avmOutput.effectiveGasFees = computeEffectiveGasFees(globalVariables.gasFees, gasSettings);
+        // Assign data from private.
+        avmOutput.globalVariables = globalVariables;
+        avmOutput.startGasUsed = tx.data.gasUsed;
+        avmOutput.gasSettings = gasSettings;
+        avmOutput.feePayer = feePayer;
+        avmOutput.publicCallRequestArrayLengths = new PublicCallRequestArrayLengths(tx.data.numberOfNonRevertiblePublicCallRequests(), tx.data.numberOfRevertiblePublicCallRequests(), tx.data.hasTeardownPublicCallRequest());
+        avmOutput.publicSetupCallRequests = dataFromPrivate.nonRevertibleAccumulatedData.publicCallRequests;
+        avmOutput.publicAppLogicCallRequests = dataFromPrivate.revertibleAccumulatedData.publicCallRequests;
+        avmOutput.publicTeardownCallRequest = dataFromPrivate.publicTeardownCallRequest;
+        avmOutput.previousNonRevertibleAccumulatedData = new PrivateToAvmAccumulatedData(dataFromPrivate.nonRevertibleAccumulatedData.noteHashes, dataFromPrivate.nonRevertibleAccumulatedData.nullifiers, dataFromPrivate.nonRevertibleAccumulatedData.l2ToL1Msgs);
+        avmOutput.previousNonRevertibleAccumulatedDataArrayLengths = avmOutput.previousNonRevertibleAccumulatedData.getArrayLengths();
+        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 = 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
+        // be a problem for the tests.
+        avmOutput.transactionFee = transactionFee;
+        const avmCircuitInputs = await makeAvmCircuitInputs(seed + 0x3000, {
+            publicInputs: avmOutput
+        });
+        avmCircuitInputs.hints.startingTreeRoots.l1ToL2MessageTree = newL1ToL2Snapshot;
+        const gasUsed = {
+            totalGas: Gas.empty(),
+            teardownGas: Gas.empty(),
+            publicGas: Gas.empty(),
+            billedGas: Gas.empty()
+        };
+        await tx.recomputeHash();
+        const publicTxEffect = new PublicTxEffect(avmOutput.transactionFee, avmOutput.accumulatedData.noteHashes.filter((h)=>!h.isZero()), avmOutput.accumulatedData.nullifiers.filter((h)=>!h.isZero()), avmOutput.accumulatedData.l2ToL1Msgs.filter((h)=>!h.isEmpty()), avmOutput.accumulatedData.publicLogs.toLogs(), avmOutput.accumulatedData.publicDataWrites.filter((h)=>!h.isEmpty()));
+        return makeProcessedTxFromTxWithPublicCalls(tx, globalVariables, {
+            type: ProvingRequestType.PUBLIC_VM,
+            inputs: avmCircuitInputs
+        }, publicTxEffect, gasUsed, RevertCode.OK, undefined /* revertReason */ );
+    }
+}
+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();
     const tx = await mockTx(seed);
-    const output = new PublicSimulationOutput(undefined, makeGlobalVariables(), await TxEffect.random(), [
-        accumulatePrivateReturnValues(privateExecutionResult)
-    ], {
+    const output = new PublicSimulationOutput(undefined, makeGlobalVariables(), await TxEffect.random(), times(2, ()=>NestedProcessReturnValues.random(2)), {
         totalGas: makeGas(),
         teardownGas: makeGas(),
         publicGas: makeGas(),
@@ -103,8 +219,72 @@ 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'),
+        aztecVersion: DEV_VERSION,
         functions: [],
         nonDispatchPublicFunctions: [],
         outputs: {
@@ -131,28 +311,33 @@ export const randomDeployedContract = async ()=>{
         })
     };
 };
-const makeAndSignConsensusPayload = (domainSeparator, options)=>{
-    const header = options?.header ?? makeL2BlockHeader(1);
-    const { signer = Secp256k1Signer.random(), archive = Fr.random(), stateReference = header.state } = 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(),
+        header,
         archive,
-        stateReference
+        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,
@@ -161,53 +346,92 @@ 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 ?? Secp256k1Signer.random(), proposerSigner = signer ?? Secp256k1Signer.random(), archive = Fr.random(), stateReference = header.state } = options ?? {};
-    const payload = ConsensusPayload.fromFields({
-        header: header.toCheckpointHeader(),
-        archive,
-        stateReference
-    });
-    // Sign as attester
-    const attestationHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
-    const attestationSignature = attesterSigner.sign(attestationHash);
-    // Sign as proposer
-    const proposalHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockProposal);
-    const proposerSignature = proposerSigner.sign(proposalHash);
-    return new BlockAttestation(payload, attestationSignature, proposerSignature);
+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 makeBlockAttestationFromBlock = (block, attesterSigner, proposerSigner)=>{
-    const header = block.header;
-    const archive = block.archive.root;
-    const stateReference = block.header.state;
-    const payload = ConsensusPayload.fromFields({
-        header: header.toCheckpointHeader(),
-        archive,
-        stateReference
-    });
+/**
+ * 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 = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
+    const attestationHash = getHashedSignaturePayloadTypedData(payload);
     const attestationSigner = attesterSigner ?? Secp256k1Signer.random();
     const attestationSignature = attestationSigner.sign(attestationHash);
-    // Sign as proposer
-    const proposalHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockProposal);
+    // 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 BlockAttestation(payload, attestationSignature, proposerSignature);
+    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);
 };
-export async function randomPublishedL2Block(l2BlockNumber, opts = {}) {
-    const block = await L2Block.random(l2BlockNumber);
-    const l1 = L1PublishedData.fromFields({
-        blockNumber: BigInt(block.number),
-        timestamp: block.header.globalVariables.timestamp,
-        blockHash: Buffer32.random().toString()
+/**
+ * Create a checkpoint attestation from a checkpoint
+ */ export const makeCheckpointAttestationFromCheckpoint = (checkpoint, attesterSigner, proposerSigner)=>{
+    const header = checkpoint.header;
+    const archive = checkpoint.archive.root;
+    const feeAssetPriceModifier = checkpoint.feeAssetPriceModifier;
+    return makeCheckpointAttestation({
+        header,
+        archive,
+        feeAssetPriceModifier,
+        attesterSigner,
+        proposerSigner
     });
-    const signers = opts.signers ?? times(3, ()=>Secp256k1Signer.random());
-    const atts = await Promise.all(signers.map((signer)=>makeBlockAttestationFromBlock(block, signer)));
-    const attestations = atts.map((attestation, i)=>new CommitteeAttestation(signers[i].address, attestation.signature));
-    return new PublishedL2Block(block, l1, attestations);
-}
+};
+/**
+ * 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;
+    return makeCheckpointAttestation({
+        header,
+        archive,
+        attesterSigner,
+        proposerSigner
+    });
+};

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"}