@aztec/archiver 0.55.1 → 0.57.0

package/src/archiver/memory_archiver_store/memory_archiver_store.ts

@@ -1,5 +1,4 @@
 import {
-  type Body,
   type EncryptedL2BlockL2Logs,
   type EncryptedNoteL2BlockL2Logs,
   ExtendedUnencryptedL2Log,
@@ -16,18 +15,19 @@ import {
   TxReceipt,
   type UnencryptedL2BlockL2Logs,
 } from '@aztec/circuit-types';
-import { Fr, INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js';
+import { Fr, type Header, INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js';
 import { type ContractArtifact } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import {
   type ContractClassPublic,
+  type ContractClassPublicWithBlockNumber,
   type ContractInstanceWithAddress,
   type ExecutablePrivateFunctionWithMembershipProof,
   type UnconstrainedFunctionWithMembershipProof,
 } from '@aztec/types/contracts';
 
 import { type ArchiverDataStore, type ArchiverL1SynchPoint } from '../archiver_store.js';
-import { type DataRetrieval, type SingletonDataRetrieval } from '../structs/data_retrieval.js';
+import { type DataRetrieval } from '../structs/data_retrieval.js';
 import { type L1Published } from '../structs/published.js';
 import { L1ToL2MessageStore } from './l1_to_l2_message_store.js';
 
@@ -40,33 +40,16 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    */
   private l2Blocks: L1Published<L2Block>[] = [];
 
-  /**
-   * A mapping of body hash to body
-   */
-  private l2BlockBodies: Map<string, Body> = new Map();
-
   /**
    * An array containing all the tx effects in the L2 blocks that have been fetched so far.
    */
   private txEffects: TxEffect[] = [];
 
-  /**
-   * An array containing all the encrypted logs that have been fetched so far.
-   * Note: Index in the "outer" array equals to (corresponding L2 block's number - INITIAL_L2_BLOCK_NUM).
-   */
-  private noteEncryptedLogsPerBlock: EncryptedNoteL2BlockL2Logs[] = [];
+  private noteEncryptedLogsPerBlock: Map<number, EncryptedNoteL2BlockL2Logs> = new Map();
 
-  /**
-   * An array containing all the encrypted logs that have been fetched so far.
-   * Note: Index in the "outer" array equals to (corresponding L2 block's number - INITIAL_L2_BLOCK_NUM).
-   */
-  private encryptedLogsPerBlock: EncryptedL2BlockL2Logs[] = [];
+  private encryptedLogsPerBlock: Map<number, EncryptedL2BlockL2Logs> = new Map();
 
-  /**
-   * An array containing all the unencrypted logs that have been fetched so far.
-   * Note: Index in the "outer" array equals to (corresponding L2 block's number - INITIAL_L2_BLOCK_NUM).
-   */
-  private unencryptedLogsPerBlock: UnencryptedL2BlockL2Logs[] = [];
+  private unencryptedLogsPerBlock: Map<number, UnencryptedL2BlockL2Logs> = new Map();
 
   /**
    * Contains all L1 to L2 messages.
@@ -75,7 +58,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
 
   private contractArtifacts: Map<string, ContractArtifact> = new Map();
 
-  private contractClasses: Map<string, ContractClassPublic> = new Map();
+  private contractClasses: Map<string, ContractClassPublicWithBlockNumber> = new Map();
 
   private privateFunctions: Map<string, ExecutablePrivateFunctionWithMembershipProof[]> = new Map();
 
@@ -84,11 +67,10 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   private contractInstances: Map<string, ContractInstanceWithAddress> = new Map();
 
   private lastL1BlockNewBlocks: bigint | undefined = undefined;
-  private lastL1BlockNewBlockBodies: bigint | undefined = undefined;
   private lastL1BlockNewMessages: bigint | undefined = undefined;
-  private lastL1BlockNewProvenLogs: bigint | undefined = undefined;
 
   private lastProvenL2BlockNumber: number = 0;
+  private lastProvenL2EpochNumber: number = 0;
 
   constructor(
     /** The max number of logs that can be obtained in 1 "getUnencryptedLogs" call. */
@@ -136,9 +118,24 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(true);
   }
 
-  public addContractClasses(data: ContractClassPublic[], _blockNumber: number): Promise<boolean> {
+  public addContractClasses(data: ContractClassPublic[], blockNumber: number): Promise<boolean> {
     for (const contractClass of data) {
-      this.contractClasses.set(contractClass.id.toString(), contractClass);
+      if (!this.contractClasses.has(contractClass.id.toString())) {
+        this.contractClasses.set(contractClass.id.toString(), {
+          ...contractClass,
+          l2BlockNumber: blockNumber,
+        });
+      }
+    }
+    return Promise.resolve(true);
+  }
+
+  public deleteContractClasses(data: ContractClassPublic[], blockNumber: number): Promise<boolean> {
+    for (const contractClass of data) {
+      const restored = this.contractClasses.get(contractClass.id.toString());
+      if (restored && restored.l2BlockNumber >= blockNumber) {
+        this.contractClasses.delete(contractClass.id.toString());
+      }
     }
     return Promise.resolve(true);
   }
@@ -150,6 +147,13 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(true);
   }
 
+  public deleteContractInstances(data: ContractInstanceWithAddress[], _blockNumber: number): Promise<boolean> {
+    for (const contractInstance of data) {
+      this.contractInstances.delete(contractInstance.address.toString());
+    }
+    return Promise.resolve(true);
+  }
+
   /**
    * Append new blocks to the store's list.
    * @param blocks - The L2 blocks to be added to the store and the last processed L1 block.
@@ -163,62 +167,63 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     this.lastL1BlockNewBlocks = blocks[blocks.length - 1].l1.blockNumber;
     this.l2Blocks.push(...blocks);
     this.txEffects.push(...blocks.flatMap(b => b.data.body.txEffects));
+
     return Promise.resolve(true);
   }
 
   /**
-   * Append new block bodies to the store's list.
-   * @param blockBodies - The L2 block bodies to be added to the store.
-   * @returns True if the operation is successful.
+   * Unwinds blocks from the database
+   * @param from -  The tip of the chain, passed for verification purposes,
+   *                ensuring that we don't end up deleting something we did not intend
+   * @param blocksToUnwind - The number of blocks we are to unwind
+   * @returns True if the operation is successful
    */
-  addBlockBodies(blockBodies: DataRetrieval<Body>): Promise<boolean> {
-    for (const body of blockBodies.retrievedData) {
-      void this.l2BlockBodies.set(body.getTxsEffectsHash().toString('hex'), body);
+  public async unwindBlocks(from: number, blocksToUnwind: number): Promise<boolean> {
+    const last = await this.getSynchedL2BlockNumber();
+    if (from != last) {
+      throw new Error(`Can only remove the tip`);
     }
-    this.lastL1BlockNewBlockBodies = blockBodies.lastProcessedL1BlockNumber;
-    return Promise.resolve(true);
-  }
 
-  /**
-   * Gets block bodies that have the same txHashes as we supply.
-   *
-   * @param txsEffectsHashes - A list of txsEffectsHashes (body hashes).
-   * @returns The requested L2 block bodies
-   */
-  getBlockBodies(txsEffectsHashes: Buffer[]): Promise<(Body | undefined)[]> {
-    return Promise.resolve(
-      txsEffectsHashes.map(txsEffectsHash => this.l2BlockBodies.get(txsEffectsHash.toString('hex'))),
-    );
+    const stopAt = from - blocksToUnwind;
+    while ((await this.getSynchedL2BlockNumber()) > stopAt) {
+      const block = this.l2Blocks.pop();
+      if (block == undefined) {
+        break;
+      }
+      block.data.body.txEffects.forEach(() => this.txEffects.pop());
+    }
+
+    return Promise.resolve(true);
   }
 
   /**
    * Append new logs to the store's list.
-   * @param encryptedLogs - The encrypted logs to be added to the store.
-   * @param unencryptedLogs - The unencrypted logs to be added to the store.
-   * @param blockNumber - The block for which to add the logs.
+   * @param block - The block for which to add the logs.
    * @returns True if the operation is successful.
    */
-  addLogs(
-    noteEncryptedLogs: EncryptedNoteL2BlockL2Logs,
-    encryptedLogs: EncryptedL2BlockL2Logs,
-    unencryptedLogs: UnencryptedL2BlockL2Logs,
-    blockNumber: number,
-  ): Promise<boolean> {
-    if (noteEncryptedLogs) {
-      this.noteEncryptedLogsPerBlock[blockNumber - INITIAL_L2_BLOCK_NUM] = noteEncryptedLogs;
-    }
-
-    if (encryptedLogs) {
-      this.encryptedLogsPerBlock[blockNumber - INITIAL_L2_BLOCK_NUM] = encryptedLogs;
-    }
+  addLogs(blocks: L2Block[]): Promise<boolean> {
+    blocks.forEach(block => {
+      this.noteEncryptedLogsPerBlock.set(block.number, block.body.noteEncryptedLogs);
+      this.encryptedLogsPerBlock.set(block.number, block.body.encryptedLogs);
+      this.unencryptedLogsPerBlock.set(block.number, block.body.unencryptedLogs);
+    });
+    return Promise.resolve(true);
+  }
 
-    if (unencryptedLogs) {
-      this.unencryptedLogsPerBlock[blockNumber - INITIAL_L2_BLOCK_NUM] = unencryptedLogs;
-    }
+  deleteLogs(blocks: L2Block[]): Promise<boolean> {
+    blocks.forEach(block => {
+      this.encryptedLogsPerBlock.delete(block.number);
+      this.noteEncryptedLogsPerBlock.delete(block.number);
+      this.unencryptedLogsPerBlock.delete(block.number);
+    });
 
     return Promise.resolve(true);
   }
 
+  getTotalL1ToL2MessageCount(): Promise<bigint> {
+    return Promise.resolve(this.l1ToL2Messages.getTotalL1ToL2MessageCount());
+  }
+
   /**
    * Append L1 to L2 messages to the store.
    * @param messages - The L1 to L2 messages to be added to the store and the last processed L1 block.
@@ -257,12 +262,15 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * @remarks When "from" is smaller than genesis block number, blocks from the beginning are returned.
    */
   public getBlocks(from: number, limit: number): Promise<L1Published<L2Block>[]> {
-    // Return an empty array if we are outside of range
     if (limit < 1) {
       return Promise.reject(new Error(`Invalid limit: ${limit}`));
     }
 
-    const fromIndex = Math.max(from - INITIAL_L2_BLOCK_NUM, 0);
+    if (from < INITIAL_L2_BLOCK_NUM) {
+      return Promise.reject(new Error(`Invalid start: ${from}`));
+    }
+
+    const fromIndex = from - INITIAL_L2_BLOCK_NUM;
     if (fromIndex >= this.l2Blocks.length) {
       return Promise.resolve([]);
     }
@@ -271,6 +279,11 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(this.l2Blocks.slice(fromIndex, toIndex));
   }
 
+  public async getBlockHeaders(from: number, limit: number): Promise<Header[]> {
+    const blocks = await this.getBlocks(from, limit);
+    return blocks.map(block => block.data.header);
+  }
+
   /**
    * Gets a tx effect.
    * @param txHash - The txHash of the tx effect.
@@ -328,9 +341,14 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     logType: TLogType,
   ): Promise<L2BlockL2Logs<FromLogType<TLogType>>[]> {
     if (from < INITIAL_L2_BLOCK_NUM || limit < 1) {
-      throw new Error(`Invalid limit: ${limit}`);
+      return Promise.resolve([]);
     }
-    const logs = (() => {
+
+    if (from > this.l2Blocks.length) {
+      return Promise.resolve([]);
+    }
+
+    const logMap = (() => {
       switch (logType) {
         case LogType.ENCRYPTED:
           return this.encryptedLogsPerBlock;
@@ -340,14 +358,24 @@ export class MemoryArchiverStore implements ArchiverDataStore {
         default:
           return this.unencryptedLogsPerBlock;
       }
-    })() as L2BlockL2Logs<FromLogType<TLogType>>[];
+    })() as Map<number, L2BlockL2Logs<FromLogType<TLogType>>>;
 
-    if (from > logs.length) {
-      return Promise.resolve([]);
-    }
-    const startIndex = from - INITIAL_L2_BLOCK_NUM;
+    const startIndex = from;
     const endIndex = startIndex + limit;
-    return Promise.resolve(logs.slice(startIndex, endIndex));
+    const upper = Math.min(endIndex, this.l2Blocks.length + INITIAL_L2_BLOCK_NUM);
+
+    const l = [];
+    for (let i = startIndex; i < upper; i++) {
+      const log = logMap.get(i);
+      if (log) {
+        l.push(log);
+      } else {
+        // I hate typescript sometimes
+        l.push(undefined as unknown as L2BlockL2Logs<FromLogType<TLogType>>);
+      }
+    }
+
+    return Promise.resolve(l);
   }
 
   /**
@@ -358,37 +386,37 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    */
   getUnencryptedLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
     let txHash: TxHash | undefined;
-    let fromBlockIndex = 0;
-    let toBlockIndex = this.unencryptedLogsPerBlock.length;
+    let fromBlock = 0;
+    let toBlock = this.l2Blocks.length + INITIAL_L2_BLOCK_NUM;
     let txIndexInBlock = 0;
     let logIndexInTx = 0;
 
     if (filter.afterLog) {
       // Continuation parameter is set --> tx hash is ignored
       if (filter.fromBlock == undefined || filter.fromBlock <= filter.afterLog.blockNumber) {
-        fromBlockIndex = filter.afterLog.blockNumber - INITIAL_L2_BLOCK_NUM;
+        fromBlock = filter.afterLog.blockNumber;
         txIndexInBlock = filter.afterLog.txIndex;
         logIndexInTx = filter.afterLog.logIndex + 1; // We want to start from the next log
       } else {
-        fromBlockIndex = filter.fromBlock - INITIAL_L2_BLOCK_NUM;
+        fromBlock = filter.fromBlock;
       }
     } else {
       txHash = filter.txHash;
 
       if (filter.fromBlock !== undefined) {
-        fromBlockIndex = filter.fromBlock - INITIAL_L2_BLOCK_NUM;
+        fromBlock = filter.fromBlock;
       }
     }
 
     if (filter.toBlock !== undefined) {
-      toBlockIndex = filter.toBlock - INITIAL_L2_BLOCK_NUM;
+      toBlock = filter.toBlock;
     }
 
     // Ensure the indices are within block array bounds
-    fromBlockIndex = Math.max(fromBlockIndex, 0);
-    toBlockIndex = Math.min(toBlockIndex, this.unencryptedLogsPerBlock.length);
+    fromBlock = Math.max(fromBlock, INITIAL_L2_BLOCK_NUM);
+    toBlock = Math.min(toBlock, this.l2Blocks.length + INITIAL_L2_BLOCK_NUM);
 
-    if (fromBlockIndex > this.unencryptedLogsPerBlock.length || toBlockIndex < fromBlockIndex || toBlockIndex <= 0) {
+    if (fromBlock > this.l2Blocks.length || toBlock < fromBlock || toBlock <= 0) {
       return Promise.resolve({
         logs: [],
         maxLogsHit: false,
@@ -399,27 +427,30 @@ export class MemoryArchiverStore implements ArchiverDataStore {
 
     const logs: ExtendedUnencryptedL2Log[] = [];
 
-    for (; fromBlockIndex < toBlockIndex; fromBlockIndex++) {
-      const block = this.l2Blocks[fromBlockIndex];
-      const blockLogs = this.unencryptedLogsPerBlock[fromBlockIndex];
-      for (; txIndexInBlock < blockLogs.txLogs.length; txIndexInBlock++) {
-        const txLogs = blockLogs.txLogs[txIndexInBlock].unrollLogs();
-        for (; logIndexInTx < txLogs.length; logIndexInTx++) {
-          const log = txLogs[logIndexInTx];
-          if (
-            (!txHash || block.data.body.txEffects[txIndexInBlock].txHash.equals(txHash)) &&
-            (!contractAddress || log.contractAddress.equals(contractAddress))
-          ) {
-            logs.push(new ExtendedUnencryptedL2Log(new LogId(block.data.number, txIndexInBlock, logIndexInTx), log));
-            if (logs.length === this.maxLogs) {
-              return Promise.resolve({
-                logs,
-                maxLogsHit: true,
-              });
+    for (; fromBlock < toBlock; fromBlock++) {
+      const block = this.l2Blocks[fromBlock - INITIAL_L2_BLOCK_NUM];
+      const blockLogs = this.unencryptedLogsPerBlock.get(fromBlock);
+
+      if (blockLogs) {
+        for (; txIndexInBlock < blockLogs.txLogs.length; txIndexInBlock++) {
+          const txLogs = blockLogs.txLogs[txIndexInBlock].unrollLogs();
+          for (; logIndexInTx < txLogs.length; logIndexInTx++) {
+            const log = txLogs[logIndexInTx];
+            if (
+              (!txHash || block.data.body.txEffects[txIndexInBlock].txHash.equals(txHash)) &&
+              (!contractAddress || log.contractAddress.equals(contractAddress))
+            ) {
+              logs.push(new ExtendedUnencryptedL2Log(new LogId(block.data.number, txIndexInBlock, logIndexInTx), log));
+              if (logs.length === this.maxLogs) {
+                return Promise.resolve({
+                  logs,
+                  maxLogsHit: true,
+                });
+              }
             }
           }
+          logIndexInTx = 0;
         }
-        logIndexInTx = 0;
       }
       txIndexInBlock = 0;
     }
@@ -445,9 +476,27 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(this.lastProvenL2BlockNumber);
   }
 
-  public setProvenL2BlockNumber(l2BlockNumber: SingletonDataRetrieval<number>): Promise<void> {
-    this.lastProvenL2BlockNumber = l2BlockNumber.retrievedData;
-    this.lastL1BlockNewProvenLogs = l2BlockNumber.lastProcessedL1BlockNumber;
+  public getProvenL2EpochNumber(): Promise<number | undefined> {
+    return Promise.resolve(this.lastProvenL2EpochNumber);
+  }
+
+  public setProvenL2BlockNumber(l2BlockNumber: number): Promise<void> {
+    this.lastProvenL2BlockNumber = l2BlockNumber;
+    return Promise.resolve();
+  }
+
+  public setProvenL2EpochNumber(l2EpochNumber: number): Promise<void> {
+    this.lastProvenL2EpochNumber = l2EpochNumber;
+    return Promise.resolve();
+  }
+
+  setBlockSynchedL1BlockNumber(l1BlockNumber: bigint) {
+    this.lastL1BlockNewBlocks = l1BlockNumber;
+    return Promise.resolve();
+  }
+
+  setMessageSynchedL1BlockNumber(l1BlockNumber: bigint) {
+    this.lastL1BlockNewMessages = l1BlockNumber;
     return Promise.resolve();
   }
 
@@ -455,8 +504,6 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve({
       blocksSynchedTo: this.lastL1BlockNewBlocks,
       messagesSynchedTo: this.lastL1BlockNewMessages,
-      blockBodiesSynchedTo: this.lastL1BlockNewBlockBodies,
-      provenLogsSynchedTo: this.lastL1BlockNewProvenLogs,
     });
   }
 

package/src/index.ts

@@ -15,8 +15,6 @@ export * from './factory.js';
 
 export { retrieveL2ProofVerifiedEvents, retrieveBlockFromRollup } from './archiver/data_retrieval.js';
 
-export { getL2BlockProposedLogs } from './archiver/eth_log_handlers.js';
-
 const log = createDebugLogger('aztec:archiver');
 
 /**
@@ -27,6 +25,7 @@ async function main() {
   const config = getArchiverConfigFromEnv();
   const { l1RpcUrl: rpcUrl, l1Contracts } = config;
 
+  log.info(`Starting archiver in main(): ${JSON.stringify(config)}`);
   const publicClient = createPublicClient({
     chain: localhost,
     transport: http(rpcUrl),

package/src/test/index.ts

@@ -0,0 +1 @@
+export * from './mock_l2_block_source.js';

package/src/test/mock_l2_block_source.ts

@@ -0,0 +1,165 @@
+import { L2Block, type L2BlockSource, type TxEffect, type TxHash, TxReceipt, TxStatus } from '@aztec/circuit-types';
+import { EthAddress, type Header } from '@aztec/circuits.js';
+
+import { getSlotRangeForEpoch } from '../archiver/epoch_helpers.js';
+
+/**
+ * A mocked implementation of L2BlockSource to be used in p2p tests.
+ */
+export class MockBlockSource implements L2BlockSource {
+  private l2Blocks: L2Block[] = [];
+  private txEffects: TxEffect[] = [];
+  private provenEpochNumber: number = 0;
+
+  constructor(numBlocks = 100, private provenBlockNumber?: number) {
+    this.addBlocks(numBlocks);
+  }
+
+  public addBlocks(numBlocks: number) {
+    for (let i = 0; i < numBlocks; i++) {
+      const blockNum = this.l2Blocks.length;
+      const block = L2Block.random(blockNum, blockNum);
+      this.l2Blocks.push(block);
+      this.txEffects.push(...block.body.txEffects);
+    }
+  }
+
+  public setProvenBlockNumber(provenBlockNumber: number) {
+    this.provenBlockNumber = provenBlockNumber;
+  }
+
+  public setProvenEpochNumber(provenEpochNumber: number) {
+    this.provenEpochNumber = provenEpochNumber;
+  }
+
+  /**
+   * Method to fetch the rollup contract address at the base-layer.
+   * @returns The rollup address.
+   */
+  getRollupAddress(): Promise<EthAddress> {
+    return Promise.resolve(EthAddress.random());
+  }
+
+  /**
+   * Method to fetch the registry contract address at the base-layer.
+   * @returns The registry address.
+   */
+  getRegistryAddress(): Promise<EthAddress> {
+    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.
+   */
+  public getBlockNumber() {
+    return Promise.resolve(this.l2Blocks.length - 1);
+  }
+
+  public async getProvenBlockNumber(): Promise<number> {
+    return this.provenBlockNumber ?? (await this.getBlockNumber());
+  }
+
+  public getProvenL2EpochNumber(): Promise<number | undefined> {
+    return Promise.resolve(this.provenEpochNumber);
+  }
+
+  /**
+   * Gets an l2 block.
+   * @param number - The block number to return (inclusive).
+   * @returns The requested L2 block.
+   */
+  public getBlock(number: number) {
+    return Promise.resolve(this.l2Blocks[number]);
+  }
+
+  /**
+   * 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.
+   */
+  public getBlocks(from: number, limit: number, proven?: boolean) {
+    return Promise.resolve(
+      this.l2Blocks
+        .slice(from, from + limit)
+        .filter(b => !proven || this.provenBlockNumber === undefined || b.number <= this.provenBlockNumber),
+    );
+  }
+
+  getBlockHeader(number: number | 'latest'): Promise<Header | undefined> {
+    return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number : -1)?.header);
+  }
+
+  getBlocksForEpoch(epochNumber: bigint): Promise<L2Block[]> {
+    const [start, end] = getSlotRangeForEpoch(epochNumber);
+    const blocks = this.l2Blocks.filter(b => {
+      const slot = b.header.globalVariables.slotNumber.toBigInt();
+      return slot >= start && slot <= end;
+    });
+    return Promise.resolve(blocks);
+  }
+
+  /**
+   * Gets a tx effect.
+   * @param txHash - The hash of a transaction which resulted in the returned tx effect.
+   * @returns The requested tx effect.
+   */
+  public getTxEffect(txHash: TxHash) {
+    const txEffect = this.txEffects.find(tx => tx.txHash.equals(txHash));
+    return Promise.resolve(txEffect);
+  }
+
+  /**
+   * 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).
+   */
+  public getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
+    for (const block of this.l2Blocks) {
+      for (const txEffect of block.body.txEffects) {
+        if (txEffect.txHash.equals(txHash)) {
+          return Promise.resolve(
+            new TxReceipt(
+              txHash,
+              TxStatus.SUCCESS,
+              '',
+              txEffect.transactionFee.toBigInt(),
+              block.hash().toBuffer(),
+              block.number,
+            ),
+          );
+        }
+      }
+    }
+    return Promise.resolve(undefined);
+  }
+
+  getL2EpochNumber(): Promise<bigint> {
+    throw new Error('Method not implemented.');
+  }
+
+  getL2SlotNumber(): Promise<bigint> {
+    throw new Error('Method not implemented.');
+  }
+
+  isEpochComplete(_epochNumber: bigint): Promise<boolean> {
+    throw new Error('Method not implemented.');
+  }
+
+  /**
+   * Starts the block source. In this mock implementation, this is a noop.
+   * @returns A promise that signals the initialization of the l2 block source on completion.
+   */
+  public start(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  /**
+   * Stops the block source. In this mock implementation, this is a noop.
+   * @returns A promise that signals the l2 block source is now stopped.
+   */
+  public stop(): Promise<void> {
+    return Promise.resolve();
+  }
+}