@aztec/archiver 0.72.1 → 0.74.0

package/src/archiver/archiver_store_test_suite.ts

@@ -30,7 +30,10 @@ import { type L1Published } from './structs/published.js';
  * @param testName - The name of the test suite.
  * @param getStore - Returns an instance of a store that's already been initialized.
  */
-export function describeArchiverDataStore(testName: string, getStore: () => ArchiverDataStore) {
+export function describeArchiverDataStore(
+  testName: string,
+  getStore: () => ArchiverDataStore | Promise<ArchiverDataStore>,
+) {
   describe(testName, () => {
     let store: ArchiverDataStore;
     let blocks: L1Published<L2Block>[];
@@ -52,7 +55,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
     });
 
     beforeEach(async () => {
-      store = getStore();
+      store = await getStore();
       blocks = await timesParallel(10, async i => makeL1Published(await L2Block.random(i + 1), i + 10));
     });
 
@@ -209,7 +212,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         () => wrapInBlock(blocks[5].data.body.txEffects[2], blocks[5].data),
         () => wrapInBlock(blocks[1].data.body.txEffects[0], blocks[1].data),
       ])('retrieves a previously stored transaction', async getExpectedTx => {
-        const expectedTx = getExpectedTx();
+        const expectedTx = await getExpectedTx();
         const actualTx = await store.getTxEffect(expectedTx.data.txHash);
         expect(actualTx).toEqual(expectedTx);
       });
@@ -227,7 +230,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       ])('tries to retrieves a previously stored transaction after deleted', async getExpectedTx => {
         await store.unwindBlocks(blocks.length, blocks.length);
 
-        const expectedTx = getExpectedTx();
+        const expectedTx = await getExpectedTx();
         const actualTx = await store.getTxEffect(expectedTx.data.txHash);
         expect(actualTx).toEqual(undefined);
       });
@@ -300,10 +303,10 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       const blockNum = 10;
 
       beforeEach(async () => {
-        contractClass = makeContractClassPublic();
+        contractClass = await makeContractClassPublic();
         await store.addContractClasses(
           [contractClass],
-          [computePublicBytecodeCommitment(contractClass.packedBytecode)],
+          [await computePublicBytecodeCommitment(contractClass.packedBytecode)],
           blockNum,
         );
       });
