@aztec/archiver 0.0.1-commit.03f7ef2 → 0.0.1-commit.04d373f

package/dest/test/mock_l2_block_source.js

@@ -1,35 +1,106 @@
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
 import { DefaultL1ContractsConfig } from '@aztec/ethereum/config';
-import { BlockNumber } 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 { L2Block, L2BlockHash, PublishedL2Block } from '@aztec/stdlib/block';
-import { L1PublishedData } from '@aztec/stdlib/checkpoint';
-import { EmptyL1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
-import { TxReceipt, TxStatus } from '@aztec/stdlib/tx';
+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, getEpochAtSlot, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+import { computeCheckpointOutHash } from '@aztec/stdlib/messaging';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
+import { BlockHeader, TxExecutionResult, TxReceipt, TxStatus } 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));
-            this.l2Blocks.push(block);
+    /** 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;
         }
-        this.log.verbose(`Created ${numBlocks} blocks in the mock L2 block source`);
+        const archive = this.genesisArchiveRoot ? new AppendOnlyTreeSnapshot(this.genesisArchiveRoot, 1) : AppendOnlyTreeSnapshot.empty();
+        return this.genesisBlock = new L2Block(archive, this.initialHeader, Body.empty(), CheckpointNumber.ZERO, IndexWithinCheckpoint(0));
+    }
+    /** Creates blocks grouped into single-block checkpoints. */ async createBlocks(numBlocks) {
+        await this.createCheckpoints(numBlocks, 1);
+    }
+    getCheckpointNumber() {
+        return Promise.resolve(this.checkpointList.length === 0 ? CheckpointNumber.ZERO : CheckpointNumber(this.checkpointList.length));
+    }
+    /** Creates checkpoints, each containing `blocksPerCheckpoint` blocks. */ async createCheckpoints(numCheckpoints, blocksPerCheckpoint = 1) {
+        for(let c = 0; c < numCheckpoints; c++){
+            const checkpointNum = CheckpointNumber(this.checkpointList.length + 1);
+            const startBlockNum = this.l2Blocks.length + 1;
+            const slotNumber = SlotNumber(Number(checkpointNum));
+            const checkpoint = await Checkpoint.random(checkpointNum, {
+                numBlocks: blocksPerCheckpoint,
+                startBlockNumber: startBlockNum,
+                slotNumber,
+                checkpointNumber: checkpointNum
+            });
+            this.checkpointList.push(checkpoint);
+            this.l2Blocks.push(...checkpoint.blocks);
+        }
+        this.log.verbose(`Created ${numCheckpoints} checkpoints with ${blocksPerCheckpoint} blocks each in the mock L2 block source`);
     }
