@aztec/archiver 0.0.0-test.1 → 0.0.1-commit.0208eb9

package/dest/test/fake_l1_state.js

@@ -0,0 +1,383 @@
+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 { getSlotAtTimestamp } from '@aztec/stdlib/epoch-helpers';
+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 blocks for a checkpoint without adding them to L1 state.
+   * Useful for creating blocks to pass to addBlock() for testing provisional block handling.
+   * Returns the blocks directly.
+   */ async makeBlocks(checkpointNumber, options) {
+        return (await this.makeCheckpointAndMessages(checkpointNumber, options)).checkpoint.blocks;
+    }
+    /**
+   * 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, signers = [], messagesL1BlockNumber = l1BlockNumber - 3n } = options;
+        // Create the checkpoint using the stdlib helper
+        const { checkpoint, messages, lastArchive } = await this.makeCheckpointAndMessages(checkpointNumber, {
+            ...options,
+            numL1ToL2Messages: options.numL1ToL2Messages ?? 3
+        });
+        // 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
+        };
+    }
+    /** Creates a checkpoint and messages without adding them to L1 state. */ makeCheckpointAndMessages(checkpointNumber, options) {
+        const { numBlocks = 1, txsPerBlock = 4, maxEffects, slotNumber, previousArchive = this.lastArchive, timestamp, l1BlockNumber, numL1ToL2Messages = 0, blocks } = options;
+        return mockCheckpointAndMessages(checkpointNumber, {
+            startBlockNumber: this.getNextBlockNumber(checkpointNumber),
+            numBlocks,
+            blocks,
+            numTxsPerBlock: txsPerBlock,
+            numL1ToL2Messages,
+            previousArchive,
+            slotNumber: slotNumber ?? (l1BlockNumber !== undefined ? this.getL2SlotAtL1Block(l1BlockNumber) : undefined),
+            timestamp: timestamp ?? (l1BlockNumber !== undefined ? this.getTimestampAtL1Block(l1BlockNumber) : undefined),
+            ...maxEffects !== undefined ? {
+                maxEffects
+            } : {}
+        });
+    }
+    /** Returns the L2 slot at the given L1 block (assuming all L1 blocks are mined) */ getL2SlotAtL1Block(l1BlockNumber) {
+        const timestamp = this.getTimestampAtL1Block(l1BlockNumber);
+        return getSlotAtTimestamp(timestamp, this.config);
+    }
+    /** Returns the timestamp at the given L1 block (assuming all L1 blocks are mined) */ getTimestampAtL1Block(l1BlockNumber) {
+        const { l1GenesisTime, l1StartBlock, ethereumSlotDuration } = this.config;
+        return l1GenesisTime + (l1BlockNumber - l1StartBlock) * BigInt(ethereumSlotDuration);
+    }
+    /**
+   * 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=index.d.ts.map
+//# 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,6 @@
+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';
+export * from './mock_archiver.js'; // NOTE: noop_l1_archiver.js is intentionally NOT exported here because it imports
+ // jest-mock-extended, which depends on @jest/globals and can only run inside Jest.
+ // Import it directly: import { NoopL1Archiver } from '@aztec/archiver/test/noop-l1';

package/dest/test/mock_archiver.d.ts

@@ -1,5 +1,7 @@
-import type { Fr } from '@aztec/foundation/fields';
-import type { L2Block, L2BlockSource } from '@aztec/stdlib/block';
+import type { CheckpointNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { Checkpoint } from '@aztec/stdlib/checkpoint';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 import { MockL2BlockSource } from './mock_l2_block_source.js';
 /**
@@ -7,17 +9,23 @@ import { MockL2BlockSource } from './mock_l2_block_source.js';
  */
 export declare class MockArchiver extends MockL2BlockSource implements L2BlockSource, L1ToL2MessageSource {
     private messageSource;
-    setL1ToL2Messages(blockNumber: number, msgs: Fr[]): void;
-    getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]>;
+    setL1ToL2Messages(checkpointNumber: CheckpointNumber, msgs: Fr[]): void;
+    getL1ToL2Messages(checkpointNumber: CheckpointNumber): Promise<Fr[]>;
     getL1ToL2MessageIndex(_l1ToL2Message: Fr): Promise<bigint | undefined>;
 }
 /**
  * A mocked implementation of the archiver with a set of precomputed blocks and messages.
  */
 export declare class MockPrefilledArchiver extends MockArchiver {
-    private precomputed;
-    constructor(precomputed: L2Block[], messages: Fr[][]);
-    setPrefilledBlocks(blocks: L2Block[], messages: Fr[][]): void;
+    private prefilled;
+    constructor(prefilled: {
+        checkpoint: Checkpoint;
+        messages: Fr[];
+    }[]);
+    setPrefilled(prefilled: {
+        checkpoint: Checkpoint;
+        messages: Fr[];
+    }[]): void;
     createBlocks(numBlocks: number): Promise<void>;
 }