@@ -320,7 +323,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       it('returns contract class if later "deployment" class was deleted', async () => {
         await store.addContractClasses(
           [contractClass],
-          [computePublicBytecodeCommitment(contractClass.packedBytecode)],
+          [await computePublicBytecodeCommitment(contractClass.packedBytecode)],
           blockNum + 1,
         );
         await store.deleteContractClasses([contractClass], blockNum + 1);
@@ -374,11 +377,11 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         new Fr((blockNumber * 100 + txIndex * 10 + logIndex) * (isPublic ? 123 : 1));
 
       // See parseLogFromPublic
-      const makeLengthsField = (publicValuesLen: number, privateValuesLen: number, ciphertextLen: number) => {
+      // Search the codebase for "disgusting encoding" to see other hardcoded instances of this encoding, that you might need to change if you ever find yourself here.
+      const makeLengthsField = (publicValuesLen: number, privateValuesLen: number) => {
         const buf = Buffer.alloc(32);
-        buf.writeUint16BE(publicValuesLen, 24);
-        buf.writeUint16BE(privateValuesLen, 27);
-        buf.writeUint16BE(ciphertextLen, 30);
+        buf.writeUint16BE(publicValuesLen, 27);
+        buf.writeUint16BE(privateValuesLen, 30);
         return Fr.fromBuffer(buf);
       };
 
@@ -390,7 +393,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       const makePublicLog = (tag: Fr) =>
         PublicLog.fromFields([
           AztecAddress.fromNumber(1).toField(), // log address
-          makeLengthsField(2, PUBLIC_LOG_DATA_SIZE_IN_FIELDS - 3, 42), // field 0
+          makeLengthsField(2, PUBLIC_LOG_DATA_SIZE_IN_FIELDS - 3), // field 0
           tag, // field 1
           ...times(PUBLIC_LOG_DATA_SIZE_IN_FIELDS - 1, i => new Fr(tag.toNumber() + i)), // fields 2 to end
         ]);
@@ -532,13 +535,13 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         const invalidLogs = [
           PublicLog.fromFields([
             AztecAddress.fromNumber(1).toField(),
-            makeLengthsField(2, 3, 42), // This field claims we have 5 items, but we actually have more
+            makeLengthsField(2, 3), // This field claims we have 5 items, but we actually have more
             tag,
             ...times(PUBLIC_LOG_DATA_SIZE_IN_FIELDS - 1, i => new Fr(tag.toNumber() + i)),
           ]),
           PublicLog.fromFields([
             AztecAddress.fromNumber(1).toField(),
-            makeLengthsField(2, PUBLIC_LOG_DATA_SIZE_IN_FIELDS, 42), // This field claims we have more than the max items
+            makeLengthsField(2, PUBLIC_LOG_DATA_SIZE_IN_FIELDS), // This field claims we have more than the max items
             tag,
             ...times(PUBLIC_LOG_DATA_SIZE_IN_FIELDS - 1, i => new Fr(tag.toNumber() + i)),
           ]),

package/src/archiver/config.ts

@@ -22,7 +22,7 @@ export type ArchiverConfig = {
   archiverUrl?: string;
 
   /** URL for an L1 consensus client */
-  l1ConsensusClientUrl: string;
+  l1ConsensusHostUrl?: string;
 
   /** The polling interval in ms for retrieving new L2 blocks and encrypted logs. */
   archiverPollingIntervalMS?: number;
@@ -47,10 +47,10 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
     description:
       'URL for an archiver service. If set, will return an archiver client as opposed to starting a new one.',
   },
-  l1ConsensusClientUrl: {
-    env: 'L1_CONSENSUS_CLIENT_URL',
+  l1ConsensusHostUrl: {
+    env: 'L1_CONSENSUS_HOST_URL',
     description: 'URL for an L1 consensus client.',
-    parseEnv: (val: string) => (val ? val : 'http://localhost:5052'),
+    parseEnv: (val: string) => val,
   },
   archiverPollingIntervalMS: {
     env: 'ARCHIVER_POLLING_INTERVAL_MS',

package/src/archiver/data_retrieval.ts

@@ -1,12 +1,13 @@
+import { type BlobSinkClientInterface } from '@aztec/blob-sink/client';
 import { Body, InboxLeaf, L2Block } from '@aztec/circuit-types';
 import { AppendOnlyTreeSnapshot, BlockHeader, Fr, Proof } from '@aztec/circuits.js';
 import { asyncPool } from '@aztec/foundation/async-pool';
-import { Blob } from '@aztec/foundation/blob';
+import { Blob, BlobDeserializationError } from '@aztec/foundation/blob';
 import { type EthAddress } from '@aztec/foundation/eth-address';
 import { type ViemSignature } from '@aztec/foundation/eth-signature';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { numToUInt32BE } from '@aztec/foundation/serialize';
-import { type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
+import { ForwarderAbi, type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
 
 import {
   type Chain,
@@ -20,6 +21,7 @@ import {
   hexToBytes,
 } from 'viem';
 
+import { NoBlobBodiesFoundError } from './errors.js';
 import { type DataRetrieval } from './structs/data_retrieval.js';
 import { type L1Published, type L1PublishedData } from './structs/published.js';
 
@@ -35,6 +37,7 @@ import { type L1Published, type L1PublishedData } from './structs/published.js';
 export async function retrieveBlocksFromRollup(
   rollup: GetContractReturnType<typeof RollupAbi, PublicClient<HttpTransport, Chain>>,
   publicClient: PublicClient,
+  blobSinkClient: BlobSinkClientInterface,
   searchStartBlock: bigint,
   searchEndBlock: bigint,
   logger: Logger = createLogger('archiver'),
@@ -63,7 +66,13 @@ export async function retrieveBlocksFromRollup(
       `Got ${l2BlockProposedLogs.length} L2 block processed logs for L2 blocks ${l2BlockProposedLogs[0].args.blockNumber}-${lastLog.args.blockNumber} between L1 blocks ${searchStartBlock}-${searchEndBlock}`,
     );
 
-    const newBlocks = await processL2BlockProposedLogs(rollup, publicClient, l2BlockProposedLogs, logger);
+    const newBlocks = await processL2BlockProposedLogs(
+      rollup,
+      publicClient,
+      blobSinkClient,
+      l2BlockProposedLogs,
+      logger,
+    );
     retrievedBlocks.push(...newBlocks);
     searchStartBlock = lastLog.blockNumber! + 1n;
   } while (searchStartBlock <= searchEndBlock);
@@ -80,6 +89,7 @@ export async function retrieveBlocksFromRollup(
 export async function processL2BlockProposedLogs(
   rollup: GetContractReturnType<typeof RollupAbi, PublicClient<HttpTransport, Chain>>,
   publicClient: PublicClient,
+  blobSinkClient: BlobSinkClientInterface,
   logs: GetContractEventsReturnType<typeof RollupAbi, 'L2BlockProposed'>,
   logger: Logger,
 ): Promise<L1Published<L2Block>[]> {
@@ -88,10 +98,19 @@ export async function processL2BlockProposedLogs(
     const l2BlockNumber = log.args.blockNumber!;
     const archive = log.args.archive!;
     const archiveFromChain = await rollup.read.archiveAt([l2BlockNumber]);
+    const blobHashes = log.args.versionedBlobHashes!.map(blobHash => Buffer.from(blobHash.slice(2), 'hex'));
 
     // The value from the event and contract will match only if the block is in the chain.
     if (archive === archiveFromChain) {
-      const block = await getBlockFromRollupTx(publicClient, log.transactionHash!, l2BlockNumber);
+      const block = await getBlockFromRollupTx(
+        publicClient,
+        blobSinkClient,
+        log.transactionHash!,
+        blobHashes,
+        l2BlockNumber,
+        rollup.address,
+        logger,
+      );
 
       const l1: L1PublishedData = {
         blockNumber: log.blockNumber,
@@ -116,6 +135,57 @@ export async function getL1BlockTime(publicClient: PublicClient, blockNumber: bi
   return block.timestamp;
 }
 
+/**
+ * Extracts the first 'propose' method calldata from a forwarder transaction's data.
+ * @param forwarderData - The forwarder transaction input data
+ * @param rollupAddress - The address of the rollup contract
+ * @returns The calldata for the first 'propose' method call to the rollup contract
+ */
+function extractRollupProposeCalldata(forwarderData: Hex, rollupAddress: Hex): Hex {
+  // TODO(#11451): custom forwarders
+  const { functionName: forwarderFunctionName, args: forwarderArgs } = decodeFunctionData({
+    abi: ForwarderAbi,
+    data: forwarderData,
+  });
+
+  if (forwarderFunctionName !== 'forward') {
+    throw new Error(`Unexpected forwarder method called ${forwarderFunctionName}`);
+  }
+
+  if (forwarderArgs.length !== 2) {
+    throw new Error(`Unexpected number of arguments for forwarder`);
+  }
+
+  const [to, data] = forwarderArgs;
+
+  // Find all rollup calls
+  const rollupAddressLower = rollupAddress.toLowerCase();
+
+  for (let i = 0; i < to.length; i++) {
+    const addr = to[i];
+    if (addr.toLowerCase() !== rollupAddressLower) {
+      continue;
+    }
+    const callData = data[i];
+
+    try {
+      const { functionName: rollupFunctionName } = decodeFunctionData({
+        abi: RollupAbi,
+        data: callData,
+      });
+
+      if (rollupFunctionName === 'propose') {
+        return callData;
+      }
+    } catch (err) {
+      // Skip invalid function data
+      continue;
+    }
+  }
+
+  throw new Error(`Rollup address not found in forwarder args`);
+}
+
 /**
  * Gets block from the calldata of an L1 transaction.
  * Assumes that the block was published from an EOA.
@@ -127,19 +197,27 @@ export async function getL1BlockTime(publicClient: PublicClient, blockNumber: bi
  */
 async function getBlockFromRollupTx(
   publicClient: PublicClient,
+  blobSinkClient: BlobSinkClientInterface,
   txHash: `0x${string}`,
+  blobHashes: Buffer[], // WORKTODO(md): buffer32?
   l2BlockNum: bigint,
+  rollupAddress: Hex,
+  logger: Logger,
 ): Promise<L2Block> {
-  const { input: data } = await publicClient.getTransaction({ hash: txHash });
-  const { functionName, args } = decodeFunctionData({ abi: RollupAbi, data });
+  const { input: forwarderData, blockHash } = await publicClient.getTransaction({ hash: txHash });
 
-  const allowedMethods = ['propose', 'proposeAndClaim'];
+  const rollupData = extractRollupProposeCalldata(forwarderData, rollupAddress);
+  const { functionName: rollupFunctionName, args: rollupArgs } = decodeFunctionData({
+    abi: RollupAbi,
+    data: rollupData,
+  });
 
-  if (!allowedMethods.includes(functionName)) {
-    throw new Error(`Unexpected method called ${functionName}`);
+  if (rollupFunctionName !== 'propose') {
+    throw new Error(`Unexpected rollup method called ${rollupFunctionName}`);
   }
+
   // TODO(#9101): 'bodyHex' will be removed from below
-  const [decodedArgs, , bodyHex, blobInputs] = args! as readonly [
+  const [decodedArgs, , bodyHex, blobInputs] = rollupArgs! as readonly [
     {
       header: Hex;
       archive: Hex;
@@ -156,12 +234,30 @@ async function getBlockFromRollupTx(
   ];
 
   const header = BlockHeader.fromBuffer(Buffer.from(hexToBytes(decodedArgs.header)));
+  const blobBodies = await blobSinkClient.getBlobSidecar(blockHash, blobHashes);
+  if (blobBodies.length === 0) {
+    throw new NoBlobBodiesFoundError(Number(l2BlockNum));
+  }
+
+  // TODO(#9101): Once calldata is removed, we can remove this field encoding and update
+  // Body.fromBlobFields to accept blob buffers directly
+  let blockFields: Fr[];
+  try {
+    blockFields = blobBodies.flatMap(b => b.toEncodedFields());
+  } catch (err: any) {
+    if (err instanceof BlobDeserializationError) {
+      logger.fatal(err.message);
+    } else {
+      logger.fatal('Unable to sync: failed to decode fetched blob, this blob was likely not created by us');
+    }
+    throw err;
+  }
+
   // TODO(#9101): Retreiving the block body from calldata is a temporary soln before we have
   // either a beacon chain client or link to some blob store. Web2 is ok because we will
   // verify the block body vs the blob as below.
   const blockBody = Body.fromBuffer(Buffer.from(hexToBytes(bodyHex)));
 
-  const blockFields = blockBody.toBlobFields();
   // TODO(#9101): The below reconstruction is currently redundant, but once we extract blobs will be the way to construct blocks.
   // The blob source will give us blockFields, and we must construct the body from them:
   // TODO(#8954): When logs are refactored into fields, we won't need to inject them here.
@@ -173,7 +269,7 @@ async function getBlockFromRollupTx(
   }
 
   // TODO(#9101): Once we stop publishing calldata, we will still need the blobCheck below to ensure that the block we are building does correspond to the blob fields
-  const blobCheck = Blob.getBlobs(blockFields);
+  const blobCheck = await Blob.getBlobs(blockFields);
   if (Blob.getEthBlobEvaluationInputs(blobCheck) !== blobInputs) {
     // NB: We can just check the blobhash here, which is the first 32 bytes of blobInputs
     // A mismatch means that the fields published in the blob in propose() do NOT match those in the extracted block.

package/src/archiver/errors.ts

@@ -0,0 +1,5 @@
+export class NoBlobBodiesFoundError extends Error {
+  constructor(l2BlockNum: number) {
+    super(`No blob bodies found for block ${l2BlockNum}`);
+  }
+}

package/src/archiver/kv_archiver_store/block_store.ts

@@ -1,7 +1,8 @@
 import { Body, type InBlock, L2Block, L2BlockHash, type TxEffect, type TxHash, TxReceipt } from '@aztec/circuit-types';
 import { AppendOnlyTreeSnapshot, type AztecAddress, BlockHeader, INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js';
+import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
-import { type AztecKVStore, type AztecMap, type AztecSingleton, type Range } from '@aztec/kv-store';
+import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncSingleton, Range } from '@aztec/kv-store';
 
 import { type L1Published, type L1PublishedData } from '../structs/published.js';
 
@@ -18,29 +19,29 @@ type BlockStorage = {
  */
 export class BlockStore {
   /** Map block number to block data */
-  #blocks: AztecMap<number, BlockStorage>;
+  #blocks: AztecAsyncMap<number, BlockStorage>;
 
   /** Map block hash to block body */
-  #blockBodies: AztecMap<string, Buffer>;
+  #blockBodies: AztecAsyncMap<string, Buffer>;
 
   /** Stores L1 block number in which the last processed L2 block was included */
-  #lastSynchedL1Block: AztecSingleton<bigint>;
+  #lastSynchedL1Block: AztecAsyncSingleton<bigint>;
 
   /** Stores l2 block number of the last proven block */
-  #lastProvenL2Block: AztecSingleton<number>;
+  #lastProvenL2Block: AztecAsyncSingleton<number>;
 
   /** Stores l2 epoch number of the last proven epoch */
-  #lastProvenL2Epoch: AztecSingleton<number>;
+  #lastProvenL2Epoch: AztecAsyncSingleton<number>;
 
   /** Index mapping transaction hash (as a string) to its location in a block */
-  #txIndex: AztecMap<string, BlockIndexValue>;
+  #txIndex: AztecAsyncMap<string, BlockIndexValue>;
 
   /** Index mapping a contract's address (as a string) to its location in a block */
-  #contractIndex: AztecMap<string, BlockIndexValue>;
+  #contractIndex: AztecAsyncMap<string, BlockIndexValue>;
 
   #log = createLogger('archiver:block_store');
 
-  constructor(private db: AztecKVStore) {
+  constructor(private db: AztecAsyncKVStore) {
     this.#blocks = db.openMap('archiver_blocks');
     this.#blockBodies = db.openMap('archiver_block_bodies');
     this.#txIndex = db.openMap('archiver_tx_index');
@@ -55,28 +56,28 @@ export class BlockStore {
    * @param blocks - The L2 blocks to be added to the store.
    * @returns True if the operation is successful.
    */
-  addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean> {
+  async addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean> {
     if (blocks.length === 0) {
-      return Promise.resolve(true);
+      return true;
     }
 
-    return this.db.transaction(() => {
+    return await this.db.transactionAsync(async () => {
       for (const block of blocks) {
-        void this.#blocks.set(block.data.number, {
+        await this.#blocks.set(block.data.number, {
           header: block.data.header.toBuffer(),
           archive: block.data.archive.toBuffer(),
           l1: block.l1,
         });
 
-        block.data.body.txEffects.forEach((tx, i) => {
-          void this.#txIndex.set(tx.txHash.toString(), [block.data.number, i]);
-        });
+        for (let i = 0; i < block.data.body.txEffects.length; i++) {
+          const txEffect = block.data.body.txEffects[i];
+          await this.#txIndex.set(txEffect.txHash.toString(), [block.data.number, i]);
+        }
 
-        void this.#blockBodies.set(block.data.hash().toString(), block.data.body.toBuffer());
+        await this.#blockBodies.set((await block.data.hash()).toString(), block.data.body.toBuffer());
       }
 
-      void this.#lastSynchedL1Block.set(blocks[blocks.length - 1].l1.blockNumber);
-
+      await this.#lastSynchedL1Block.set(blocks[blocks.length - 1].l1.blockNumber);
       return true;
     });
   }
@@ -88,26 +89,24 @@ export class BlockStore {
    * @param blocksToUnwind - The number of blocks we are to unwind
    * @returns True if the operation is successful
    */
-  unwindBlocks(from: number, blocksToUnwind: number) {
-    return this.db.transaction(() => {
-      const last = this.getSynchedL2BlockNumber();
-      if (from != last) {
+  async unwindBlocks(from: number, blocksToUnwind: number) {
+    return await this.db.transactionAsync(async () => {
+      const last = await this.getSynchedL2BlockNumber();
+      if (from !== last) {
         throw new Error(`Can only unwind blocks from the tip (requested ${from} but current tip is ${last})`);
       }
 
       for (let i = 0; i < blocksToUnwind; i++) {
         const blockNumber = from - i;
-        const block = this.getBlock(blockNumber);
+        const block = await this.getBlock(blockNumber);
 
         if (block === undefined) {
           throw new Error(`Cannot remove block ${blockNumber} from the store, we don't have it`);
         }
-        void this.#blocks.delete(block.data.number);
-        block.data.body.txEffects.forEach(tx => {
-          void this.#txIndex.delete(tx.txHash.toString());
-        });
-        const blockHash = block.data.hash().toString();
-        void this.#blockBodies.delete(blockHash);
+        await this.#blocks.delete(block.data.number);
+        await Promise.all(block.data.body.txEffects.map(tx => this.#txIndex.delete(tx.txHash.toString())));
+        const blockHash = (await block.data.hash()).toString();
+        await this.#blockBodies.delete(blockHash);
         this.#log.debug(`Unwound block ${blockNumber} ${blockHash}`);
       }
 
@@ -121,9 +120,10 @@ export class BlockStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks
    */
-  *getBlocks(start: number, limit: number): IterableIterator<L1Published<L2Block>> {
-    for (const blockStorage of this.#blocks.values(this.#computeBlockRange(start, limit))) {
-      yield this.getBlockFromBlockStorage(blockStorage);
+  async *getBlocks(start: number, limit: number): AsyncIterableIterator<L1Published<L2Block>> {
+    for await (const blockStorage of this.#blocks.valuesAsync(this.#computeBlockRange(start, limit))) {
+      const block = await this.getBlockFromBlockStorage(blockStorage);
+      yield block;
     }
   }
 
@@ -132,10 +132,10 @@ export class BlockStore {
    * @param blockNumber - The number of the block to return.
    * @returns The requested L2 block.
    */
-  getBlock(blockNumber: number): L1Published<L2Block> | undefined {
-    const blockStorage = this.#blocks.get(blockNumber);
+  async getBlock(blockNumber: number): Promise<L1Published<L2Block> | undefined> {
+    const blockStorage = await this.#blocks.getAsync(blockNumber);
     if (!blockStorage || !blockStorage.header) {
-      return undefined;
+      return Promise.resolve(undefined);
     }
 
     return this.getBlockFromBlockStorage(blockStorage);
@@ -147,17 +147,17 @@ export class BlockStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 block headers
    */
-  *getBlockHeaders(start: number, limit: number): IterableIterator<BlockHeader> {
-    for (const blockStorage of this.#blocks.values(this.#computeBlockRange(start, limit))) {
+  async *getBlockHeaders(start: number, limit: number): AsyncIterableIterator<BlockHeader> {
+    for await (const blockStorage of this.#blocks.valuesAsync(this.#computeBlockRange(start, limit))) {
       yield BlockHeader.fromBuffer(blockStorage.header);
     }
   }
 
-  private getBlockFromBlockStorage(blockStorage: BlockStorage) {
+  private async getBlockFromBlockStorage(blockStorage: BlockStorage) {
     const header = BlockHeader.fromBuffer(blockStorage.header);
     const archive = AppendOnlyTreeSnapshot.fromBuffer(blockStorage.archive);
-    const blockHash = header.hash().toString();
-    const blockBodyBuffer = this.#blockBodies.get(blockHash);
+    const blockHash = (await header.hash()).toString();
+    const blockBodyBuffer = await this.#blockBodies.getAsync(blockHash);
     if (blockBodyBuffer === undefined) {
       throw new Error(
         `Could not retrieve body for block ${header.globalVariables.blockNumber.toNumber()} ${blockHash}`,
@@ -174,13 +174,13 @@ export class BlockStore {
    * @param txHash - The txHash of the tx corresponding to the tx effect.
    * @returns The requested tx effect (or undefined if not found).
    */
-  getTxEffect(txHash: TxHash): InBlock<TxEffect> | undefined {
-    const [blockNumber, txIndex] = this.getTxLocation(txHash) ?? [];
+  async getTxEffect(txHash: TxHash): Promise<InBlock<TxEffect> | undefined> {
+    const [blockNumber, txIndex] = (await this.getTxLocation(txHash)) ?? [];
     if (typeof blockNumber !== 'number' || typeof txIndex !== 'number') {
       return undefined;
     }
 
-    const block = this.getBlock(blockNumber);
+    const block = await this.getBlock(blockNumber);
     if (!block) {
       return undefined;
     }
@@ -188,7 +188,7 @@ export class BlockStore {
     return {
       data: block.data.body.txEffects[txIndex],
       l2BlockNumber: block.data.number,
-      l2BlockHash: block.data.hash().toString(),
+      l2BlockHash: (await block.data.hash()).toString(),
     };
   }
 
@@ -197,13 +197,13 @@ export class BlockStore {
    * @param txHash - The hash of a tx we try to get the receipt for.
    * @returns The requested tx receipt (or undefined if not found).
    */
-  getSettledTxReceipt(txHash: TxHash): TxReceipt | undefined {
-    const [blockNumber, txIndex] = this.getTxLocation(txHash) ?? [];
+  async getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
+    const [blockNumber, txIndex] = (await this.getTxLocation(txHash)) ?? [];
     if (typeof blockNumber !== 'number' || typeof txIndex !== 'number') {
       return undefined;
     }
 
-    const block = this.getBlock(blockNumber)!;
+    const block = (await this.getBlock(blockNumber))!;
     const tx = block.data.body.txEffects[txIndex];
 
     return new TxReceipt(
@@ -211,7 +211,7 @@ export class BlockStore {
       TxReceipt.statusFromRevertCode(tx.revertCode),
       '',
       tx.transactionFee.toBigInt(),
-      L2BlockHash.fromField(block.data.hash()),
+      L2BlockHash.fromField(await block.data.hash()),
       block.data.number,
     );
   }
@@ -221,8 +221,8 @@ export class BlockStore {
    * @param txHash - The txHash of the tx.
    * @returns The block number and index of the tx.
    */
-  getTxLocation(txHash: TxHash): [blockNumber: number, txIndex: number] | undefined {
-    return this.#txIndex.get(txHash.toString());
+  getTxLocation(txHash: TxHash): Promise<[blockNumber: number, txIndex: number] | undefined> {
+    return this.#txIndex.getAsync(txHash.toString());
   }
 
   /**
@@ -230,16 +230,16 @@ export class BlockStore {
    * @param contractAddress - The address of the contract to look up.
    * @returns The block number and index of the contract.
    */
-  getContractLocation(contractAddress: AztecAddress): [blockNumber: number, index: number] | undefined {
-    return this.#contractIndex.get(contractAddress.toString());
+  getContractLocation(contractAddress: AztecAddress): Promise<[blockNumber: number, index: number] | undefined> {
+    return this.#contractIndex.getAsync(contractAddress.toString());
   }
 
   /**
    * Gets the number of the latest L2 block processed.
    * @returns The number of the latest L2 block processed.
    */
-  getSynchedL2BlockNumber(): number {
-    const [lastBlockNumber] = this.#blocks.keys({ reverse: true, limit: 1 });
+  async getSynchedL2BlockNumber(): Promise<number> {
+    const [lastBlockNumber] = await toArray(this.#blocks.keysAsync({ reverse: true, limit: 1 }));
     return typeof lastBlockNumber === 'number' ? lastBlockNumber : INITIAL_L2_BLOCK_NUM - 1;
   }
 
@@ -247,31 +247,31 @@ export class BlockStore {
    * Gets the most recent L1 block processed.
    * @returns The L1 block that published the latest L2 block
    */
-  getSynchedL1BlockNumber(): bigint | undefined {
-    return this.#lastSynchedL1Block.get();
+  getSynchedL1BlockNumber(): Promise<bigint | undefined> {
+    return this.#lastSynchedL1Block.getAsync();
   }
 
   setSynchedL1BlockNumber(l1BlockNumber: bigint) {
-    void this.#lastSynchedL1Block.set(l1BlockNumber);
+    return this.#lastSynchedL1Block.set(l1BlockNumber);
   }
 
-  getProvenL2BlockNumber(): number {
-    return this.#lastProvenL2Block.get() ?? 0;
+  async getProvenL2BlockNumber(): Promise<number> {
+    return (await this.#lastProvenL2Block.getAsync()) ?? 0;
   }
 
   setProvenL2BlockNumber(blockNumber: number) {
-    void this.#lastProvenL2Block.set(blockNumber);
+    return this.#lastProvenL2Block.set(blockNumber);
   }
 
-  getProvenL2EpochNumber(): number | undefined {
-    return this.#lastProvenL2Epoch.get();
+  getProvenL2EpochNumber(): Promise<number | undefined> {
+    return this.#lastProvenL2Epoch.getAsync();
   }
 
   setProvenL2EpochNumber(epochNumber: number) {
-    void this.#lastProvenL2Epoch.set(epochNumber);
+    return this.#lastProvenL2Epoch.set(epochNumber);
   }
 
-  #computeBlockRange(start: number, limit: number): Required<Pick<Range<number>, 'start' | 'end'>> {
+  #computeBlockRange(start: number, limit: number): Required<Pick<Range<number>, 'start' | 'limit'>> {
     if (limit < 1) {
       throw new Error(`Invalid limit: ${limit}`);
     }
@@ -280,7 +280,6 @@ export class BlockStore {
       throw new Error(`Invalid start: ${start}`);
     }
 
-    const end = start + limit;
-    return { start, end };
+    return { start, limit };
   }
 }