@aztec/archiver 0.24.0 → 0.26.2

package/src/archiver/eth_log_handlers.ts

@@ -1,17 +1,18 @@
 import {
+  Body,
   ContractData,
   EncodedContractFunction,
   ExtendedContractData,
   L1Actor,
   L1ToL2Message,
   L2Actor,
-  L2Block,
 } from '@aztec/circuit-types';
+import { AppendOnlyTreeSnapshot, Header } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
-import { ContractDeploymentEmitterAbi, InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
+import { AvailabilityOracleAbi, ContractDeploymentEmitterAbi, InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
 
 import { Hex, Log, PublicClient, decodeFunctionData, getAbiItem, getAddress, hexToBytes } from 'viem';
 
@@ -21,7 +22,7 @@ import { Hex, Log, PublicClient, decodeFunctionData, getAbiItem, getAddress, hex
  * @returns Array of all Pending L1 to L2 messages that were processed
  */
 export function processPendingL1ToL2MessageAddedLogs(
-  logs: Log<bigint, number, undefined, true, typeof InboxAbi, 'MessageAdded'>[],
+  logs: Log<bigint, number, false, undefined, true, typeof InboxAbi, 'MessageAdded'>[],
 ): [L1ToL2Message, bigint][] {
   const l1ToL2Messages: [L1ToL2Message, bigint][] = [];
   for (const log of logs) {
@@ -46,10 +47,10 @@ export function processPendingL1ToL2MessageAddedLogs(
 /**
  * Process newly received L1ToL2MessageCancelled logs.
  * @param logs - L1ToL2MessageCancelled logs.
- * @returns Array of message keys of the L1 to L2 messages that were cancelled
+ * @returns Array of entry keys of the L1 to L2 messages that were cancelled
  */
 export function processCancelledL1ToL2MessagesLogs(
-  logs: Log<bigint, number, undefined, true, typeof InboxAbi, 'L1ToL2MessageCancelled'>[],
+  logs: Log<bigint, number, false, undefined, true, typeof InboxAbi, 'L1ToL2MessageCancelled'>[],
 ): [Fr, bigint][] {
   const cancelledL1ToL2Messages: [Fr, bigint][] = [];
   for (const log of logs) {
@@ -63,62 +64,116 @@ export function processCancelledL1ToL2MessagesLogs(
  * @param publicClient - The viem public client to use for transaction retrieval.
  * @param expectedL2BlockNumber - The next expected L2 block number.
  * @param logs - L2BlockProcessed logs.
+ * @returns - An array of tuples representing block metadata including the header, archive tree snapshot, and associated l1 block number.
  */
-export async function processBlockLogs(
+export async function processL2BlockProcessedLogs(
   publicClient: PublicClient,
   expectedL2BlockNumber: bigint,
-  logs: Log<bigint, number, undefined, true, typeof RollupAbi, 'L2BlockProcessed'>[],
-): Promise<L2Block[]> {
-  const retrievedBlocks: L2Block[] = [];
+  logs: Log<bigint, number, false, undefined, true, typeof RollupAbi, 'L2BlockProcessed'>[],
+): Promise<[Header, AppendOnlyTreeSnapshot, bigint][]> {
+  const retrievedBlockMetadata: [Header, AppendOnlyTreeSnapshot, bigint][] = [];
   for (const log of logs) {
     const blockNum = log.args.blockNumber;
     if (blockNum !== expectedL2BlockNumber) {
       throw new Error('Block number mismatch. Expected: ' + expectedL2BlockNumber + ' but got: ' + blockNum + '.');
     }
     // TODO: Fetch blocks from calldata in parallel
-    const newBlock = await getBlockFromCallData(publicClient, log.transactionHash!, log.args.blockNumber);
-    newBlock.setL1BlockNumber(log.blockNumber!);
-    retrievedBlocks.push(newBlock);
+    const [header, archive] = await getBlockMetadataFromRollupTx(
+      publicClient,
+      log.transactionHash!,
+      log.args.blockNumber,
+    );
+
+    retrievedBlockMetadata.push([header, archive, log.blockNumber!]);
     expectedL2BlockNumber++;
   }
-  return retrievedBlocks;
+
+  return retrievedBlockMetadata;
+}
+
+export async function processTxsPublishedLogs(
+  publicClient: PublicClient,
+  logs: Log<bigint, number, false, undefined, true, typeof AvailabilityOracleAbi, 'TxsPublished'>[],
+): Promise<[Body, Buffer][]> {
+  const retrievedBlockBodies: [Body, Buffer][] = [];
+  for (const log of logs) {
+    const newBlockBody = await getBlockBodiesFromAvailabilityOracleTx(publicClient, log.transactionHash!);
+    retrievedBlockBodies.push([newBlockBody, Buffer.from(hexToBytes(log.args.txsHash))]);
+  }
+
+  return retrievedBlockBodies;
 }
 
 /**
- * Builds an L2 block out of calldata from the tx that published it.
+ * Gets block metadata (header and archive snapshot) from the calldata of an L1 transaction.
  * Assumes that the block was published from an EOA.
  * TODO: Add retries and error management.
  * @param publicClient - The viem public client to use for transaction retrieval.
  * @param txHash - Hash of the tx that published it.
  * @param l2BlockNum - L2 block number.
- * @returns An L2 block deserialized from the calldata.
+ * @returns L2 block metadata (header and archive) from the calldata, deserialized
  */
-async function getBlockFromCallData(
+async function getBlockMetadataFromRollupTx(
   publicClient: PublicClient,
   txHash: `0x${string}`,
   l2BlockNum: bigint,
-): Promise<L2Block> {
+): Promise<[Header, AppendOnlyTreeSnapshot]> {
   const { input: data } = await publicClient.getTransaction({ hash: txHash });
-  // TODO: File a bug in viem who complains if we dont remove the ctor from the abi here
   const { functionName, args } = decodeFunctionData({
-    abi: RollupAbi.filter(item => item.type.toString() !== 'constructor'),
+    abi: RollupAbi,
     data,
   });
+
   if (functionName !== 'process') {
     throw new Error(`Unexpected method called ${functionName}`);
   }
-  const [headerHex, archiveRootHex, , bodyHex] = args! as [Hex, Hex, Hex, Hex, Hex];
-  const blockBuffer = Buffer.concat([
-    Buffer.from(hexToBytes(headerHex)),
-    Buffer.from(hexToBytes(archiveRootHex)), // L2Block.archive.root
-    numToUInt32BE(Number(l2BlockNum)), // L2Block.archive.nextAvailableLeafIndex
-    Buffer.from(hexToBytes(bodyHex)),
-  ]);
-  const block = L2Block.fromBufferWithLogs(blockBuffer);
-  if (BigInt(block.number) !== l2BlockNum) {
-    throw new Error(`Block number mismatch: expected ${l2BlockNum} but got ${block.number}`);
+  const [headerHex, archiveRootHex] = args! as readonly [Hex, Hex, Hex, Hex];
+
+  const header = Header.fromBuffer(Buffer.from(hexToBytes(headerHex)));
+
+  const blockNumberFromHeader = header.globalVariables.blockNumber.toBigInt();
+
+  if (blockNumberFromHeader !== l2BlockNum) {
+    throw new Error(`Block number mismatch: expected ${l2BlockNum} but got ${blockNumberFromHeader}`);
+  }
+
+  const archive = AppendOnlyTreeSnapshot.fromBuffer(
+    Buffer.concat([
+      Buffer.from(hexToBytes(archiveRootHex)), // L2Block.archive.root
+      numToUInt32BE(Number(l2BlockNum)), // L2Block.archive.nextAvailableLeafIndex
+    ]),
+  );
+
+  return [header, archive];
+}
+
+/**
+ * Gets block bodies from calldata of an L1 transaction, and deserializes them into Body objects.
+ * Assumes that the block was published from an EOA.
+ * TODO: Add retries and error management.
+ * @param publicClient - The viem public client to use for transaction retrieval.
+ * @param txHash - Hash of the tx that published it.
+ * @returns An L2 block body from the calldata, deserialized
+ */
+async function getBlockBodiesFromAvailabilityOracleTx(
+  publicClient: PublicClient,
+  txHash: `0x${string}`,
+): Promise<Body> {
+  const { input: data } = await publicClient.getTransaction({ hash: txHash });
+  const { functionName, args } = decodeFunctionData({
+    abi: AvailabilityOracleAbi,
+    data,
+  });
+
+  if (functionName !== 'publish') {
+    throw new Error(`Unexpected method called ${functionName}`);
   }
-  return block;
+
+  const [bodyHex] = args! as [Hex];
+
+  const blockBody = Body.fromBuffer(Buffer.from(hexToBytes(bodyHex)));
+
+  return blockBody;
 }
 
 /**
@@ -129,21 +184,43 @@ async function getBlockFromCallData(
  * @param toBlock - Last block to get logs from (inclusive).
  * @returns An array of `L2BlockProcessed` logs.
  */
-export async function getL2BlockProcessedLogs(
+export function getL2BlockProcessedLogs(
   publicClient: PublicClient,
   rollupAddress: EthAddress,
   fromBlock: bigint,
   toBlock: bigint,
-) {
-  // Note: For some reason the return type of `getLogs` would not get correctly derived if I didn't set the abiItem
-  //       as a standalone constant.
-  const abiItem = getAbiItem({
-    abi: RollupAbi,
-    name: 'L2BlockProcessed',
-  });
-  return await publicClient.getLogs<typeof abiItem, true>({
+): Promise<Log<bigint, number, false, undefined, true, typeof RollupAbi, 'L2BlockProcessed'>[]> {
+  return publicClient.getLogs({
     address: getAddress(rollupAddress.toString()),
-    event: abiItem,
+    event: getAbiItem({
+      abi: RollupAbi,
+      name: 'L2BlockProcessed',
+    }),
+    fromBlock,
+    toBlock: toBlock + 1n, // the toBlock argument in getLogs is exclusive
+  });
+}
+
+/**
+ * Gets relevant `TxsPublished` logs from chain.
+ * @param publicClient - The viem public client to use for transaction retrieval.
+ * @param dataAvailabilityOracleAddress - The address of the availability oracle contract.
+ * @param fromBlock - First block to get logs from (inclusive).
+ * @param toBlock - Last block to get logs from (inclusive).
+ * @returns An array of `TxsPublished` logs.
+ */
+export function getTxsPublishedLogs(
+  publicClient: PublicClient,
+  dataAvailabilityOracleAddress: EthAddress,
+  fromBlock: bigint,
+  toBlock: bigint,
+): Promise<Log<bigint, number, false, undefined, true, typeof AvailabilityOracleAbi, 'TxsPublished'>[]> {
+  return publicClient.getLogs({
+    address: getAddress(dataAvailabilityOracleAddress.toString()),
+    event: getAbiItem({
+      abi: AvailabilityOracleAbi,
+      name: 'TxsPublished',
+    }),
     fromBlock,
     toBlock: toBlock + 1n, // the toBlock argument in getLogs is exclusive
   });
@@ -157,19 +234,18 @@ export async function getL2BlockProcessedLogs(
  * @param toBlock - Last block to get logs from (inclusive).
  * @returns An array of `ContractDeployment` logs.
  */
-export async function getContractDeploymentLogs(
+export function getContractDeploymentLogs(
   publicClient: PublicClient,
   contractDeploymentEmitterAddress: EthAddress,
   fromBlock: bigint,
   toBlock: bigint,
-): Promise<Log<bigint, number, undefined, true, typeof ContractDeploymentEmitterAbi, 'ContractDeployment'>[]> {
-  const abiItem = getAbiItem({
-    abi: ContractDeploymentEmitterAbi,
-    name: 'ContractDeployment',
-  });
-  return await publicClient.getLogs({
+): Promise<Log<bigint, number, false, undefined, true, typeof ContractDeploymentEmitterAbi, 'ContractDeployment'>[]> {
+  return publicClient.getLogs({
     address: getAddress(contractDeploymentEmitterAddress.toString()),
-    event: abiItem,
+    event: getAbiItem({
+      abi: ContractDeploymentEmitterAbi,
+      name: 'ContractDeployment',
+    }),
     fromBlock,
     toBlock: toBlock + 1n, // the toBlock argument in getLogs is exclusive
   });
@@ -177,20 +253,20 @@ export async function getContractDeploymentLogs(
 
 /**
  * Processes newly received ContractDeployment logs.
- * @param blockHashMapping - A mapping from block number to relevant block hash.
+ * @param blockNumberToBodyHash - A mapping from block number to relevant body hash.
  * @param logs - ContractDeployment logs.
  * @returns The set of retrieved extended contract data items.
  */
 export function processContractDeploymentLogs(
-  blockHashMapping: { [key: number]: Buffer | undefined },
-  logs: Log<bigint, number, undefined, true, typeof ContractDeploymentEmitterAbi, 'ContractDeployment'>[],
+  blockNumberToBodyHash: { [key: number]: Buffer | undefined },
+  logs: Log<bigint, number, false, undefined, true, typeof ContractDeploymentEmitterAbi, 'ContractDeployment'>[],
 ): [ExtendedContractData[], number][] {
   const extendedContractData: [ExtendedContractData[], number][] = [];
   for (let i = 0; i < logs.length; i++) {
     const log = logs[i];
     const l2BlockNum = Number(log.args.l2BlockNum);
     const blockHash = Buffer.from(hexToBytes(log.args.l2BlockHash));
-    const expectedBlockHash = blockHashMapping[l2BlockNum];
+    const expectedBlockHash = blockNumberToBodyHash[l2BlockNum];
     if (expectedBlockHash === undefined || !blockHash.equals(expectedBlockHash)) {
       continue;
     }
@@ -223,19 +299,18 @@ export function processContractDeploymentLogs(
  * @param toBlock - Last block to get logs from (inclusive).
  * @returns An array of `MessageAdded` logs.
  */
-export async function getPendingL1ToL2MessageLogs(
+export function getPendingL1ToL2MessageLogs(
   publicClient: PublicClient,
   inboxAddress: EthAddress,
   fromBlock: bigint,
   toBlock: bigint,
-): Promise<Log<bigint, number, undefined, true, typeof InboxAbi, 'MessageAdded'>[]> {
-  const abiItem = getAbiItem({
-    abi: InboxAbi,
-    name: 'MessageAdded',
-  });
-  return await publicClient.getLogs({
+): Promise<Log<bigint, number, false, undefined, true, typeof InboxAbi, 'MessageAdded'>[]> {
+  return publicClient.getLogs({
     address: getAddress(inboxAddress.toString()),
-    event: abiItem,
+    event: getAbiItem({
+      abi: InboxAbi,
+      name: 'MessageAdded',
+    }),
     fromBlock,
     toBlock: toBlock + 1n, // the toBlock argument in getLogs is exclusive
   });
@@ -249,19 +324,18 @@ export async function getPendingL1ToL2MessageLogs(
  * @param toBlock - Last block to get logs from (inclusive).
  * @returns An array of `L1ToL2MessageCancelled` logs.
  */
-export async function getL1ToL2MessageCancelledLogs(
+export function getL1ToL2MessageCancelledLogs(
   publicClient: PublicClient,
   inboxAddress: EthAddress,
   fromBlock: bigint,
   toBlock: bigint,
-): Promise<Log<bigint, number, undefined, true, typeof InboxAbi, 'L1ToL2MessageCancelled'>[]> {
-  const abiItem = getAbiItem({
-    abi: InboxAbi,
-    name: 'L1ToL2MessageCancelled',
-  });
-  return await publicClient.getLogs({
+): Promise<Log<bigint, number, false, undefined, true, typeof InboxAbi, 'L1ToL2MessageCancelled'>[]> {
+  return publicClient.getLogs({
     address: getAddress(inboxAddress.toString()),
-    event: abiItem,
+    event: getAbiItem({
+      abi: InboxAbi,
+      name: 'L1ToL2MessageCancelled',
+    }),
     fromBlock,
     toBlock: toBlock + 1n, // the toBlock argument in getLogs is exclusive
   });

package/src/archiver/kv_archiver_store/block_body_store.ts

@@ -0,0 +1,54 @@
+import { Body } from '@aztec/circuit-types';
+import { AztecKVStore, AztecMap } from '@aztec/kv-store';
+
+export class BlockBodyStore {
+  /** Map block body hash to block body */
+  #blockBodies: AztecMap<string, Buffer>;
+
+  constructor(private db: AztecKVStore) {
+    this.#blockBodies = db.openMap('archiver_block_bodies');
+  }
+
+  /**
+   * Append new block bodies to the store's map.
+   * @param blockBodies - The L2 block bodies to be added to the store.
+   * @returns True if the operation is successful.
+   */
+  addBlockBodies(blockBodies: Body[]): Promise<boolean> {
+    return this.db.transaction(() => {
+      for (const body of blockBodies) {
+        void this.#blockBodies.set(body.getCalldataHash().toString('hex'), body.toBuffer());
+      }
+
+      return true;
+    });
+  }
+
+  /**
+   * Gets a list of L2 block bodies with its associated txsHashes
+   * @param txsHashes - The txsHashes list that corresponds to the blockBodies we want to retrieve
+   * @returns The requested L2 block bodies
+   */
+  async getBlockBodies(txsHashes: Buffer[]): Promise<Body[]> {
+    const blockBodiesBuffer = await this.db.transaction(() =>
+      txsHashes.map(txsHash => this.#blockBodies.get(txsHash.toString('hex'))),
+    );
+
+    if (blockBodiesBuffer.some(bodyBuffer => bodyBuffer === undefined)) {
+      throw new Error('Block body buffer is undefined');
+    }
+
+    return blockBodiesBuffer.map(blockBodyBuffer => Body.fromBuffer(blockBodyBuffer!));
+  }
+
+  /**
+   * Gets an L2 block body.
+   * @param txsHash - The txHash of the the block body to return
+   * @returns The requested L2 block body
+   */
+  getBlockBody(txsHash: Buffer): Body | undefined {
+    const blockBody = this.#blockBodies.get(txsHash.toString('hex'));
+
+    return blockBody && Body.fromBuffer(blockBody);
+  }
+}

package/src/archiver/kv_archiver_store/block_store.ts

@@ -1,14 +1,16 @@
-import { INITIAL_L2_BLOCK_NUM, L2Block, L2Tx, TxHash } from '@aztec/circuit-types';
-import { AztecAddress } from '@aztec/circuits.js';
+import { L2Block, TxEffect, TxHash, TxReceipt, TxStatus } from '@aztec/circuit-types';
+import { AppendOnlyTreeSnapshot, AztecAddress, Header, INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { AztecKVStore, AztecMap, Range } from '@aztec/kv-store';
 
+import { BlockBodyStore } from './block_body_store.js';
+
 type BlockIndexValue = [blockNumber: number, index: number];
 
-type BlockContext = {
-  blockNumber: number;
+type BlockStorage = {
   l1BlockNumber: bigint;
-  block: Buffer;
+  header: Buffer;
+  archive: Buffer;
 };
 
 /**
@@ -16,7 +18,7 @@ type BlockContext = {
  */
 export class BlockStore {
   /** Map block number to block data */
-  #blocks: AztecMap<number, BlockContext>;
+  #blocks: AztecMap<number, BlockStorage>;
 
   /** Index mapping transaction hash (as a string) to its location in a block */
   #txIndex: AztecMap<string, BlockIndexValue>;
@@ -26,9 +28,12 @@ export class BlockStore {
 
   #log = createDebugLogger('aztec:archiver:block_store');
 
-  constructor(private db: AztecKVStore) {
-    this.#blocks = db.openMap('archiver_blocks');
+  #blockBodyStore: BlockBodyStore;
+
+  constructor(private db: AztecKVStore, blockBodyStore: BlockBodyStore) {
+    this.#blockBodyStore = blockBodyStore;
 
+    this.#blocks = db.openMap('archiver_blocks');
     this.#txIndex = db.openMap('archiver_tx_index');
     this.#contractIndex = db.openMap('archiver_contract_index');
   }
@@ -42,25 +47,24 @@ export class BlockStore {
     return this.db.transaction(() => {
       for (const block of blocks) {
         void this.#blocks.set(block.number, {
-          blockNumber: block.number,
-          block: block.toBuffer(),
+          header: block.header.toBuffer(),
+          archive: block.archive.toBuffer(),
           l1BlockNumber: block.getL1BlockNumber(),
         });
 
-        for (const [i, tx] of block.getTxs().entries()) {
-          if (tx.txHash.isZero()) {
-            continue;
-          }
+        block.getTxs().forEach((tx, i) => {
           void this.#txIndex.set(tx.txHash.toString(), [block.number, i]);
-        }
+        });
 
-        for (const [i, contractData] of block.newContractData.entries()) {
-          if (contractData.contractAddress.isZero()) {
-            continue;
-          }
+        block.body.txEffects
+          .flatMap(txEffect => txEffect.contractData)
+          .forEach((contractData, i) => {
+            if (contractData.contractAddress.isZero()) {
+              return;
+            }
 
-          void this.#contractIndex.set(contractData.contractAddress.toString(), [block.number, i]);
-        }
+            void this.#contractIndex.set(contractData.contractAddress.toString(), [block.number, i]);
+          });
       }
 
       return true;
@@ -71,35 +75,51 @@ export class BlockStore {
    * Gets up to `limit` amount of L2 blocks starting from `from`.
    * @param start - Number of the first block to return (inclusive).
    * @param limit - The number of blocks to return.
-   * @returns The requested L2 blocks, without logs attached
+   * @returns The requested L2 blocks
    */
   *getBlocks(start: number, limit: number): IterableIterator<L2Block> {
-    for (const blockCtx of this.#blocks.values(this.#computeBlockRange(start, limit))) {
-      yield L2Block.fromBuffer(blockCtx.block);
+    for (const blockStorage of this.#blocks.values(this.#computeBlockRange(start, limit))) {
+      yield this.getBlockFromBlockStorage(blockStorage);
     }
   }
 
   /**
    * Gets an L2 block.
    * @param blockNumber - The number of the block to return.
-   * @returns The requested L2 block, without logs attached
+   * @returns The requested L2 block.
    */
   getBlock(blockNumber: number): L2Block | undefined {
-    const blockCtx = this.#blocks.get(blockNumber);
-    if (!blockCtx || !blockCtx.block) {
+    const blockStorage = this.#blocks.get(blockNumber);
+    if (!blockStorage || !blockStorage.header) {
       return undefined;
     }
 
-    return L2Block.fromBuffer(blockCtx.block);
+    return this.getBlockFromBlockStorage(blockStorage);
+  }
+
+  private getBlockFromBlockStorage(blockStorage: BlockStorage) {
+    const header = Header.fromBuffer(blockStorage.header);
+    const archive = AppendOnlyTreeSnapshot.fromBuffer(blockStorage.archive);
+    const body = this.#blockBodyStore.getBlockBody(header.contentCommitment.txsHash);
+
+    if (body === undefined) {
+      throw new Error('Body is not able to be retrieved from BodyStore');
+    }
+
+    return L2Block.fromFields({
+      header,
+      archive,
+      body,
+    });
   }
 
   /**
-   * Gets an l2 tx.
-   * @param txHash - The txHash of the l2 tx.
-   * @returns The requested L2 tx.
+   * Gets a tx effect.
+   * @param txHash - The txHash of the tx corresponding to the tx effect.
+   * @returns The requested tx effect (or undefined if not found).
    */
-  getL2Tx(txHash: TxHash): L2Tx | undefined {
-    const [blockNumber, txIndex] = this.getL2TxLocation(txHash) ?? [];
+  getTxEffect(txHash: TxHash): TxEffect | undefined {
+    const [blockNumber, txIndex] = this.getTxLocation(txHash) ?? [];
     if (typeof blockNumber !== 'number' || typeof txIndex !== 'number') {
       return undefined;
     }
@@ -109,11 +129,26 @@ export class BlockStore {
   }
 
   /**
-   * Looks up which block included the requested L2 tx.
-   * @param txHash - The txHash of the l2 tx.
+   * 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).
+   */
+  getSettledTxReceipt(txHash: TxHash): TxReceipt | undefined {
+    const [blockNumber, txIndex] = this.getTxLocation(txHash) ?? [];
+    if (typeof blockNumber !== 'number' || typeof txIndex !== 'number') {
+      return undefined;
+    }
+
+    const block = this.getBlock(blockNumber)!;
+    return new TxReceipt(txHash, TxStatus.MINED, '', block.hash().toBuffer(), block.number);
+  }
+
+  /**
+   * Looks up which block included the requested tx effect.
+   * @param txHash - The txHash of the tx.
    * @returns The block number and index of the tx.
    */
-  getL2TxLocation(txHash: TxHash): [blockNumber: number, txIndex: number] | undefined {
+  getTxLocation(txHash: TxHash): [blockNumber: number, txIndex: number] | undefined {
     return this.#txIndex.get(txHash.toString());
   }
 

package/src/archiver/kv_archiver_store/contract_class_store.ts

@@ -21,6 +21,10 @@ export class ContractClassStore {
     const contractClass = this.#contractClasses.get(id.toString());
     return contractClass && { ...deserializeContractClassPublic(contractClass), id };
   }
+
+  getContractClassIds(): Fr[] {
+    return Array.from(this.#contractClasses.keys()).map(key => Fr.fromString(key));
+  }
 }
 
 export function serializeContractClassPublic(contractClass: ContractClassPublic): Buffer {

package/src/archiver/kv_archiver_store/contract_store.ts

@@ -77,7 +77,12 @@ export class ContractStore {
     }
 
     const block = this.#blockStore.getBlock(blockNumber);
-    return block?.newContractData[index];
+
+    if (block?.body.txEffects[index].contractData.length !== 1) {
+      throw new Error(`Contract data at block: ${blockNumber}, tx: ${index} does not have length of 1`);
+    }
+
+    return block?.body.txEffects[index].contractData[0];
   }
 
   /**
@@ -88,6 +93,6 @@ export class ContractStore {
    */
   getContractDataInBlock(blockNumber: number): ContractData[] {
     const block = this.#blockStore.getBlock(blockNumber);
-    return block?.newContractData ?? [];
+    return block?.body.txEffects.flatMap(txEffect => txEffect.contractData) ?? [];
   }
 }