-//# sourceMappingURL=mock_archiver.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9ja19hcmNoaXZlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Rlc3QvbW9ja19hcmNoaXZlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ3hFLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3pELE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQzNELE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFHbkUsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFOUQ7O0dBRUc7QUFDSCxxQkFBYSxZQUFhLFNBQVEsaUJBQWtCLFlBQVcsYUFBYSxFQUFFLG1CQUFtQjtJQUMvRixPQUFPLENBQUMsYUFBYSxDQUFrQztJQUVoRCxpQkFBaUIsQ0FBQyxnQkFBZ0IsRUFBRSxnQkFBZ0IsRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLFFBRXRFO0lBRUQsaUJBQWlCLENBQUMsZ0JBQWdCLEVBQUUsZ0JBQWdCLEdBQUcsT0FBTyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBRW5FO0lBRUQscUJBQXFCLENBQUMsY0FBYyxFQUFFLEVBQUUsR0FBRyxPQUFPLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQyxDQUVyRTtDQUNGO0FBRUQ7O0dBRUc7QUFDSCxxQkFBYSxxQkFBc0IsU0FBUSxZQUFZO0lBQ3JELE9BQU8sQ0FBQyxTQUFTLENBQW9CO0lBRXJDLFlBQVksU0FBUyxFQUFFO1FBQUUsVUFBVSxFQUFFLFVBQVUsQ0FBQztRQUFDLFFBQVEsRUFBRSxFQUFFLEVBQUUsQ0FBQTtLQUFFLEVBQUUsRUFHbEU7SUFFTSxZQUFZLENBQUMsU0FBUyxFQUFFO1FBQUUsVUFBVSxFQUFFLFVBQVUsQ0FBQztRQUFDLFFBQVEsRUFBRSxFQUFFLEVBQUUsQ0FBQTtLQUFFLEVBQUUsUUFRMUU7SUFFZSxZQUFZLENBQUMsU0FBUyxFQUFFLE1BQU0saUJBWTdDO0NBQ0YifQ==

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

