@aztec-labs/archiver 6.0.0-nightly.20260829

package/dest/test/mock_l2_block_source.js

@@ -0,0 +1,489 @@
+import { GENESIS_ARCHIVE_ROOT } from '@aztec-labs/constants';
+import { DefaultL1ContractsConfig } from '@aztec-labs/ethereum/config';
+import { BlockNumber, CheckpointNumber, IndexWithinCheckpoint, SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { Buffer32 } from '@aztec-labs/foundation/buffer';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { Body, GENESIS_BLOCK_HEADER_HASH, GENESIS_CHECKPOINT_HEADER_HASH, L2Block } from '@aztec-labs/stdlib/block';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec-labs/stdlib/checkpoint';
+import { EmptyL1RollupConstants, getSlotRangeForEpoch } from '@aztec-labs/stdlib/epoch-helpers';
+import { computeCheckpointOutHash } from '@aztec-labs/stdlib/messaging';
+import { CheckpointHeader } from '@aztec-labs/stdlib/rollup';
+import { AppendOnlyTreeSnapshot } from '@aztec-labs/stdlib/trees';
+import { BlockHeader } from '@aztec-labs/stdlib/tx';
+/**
+ * A mocked implementation of L2BlockSource to be used in tests.
+ */ export class MockL2BlockSource {
+    l2Blocks = [];
+    checkpointList = [];
+    provenBlockNumber = 0;
+    finalizedBlockNumber = 0;
+    checkpointedBlockNumber = 0;
+    initialHeader = BlockHeader.empty();
+    initialHeaderHash = GENESIS_BLOCK_HEADER_HASH;
+    genesisArchiveRoot;
+    genesisBlock;
+    log = createLogger('archiver:mock_l2_block_source');
+    /** Returns the initial header used to synthesize block 0. */ getInitialHeader() {
+        return this.initialHeader;
+    }
+    /**
+   * Sets the initial header used to synthesize block 0. Tests that wire up a real
+   * world-state should call this with `worldState.getInitialHeader()` so the L2BlockStream
+   * agrees on the genesis hash on both sides. Precomputes and caches the header hash so
+   * `getGenesisBlockHash()` can return synchronously.
+   */ async setInitialHeader(header) {
+        this.initialHeader = header;
+        this.initialHeaderHash = await header.hash();
+        this.genesisBlock = undefined;
+    }
+    /**
+   * Returns the precomputed hash of the genesis block header. Defaults to the static
+   * {@link GENESIS_BLOCK_HEADER_HASH} unless {@link setInitialHeader} has been called with a
+   * custom header.
+   */ getGenesisBlockHash() {
+        return this.initialHeaderHash;
+    }
+    /**
+   * Sets the post-genesis archive root used to synthesize block 0. Mirrors the real archiver,
+   * whose synthetic block 0 carries `new AppendOnlyTreeSnapshot(genesisArchiveRoot, 1)` rather
+   * than `AppendOnlyTreeSnapshot.empty()`. Tests wiring up a real world-state should set this so
+   * archive-based block lookups against the mock match production semantics.
+   */ setGenesisArchiveRoot(root) {
+        this.genesisArchiveRoot = root;
+        this.genesisBlock = undefined;
+    }
+    getGenesisBlock() {
+        if (this.genesisBlock) {
+            return this.genesisBlock;
+        }
+        const archive = this.genesisArchiveRoot ? new AppendOnlyTreeSnapshot(this.genesisArchiveRoot, 1) : AppendOnlyTreeSnapshot.empty();
+        return this.genesisBlock = new L2Block(archive, this.initialHeader, Body.empty(), CheckpointNumber.ZERO, IndexWithinCheckpoint(0));
+    }
+    /** Creates blocks grouped into single-block checkpoints. */ async createBlocks(numBlocks) {
+        await this.createCheckpoints(numBlocks, 1);
+    }
+    getCheckpointNumber() {
+        return Promise.resolve(this.checkpointList.length === 0 ? CheckpointNumber.ZERO : CheckpointNumber(this.checkpointList.length));
+    }
+    /** Creates checkpoints, each containing `blocksPerCheckpoint` blocks. */ async createCheckpoints(numCheckpoints, blocksPerCheckpoint = 1) {
+        for(let c = 0; c < numCheckpoints; c++){
+            const checkpointNum = CheckpointNumber(this.checkpointList.length + 1);
+            const startBlockNum = this.l2Blocks.length + 1;
+            const slotNumber = SlotNumber(Number(checkpointNum));
+            const checkpoint = await Checkpoint.random(checkpointNum, {
+                numBlocks: blocksPerCheckpoint,
+                startBlockNumber: startBlockNum,
+                slotNumber,
+                checkpointNumber: checkpointNum
+            });
+            this.checkpointList.push(checkpoint);
+            this.l2Blocks.push(...checkpoint.blocks);
+        }
+        this.log.verbose(`Created ${numCheckpoints} checkpoints with ${blocksPerCheckpoint} blocks each in the mock L2 block source`);
+    }
+    addProposedBlocks(blocks) {
+        this.l2Blocks.push(...blocks);
+        this.log.verbose(`Added ${blocks.length} proposed blocks to the mock L2 block source`);
+    }
+    removeBlocks(numBlocks) {
+        this.l2Blocks = this.l2Blocks.slice(0, -numBlocks);
+        const maxBlockNum = this.l2Blocks.length;
+        // Remove any checkpoint whose last block is beyond the remaining blocks.
+        this.checkpointList = this.checkpointList.filter((c)=>{
+            const lastBlockNum = c.blocks[0].number + c.blocks.length - 1;
+            return lastBlockNum <= maxBlockNum;
+        });
+        // Keep tip numbers consistent with remaining blocks.
+        this.checkpointedBlockNumber = Math.min(this.checkpointedBlockNumber, maxBlockNum);
+        this.provenBlockNumber = Math.min(this.provenBlockNumber, maxBlockNum);
+        this.finalizedBlockNumber = Math.min(this.finalizedBlockNumber, maxBlockNum);
+        this.log.verbose(`Removed ${numBlocks} blocks from the mock L2 block source`);
+    }
+    setProvenBlockNumber(provenBlockNumber) {
+        this.provenBlockNumber = provenBlockNumber;
+    }
+    setFinalizedBlockNumber(finalizedBlockNumber) {
+        if (finalizedBlockNumber > this.provenBlockNumber) {
+            this.provenBlockNumber = finalizedBlockNumber;
+        }
+        this.finalizedBlockNumber = finalizedBlockNumber;
+    }
+    setCheckpointedBlockNumber(checkpointedBlockNumber) {
+        const prevCheckpointed = this.checkpointedBlockNumber;
+        this.checkpointedBlockNumber = checkpointedBlockNumber;
+        // Auto-create single-block checkpoints for newly checkpointed blocks that don't have one yet.
+        // This handles blocks added via addProposedBlocks that are now being marked as checkpointed.
+        const newCheckpoints = [];
+        for(let blockNum = prevCheckpointed + 1; blockNum <= checkpointedBlockNumber; blockNum++){
+            const block = this.l2Blocks[blockNum - 1];
+            if (!block) {
+                continue;
+            }
+            if (this.checkpointList.some((c)=>c.blocks.some((b)=>b.number === block.number))) {
+                continue;
+            }
+            const checkpointNum = CheckpointNumber(this.checkpointList.length + newCheckpoints.length + 1);
+            const checkpoint = new Checkpoint(block.archive, CheckpointHeader.random({
+                slotNumber: block.header.globalVariables.slotNumber
+            }), [
+                block
+            ], checkpointNum);
+            newCheckpoints.push(checkpoint);
+        }
+        // Insert new checkpoints in order by number.
+        if (newCheckpoints.length > 0) {
+            this.checkpointList.push(...newCheckpoints);
+            this.checkpointList.sort((a, b)=>a.number - b.number);
+        }
+    }
+    /**
+   * Method to fetch the rollup contract address at the base-layer.
+   * @returns The rollup address.
+   */ getRollupAddress() {
+        return Promise.resolve(EthAddress.random());
+    }
+    /**
+   * Method to fetch the registry contract address at the base-layer.
+   * @returns The registry address.
+   */ getRegistryAddress() {
+        return Promise.resolve(EthAddress.random());
+    }
+    async getBlockNumber(query) {
+        if (!query) {
+            return BlockNumber(this.l2Blocks.length);
+        }
+        if ('number' in query) {
+            return query.number;
+        }
+        if ('tag' in query) {
+            return BlockNumber(this.resolveBlockTag(query.tag));
+        }
+        const block = await this.getBlock(query);
+        return block ? block.header.globalVariables.blockNumber : undefined;
+    }
+    getCheckpoint(query) {
+        const checkpoint = this.resolveCheckpointQuery(query);
+        if (!checkpoint) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(new PublishedCheckpoint(checkpoint, this.mockL1DataForCheckpoint(checkpoint), []));
+    }
+    getCheckpoints(query) {
+        const checkpoints = this.resolveCheckpointsQuery(query);
+        return Promise.resolve(checkpoints.map((checkpoint)=>new PublishedCheckpoint(checkpoint, this.mockL1DataForCheckpoint(checkpoint), [])));
+    }
+    getCheckpointByArchive(archive) {
+        const checkpoint = this.checkpointList.find((c)=>c.archive.root.equals(archive));
+        return Promise.resolve(checkpoint);
+    }
+    getCheckpointData(query) {
+        const checkpoint = this.resolveCheckpointQuery(query);
+        if (!checkpoint) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(this.checkpointToData(checkpoint));
+    }
+    getCheckpointsData(query) {
+        const checkpoints = this.resolveCheckpointsQuery(query);
+        return Promise.resolve(checkpoints.map((c)=>this.checkpointToData(c)));
+    }
+    checkpointToData(checkpoint) {
+        return {
+            checkpointNumber: checkpoint.number,
+            header: checkpoint.header,
+            archive: checkpoint.archive,
+            checkpointOutHash: computeCheckpointOutHash(checkpoint.blocks.map((b)=>b.body.txEffects.map((tx)=>tx.l2ToL1Msgs))),
+            startBlock: checkpoint.blocks[0].number,
+            blockCount: checkpoint.blocks.length,
+            feeAssetPriceModifier: checkpoint.feeAssetPriceModifier,
+            attestations: [],
+            l1: this.mockL1DataForCheckpoint(checkpoint)
+        };
+    }
+    resolveCheckpointQuery(query) {
+        if ('number' in query) {
+            return this.checkpointList[query.number - 1];
+        }
+        if ('slot' in query) {
+            return this.checkpointList.find((c)=>c.header.slotNumber === query.slot);
+        }
+        switch(query.tag){
+            case 'checkpointed':
+                return this.checkpointList[this.checkpointList.length - 1];
+            case 'proven':
+                {
+                    const provenCheckpoint = this.checkpointList.filter((c)=>c.blocks.some((b)=>b.number <= this.provenBlockNumber));
+                    return provenCheckpoint.at(-1);
+                }
+            case 'finalized':
+                {
+                    const finalizedCheckpoint = this.checkpointList.filter((c)=>c.blocks.some((b)=>b.number <= this.finalizedBlockNumber));
+                    return finalizedCheckpoint.at(-1);
+                }
+        }
+    }
+    resolveCheckpointsQuery(query) {
+        if ('from' in query) {
+            return this.checkpointList.slice(query.from - 1, query.from - 1 + query.limit);
+        }
+        if ('fromSlot' in query) {
+            const matching = this.checkpointList.filter((c)=>query.reverse ? c.header.slotNumber <= query.fromSlot : c.header.slotNumber >= query.fromSlot);
+            const nearestFirst = query.reverse ? matching.reverse() : matching;
+            return nearestFirst.slice(0, query.limit);
+        }
+        return this.getCheckpointsInEpoch(query.epoch);
+    }
+    getBlocksForSlot(slotNumber) {
+        const blocks = this.l2Blocks.filter((b)=>b.header.globalVariables.slotNumber === slotNumber);
+        return Promise.resolve(blocks);
+    }
+    /**
+   * Gets a tx effect.
+   * @param txHash - The hash of the tx corresponding to the tx effect.
+   * @returns The requested tx effect with block info (or undefined if not found).
+   */ async getTxEffect(txHash) {
+        const match = this.l2Blocks.flatMap((b)=>b.body.txEffects.map((tx)=>[
+                    tx,
+                    b
+                ])).find(([tx])=>tx.txHash.equals(txHash));
+        if (!match) {
+            return Promise.resolve(undefined);
+        }
+        const [txEffect, block] = match;
+        return {
+            data: txEffect,
+            l2BlockNumber: block.number,
+            l2BlockHash: await block.hash(),
+            txIndexInBlock: block.body.txEffects.findIndex((t)=>t.txHash.equals(txHash)),
+            slotNumber: block.header.globalVariables.slotNumber
+        };
+    }
+    getL2ToL1MembershipWitness() {
+        // Mock does not back the L2-to-L1 message witness flow.
+        return Promise.resolve(undefined);
+    }
+    async getL2Tips() {
+        const [latest, proven, finalized, checkpointed] = [
+            await this.getBlockNumber(),
+            this.provenBlockNumber,
+            this.finalizedBlockNumber,
+            this.checkpointedBlockNumber
+        ];
+        const latestBlock = this.l2Blocks[latest - 1];
+        const provenBlock = this.l2Blocks[proven - 1];
+        const finalizedBlock = this.l2Blocks[finalized - 1];
+        const checkpointedBlock = this.l2Blocks[checkpointed - 1];
+        // For genesis tips (block number 0) report the dynamic initial header hash so consumers
+        // running L2BlockStream against this mock agree at block 0 with their local tip store.
+        const genesisHash = (await this.initialHeader.hash()).toString();
+        const tipHash = async (block, number)=>{
+            if (block) {
+                return (await block.hash()).toString();
+            }
+            return number === 0 ? genesisHash : '';
+        };
+        const latestBlockId = {
+            number: BlockNumber(latest),
+            hash: await tipHash(latestBlock, latest)
+        };
+        const provenBlockId = {
+            number: BlockNumber(proven),
+            hash: await tipHash(provenBlock, proven)
+        };
+        const finalizedBlockId = {
+            number: BlockNumber(finalized),
+            hash: await tipHash(finalizedBlock, finalized)
+        };
+        const checkpointedBlockId = {
+            number: BlockNumber(checkpointed),
+            hash: await tipHash(checkpointedBlock, checkpointed)
+        };
+        const makeTipId = (blockId)=>{
+            const checkpointNumber = this.findCheckpointNumberForBlock(blockId.number) ?? CheckpointNumber(0);
+            // Match production semantics: checkpoint 0 is fully synthetic (no real checkpoint header
+            // exists at 0), so its hash stays at the protocol constant `GENESIS_CHECKPOINT_HEADER_HASH`
+            // even though the block-0 hash is dynamic. See L2TipsCache for the production path.
+            const hash = checkpointNumber === 0 ? GENESIS_CHECKPOINT_HEADER_HASH.toString() : blockId.hash;
+            return {
+                block: blockId,
+                checkpoint: {
+                    number: checkpointNumber,
+                    hash
+                }
+            };
+        };
+        return {
+            proposed: latestBlockId,
+            checkpointed: makeTipId(checkpointedBlockId),
+            proven: makeTipId(provenBlockId),
+            finalized: makeTipId(finalizedBlockId)
+        };
+    }
+    getSyncedL2EpochNumber() {
+        throw new Error('Method not implemented.');
+    }
+    getSyncedL2SlotNumber() {
+        throw new Error('Method not implemented.');
+    }
+    isEpochComplete(_epochNumber) {
+        throw new Error('Method not implemented.');
+    }
+    getL1Constants() {
+        return Promise.resolve(EmptyL1RollupConstants);
+    }
+    isPruneDueAtSlot(_slot) {
+        return Promise.resolve(false);
+    }
+    getGenesisValues() {
+        return Promise.resolve({
+            genesisArchiveRoot: this.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT)
+        });
+    }
+    getL1Timestamp() {
+        throw new Error('Method not implemented.');
+    }
+    /**
+   * Starts the block source. In this mock implementation, this is a noop.
+   * @returns A promise that signals the initialization of the l2 block source on completion.
+   */ start() {
+        this.log.verbose('Starting mock L2 block source');
+        return Promise.resolve();
+    }
+    /**
+   * Stops the block source. In this mock implementation, this is a noop.
+   * @returns A promise that signals the l2 block source is now stopped.
+   */ stop() {
+        this.log.verbose('Stopping mock L2 block source');
+        return Promise.resolve();
+    }
+    getContractClass(_id) {
+        return Promise.resolve(undefined);
+    }
+    getBytecodeCommitment(_id) {
+        return Promise.resolve(undefined);
+    }
+    getContract(_address, _timestamp) {
+        return Promise.resolve(undefined);
+    }
+    getContractClassIds() {
+        return Promise.resolve([]);
+    }
+    getDebugFunctionName(_address, _selector) {
+        return Promise.resolve(undefined);
+    }
+    registerContractFunctionSignatures(_signatures) {
+        return Promise.resolve();
+    }
+    syncImmediate() {
+        return Promise.resolve();
+    }
+    async getBlock(query) {
+        if ('number' in query) {
+            if (query.number === 0) {
+                return this.getGenesisBlock();
+            }
+            return this.l2Blocks[query.number - 1];
+        }
+        if ('hash' in query) {
+            const genesis = this.getGenesisBlock();
+            if ((await genesis.hash()).equals(query.hash)) {
+                return genesis;
+            }
+            for (const b of this.l2Blocks){
+                const hash = await b.hash();
+                if (hash.equals(query.hash)) {
+                    return b;
+                }
+            }
+            return undefined;
+        }
+        if ('archive' in query) {
+            const genesis = this.getGenesisBlock();
+            if (genesis.archive.root.equals(query.archive)) {
+                return genesis;
+            }
+            return this.l2Blocks.find((b)=>b.archive.root.equals(query.archive));
+        }
+        const number = this.resolveBlockTag(query.tag);
+        if (number === 0) {
+            return this.getGenesisBlock();
+        }
+        return this.l2Blocks[number - 1];
+    }
+    resolveBlockTag(tag) {
+        switch(tag){
+            case 'latest':
+            case 'proposed':
+                return this.l2Blocks.length;
+            case 'checkpointed':
+                return this.checkpointedBlockNumber;
+            case 'proven':
+                return this.provenBlockNumber;
+            case 'finalized':
+                return this.finalizedBlockNumber;
+        }
+    }
+    getBlocks(query) {
+        let blocks;
+        if ('from' in query) {
+            blocks = this.l2Blocks.slice(query.from - 1, query.from - 1 + query.limit);
+        } else {
+            const epochCheckpoints = this.getCheckpointsInEpoch(query.epoch);
+            blocks = epochCheckpoints.flatMap((c)=>c.blocks);
+        }
+        if (query.onlyCheckpointed) {
+            blocks = blocks.filter((b)=>b.header.globalVariables.blockNumber <= this.checkpointedBlockNumber);
+        }
+        return Promise.resolve(blocks);
+    }
+    async getBlockData(query) {
+        const block = await this.getBlock(query);
+        if (!block) {
+            return undefined;
+        }
+        return {
+            header: block.header,
+            archive: block.archive,
+            blockHash: await block.hash(),
+            checkpointNumber: block.checkpointNumber,
+            indexWithinCheckpoint: block.indexWithinCheckpoint
+        };
+    }
+    async getBlocksData(query) {
+        const blocks = await this.getBlocks(query);
+        return Promise.all(blocks.map(async (block)=>({
+                header: block.header,
+                archive: block.archive,
+                blockHash: await block.hash(),
+                checkpointNumber: block.checkpointNumber,
+                indexWithinCheckpoint: block.indexWithinCheckpoint
+            })));
+    }
+    isPendingChainInvalid() {
+        return Promise.resolve(false);
+    }
+    getPendingChainValidationStatus() {
+        return Promise.resolve({
+            valid: true
+        });
+    }
+    getProposedCheckpointData(_query) {
+        return Promise.resolve(undefined);
+    }
+    /** Returns checkpoints whose slot falls within the given epoch. */ getCheckpointsInEpoch(epochNumber) {
+        const epochDuration = DefaultL1ContractsConfig.aztecEpochDuration;
+        const [start, end] = getSlotRangeForEpoch(epochNumber, {
+            epochDuration
+        });
+        return this.checkpointList.filter((c)=>c.header.slotNumber >= start && c.header.slotNumber <= end);
+    }
+    /** Creates a mock L1PublishedData for a checkpoint. */ mockL1DataForCheckpoint(checkpoint) {
+        return new L1PublishedData(BigInt(checkpoint.number), BigInt(checkpoint.number), Buffer32.random().toString());
+    }
+    /** Finds the checkpoint number for a block, or undefined if the block is not in any checkpoint. */ findCheckpointNumberForBlock(blockNumber) {
+        const checkpoint = this.checkpointList.find((c)=>c.blocks.some((b)=>b.number === blockNumber));
+        return checkpoint?.number;
+    }
+}

