@aztec/archiver 4.0.0-nightly.20260113 → 4.0.0-nightly.20260115

package/dest/test/fake_l1_state.js

@@ -0,0 +1,364 @@
+import { getBlobsPerL1Block, getPrefixedEthBlobCommitments } from '@aztec/blob-lib';
+import { MULTI_CALL_3_ADDRESS } from '@aztec/ethereum/contracts';
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
+import { createLogger } from '@aztec/foundation/log';
+import { RollupAbi } from '@aztec/l1-artifacts';
+import { CommitteeAttestation, CommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
+import { InboxLeaf } from '@aztec/stdlib/messaging';
+import { makeAndSignCommitteeAttestationsAndSigners, makeCheckpointAttestationFromCheckpoint, mockCheckpointAndMessages } from '@aztec/stdlib/testing';
+import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
+import { mock } from 'jest-mock-extended';
+import { encodeFunctionData, multicall3Abi, toHex } from 'viem';
+import { updateRollingHash } from '../structs/inbox_message.js';
+/**
+ * Stateful fake for L1 data used by the archiver.
+ *
+ * This class simulates the L1 blockchain state that the archiver reads from:
+ * - RollupContract: status(), archiveAt(), getVersion(), getTargetCommitteeSize(), CheckpointProposed events
+ * - InboxContract: getState(), MessageSent events
+ * - PublicClient: getBlockNumber(), getBlock(), getTransaction()
+ * - BlobClient: getBlobSidecar()
+ *
+ * @example
+ * ```ts
+ * const fake = new FakeL1State(config);
+ *
+ * // Add checkpoint (creates messages automatically)
+ * const { checkpoint, messages } = await fake.addCheckpoint(CheckpointNumber(1), { l1BlockNumber: 101n });
+ * fake.setL1BlockNumber(105n);
+ *
+ * // Status auto-updated
+ * expect(fake.getRollupStatus().pendingCheckpointNumber).toEqual(CheckpointNumber(1));
+ * ```
+ */ export class FakeL1State {
+    config;
+    log;
+    l1BlockNumber;
+    checkpoints;
+    messages;
+    messagesRollingHash;
+    lastArchive;
+    provenCheckpointNumber;
+    targetCommitteeSize;
+    version;
+    // Computed from checkpoints based on L1 block visibility
+    pendingCheckpointNumber;
+    constructor(config){
+        this.config = config;
+        this.log = createLogger('archiver:test:fake-l1');
+        this.checkpoints = [];
+        this.messages = [];
+        this.messagesRollingHash = Buffer16.ZERO;
+        this.provenCheckpointNumber = CheckpointNumber(0);
+        this.targetCommitteeSize = 0;
+        this.version = 1n;
+        this.pendingCheckpointNumber = CheckpointNumber(0);
+        this.l1BlockNumber = config.l1StartBlock;
+        this.lastArchive = new AppendOnlyTreeSnapshot(config.genesisArchiveRoot, 1);
+    }
+    /**
+   * Adds messages for a checkpoint. Returns the message leaves.
+   * Auto-updates rolling hash.
+   *
+   * Note: For most use cases, use `addCheckpoint` which creates both checkpoint and messages.
+   * Use this method only when you need to add messages without creating a checkpoint (e.g., for reorg tests).
+   */ addMessages(checkpointNumber, l1BlockNumber, messageLeaves) {
+        messageLeaves.forEach((leaf, i)=>{
+            const index = InboxLeaf.smallestIndexForCheckpoint(checkpointNumber) + BigInt(i);
+            this.messagesRollingHash = updateRollingHash(this.messagesRollingHash, leaf);
+            this.messages.push({
+                l1BlockNumber,
+                checkpointNumber,
+                index,
+                leaf,
+                rollingHash: this.messagesRollingHash
+            });
+        });
+    }
+    /**
+   * Creates and adds a checkpoint with its L1-to-L2 messages.
+   * Returns both the checkpoint and the message leaves.
+   * Auto-chains from lastArchive, auto-updates pending status if L1 block >= checkpoint's L1 block.
+   */ async addCheckpoint(checkpointNumber, options) {
+        this.log.warn(`Adding checkpoint ${checkpointNumber}`);
+        const { l1BlockNumber, numBlocks = 1, txsPerBlock = 4, maxEffects, signers = [], slotNumber, previousArchive = this.lastArchive, timestamp, numL1ToL2Messages = 3, messagesL1BlockNumber = l1BlockNumber - 3n } = options;
+        // Create the checkpoint using the stdlib helper
+        // Only pass slotNumber and timestamp if they're defined to avoid overwriting defaults
+        const { checkpoint, messages, lastArchive } = await mockCheckpointAndMessages(checkpointNumber, {
+            startBlockNumber: this.getNextBlockNumber(checkpointNumber),
+            numBlocks,
+            numTxsPerBlock: txsPerBlock,
+            numL1ToL2Messages,
+            previousArchive,
+            ...slotNumber !== undefined ? {
+                slotNumber
+            } : {},
+            ...timestamp !== undefined ? {
+                timestamp
+            } : {},
+            ...maxEffects !== undefined ? {
+                maxEffects
+            } : {}
+        });
+        // Store the messages internally so they match the checkpoint's inHash
+        this.addMessages(checkpointNumber, messagesL1BlockNumber, messages);
+        // Create the transaction and blobs
+        const tx = this.makeRollupTx(checkpoint, signers);
+        const blobHashes = this.makeVersionedBlobHashes(checkpoint);
+        const blobs = this.makeBlobsFromCheckpoint(checkpoint);
+        // Store the checkpoint data
+        this.checkpoints.push({
+            checkpointNumber,
+            checkpoint,
+            l1BlockNumber,
+            tx,
+            blobHashes,
+            blobs,
+            signers
+        });
+        // Update last archive for auto-chaining
+        this.lastArchive = lastArchive ?? checkpoint.blocks.at(-1).archive;
+        // Auto-update pending checkpoint number
+        this.updatePendingCheckpointNumber();
+        return {
+            checkpoint,
+            messages
+        };
+    }
+    /**
+   * Sets the current L1 block number.
+   * Auto-updates pending checkpoint number based on visible checkpoints.
+   */ setL1BlockNumber(blockNumber) {
+        this.l1BlockNumber = blockNumber;
+        this.updatePendingCheckpointNumber();
+    }
+    /** Marks a checkpoint as proven. Updates provenCheckpointNumber. */ markCheckpointAsProven(checkpointNumber) {
+        this.provenCheckpointNumber = checkpointNumber;
+    }
+    /** Sets the target committee size for attestation validation. */ setTargetCommitteeSize(size) {
+        this.targetCommitteeSize = size;
+    }
+    /**
+   * Removes all entries for a checkpoint number (simulates L1 reorg or prune).
+   * Note: Does NOT remove messages for this checkpoint (use numL1ToL2Messages: 0 when re-adding).
+   * Auto-updates pending status.
+   */ removeCheckpoint(checkpointNumber) {
+        this.checkpoints = this.checkpoints.filter((cpData)=>cpData.checkpointNumber !== checkpointNumber);
+        this.updatePendingCheckpointNumber();
+    }
+    /**
+   * Removes messages after a given total index (simulates L1 reorg).
+   * Auto-updates rolling hash.
+   */ removeMessagesAfter(totalIndex) {
+        this.messages = this.messages.slice(0, totalIndex);
+        // Recalculate rolling hash
+        this.messagesRollingHash = this.messages.reduce((hash, msg)=>updateRollingHash(hash, msg.leaf), Buffer16.ZERO);
+    }
+    /**
+   * Simulates a pruned checkpoint by marking all entries with this number as pruned.
+   * The event will still be returned, but archiveAt() will return the previous checkpoint's archive
+   * (or genesis if no previous checkpoint), causing a mismatch that the archiver will detect.
+   */ markCheckpointAsPruned(checkpointNumber) {
+        for (const cpData of this.checkpoints){
+            if (cpData.checkpointNumber === checkpointNumber) {
+                cpData.pruned = true;
+            }
+        }
+        this.updatePendingCheckpointNumber();
+    }
+    /**
+   * Moves messages at a given L1 block to a new L1 block.
+   * Useful for simulating partial message visibility (messages at higher L1 blocks won't be fetched).
+   */ moveMessagesToL1Block(fromL1Block, toL1Block) {
+        this.messages.forEach((msg)=>{
+            if (msg.l1BlockNumber === fromL1Block) {
+                msg.l1BlockNumber = toL1Block;
+            }
+        });
+    }
+    /**
+   * Moves a specific message (by index in the messages array) to a new L1 block.
+   */ moveMessageAtIndexToL1Block(index, toL1Block) {
+        if (this.messages[index]) {
+            this.messages[index].l1BlockNumber = toL1Block;
+        }
+    }
+    /** Gets current rollup status. */ getRollupStatus() {
+        return {
+            provenCheckpointNumber: this.provenCheckpointNumber,
+            pendingCheckpointNumber: this.pendingCheckpointNumber,
+            provenArchive: this.getArchiveAt(this.provenCheckpointNumber),
+            pendingArchive: this.getArchiveAt(this.pendingCheckpointNumber)
+        };
+    }
+    /** Gets the last archive (for manual chaining if needed). */ getLastArchive() {
+        return this.lastArchive;
+    }
+    /** Gets the latest checkpoint entry by number (returns the last added one). */ getCheckpoint(checkpointNumber) {
+        return this.checkpoints.findLast((cpData)=>cpData.checkpointNumber === checkpointNumber)?.checkpoint;
+    }
+    /** Gets messages for a checkpoint. */ getMessages(checkpointNumber) {
+        return this.messages.filter((m)=>m.checkpointNumber === checkpointNumber).map((m)=>m.leaf);
+    }
+    /** Gets the blobs for a checkpoint. */ getCheckpointBlobs(checkpointNumber) {
+        return this.checkpoints.findLast((cpData)=>cpData.checkpointNumber === checkpointNumber)?.blobs ?? [];
+    }
+    /** Creates mock RollupContract that reads from this fake state. */ createMockRollupContract(_publicClient) {
+        const mockRollup = mock();
+        mockRollup.getVersion.mockImplementation(()=>Promise.resolve(this.version));
+        mockRollup.getTargetCommitteeSize.mockImplementation(()=>Promise.resolve(this.targetCommitteeSize));
+        mockRollup.archiveAt.mockImplementation((cpNum)=>Promise.resolve(this.getArchiveAt(cpNum)));
+        mockRollup.status.mockImplementation((localCheckpointNum)=>{
+            const status = this.getRollupStatus();
+            return Promise.resolve({
+                provenCheckpointNumber: status.provenCheckpointNumber,
+                provenArchive: status.provenArchive,
+                pendingCheckpointNumber: status.pendingCheckpointNumber,
+                pendingArchive: status.pendingArchive,
+                archiveOfMyCheckpoint: this.getArchiveAt(localCheckpointNum)
+            });
+        });
+        // Mock the wrapper method for fetching checkpoint events
+        mockRollup.getCheckpointProposedEvents.mockImplementation((fromBlock, toBlock)=>Promise.resolve(this.getCheckpointProposedLogs(fromBlock, toBlock)));
+        Object.defineProperty(mockRollup, 'address', {
+            get: ()=>this.config.rollupAddress.toString()
+        });
+        return mockRollup;
+    }
+    /** Creates mock InboxContract that reads from this fake state. */ createMockInboxContract(_publicClient) {
+        const mockInbox = mock();
+        mockInbox.getState.mockImplementation(()=>Promise.resolve({
+                messagesRollingHash: this.messagesRollingHash,
+                totalMessagesInserted: BigInt(this.messages.length),
+                treeInProgress: 0n
+            }));
+        // Mock the wrapper methods for fetching message events
+        mockInbox.getMessageSentEvents.mockImplementation((fromBlock, toBlock)=>Promise.resolve(this.getMessageSentLogs(fromBlock, toBlock)));
+        mockInbox.getMessageSentEventByHash.mockImplementation((hash, fromBlock, toBlock)=>Promise.resolve(this.getMessageSentLogs(fromBlock, toBlock, hash)));
+        return mockInbox;
+    }
+    /** Creates mock PublicClient that reads from this fake state. */ createMockPublicClient() {
+        const publicClient = mock();
+        publicClient.getChainId.mockResolvedValue(1);
+        publicClient.getBlockNumber.mockImplementation(()=>Promise.resolve(this.l1BlockNumber));
+        // Use async function pattern that existing test uses for getBlock
+        publicClient.getBlock.mockImplementation(async (args = {})=>{
+            const blockNum = args.blockNumber ?? await publicClient.getBlockNumber();
+            return {
+                number: blockNum,
+                timestamp: BigInt(blockNum) * BigInt(this.config.ethereumSlotDuration) + this.config.l1GenesisTime,
+                hash: Buffer32.fromBigInt(blockNum).toString()
+            };
+        });
+        // Use the same pattern as existing test for getTransaction
+        publicClient.getTransaction.mockImplementation((args)=>Promise.resolve(args.hash ? this.checkpoints.find((cpData)=>cpData.tx.hash === args.hash)?.tx : undefined));
+        return publicClient;
+    }
+    /** Creates mock BlobClient that reads from this fake state. */ createMockBlobClient() {
+        const blobClient = mock();
+        // The blockId is the transaction's blockHash, which we set to the checkpoint's archive root
+        blobClient.getBlobSidecar.mockImplementation((blockId)=>Promise.resolve(this.checkpoints.find((cpData)=>cpData.checkpoint.archive.root.toString() === blockId)?.blobs ?? []));
+        blobClient.testSources.mockResolvedValue(undefined);
+        return blobClient;
+    }
+    updatePendingCheckpointNumber() {
+        this.pendingCheckpointNumber = this.checkpoints.filter((cpData)=>cpData.l1BlockNumber <= this.l1BlockNumber && !cpData.pruned).reduce((max, cpData)=>cpData.checkpointNumber > max ? cpData.checkpointNumber : max, CheckpointNumber(0));
+    }
+    getArchiveAt(checkpointNumber) {
+        if (checkpointNumber === 0) {
+            return this.config.genesisArchiveRoot;
+        }
+        // Find the latest non-pruned entry for this checkpoint number
+        const entries = this.checkpoints.filter((cpData)=>cpData.checkpointNumber === checkpointNumber);
+        const latestEntry = entries.at(-1);
+        if (!latestEntry || latestEntry.pruned) {
+            // For pruned or missing checkpoints, return the previous non-pruned checkpoint's archive
+            return this.getArchiveAt(CheckpointNumber(checkpointNumber - 1));
+        }
+        return latestEntry.checkpoint.archive.root;
+    }
+    getNextBlockNumber(checkpointNumber) {
+        const lastBlockNumber = this.checkpoints.filter((cpData)=>cpData.checkpointNumber < checkpointNumber).flatMap((cpData)=>cpData.checkpoint.blocks.map((b)=>b.number)).reduce((max, num)=>Math.max(max, num), 0);
+        return lastBlockNumber + 1;
+    }
+    getCheckpointProposedLogs(fromBlock, toBlock) {
+        return this.checkpoints.filter((cpData)=>cpData.l1BlockNumber >= fromBlock && cpData.l1BlockNumber <= toBlock).map((cpData)=>({
+                l1BlockNumber: cpData.l1BlockNumber,
+                l1BlockHash: Buffer32.fromBigInt(cpData.l1BlockNumber),
+                l1TransactionHash: cpData.tx.hash,
+                args: {
+                    checkpointNumber: cpData.checkpointNumber,
+                    archive: cpData.checkpoint.archive.root,
+                    versionedBlobHashes: cpData.blobHashes.map((h)=>Buffer.from(h.slice(2), 'hex')),
+                    // These are intentionally undefined to skip hash validation in the archiver
+                    // (validation is skipped when these fields are falsy)
+                    payloadDigest: undefined,
+                    attestationsHash: undefined
+                }
+            }));
+    }
+    getMessageSentLogs(fromBlock, toBlock, hashFilter) {
+        return this.messages.filter((msg)=>(!hashFilter || msg.leaf.toString() === hashFilter) && (!fromBlock || msg.l1BlockNumber >= fromBlock) && (!toBlock || msg.l1BlockNumber <= toBlock)).map((msg)=>({
+                l1BlockNumber: msg.l1BlockNumber,
+                l1BlockHash: Buffer32.fromBigInt(msg.l1BlockNumber),
+                l1TransactionHash: `0x${msg.l1BlockNumber.toString(16)}`,
+                args: {
+                    checkpointNumber: msg.checkpointNumber,
+                    index: msg.index,
+                    leaf: msg.leaf,
+                    rollingHash: msg.rollingHash
+                }
+            }));
+    }
+    makeRollupTx(checkpoint, signers) {
+        const attestations = signers.map((signer)=>makeCheckpointAttestationFromCheckpoint(checkpoint, signer)).map((attestation)=>CommitteeAttestation.fromSignature(attestation.signature)).map((committeeAttestation)=>committeeAttestation.toViem());
+        const header = checkpoint.header.toViem();
+        const blobInput = getPrefixedEthBlobCommitments(getBlobsPerL1Block(checkpoint.toBlobFields()));
+        const archive = toHex(checkpoint.archive.root.toBuffer());
+        const attestationsAndSigners = new CommitteeAttestationsAndSigners(attestations.map((attestation)=>CommitteeAttestation.fromViem(attestation)));
+        const attestationsAndSignersSignature = makeAndSignCommitteeAttestationsAndSigners(attestationsAndSigners, signers[0]);
+        const rollupInput = encodeFunctionData({
+            abi: RollupAbi,
+            functionName: 'propose',
+            args: [
+                {
+                    header,
+                    archive,
+                    oracleInput: {
+                        feeAssetPriceModifier: 0n
+                    }
+                },
+                attestationsAndSigners.getPackedAttestations(),
+                attestationsAndSigners.getSigners().map((signer)=>signer.toString()),
+                attestationsAndSignersSignature.toViemSignature(),
+                blobInput
+            ]
+        });
+        const multiCallInput = encodeFunctionData({
+            abi: multicall3Abi,
+            functionName: 'aggregate3',
+            args: [
+                [
+                    {
+                        target: this.config.rollupAddress.toString(),
+                        callData: rollupInput,
+                        allowFailure: false
+                    }
+                ]
+            ]
+        });
+        return {
+            input: multiCallInput,
+            hash: archive,
+            blockHash: archive,
+            to: MULTI_CALL_3_ADDRESS
+        };
+    }
+    makeVersionedBlobHashes(checkpoint) {
+        return getBlobsPerL1Block(checkpoint.toBlobFields()).map((b)=>`0x${b.getEthVersionedBlobHash().toString('hex')}`);
+    }
+    makeBlobsFromCheckpoint(checkpoint) {
+        return getBlobsPerL1Block(checkpoint.toBlobFields());
+    }
+}

package/dest/test/index.d.ts

@@ -1,4 +1,5 @@
+export * from './mock_structs.js';
 export * from './mock_l2_block_source.js';
 export * from './mock_l1_to_l2_message_source.js';
 export * from './mock_archiver.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLG9CQUFvQixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsb0JBQW9CLENBQUMifQ==

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,oBAAoB,CAAC"}

package/dest/test/index.js

@@ -1,3 +1,4 @@
+export * from './mock_structs.js';
 export * from './mock_l2_block_source.js';
 export * from './mock_l1_to_l2_message_source.js';
 export * from './mock_archiver.js';

package/dest/test/mock_structs.d.ts

@@ -1,10 +1,84 @@
 import { CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Buffer16 } from '@aztec/foundation/buffer';
-import { type InboxMessage } from '../archiver/structs/inbox_message.js';
+import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { PrivateLog, PublicLog, SiloedTag, Tag } from '@aztec/stdlib/logs';
+import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
+import { StateReference } from '@aztec/stdlib/tx';
+import { type InboxMessage } from '../structs/inbox_message.js';
 export declare function makeInboxMessage(previousRollingHash?: Buffer16, overrides?: Partial<InboxMessage>): InboxMessage;
 export declare function makeInboxMessages(count: number, opts?: {
     initialHash?: Buffer16;
     initialCheckpointNumber?: CheckpointNumber;
     overrideFn?: (msg: InboxMessage, index: number) => InboxMessage;
 }): InboxMessage[];
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9ja19zdHJ1Y3RzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdC9tb2NrX3N0cnVjdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDbkUsT0FBTyxFQUFFLFFBQVEsRUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBSzlELE9BQU8sRUFBRSxLQUFLLFlBQVksRUFBcUIsTUFBTSxzQ0FBc0MsQ0FBQztBQUU1Rix3QkFBZ0IsZ0JBQWdCLENBQzlCLG1CQUFtQixXQUFnQixFQUNuQyxTQUFTLEdBQUUsT0FBTyxDQUFDLFlBQVksQ0FBTSxHQUNwQyxZQUFZLENBZ0JkO0FBRUQsd0JBQWdCLGlCQUFpQixDQUMvQixLQUFLLEVBQUUsTUFBTSxFQUNiLElBQUksR0FBRTtJQUNKLFdBQVcsQ0FBQyxFQUFFLFFBQVEsQ0FBQztJQUN2Qix1QkFBdUIsQ0FBQyxFQUFFLGdCQUFnQixDQUFDO0lBQzNDLFVBQVUsQ0FBQyxFQUFFLENBQUMsR0FBRyxFQUFFLFlBQVksRUFBRSxLQUFLLEVBQUUsTUFBTSxLQUFLLFlBQVksQ0FBQztDQUM1RCxHQUNMLFlBQVksRUFBRSxDQWFoQiJ9
+/** Creates inbox messages distributed across multiple blocks with proper checkpoint numbering. */
+export declare function makeInboxMessagesWithFullBlocks(blockCount: number, opts?: {
+    initialCheckpointNumber?: CheckpointNumber;
+}): 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;
+/** 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,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

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

@@ -1 +1 @@
-{"version":3,"file":"mock_structs.d.ts","sourceRoot":"","sources":["../../src/test/mock_structs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAK9D,OAAO,EAAE,KAAK,YAAY,EAAqB,MAAM,sCAAsC,CAAC;AAE5F,wBAAgB,gBAAgB,CAC9B,mBAAmB,WAAgB,EACnC,SAAS,GAAE,OAAO,CAAC,YAAY,CAAM,GACpC,YAAY,CAgBd;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,IAAI,GAAE;IACJ,WAAW,CAAC,EAAE,QAAQ,CAAC;IACvB,uBAAuB,CAAC,EAAE,gBAAgB,CAAC;IAC3C,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,KAAK,YAAY,CAAC;CAC5D,GACL,YAAY,EAAE,CAahB"}
+{"version":3,"file":"mock_structs.d.ts","sourceRoot":"","sources":["../../src/test/mock_structs.ts"],"names":[],"mappings":"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"}

package/dest/test/mock_structs.js

@@ -1,9 +1,21 @@
-import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { MAX_NOTE_HASHES_PER_TX, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
+import { times, timesParallel } from '@aztec/foundation/collection';
 import { randomBigInt, randomInt } from '@aztec/foundation/crypto/random';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { CommitteeAttestation, L2BlockNew } from '@aztec/stdlib/block';
+import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { PrivateLog, PublicLog, SiloedTag, Tag } from '@aztec/stdlib/logs';
 import { InboxLeaf } from '@aztec/stdlib/messaging';
-import { updateRollingHash } from '../archiver/structs/inbox_message.js';
+import { orderAttestations } from '@aztec/stdlib/p2p';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { makeCheckpointAttestationFromCheckpoint } from '@aztec/stdlib/testing';
+import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
+import { PartialStateReference, StateReference, TxEffect } from '@aztec/stdlib/tx';
+import { updateRollingHash } from '../structs/inbox_message.js';
 export function makeInboxMessage(previousRollingHash = Buffer16.ZERO, overrides = {}) {
     const { checkpointNumber = CheckpointNumber(randomInt(100) + 1) } = overrides;
     const { l1BlockNumber = randomBigInt(100n) + 1n } = overrides;
@@ -36,3 +48,122 @@ export function makeInboxMessages(count, opts = {}) {
     }
     return messages;
 }
+/** Creates inbox messages distributed across multiple blocks with proper checkpoint numbering. */ export function makeInboxMessagesWithFullBlocks(blockCount, opts = {}) {
+    const { initialCheckpointNumber = CheckpointNumber(13) } = opts;
+    return makeInboxMessages(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * blockCount, {
+        overrideFn: (msg, i)=>{
+            const checkpointNumber = CheckpointNumber(initialCheckpointNumber + Math.floor(i / NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
+            const index = InboxLeaf.smallestIndexForCheckpoint(checkpointNumber) + BigInt(i % NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+            return {
+                ...msg,
+                checkpointNumber,
+                index
+            };
+        }
+    });
+}
+/** Creates a deterministic block hash from a block number. */ export function makeBlockHash(blockNumber) {
+    return `0x${blockNumber.toString(16).padStart(64, '0')}`;
+}
+/**
+ * Creates a StateReference with properly calculated noteHashTree.nextAvailableLeafIndex.
+ * This ensures LogStore's dataStartIndexForBlock calculation doesn't produce negative values.
+ */ export function makeStateForBlock(blockNumber, txsPerBlock) {
+    const noteHashIndex = blockNumber * txsPerBlock * MAX_NOTE_HASHES_PER_TX;
+    return new StateReference(AppendOnlyTreeSnapshot.random(), new PartialStateReference(new AppendOnlyTreeSnapshot(Fr.random(), noteHashIndex), AppendOnlyTreeSnapshot.random(), AppendOnlyTreeSnapshot.random()));
+}
+/** Creates L1PublishedData with deterministic values based on l1BlockNumber. */ export function makeL1PublishedData(l1BlockNumber) {
+    return new L1PublishedData(BigInt(l1BlockNumber), BigInt(l1BlockNumber * 1000), makeBlockHash(l1BlockNumber));
+}
+/** Wraps a Checkpoint with L1 published data and random attestations. */ export function makePublishedCheckpoint(checkpoint, l1BlockNumber, attestationCount = 3) {
+    return new PublishedCheckpoint(checkpoint, makeL1PublishedData(l1BlockNumber), times(attestationCount, CommitteeAttestation.random));
+}
+/**
+ * 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 async function makeChainedCheckpoints(count, options = {}) {
+    const { blocksPerCheckpoint = 1, txsPerBlock = 4, startCheckpointNumber = CheckpointNumber(1), startBlockNumber = 1, startL1BlockNumber = 10, makeCheckpointOptions } = options;
+    let previousArchive = options.previousArchive;
+    const checkpoints = [];
+    for(let i = 0; i < count; i++){
+        const cpNumber = CheckpointNumber(startCheckpointNumber + i);
+        const blockStart = startBlockNumber + i * blocksPerCheckpoint;
+        const customOptions = makeCheckpointOptions?.(cpNumber) ?? {};
+        const checkpoint = await Checkpoint.random(cpNumber, {
+            numBlocks: blocksPerCheckpoint,
+            startBlockNumber: blockStart,
+            previousArchive,
+            txsPerBlock,
+            state: makeStateForBlock(blockStart, txsPerBlock),
+            txOptions: {
+                numPublicCallsPerTx: 2,
+                numPublicLogsPerCall: 2
+            },
+            ...customOptions
+        });
+        previousArchive = checkpoint.blocks.at(-1).archive;
+        checkpoints.push(makePublishedCheckpoint(checkpoint, startL1BlockNumber + i * 10));
+    }
+    return checkpoints;
+}
+/**
+ * Creates a PublishedCheckpoint with attestations signed by the provided signers.
+ * Useful for testing attestation validation.
+ */ export function makeSignedPublishedCheckpoint(checkpoint, signers, committee, l1BlockNumber = 1) {
+    const attestations = signers.map((signer)=>makeCheckpointAttestationFromCheckpoint(checkpoint, signer));
+    const committeeAttestations = orderAttestations(attestations, committee);
+    return new PublishedCheckpoint(checkpoint, makeL1PublishedData(l1BlockNumber), committeeAttestations);
+}
+/** Creates a deterministic SiloedTag for private log testing. */ export function makePrivateLogTag(blockNumber, txIndex, logIndex) {
+    return new SiloedTag(blockNumber === 1 && txIndex === 0 && logIndex === 0 ? Fr.ZERO : new Fr(blockNumber * 100 + txIndex * 10 + logIndex));
+}
+/** Creates a PrivateLog with fields derived from the tag. */ export function makePrivateLog(tag) {
+    return PrivateLog.from({
+        fields: makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, (i)=>!i ? tag.value : new Fr(tag.value.toBigInt() + BigInt(i))),
+        emittedLength: PRIVATE_LOG_SIZE_IN_FIELDS
+    });
+}
+/** Creates multiple private logs for a transaction. */ export function mockPrivateLogs(blockNumber, txIndex, numLogsPerTx) {
+    return times(numLogsPerTx, (logIndex)=>{
+        const tag = makePrivateLogTag(blockNumber, txIndex, logIndex);
+        return makePrivateLog(tag);
+    });
+}
+/** Creates a deterministic Tag for public log testing. */ export function makePublicLogTag(blockNumber, txIndex, logIndex) {
+    return new Tag(blockNumber === 1 && txIndex === 0 && logIndex === 0 ? Fr.ZERO : new Fr((blockNumber * 100 + txIndex * 10 + logIndex) * 123));
+}
+/** Creates a PublicLog with fields derived from the tag. */ export function makePublicLog(tag, contractAddress = AztecAddress.fromNumber(543254)) {
+    return PublicLog.from({
+        contractAddress,
+        fields: new Array(10).fill(null).map((_, i)=>!i ? tag.value : new Fr(tag.value.toBigInt() + BigInt(i)))
+    });
+}
+/** Creates multiple public logs for a transaction. */ export function makePublicLogs(blockNumber, txIndex, numLogsPerTx, contractAddress = AztecAddress.fromNumber(543254)) {
+    return times(numLogsPerTx, (logIndex)=>{
+        const tag = makePublicLogTag(blockNumber, txIndex, logIndex);
+        return makePublicLog(tag, contractAddress);
+    });
+}
+/** Creates a checkpoint with specified logs on each tx effect. */ export async function makeCheckpointWithLogs(blockNumber, options = {}) {
+    const { previousArchive, numTxsPerBlock = 4, privateLogs, publicLogs } = options;
+    const block = await L2BlockNew.random(BlockNumber(blockNumber), {
+        checkpointNumber: CheckpointNumber(blockNumber),
+        indexWithinCheckpoint: 0,
+        state: makeStateForBlock(blockNumber, numTxsPerBlock),
+        ...previousArchive ? {
+            lastArchive: previousArchive
+        } : {}
+    });
+    block.header.globalVariables.blockNumber = BlockNumber(blockNumber);
+    block.body.txEffects = await timesParallel(numTxsPerBlock, async (txIndex)=>{
+        const txEffect = await TxEffect.random();
+        txEffect.privateLogs = privateLogs ? mockPrivateLogs(blockNumber, txIndex, privateLogs.numLogsPerTx) : [];
+        txEffect.publicLogs = publicLogs ? makePublicLogs(blockNumber, txIndex, publicLogs.numLogsPerTx, publicLogs.contractAddress) : [];
+        return txEffect;
+    });
+    const checkpoint = new Checkpoint(AppendOnlyTreeSnapshot.random(), CheckpointHeader.random(), [
+        block
+    ], CheckpointNumber(blockNumber));
+    return makePublishedCheckpoint(checkpoint, blockNumber);
+}