@@ -1 +1 @@
-{"version":3,"file":"mock_archiver.d.ts","sourceRoot":"","sources":["../../src/test/mock_archiver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAGnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D;;GAEG;AACH,qBAAa,YAAa,SAAQ,iBAAkB,YAAW,aAAa,EAAE,mBAAmB;IAC/F,OAAO,CAAC,aAAa,CAAkC;IAEhD,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE;IAIxD,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,EAAE,CAAC;IAIrD,qBAAqB,CAAC,cAAc,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;CAGvE;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,YAAY;IACrD,OAAO,CAAC,WAAW,CAAY;gBAEnB,WAAW,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE;IAM7C,kBAAkB,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE;IAO7C,YAAY,CAAC,SAAS,EAAE,MAAM;CAW/C"}
+{"version":3,"file":"mock_archiver.d.ts","sourceRoot":"","sources":["../../src/test/mock_archiver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAGnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D;;GAEG;AACH,qBAAa,YAAa,SAAQ,iBAAkB,YAAW,aAAa,EAAE,mBAAmB;IAC/F,OAAO,CAAC,aAAa,CAAkC;IAEhD,iBAAiB,CAAC,gBAAgB,EAAE,gBAAgB,EAAE,IAAI,EAAE,EAAE,EAAE,QAEtE;IAED,iBAAiB,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,EAAE,EAAE,CAAC,CAEnE;IAED,qBAAqB,CAAC,cAAc,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAErE;CACF;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,YAAY;IACrD,OAAO,CAAC,SAAS,CAAoB;IAErC,YAAY,SAAS,EAAE;QAAE,UAAU,EAAE,UAAU,CAAC;QAAC,QAAQ,EAAE,EAAE,EAAE,CAAA;KAAE,EAAE,EAGlE;IAEM,YAAY,CAAC,SAAS,EAAE;QAAE,UAAU,EAAE,UAAU,CAAC;QAAC,QAAQ,EAAE,EAAE,EAAE,CAAA;KAAE,EAAE,QAQ1E;IAEe,YAAY,CAAC,SAAS,EAAE,MAAM,iBAY7C;CACF"}

package/dest/test/mock_archiver.js

@@ -4,11 +4,11 @@ import { MockL2BlockSource } from './mock_l2_block_source.js';
  * A mocked implementation of the archiver that implements L2BlockSource and L1ToL2MessageSource.
  */ export class MockArchiver extends MockL2BlockSource {
     messageSource = new MockL1ToL2MessageSource(0);
-    setL1ToL2Messages(blockNumber, msgs) {
-        this.messageSource.setL1ToL2Messages(blockNumber, msgs);
+    setL1ToL2Messages(checkpointNumber, msgs) {
+        this.messageSource.setL1ToL2Messages(checkpointNumber, msgs);
     }
-    getL1ToL2Messages(blockNumber) {
-        return this.messageSource.getL1ToL2Messages(blockNumber);
+    getL1ToL2Messages(checkpointNumber) {
+        return this.messageSource.getL1ToL2Messages(checkpointNumber);
     }
     getL1ToL2MessageIndex(_l1ToL2Message) {
         return this.messageSource.getL1ToL2MessageIndex(_l1ToL2Message);
@@ -17,24 +17,28 @@ import { MockL2BlockSource } from './mock_l2_block_source.js';
 /**
  * A mocked implementation of the archiver with a set of precomputed blocks and messages.
  */ export class MockPrefilledArchiver extends MockArchiver {
-    precomputed;
-    constructor(precomputed, messages){
+    prefilled = [];
+    constructor(prefilled){
         super();
-        this.precomputed = precomputed.slice();
-        messages.forEach((msgs, i)=>this.setL1ToL2Messages(i + 1, msgs));
+        this.setPrefilled(prefilled);
     }
-    setPrefilledBlocks(blocks, messages) {
-        for (const block of blocks){
-            this.precomputed[block.number - 1] = block;
+    setPrefilled(prefilled) {
+        for (const { checkpoint, messages } of prefilled){
+            this.prefilled[checkpoint.number - 1] = checkpoint;
+            if (checkpoint.blocks.length !== 1) {
+                throw new Error('Prefilled checkpoint must only have 1 block at the moment.');
+            }
+            this.setL1ToL2Messages(checkpoint.number, messages);
         }
-        messages.forEach((msgs, i)=>this.setL1ToL2Messages(blocks[i].number, msgs));
     }
     createBlocks(numBlocks) {
-        if (this.l2Blocks.length + numBlocks > this.precomputed.length) {
+        const flattenedBlocks = this.prefilled.flatMap((c)=>c.blocks);
+        if (this.l2Blocks.length + numBlocks > flattenedBlocks.length) {
             throw new Error(`Not enough precomputed blocks to create ${numBlocks} more blocks (already at ${this.l2Blocks.length})`);
         }
         const fromBlock = this.l2Blocks.length;
-        this.addBlocks(this.precomputed.slice(fromBlock, fromBlock + numBlocks));
+        // TODO: Add L2 blocks and checkpoints separately once archiver has the apis for that.
+        this.addProposedBlocks(this.prefilled.slice(fromBlock, fromBlock + numBlocks).flatMap((c)=>c.blocks));
         return Promise.resolve();
     }
 }

package/dest/test/mock_l1_to_l2_message_source.d.ts

@@ -1,16 +1,19 @@
-import type { Fr } from '@aztec/foundation/fields';
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { L2Tips } from '@aztec/stdlib/block';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 /**
  * A mocked implementation of L1ToL2MessageSource to be used in tests.
  */
 export declare class MockL1ToL2MessageSource implements L1ToL2MessageSource {
     private blockNumber;
-    private messagesPerBlock;
+    private messagesPerCheckpoint;
     constructor(blockNumber: number);
-    setL1ToL2Messages(blockNumber: number, msgs: Fr[]): void;
+    setL1ToL2Messages(checkpointNumber: CheckpointNumber, msgs: Fr[]): void;
     setBlockNumber(blockNumber: number): void;
-    getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]>;
+    getL1ToL2Messages(checkpointNumber: CheckpointNumber): Promise<Fr[]>;
     getL1ToL2MessageIndex(_l1ToL2Message: Fr): Promise<bigint | undefined>;
-    getBlockNumber(): Promise<number>;
+    getBlockNumber(): Promise<BlockNumber>;
+    getL2Tips(): Promise<L2Tips>;
 }
-//# sourceMappingURL=mock_l1_to_l2_message_source.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9ja19sMV90b19sMl9tZXNzYWdlX3NvdXJjZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Rlc3QvbW9ja19sMV90b19sMl9tZXNzYWdlX3NvdXJjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsV0FBVyxFQUFFLGdCQUFnQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDaEYsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3BELE9BQU8sS0FBSyxFQUFvQyxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNwRixPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRW5FOztHQUVHO0FBQ0gscUJBQWEsdUJBQXdCLFlBQVcsbUJBQW1CO0lBR3JELE9BQU8sQ0FBQyxXQUFXO0lBRi9CLE9BQU8sQ0FBQyxxQkFBcUIsQ0FBcUM7SUFFbEUsWUFBb0IsV0FBVyxFQUFFLE1BQU0sRUFBSTtJQUVwQyxpQkFBaUIsQ0FBQyxnQkFBZ0IsRUFBRSxnQkFBZ0IsRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLFFBRXRFO0lBRU0sY0FBYyxDQUFDLFdBQVcsRUFBRSxNQUFNLFFBRXhDO0lBRUQsaUJBQWlCLENBQUMsZ0JBQWdCLEVBQUUsZ0JBQWdCLEdBQUcsT0FBTyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBRW5FO0lBRUQscUJBQXFCLENBQUMsY0FBYyxFQUFFLEVBQUUsR0FBRyxPQUFPLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQyxDQUVyRTtJQUVELGNBQWMseUJBRWI7SUFFRCxTQUFTLElBQUksT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQWMzQjtDQUNGIn0=

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

@@ -1 +1 @@
-{"version":3,"file":"mock_l1_to_l2_message_source.d.ts","sourceRoot":"","sources":["../../src/test/mock_l1_to_l2_message_source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE;;GAEG;AACH,qBAAa,uBAAwB,YAAW,mBAAmB;IAGrD,OAAO,CAAC,WAAW;IAF/B,OAAO,CAAC,gBAAgB,CAA2B;gBAE/B,WAAW,EAAE,MAAM;IAEhC,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE;IAIjD,cAAc,CAAC,WAAW,EAAE,MAAM;IAIzC,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,EAAE,CAAC;IAIrD,qBAAqB,CAAC,cAAc,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAItE,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC;CAGlC"}
+{"version":3,"file":"mock_l1_to_l2_message_source.d.ts","sourceRoot":"","sources":["../../src/test/mock_l1_to_l2_message_source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAoC,MAAM,EAAE,MAAM,qBAAqB,CAAC;AACpF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE;;GAEG;AACH,qBAAa,uBAAwB,YAAW,mBAAmB;IAGrD,OAAO,CAAC,WAAW;IAF/B,OAAO,CAAC,qBAAqB,CAAqC;IAElE,YAAoB,WAAW,EAAE,MAAM,EAAI;IAEpC,iBAAiB,CAAC,gBAAgB,EAAE,gBAAgB,EAAE,IAAI,EAAE,EAAE,EAAE,QAEtE;IAEM,cAAc,CAAC,WAAW,EAAE,MAAM,QAExC;IAED,iBAAiB,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,EAAE,EAAE,CAAC,CAEnE;IAED,qBAAqB,CAAC,cAAc,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAErE;IAED,cAAc,yBAEb;IAED,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAc3B;CACF"}

package/dest/test/mock_l1_to_l2_message_source.js

@@ -1,25 +1,48 @@
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 /**
  * A mocked implementation of L1ToL2MessageSource to be used in tests.
  */ export class MockL1ToL2MessageSource {
     blockNumber;
-    messagesPerBlock;
+    messagesPerCheckpoint;
     constructor(blockNumber){
         this.blockNumber = blockNumber;
-        this.messagesPerBlock = new Map();
+        this.messagesPerCheckpoint = new Map();
     }
-    setL1ToL2Messages(blockNumber, msgs) {
-        this.messagesPerBlock.set(blockNumber, msgs);
+    setL1ToL2Messages(checkpointNumber, msgs) {
+        this.messagesPerCheckpoint.set(checkpointNumber, msgs);
     }
     setBlockNumber(blockNumber) {
         this.blockNumber = blockNumber;
     }
-    getL1ToL2Messages(blockNumber) {
-        return Promise.resolve(this.messagesPerBlock.get(Number(blockNumber)) ?? []);
+    getL1ToL2Messages(checkpointNumber) {
+        return Promise.resolve(this.messagesPerCheckpoint.get(checkpointNumber) ?? []);
     }
     getL1ToL2MessageIndex(_l1ToL2Message) {
         throw new Error('Method not implemented.');
     }
     getBlockNumber() {
-        return Promise.resolve(this.blockNumber);
+        return Promise.resolve(BlockNumber(this.blockNumber));
+    }
+    getL2Tips() {
+        const number = this.blockNumber;
+        const blockId = {
+            number: BlockNumber(number),
+            hash: new Fr(number).toString()
+        };
+        const checkpointId = {
+            number: CheckpointNumber(number),
+            hash: new Fr(number + 1).toString()
+        };
+        const tip = {
+            block: blockId,
+            checkpoint: checkpointId
+        };
+        return Promise.resolve({
+            proposed: blockId,
+            checkpointed: tip,
+            proven: tip,
+            finalized: tip
+        });
     }
 }