-    addBlocks(blocks) {
+    addProposedBlocks(blocks) {
         this.l2Blocks.push(...blocks);
-        this.log.verbose(`Added ${blocks.length} blocks to the mock L2 block source`);
+        this.log.verbose(`Added ${blocks.length} proposed blocks to the mock L2 block source`);
     }
     removeBlocks(numBlocks) {
         this.l2Blocks = this.l2Blocks.slice(0, -numBlocks);
+        const maxBlockNum = this.l2Blocks.length;
+        // Remove any checkpoint whose last block is beyond the remaining blocks.
+        this.checkpointList = this.checkpointList.filter((c)=>{
+            const lastBlockNum = c.blocks[0].number + c.blocks.length - 1;
+            return lastBlockNum <= maxBlockNum;
+        });
+        // Keep tip numbers consistent with remaining blocks.
+        this.checkpointedBlockNumber = Math.min(this.checkpointedBlockNumber, maxBlockNum);
+        this.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) {
@@ -41,6 +112,41 @@ import { 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.
    * @returns The rollup address.
@@ -53,117 +159,93 @@ import { 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));
+    async getBlockNumber(query) {
+        if (!query) {
+            return BlockNumber(this.l2Blocks.length);
+        }
+        if ('number' in query) {
+            return query.number;
+        }
+        if ('tag' in query) {
+            return BlockNumber(this.resolveBlockTag(query.tag));
+        }
+        const block = await this.getBlock(query);
+        return block ? block.header.globalVariables.blockNumber : undefined;
     }
-    getCheckpointedBlock(_number) {
-        // In this mock, we don't track checkpointed blocks separately
-        return Promise.resolve(undefined);
+    getProposedCheckpointL2BlockNumber() {
+        return Promise.resolve(BlockNumber(this.proposedCheckpointBlockNumber));
     }
-    /**
-   * Gets an l2 block.
-   * @param number - The block number to return (inclusive).
-   * @returns The requested L2 block.
-   */ getBlock(number) {
-        return Promise.resolve(this.l2Blocks[number - 1]);
+    getCheckpoint(query) {
+        const checkpoint = this.resolveCheckpointQuery(query);
+        if (!checkpoint) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(new PublishedCheckpoint(checkpoint, this.mockL1DataForCheckpoint(checkpoint), []));
     }
-    /**
-   * Gets an L2 block (new format).
-   * @param number - The block number to return.
-   * @returns The requested L2 block.
-   */ getL2BlockNew(number) {
-        const block = this.l2Blocks[number - 1];
-        return Promise.resolve(block?.toL2Block());
+    getCheckpoints(query) {
+        const checkpoints = this.resolveCheckpointsQuery(query);
+        return Promise.resolve(checkpoints.map((checkpoint)=>new PublishedCheckpoint(checkpoint, this.mockL1DataForCheckpoint(checkpoint), [])));
     }
-    /**
-   * 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, proven) {
-        return Promise.resolve(this.l2Blocks.slice(from - 1, from - 1 + limit).filter((b)=>!proven || this.provenBlockNumber === undefined || b.number <= this.provenBlockNumber));
-    }
-    async getPublishedCheckpoints(from, limit) {
-        // TODO: Implement this properly. This only works when we have one block per checkpoint.
-        return (await this.getPublishedBlocks(from, limit)).map((block)=>block.toPublishedCheckpoint());
-    }
-    async getCheckpointByArchive(archive) {
-        // TODO: Implement this properly. This only works when we have one block per checkpoint.
-        return (await this.getPublishedBlockByArchive(archive))?.block.toCheckpoint();
-    }
-    async getPublishedBlocks(from, limit, proven) {
-        const blocks = await this.getBlocks(from, limit, proven);
-        return blocks.map((block)=>PublishedL2Block.fromFields({
-                block,
-                l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
-                attestations: []
-            }));
-    }
-    async getPublishedBlockByHash(blockHash) {
-        for (const block of this.l2Blocks){
-            const hash = await block.hash();
-            if (hash.equals(blockHash)) {
-                return PublishedL2Block.fromFields({
-                    block,
-                    l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
-                    attestations: []
-                });
-            }
-        }
-        return undefined;
+    getCheckpointByArchive(archive) {
+        const checkpoint = this.checkpointList.find((c)=>c.archive.root.equals(archive));
+        return Promise.resolve(checkpoint);
     }
-    getPublishedBlockByArchive(archive) {
-        const block = this.l2Blocks.find((b)=>b.archive.root.equals(archive));
-        if (!block) {
+    getCheckpointData(query) {
+        const checkpoint = this.resolveCheckpointQuery(query);
+        if (!checkpoint) {
             return Promise.resolve(undefined);
         }
-        return Promise.resolve(PublishedL2Block.fromFields({
-            block,
-            l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
-            attestations: []
-        }));
+        return Promise.resolve(this.checkpointToData(checkpoint));
     }
-    async getBlockHeaderByHash(blockHash) {
-        for (const block of this.l2Blocks){
-            const hash = await block.hash();
-            if (hash.equals(blockHash)) {
-                return block.getBlockHeader();
-            }
-        }
-        return undefined;
+    getCheckpointsData(query) {
+        const checkpoints = this.resolveCheckpointsQuery(query);
+        return Promise.resolve(checkpoints.map((c)=>this.checkpointToData(c)));
     }
-    getBlockHeaderByArchive(archive) {
-        const block = this.l2Blocks.find((b)=>b.archive.root.equals(archive));
-        return Promise.resolve(block?.getBlockHeader());
+    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)
+        };
     }
-    getBlockHeader(number) {
-        return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.getBlockHeader());
+    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);
+                }
+        }
     }
-    getCheckpointsForEpoch(epochNumber) {
-        // TODO: Implement this properly. This only works when we have one block per checkpoint.
-        return this.getBlocksForEpoch(epochNumber).then((blocks)=>blocks.map((b)=>b.toCheckpoint()));
+    resolveCheckpointsQuery(query) {
+        if ('from' in query) {
+            return this.checkpointList.slice(query.from - 1, query.from - 1 + query.limit);
+        }
+        return this.getCheckpointsInEpoch(query.epoch);
     }
-    getBlocksForEpoch(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;
-        });
+    getBlocksForSlot(slotNumber) {
+        const blocks = this.l2Blocks.filter((b)=>b.header.globalVariables.slotNumber === slotNumber);
         return Promise.resolve(blocks);
     }
-    async getBlockHeadersForEpoch(epochNumber) {
-        const blocks = await this.getBlocksForEpoch(epochNumber);
-        return blocks.map((b)=>b.getBlockHeader());
-    }
     /**
    * Gets a tx effect.
    * @param txHash - The hash of the tx corresponding to the tx effect.
@@ -180,8 +262,8 @@ import { TxReceipt, TxStatus } from '@aztec/stdlib/tx';
         return {
             data: txEffect,
             l2BlockNumber: block.number,
-            l2BlockHash: L2BlockHash.fromField(await block.hash()),
-            txIndexInBlock: block.body.txEffects.indexOf(txEffect)
+            l2BlockHash: await block.hash(),
+            txIndexInBlock: block.body.txEffects.findIndex((t)=>t.txHash.equals(txHash))
         };
     }
     /**
@@ -192,40 +274,81 @@ import { TxReceipt, TxStatus } from '@aztec/stdlib/tx';
         for (const block of this.l2Blocks){
             for (const txEffect of block.body.txEffects){
                 if (txEffect.txHash.equals(txHash)) {
-                    return new TxReceipt(txHash, TxStatus.SUCCESS, '', txEffect.transactionFee.toBigInt(), L2BlockHash.fromField(await block.hash()), block.number);
+                    // 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, getEpochAtSlot(block.slot, EmptyL1RollupConstants));
                 }
             }
         }
         return undefined;
     }
     async getL2Tips() {
-        const [latest, proven, finalized] = [
+        const [latest, proven, finalized, checkpointed, proposedCheckpoint] = [
             await this.getBlockNumber(),
-            await this.getProvenBlockNumber(),
-            this.finalizedBlockNumber
+            this.provenBlockNumber,
+            this.finalizedBlockNumber,
+            this.checkpointedBlockNumber,
+            await this.getProposedCheckpointL2BlockNumber()
         ];
         const latestBlock = this.l2Blocks[latest - 1];
         const provenBlock = this.l2Blocks[proven - 1];
         const finalizedBlock = this.l2Blocks[finalized - 1];
-        return {
-            latest: {
-                number: BlockNumber(latest),
-                hash: (await latestBlock?.hash())?.toString()
-            },
-            proven: {
-                number: BlockNumber(proven),
-                hash: (await provenBlock?.hash())?.toString()
-            },
-            finalized: {
-                number: BlockNumber(finalized),
-                hash: (await finalizedBlock?.hash())?.toString()
+        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 tipHash(latestBlock, latest)
+        };
+        const provenBlockId = {
+            number: BlockNumber(proven),
+            hash: await tipHash(provenBlock, proven)
+        };
+        const finalizedBlockId = {
+            number: BlockNumber(finalized),
+            hash: await tipHash(finalizedBlock, finalized)
+        };
+        const checkpointedBlockId = {
+            number: BlockNumber(checkpointed),
+            hash: await tipHash(checkpointedBlock, checkpointed)
+        };
+        const 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,
+                    hash
+                }
+            };
+        };
+        return {
+            proposed: latestBlockId,
+            checkpointed: makeTipId(checkpointedBlockId),
+            proven: makeTipId(provenBlockId),
+            finalized: makeTipId(finalizedBlockId),
+            proposedCheckpoint: makeTipId(proposedCheckpointBlockId)
         };
     }
-    getL2EpochNumber() {
+    getSyncedL2EpochNumber() {
         throw new Error('Method not implemented.');
     }
-    getL2SlotNumber() {
+    getSyncedL2SlotNumber() {
         throw new Error('Method not implemented.');
     }
     isEpochComplete(_epochNumber) {
@@ -234,9 +357,12 @@ import { 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() {
@@ -277,6 +403,88 @@ import { 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);
     }
@@ -285,4 +493,21 @@ import { 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;
+    }
 }