package/dest/test/mock_structs.d.ts

@@ -0,0 +1,92 @@
+import { CheckpointNumber } from '@aztec-labs/foundation/branded-types';
+import type { Secp256k1Signer } from '@aztec-labs/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { L2Block } from '@aztec-labs/stdlib/block';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec-labs/stdlib/checkpoint';
+import { PrivateLog, PublicLog, SiloedTag, Tag } from '@aztec-labs/stdlib/logs';
+import { AppendOnlyTreeSnapshot } from '@aztec-labs/stdlib/trees';
+import { StateReference } from '@aztec-labs/stdlib/tx';
+import type { InboxMessage } from '../structs/inbox_message.js';
+export declare function makeInboxMessage(previousInboxRollingHash?: Fr, overrides?: Partial<InboxMessage>): InboxMessage;
+/**
+ * Builds a contiguous run of `totalCount` inbox messages with compact global indices starting at `initialIndex`
+ * and a chained consensus rolling hash starting from `initialInboxHash`.
+ */
+export declare function makeInboxMessages(totalCount: number, opts?: {
+    initialInboxHash?: Fr;
+    initialIndex?: bigint;
+    overrideFn?: (msg: InboxMessage, index: number) => InboxMessage;
+}): InboxMessage[];
+/**
+ * Creates `blockCount` full buckets of `MAX_L1_TO_L2_MSGS_PER_BLOCK` inbox messages each, with compact indices and one
+ * bucket sequence per block.
+ */
+export declare function makeInboxMessagesWithFullBlocks(blockCount: number): InboxMessage[];
+/** Creates a deterministic block hash from a block number. */
+export declare function makeBlockHash(blockNumber: number): `0x${string}`;
+/**
+ * Creates a StateReference with properly calculated noteHashTree.nextAvailableLeafIndex.
+ * This ensures LogStore's dataStartIndexForBlock calculation doesn't produce negative values.
+ */
+export declare function makeStateForBlock(blockNumber: number, txsPerBlock: number): StateReference;
+/** Creates L1PublishedData with deterministic values based on l1BlockNumber. */
+export declare function makeL1PublishedData(l1BlockNumber: number): L1PublishedData;
+/** Creates a Checkpoint from a list of blocks with a header that matches the blocks' structure. */
+export declare function makeCheckpoint(blocks: L2Block[], checkpointNumber?: CheckpointNumber): Checkpoint;
+/** Wraps a Checkpoint with L1 published data and random attestations. */
+export declare function makePublishedCheckpoint(checkpoint: Checkpoint, l1BlockNumber: number, attestationCount?: number): PublishedCheckpoint;
+export interface MakeChainedCheckpointsOptions {
+    /** Number of L2 blocks per checkpoint. Default: 1 */
+    blocksPerCheckpoint?: number;
+    /** Number of transactions per block. Default: 4 */
+    txsPerBlock?: number;
+    /** Starting checkpoint number. Default: CheckpointNumber(1) */
+    startCheckpointNumber?: CheckpointNumber;
+    /** Starting block number. Default: 1 */
+    startBlockNumber?: number;
+    /** Starting L1 block number. Default: 10 */
+    startL1BlockNumber?: number;
+    /** Previous archive to chain from. Default: undefined */
+    previousArchive?: AppendOnlyTreeSnapshot;
+    /** Optional function to provide per-checkpoint overrides */
+    makeCheckpointOptions?: (cpNumber: CheckpointNumber) => Partial<Parameters<typeof Checkpoint.random>[1]>;
+}
+/**
+ * Creates multiple checkpoints with properly chained archives.
+ * Each checkpoint's blocks have their lastArchive set to the previous block's archive,
+ * ensuring archive chain continuity for testing.
+ */
+export declare function makeChainedCheckpoints(count: number, options?: MakeChainedCheckpointsOptions): Promise<PublishedCheckpoint[]>;
+/**
+ * Creates a PublishedCheckpoint with attestations signed by the provided signers.
+ * Useful for testing attestation validation.
+ */
+export declare function makeSignedPublishedCheckpoint(checkpoint: Checkpoint, signers: Secp256k1Signer[], committee: EthAddress[], l1BlockNumber?: number): PublishedCheckpoint;
+/** Creates a deterministic SiloedTag for private log testing. */
+export declare function makePrivateLogTag(blockNumber: number, txIndex: number, logIndex: number): SiloedTag;
+/** Creates a PrivateLog with fields derived from the tag. */
+export declare function makePrivateLog(tag: SiloedTag): PrivateLog;
+/** Creates multiple private logs for a transaction. */
+export declare function mockPrivateLogs(blockNumber: number, txIndex: number, numLogsPerTx: number): PrivateLog[];
+/** Creates a deterministic Tag for public log testing. */
+export declare function makePublicLogTag(blockNumber: number, txIndex: number, logIndex: number): Tag;
+/** Creates a PublicLog with fields derived from the tag. */
+export declare function makePublicLog(tag: Tag, contractAddress?: AztecAddress): PublicLog;
+/** Creates multiple public logs for a transaction. */
+export declare function makePublicLogs(blockNumber: number, txIndex: number, numLogsPerTx: number, contractAddress?: AztecAddress): PublicLog[];
+export interface MockCheckpointWithLogsOptions {
+    previousArchive?: AppendOnlyTreeSnapshot;
+    numTxsPerBlock?: number;
+    privateLogs?: {
+        numLogsPerTx: number;
+    };
+    publicLogs?: {
+        numLogsPerTx: number;
+        contractAddress?: AztecAddress;
+    };
+}
+/** Creates a checkpoint with specified logs on each tx effect. */
+export declare function makeCheckpointWithLogs(blockNumber: number, options?: MockCheckpointWithLogsOptions): Promise<PublishedCheckpoint>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9ja19zdHJ1Y3RzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdC9tb2NrX3N0cnVjdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFlLGdCQUFnQixFQUF5QixNQUFNLHNDQUFzQyxDQUFDO0FBSTVHLE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLGdEQUFnRCxDQUFDO0FBQ3RGLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUN6RCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFDaEUsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQ2hFLE9BQU8sRUFBd0IsT0FBTyxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDekUsT0FBTyxFQUFFLFVBQVUsRUFBRSxlQUFlLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUNqRyxPQUFPLEVBQUUsVUFBVSxFQUFFLFNBQVMsRUFBRSxTQUFTLEVBQUUsR0FBRyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFLaEYsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDbEUsT0FBTyxFQUF5QixjQUFjLEVBQVksTUFBTSx1QkFBdUIsQ0FBQztBQUV4RixPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUVoRSx3QkFBZ0IsZ0JBQWdCLENBQzlCLHdCQUF3QixLQUFVLEVBQ2xDLFNBQVMsR0FBRSxPQUFPLENBQUMsWUFBWSxDQUFNLEdBQ3BDLFlBQVksQ0FvQmQ7QUFFRDs7O0dBR0c7QUFDSCx3QkFBZ0IsaUJBQWlCLENBQy9CLFVBQVUsRUFBRSxNQUFNLEVBQ2xCLElBQUksR0FBRTtJQUNKLGdCQUFnQixDQUFDLEVBQUUsRUFBRSxDQUFDO0lBQ3RCLFlBQVksQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUN0QixVQUFVLENBQUMsRUFBRSxDQUFDLEdBQUcsRUFBRSxZQUFZLEVBQUUsS0FBSyxFQUFFLE1BQU0sS0FBSyxZQUFZLENBQUM7Q0FDNUQsR0FDTCxZQUFZLEVBQUUsQ0FtQmhCO0FBRUQ7OztHQUdHO0FBQ0gsd0JBQWdCLCtCQUErQixDQUFDLFVBQVUsRUFBRSxNQUFNLEdBQUcsWUFBWSxFQUFFLENBT2xGO0FBRUQsOERBQThEO0FBQzlELHdCQUFnQixhQUFhLENBQUMsV0FBVyxFQUFFLE1BQU0sR0FBRyxLQUFLLE1BQU0sRUFBRSxDQUVoRTtBQUVEOzs7R0FHRztBQUNILHdCQUFnQixpQkFBaUIsQ0FBQyxXQUFXLEVBQUUsTUFBTSxFQUFFLFdBQVcsRUFBRSxNQUFNLEdBQUcsY0FBYyxDQVUxRjtBQUVELGdGQUFnRjtBQUNoRix3QkFBZ0IsbUJBQW1CLENBQUMsYUFBYSxFQUFFLE1BQU0sR0FBRyxlQUFlLENBRTFFO0FBRUQsbUdBQW1HO0FBQ25HLHdCQUFnQixjQUFjLENBQUMsTUFBTSxFQUFFLE9BQU8sRUFBRSxFQUFFLGdCQUFnQixtQkFBc0IsR0FBRyxVQUFVLENBZ0JwRztBQUVELHlFQUF5RTtBQUN6RSx3QkFBZ0IsdUJBQXVCLENBQ3JDLFVBQVUsRUFBRSxVQUFVLEVBQ3RCLGFBQWEsRUFBRSxNQUFNLEVBQ3JCLGdCQUFnQixTQUFJLEdBQ25CLG1CQUFtQixDQU1yQjtBQUVELE1BQU0sV0FBVyw2QkFBNkI7SUFDNUMscURBQXFEO0lBQ3JELG1CQUFtQixDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQzdCLG1EQUFtRDtJQUNuRCxXQUFXLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDckIsK0RBQStEO0lBQy9ELHFCQUFxQixDQUFDLEVBQUUsZ0JBQWdCLENBQUM7SUFDekMsd0NBQXdDO0lBQ3hDLGdCQUFnQixDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQzFCLDRDQUE0QztJQUM1QyxrQkFBa0IsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUM1Qix5REFBeUQ7SUFDekQsZUFBZSxDQUFDLEVBQUUsc0JBQXNCLENBQUM7SUFDekMsNERBQTREO0lBQzVELHFCQUFxQixDQUFDLEVBQUUsQ0FBQyxRQUFRLEVBQUUsZ0JBQWdCLEtBQUssT0FBTyxDQUFDLFVBQVUsQ0FBQyxPQUFPLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0NBQzFHO0FBRUQ7Ozs7R0FJRztBQUNILHdCQUFzQixzQkFBc0IsQ0FDMUMsS0FBSyxFQUFFLE1BQU0sRUFDYixPQUFPLEdBQUUsNkJBQWtDLEdBQzFDLE9BQU8sQ0FBQyxtQkFBbUIsRUFBRSxDQUFDLENBaUNoQztBQUVEOzs7R0FHRztBQUNILHdCQUFnQiw2QkFBNkIsQ0FDM0MsVUFBVSxFQUFFLFVBQVUsRUFDdEIsT0FBTyxFQUFFLGVBQWUsRUFBRSxFQUMxQixTQUFTLEVBQUUsVUFBVSxFQUFFLEVBQ3ZCLGFBQWEsU0FBSSxHQUNoQixtQkFBbUIsQ0FJckI7QUFFRCxpRUFBaUU7QUFDakUsd0JBQWdCLGlCQUFpQixDQUFDLFdBQVcsRUFBRSxNQUFNLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsTUFBTSxHQUFHLFNBQVMsQ0FNbkc7QUFFRCw2REFBNkQ7QUFDN0Qsd0JBQWdCLGNBQWMsQ0FBQyxHQUFHLEVBQUUsU0FBUyxHQUFHLFVBQVUsQ0FLekQ7QUFFRCx1REFBdUQ7QUFDdkQsd0JBQWdCLGVBQWUsQ0FBQyxXQUFXLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRSxNQUFNLEVBQUUsWUFBWSxFQUFFLE1BQU0sR0FBRyxVQUFVLEVBQUUsQ0FLeEc7QUFFRCwwREFBMEQ7QUFDMUQsd0JBQWdCLGdCQUFnQixDQUFDLFdBQVcsRUFBRSxNQUFNLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsTUFBTSxHQUFHLEdBQUcsQ0FNNUY7QUFFRCw0REFBNEQ7QUFDNUQsd0JBQWdCLGFBQWEsQ0FDM0IsR0FBRyxFQUFFLEdBQUcsRUFDUixlQUFlLEdBQUUsWUFBb0QsR0FDcEUsU0FBUyxDQUtYO0FBRUQsc0RBQXNEO0FBQ3RELHdCQUFnQixjQUFjLENBQzVCLFdBQVcsRUFBRSxNQUFNLEVBQ25CLE9BQU8sRUFBRSxNQUFNLEVBQ2YsWUFBWSxFQUFFLE1BQU0sRUFDcEIsZUFBZSxHQUFFLFlBQW9ELEdBQ3BFLFNBQVMsRUFBRSxDQUtiO0FBRUQsTUFBTSxXQUFXLDZCQUE2QjtJQUM1QyxlQUFlLENBQUMsRUFBRSxzQkFBc0IsQ0FBQztJQUN6QyxjQUFjLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDeEIsV0FBVyxDQUFDLEVBQUU7UUFBRSxZQUFZLEVBQUUsTUFBTSxDQUFBO0tBQUUsQ0FBQztJQUN2QyxVQUFVLENBQUMsRUFBRTtRQUFFLFlBQVksRUFBRSxNQUFNLENBQUM7UUFBQyxlQUFlLENBQUMsRUFBRSxZQUFZLENBQUE7S0FBRSxDQUFDO0NBQ3ZFO0FBRUQsa0VBQWtFO0FBQ2xFLHdCQUFzQixzQkFBc0IsQ0FDMUMsV0FBVyxFQUFFLE1BQU0sRUFDbkIsT0FBTyxHQUFFLDZCQUFrQyxHQUMxQyxPQUFPLENBQUMsbUJBQW1CLENBQUMsQ0FzQjlCIn0=

package/dest/test/mock_structs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock_structs.d.ts","sourceRoot":"","sources":["../../src/test/mock_structs.ts"],"names":[],"mappings":"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"}