@aztec/archiver 0.0.1-commit.e3c1de76 → 0.0.1-commit.e57c76e

package/dest/test/mock_l2_block_source.js

@@ -1,31 +1,88 @@
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
 import { DefaultL1ContractsConfig } from '@aztec/ethereum/config';
-import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, CheckpointNumber, IndexWithinCheckpoint, SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
-import { CheckpointedL2Block, L2Block } from '@aztec/stdlib/block';
+import { Body, GENESIS_BLOCK_HEADER_HASH, GENESIS_CHECKPOINT_HEADER_HASH, L2Block } from '@aztec/stdlib/block';
 import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { EmptyL1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
-import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
+import { computeCheckpointOutHash } from '@aztec/stdlib/messaging';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
+import { BlockHeader } from '@aztec/stdlib/tx';
 /**
  * A mocked implementation of L2BlockSource to be used in tests.
  */ export class MockL2BlockSource {
     l2Blocks = [];
+    checkpointList = [];
     provenBlockNumber = 0;
     finalizedBlockNumber = 0;
     checkpointedBlockNumber = 0;
+    proposedCheckpointBlockNumber = 0;
+    initialHeader = BlockHeader.empty();
+    initialHeaderHash = GENESIS_BLOCK_HEADER_HASH;
+    genesisArchiveRoot;
+    genesisBlock;
     log = createLogger('archiver:mock_l2_block_source');
-    async createBlocks(numBlocks) {
-        for(let i = 0; i < numBlocks; i++){
-            const blockNum = this.l2Blocks.length + 1;
-            const block = await L2Block.random(BlockNumber(blockNum), {
-                slotNumber: SlotNumber(blockNum)
+    /** 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.l2Blocks.push(block);
+            this.checkpointList.push(checkpoint);
+            this.l2Blocks.push(...checkpoint.blocks);
         }
-        this.log.verbose(`Created ${numBlocks} blocks in the mock L2 block source`);
+        this.log.verbose(`Created ${numCheckpoints} checkpoints with ${blocksPerCheckpoint} blocks each in the mock L2 block source`);
     }
     addProposedBlocks(blocks) {
         this.l2Blocks.push(...blocks);
@@ -33,6 +90,17 @@ import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
     }
     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.proposedCheckpointBlockNumber = Math.min(this.proposedCheckpointBlockNumber, 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) {
@@ -44,8 +112,40 @@ import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
         }
         this.finalizedBlockNumber = finalizedBlockNumber;
     }
+    setProposedCheckpointBlockNumber(blockNumber) {
+        this.proposedCheckpointBlockNumber = blockNumber;
+    }
     setCheckpointedBlockNumber(checkpointedBlockNumber) {
+        const prevCheckpointed = this.checkpointedBlockNumber;
         this.checkpointedBlockNumber = checkpointedBlockNumber;
+        // Proposed checkpoint is always at least as advanced as checkpointed
+        if (this.proposedCheckpointBlockNumber < checkpointedBlockNumber) {
+            this.proposedCheckpointBlockNumber = 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.
@@ -59,199 +159,93 @@ import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
    */ getRegistryAddress() {
         return Promise.resolve(EthAddress.random());
     }
-    /**
-   * Gets the number of the latest L2 block processed by the block source implementation.
-   * @returns In this mock instance, returns the number of L2 blocks that we've mocked.
-   */ getBlockNumber() {
-        return Promise.resolve(BlockNumber(this.l2Blocks.length));
-    }
-    getProvenBlockNumber() {
-        return Promise.resolve(BlockNumber(this.provenBlockNumber));
-    }
-    getCheckpointedL2BlockNumber() {
-        return Promise.resolve(BlockNumber(this.checkpointedBlockNumber));
-    }
-    getFinalizedL2BlockNumber() {
-        return Promise.resolve(BlockNumber(this.finalizedBlockNumber));
-    }
-    getCheckpointedBlock(number) {
-        if (number > this.checkpointedBlockNumber) {
-            return Promise.resolve(undefined);
+    async getBlockNumber(query) {
+        if (!query) {
+            return BlockNumber(this.l2Blocks.length);
         }
-        const block = this.l2Blocks[number - 1];
-        if (!block) {
-            return Promise.resolve(undefined);
+        if ('number' in query) {
+            return query.number;
         }
-        const checkpointedBlock = new CheckpointedL2Block(CheckpointNumber.fromBlockNumber(number), block, new L1PublishedData(BigInt(number), BigInt(number), `0x${number.toString(16).padStart(64, '0')}`), []);
-        return Promise.resolve(checkpointedBlock);
-    }
-    async getCheckpointedBlocks(from, limit) {
-        const result = [];
-        for(let i = 0; i < limit; i++){
-            const blockNum = from + i;
-            if (blockNum > this.checkpointedBlockNumber) {
-                break;
-            }
-            const block = await this.getCheckpointedBlock(BlockNumber(blockNum));
-            if (block) {
-                result.push(block);
-            }
+        if ('tag' in query) {
+            return BlockNumber(this.resolveBlockTag(query.tag));
         }
-        return result;
-    }
-    /**
-   * Gets an l2 block.
-   * @param number - The block number to return (inclusive).
-   * @returns The requested L2 block.
-   */ getBlock(number) {
-        const block = this.l2Blocks[number - 1];
-        return Promise.resolve(block);
-    }
-    /**
-   * Gets an L2 block (new format).
-   * @param number - The block number to return.
-   * @returns The requested L2 block.
-   */ getL2Block(number) {
-        const block = this.l2Blocks[number - 1];
-        return Promise.resolve(block);
+        const block = await this.getBlock(query);
+        return block ? block.header.globalVariables.blockNumber : undefined;
     }
-    /**
-   * Gets up to `limit` amount of L2 blocks starting from `from`.
-   * @param from - Number of the first block to return (inclusive).
-   * @param limit - The maximum number of blocks to return.
-   * @returns The requested mocked L2 blocks.
-   */ getBlocks(from, limit) {
-        return Promise.resolve(this.l2Blocks.slice(from - 1, from - 1 + limit));
-    }
-    getCheckpoints(from, limit) {
-        // TODO(mbps): Implement this properly. This only works when we have one block per checkpoint.
-        const blocks = this.l2Blocks.slice(from - 1, from - 1 + limit);
-        return Promise.all(blocks.map(async (block)=>{
-            // Create a checkpoint from the block - manually construct since L2Block doesn't have toCheckpoint()
-            const checkpoint = await Checkpoint.random(block.checkpointNumber, {
-                numBlocks: 1
-            });
-            checkpoint.blocks = [
-                block
-            ];
-            return new PublishedCheckpoint(checkpoint, new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()), []);
-        }));
+    getProposedCheckpointL2BlockNumber() {
+        return Promise.resolve(BlockNumber(this.proposedCheckpointBlockNumber));
     }
-    async getCheckpointByArchive(archive) {
-        // TODO(mbps): Implement this properly. This only works when we have one block per checkpoint.
-        const block = this.l2Blocks.find((b)=>b.archive.root.equals(archive));
-        if (!block) {
-            return undefined;
-        }
-        // Create a checkpoint from the block - manually construct since L2Block doesn't have toCheckpoint()
-        const checkpoint = await Checkpoint.random(block.checkpointNumber, {
-            numBlocks: 1
-        });
-        checkpoint.blocks = [
-            block
-        ];
-        return checkpoint;
-    }
-    async getCheckpointedBlockByHash(blockHash) {
-        for (const block of this.l2Blocks){
-            const hash = await block.hash();
-            if (hash.equals(blockHash)) {
-                return CheckpointedL2Block.fromFields({
-                    checkpointNumber: CheckpointNumber.fromBlockNumber(block.number),
-                    block,
-                    l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
-                    attestations: []
-                });
-            }
-        }
-        return undefined;
-    }
-    getCheckpointedBlockByArchive(archive) {
-        const block = this.l2Blocks.find((b)=>b.archive.root.equals(archive));
-        if (!block) {
+    getCheckpoint(query) {
+        const checkpoint = this.resolveCheckpointQuery(query);
+        if (!checkpoint) {
             return Promise.resolve(undefined);
         }
-        return Promise.resolve(CheckpointedL2Block.fromFields({
-            checkpointNumber: CheckpointNumber.fromBlockNumber(block.number),
-            block,
-            l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
-            attestations: []
-        }));
-    }
-    async getL2BlockByHash(blockHash) {
-        for (const block of this.l2Blocks){
-            const hash = await block.hash();
-            if (hash.equals(blockHash)) {
-                return block;
-            }
-        }
-        return undefined;
+        return Promise.resolve(new PublishedCheckpoint(checkpoint, this.mockL1DataForCheckpoint(checkpoint), []));
     }
-    getL2BlockByArchive(archive) {
-        const block = this.l2Blocks.find((b)=>b.archive.root.equals(archive));
-        return Promise.resolve(block);
+    getCheckpoints(query) {
+        const checkpoints = this.resolveCheckpointsQuery(query);
+        return Promise.resolve(checkpoints.map((checkpoint)=>new PublishedCheckpoint(checkpoint, this.mockL1DataForCheckpoint(checkpoint), [])));
     }
-    async getBlockHeaderByHash(blockHash) {
-        for (const block of this.l2Blocks){
-            const hash = await block.hash();
-            if (hash.equals(blockHash)) {
-                return block.header;
-            }
+    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 undefined;
+        return Promise.resolve(this.checkpointToData(checkpoint));
     }
-    getBlockHeaderByArchive(archive) {
-        const block = this.l2Blocks.find((b)=>b.archive.root.equals(archive));
-        return Promise.resolve(block?.header);
+    getCheckpointsData(query) {
+        const checkpoints = this.resolveCheckpointsQuery(query);
+        return Promise.resolve(checkpoints.map((c)=>this.checkpointToData(c)));
     }
-    getBlockHeader(number) {
-        return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.header);
+    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)
+        };
     }
-    getCheckpointsForEpoch(epochNumber) {
-        // TODO(mbps): Implement this properly. This only works when we have one block per checkpoint.
-        const epochDuration = DefaultL1ContractsConfig.aztecEpochDuration;
-        const [start, end] = getSlotRangeForEpoch(epochNumber, {
-            epochDuration
-        });
-        const blocks = this.l2Blocks.filter((b)=>{
-            const slot = b.header.globalVariables.slotNumber;
-            return slot >= start && slot <= end;
-        });
-        // Create checkpoints from blocks - manually construct since L2Block doesn't have toCheckpoint()
-        return Promise.all(blocks.map(async (block)=>{
-            const checkpoint = await Checkpoint.random(block.checkpointNumber, {
-                numBlocks: 1
-            });
-            checkpoint.blocks = [
-                block
-            ];
-            return 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);
+                }
+        }
     }
-    getCheckpointedBlocksForEpoch(epochNumber) {
-        const epochDuration = DefaultL1ContractsConfig.aztecEpochDuration;
-        const [start, end] = getSlotRangeForEpoch(epochNumber, {
-            epochDuration
-        });
-        const blocks = this.l2Blocks.filter((b)=>{
-            const slot = b.header.globalVariables.slotNumber;
-            return slot >= start && slot <= end;
-        });
-        return Promise.resolve(blocks.map((block)=>CheckpointedL2Block.fromFields({
-                checkpointNumber: CheckpointNumber.fromBlockNumber(block.number),
-                block,
-                l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
-                attestations: []
-            })));
+    resolveCheckpointsQuery(query) {
+        if ('from' in query) {
+            return this.checkpointList.slice(query.from - 1, query.from - 1 + query.limit);
+        }
+        return this.getCheckpointsInEpoch(query.epoch);
     }
     getBlocksForSlot(slotNumber) {
         const blocks = this.l2Blocks.filter((b)=>b.header.globalVariables.slotNumber === slotNumber);
         return Promise.resolve(blocks);
     }
-    async getCheckpointedBlockHeadersForEpoch(epochNumber) {
-        const checkpointedBlocks = await this.getCheckpointedBlocksForEpoch(epochNumber);
-        return checkpointedBlocks.map((b)=>b.block.header);
-    }
     /**
    * Gets a tx effect.
    * @param txHash - The hash of the tx corresponding to the tx effect.
@@ -269,69 +263,82 @@ import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
             data: txEffect,
             l2BlockNumber: block.number,
             l2BlockHash: await block.hash(),
-            txIndexInBlock: block.body.txEffects.indexOf(txEffect)
+            txIndexInBlock: block.body.txEffects.findIndex((t)=>t.txHash.equals(txHash)),
+            slotNumber: block.header.globalVariables.slotNumber
         };
     }
-    /**
-   * Gets a receipt of a settled tx.
-   * @param txHash - The hash of a tx we try to get the receipt for.
-   * @returns The requested tx receipt (or undefined if not found).
-   */ async getSettledTxReceipt(txHash) {
-        for (const block of this.l2Blocks){
-            for (const txEffect of block.body.txEffects){
-                if (txEffect.txHash.equals(txHash)) {
-                    // In mock, assume all txs are checkpointed with successful execution
-                    return new TxReceipt(txHash, TxStatus.CHECKPOINTED, TxExecutionResult.SUCCESS, undefined, txEffect.transactionFee.toBigInt(), await block.hash(), block.number);
-                }
-            }
-        }
-        return undefined;
+    getL2ToL1MembershipWitness() {
+        // Mock does not back the L2-to-L1 message witness flow.
+        return Promise.resolve(undefined);
     }
     async getL2Tips() {
-        const [latest, proven, finalized, checkpointed] = [
+        const [latest, proven, finalized, checkpointed, proposedCheckpoint] = [
             await this.getBlockNumber(),
-            await this.getProvenBlockNumber(),
+            this.provenBlockNumber,
             this.finalizedBlockNumber,
-            this.checkpointedBlockNumber
+            this.checkpointedBlockNumber,
+            await this.getProposedCheckpointL2BlockNumber()
         ];
         const latestBlock = this.l2Blocks[latest - 1];
         const provenBlock = this.l2Blocks[proven - 1];
         const finalizedBlock = this.l2Blocks[finalized - 1];
         const checkpointedBlock = this.l2Blocks[checkpointed - 1];
+        const proposedCheckpointBlock = this.l2Blocks[proposedCheckpoint - 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 latestBlock?.hash())?.toString()
+            hash: await tipHash(latestBlock, latest)
         };
         const provenBlockId = {
             number: BlockNumber(proven),
-            hash: (await provenBlock?.hash())?.toString()
+            hash: await tipHash(provenBlock, proven)
         };
         const finalizedBlockId = {
             number: BlockNumber(finalized),
-            hash: (await finalizedBlock?.hash())?.toString()
+            hash: await tipHash(finalizedBlock, finalized)
         };
         const checkpointedBlockId = {
             number: BlockNumber(checkpointed),
-            hash: (await checkpointedBlock?.hash())?.toString()
+            hash: await tipHash(checkpointedBlock, checkpointed)
         };
-        const makeTipId = (blockId)=>({
+        const proposedCheckpointBlockId = {
+            number: BlockNumber(proposedCheckpoint),
+            hash: await tipHash(proposedCheckpointBlock, proposedCheckpoint)
+        };
+        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.fromBlockNumber(blockId.number),
-                    hash: blockId.hash
+                    number: checkpointNumber,
+                    hash
                 }
-            });
+            };
+        };
         return {
             proposed: latestBlockId,
             checkpointed: makeTipId(checkpointedBlockId),
             proven: makeTipId(provenBlockId),
-            finalized: makeTipId(finalizedBlockId)
+            finalized: makeTipId(finalizedBlockId),
+            proposedCheckpoint: makeTipId(proposedCheckpointBlockId)
         };
     }
-    getL2EpochNumber() {
+    getSyncedL2EpochNumber() {
         throw new Error('Method not implemented.');
     }
-    getL2SlotNumber() {
+    getSyncedL2SlotNumber() {
         throw new Error('Method not implemented.');
     }
     isEpochComplete(_epochNumber) {
@@ -340,9 +347,12 @@ import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
     getL1Constants() {
         return Promise.resolve(EmptyL1RollupConstants);
     }
+    isPruneDueAtSlot(_slot) {
+        return Promise.resolve(false);
+    }
     getGenesisValues() {
         return Promise.resolve({
-            genesisArchiveRoot: new Fr(GENESIS_ARCHIVE_ROOT)
+            genesisArchiveRoot: this.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT)
         });
     }
     getL1Timestamp() {
@@ -383,6 +393,88 @@ import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
     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);
     }
@@ -391,4 +483,21 @@ import { TxExecutionResult, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
             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;
+    }
 }