@aztec/archiver 0.24.0 → 0.26.2

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -1,14 +1,16 @@
 import {
+  Body,
   ContractData,
   ExtendedContractData,
   GetUnencryptedLogsResponse,
   L1ToL2Message,
   L2Block,
   L2BlockL2Logs,
-  L2Tx,
   LogFilter,
   LogType,
+  TxEffect,
   TxHash,
+  TxReceipt,
 } from '@aztec/circuit-types';
 import { Fr } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
@@ -17,6 +19,7 @@ import { AztecKVStore } from '@aztec/kv-store';
 import { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/types/contracts';
 
 import { ArchiverDataStore, ArchiverL1SynchPoint } from '../archiver_store.js';
+import { BlockBodyStore } from './block_body_store.js';
 import { BlockStore } from './block_store.js';
 import { ContractClassStore } from './contract_class_store.js';
 import { ContractInstanceStore } from './contract_instance_store.js';
@@ -29,6 +32,7 @@ import { MessageStore } from './message_store.js';
  */
 export class KVArchiverDataStore implements ArchiverDataStore {
   #blockStore: BlockStore;
+  #blockBodyStore: BlockBodyStore;
   #logStore: LogStore;
   #contractStore: ContractStore;
   #messageStore: MessageStore;
@@ -38,7 +42,8 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   #log = createDebugLogger('aztec:archiver:data-store');
 
   constructor(db: AztecKVStore, logsMaxPageSize: number = 1000) {
-    this.#blockStore = new BlockStore(db);
+    this.#blockBodyStore = new BlockBodyStore(db);
+    this.#blockStore = new BlockStore(db, this.#blockBodyStore);
     this.#logStore = new LogStore(db, this.#blockStore, logsMaxPageSize);
     this.#contractStore = new ContractStore(db, this.#blockStore);
     this.#messageStore = new MessageStore(db);
@@ -50,6 +55,10 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     return Promise.resolve(this.#contractClassStore.getContractClass(id));
   }
 
+  getContractClassIds(): Promise<Fr[]> {
+    return Promise.resolve(this.#contractClassStore.getContractClassIds());
+  }
+
   getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
     return Promise.resolve(this.#contractInstanceStore.getContractInstance(address));
   }
@@ -62,6 +71,25 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     return (await Promise.all(data.map(c => this.#contractInstanceStore.addContractInstance(c)))).every(Boolean);
   }
 
+  /**
+   * 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.
+   */
+  addBlockBodies(blockBodies: Body[]): Promise<boolean> {
+    return this.#blockBodyStore.addBlockBodies(blockBodies);
+  }
+
+  /**
+   * Gets block bodies that have the same txHashes as we supply.
+   *
+   * @param txsHashes - A list of txsHashes (body hashes).
+   * @returns The requested L2 block bodies
+   */
+  getBlockBodies(txsHashes: Buffer[]): Promise<Body[]> {
+    return this.#blockBodyStore.getBlockBodies(txsHashes);
+  }
+
   /**
    * Append new blocks to the store's list.
    * @param blocks - The L2 blocks to be added to the store.
@@ -73,11 +101,10 @@ export class KVArchiverDataStore implements ArchiverDataStore {
 
   /**
    * Gets up to `limit` amount of L2 blocks starting from `from`.
-   * The blocks returned do not contain any logs.
    *
    * @param start - Number of the first block to return (inclusive).
    * @param limit - The number of blocks to return.
-   * @returns The requested L2 blocks, without any logs attached
+   * @returns The requested L2 blocks
    */
   getBlocks(start: number, limit: number): Promise<L2Block[]> {
     try {
@@ -89,12 +116,21 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   }
 
   /**
-   * 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).
+   */
+  getTxEffect(txHash: TxHash): Promise<TxEffect | undefined> {
+    return Promise.resolve(this.#blockStore.getTxEffect(txHash));
+  }
+
+  /**
+   * 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).
    */
-  getL2Tx(txHash: TxHash): Promise<L2Tx | undefined> {
-    return Promise.resolve(this.#blockStore.getL2Tx(txHash));
+  getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
+    return Promise.resolve(this.#blockStore.getSettledTxReceipt(txHash));
   }
 
   /**
@@ -124,42 +160,42 @@ export class KVArchiverDataStore implements ArchiverDataStore {
 
   /**
    * Remove pending L1 to L2 messages from the store (if they were cancelled).
-   * @param messages - The message keys to be removed from the store.
+   * @param messages - The entry keys to be removed from the store.
    * @param l1BlockNumber - The L1 block number for which to remove the messages.
    * @returns True if the operation is successful.
    */
-  cancelPendingL1ToL2Messages(messages: Fr[], l1BlockNumber: bigint): Promise<boolean> {
+  cancelPendingL1ToL2EntryKeys(messages: Fr[], l1BlockNumber: bigint): Promise<boolean> {
     return Promise.resolve(this.#messageStore.cancelPendingMessages(messages, l1BlockNumber));
   }
 
   /**
    * Messages that have been published in an L2 block are confirmed.
    * Add them to the confirmed store, also remove them from the pending store.
-   * @param entryKeys - The message keys to be removed from the store.
+   * @param entryKeys - The entry keys to be removed from the store.
    * @param blockNumber - The block for which to add the messages.
    * @returns True if the operation is successful.
    */
-  confirmL1ToL2Messages(entryKeys: Fr[]): Promise<boolean> {
+  confirmL1ToL2EntryKeys(entryKeys: Fr[]): Promise<boolean> {
     return this.#messageStore.confirmPendingMessages(entryKeys);
   }
 
   /**
    * Gets up to `limit` amount of pending L1 to L2 messages, sorted by fee
    * @param limit - The number of messages to return (by default NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).
-   * @returns The requested L1 to L2 message keys.
+   * @returns The requested L1 to L2 entry keys.
    */
-  getPendingL1ToL2MessageKeys(limit: number): Promise<Fr[]> {
-    return Promise.resolve(this.#messageStore.getPendingMessageKeysByFee(limit));
+  getPendingL1ToL2EntryKeys(limit: number): Promise<Fr[]> {
+    return Promise.resolve(this.#messageStore.getPendingEntryKeysByFee(limit));
   }
 
   /**
-   * Gets the confirmed L1 to L2 message corresponding to the given message key.
-   * @param messageKey - The message key to look up.
+   * Gets the confirmed L1 to L2 message corresponding to the given entry key.
+   * @param entryKey - The entry key to look up.
    * @returns The requested L1 to L2 message or throws if not found.
    */
-  getConfirmedL1ToL2Message(messageKey: Fr): Promise<L1ToL2Message> {
+  getConfirmedL1ToL2Message(entryKey: Fr): Promise<L1ToL2Message> {
     try {
-      return Promise.resolve(this.#messageStore.getConfirmedMessage(messageKey));
+      return Promise.resolve(this.#messageStore.getConfirmedMessage(entryKey));
     } catch (err) {
       return Promise.reject(err);
     }

package/src/archiver/kv_archiver_store/log_store.ts

@@ -1,13 +1,13 @@
 import {
   ExtendedUnencryptedL2Log,
   GetUnencryptedLogsResponse,
-  INITIAL_L2_BLOCK_NUM,
   L2BlockL2Logs,
   LogFilter,
   LogId,
   LogType,
   UnencryptedL2Log,
 } from '@aztec/circuit-types';
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js/constants';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { AztecKVStore, AztecMap } from '@aztec/kv-store';
 
@@ -88,7 +88,7 @@ export class LogStore {
       throw new Error('Missing txHash');
     }
 
-    const [blockNumber, txIndex] = this.blockStore.getL2TxLocation(filter.txHash) ?? [];
+    const [blockNumber, txIndex] = this.blockStore.getTxLocation(filter.txHash) ?? [];
     if (typeof blockNumber !== 'number' || typeof txIndex !== 'number') {
       return { logs: [], maxLogsHit: false };
     }

package/src/archiver/kv_archiver_store/message_store.ts

@@ -60,18 +60,18 @@ export class MessageStore {
       void this.#lastL1BlockAddingMessages.set(l1BlockNumber);
 
       for (const message of messages) {
-        const messageKey = message.entryKey?.toString();
-        if (!messageKey) {
+        const entryKey = message.entryKey?.toString();
+        if (!entryKey) {
           throw new Error('Message does not have an entry key');
         }
 
-        void this.#messages.setIfNotExists(messageKey, {
+        void this.#messages.setIfNotExists(entryKey, {
           message: message.toBuffer(),
           fee: message.fee,
           confirmed: false,
         });
 
-        void this.#pendingMessagesByFee.update([message.fee, messageKey], 1);
+        void this.#pendingMessagesByFee.update([message.fee, entryKey], 1);
       }
 
       return true;
@@ -80,11 +80,11 @@ export class MessageStore {
 
   /**
    * Remove pending L1 to L2 messages from the store (if they were cancelled).
-   * @param messageKeys - The message keys to be removed from the store.
+   * @param entryKeys - The entry keys to be removed from the store.
    * @param l1BlockNumber - The L1 block number for which to remove the messages.
    * @returns True if the operation is successful.
    */
-  cancelPendingMessages(messageKeys: Fr[], l1BlockNumber: bigint): Promise<boolean> {
+  cancelPendingMessages(entryKeys: Fr[], l1BlockNumber: bigint): Promise<boolean> {
     return this.db.transaction(() => {
       const lastL1BlockNumber = this.#lastL1BlockCancellingMessages.get() ?? 0n;
       if (lastL1BlockNumber >= l1BlockNumber) {
@@ -93,13 +93,13 @@ export class MessageStore {
 
       void this.#lastL1BlockCancellingMessages.set(l1BlockNumber);
 
-      for (const messageKey of messageKeys) {
-        const messageCtx = this.#messages.get(messageKey.toString());
+      for (const entryKey of entryKeys) {
+        const messageCtx = this.#messages.get(entryKey.toString());
         if (!messageCtx) {
-          throw new Error(`Message ${messageKey.toString()} not found`);
+          throw new Error(`Message ${entryKey.toString()} not found`);
         }
 
-        void this.#pendingMessagesByFee.update([messageCtx.fee, messageKey.toString()], -1);
+        void this.#pendingMessagesByFee.update([messageCtx.fee, entryKey.toString()], -1);
       }
 
       return true;
@@ -109,20 +109,24 @@ export class MessageStore {
   /**
    * Messages that have been published in an L2 block are confirmed.
    * Add them to the confirmed store, also remove them from the pending store.
-   * @param messageKeys - The message keys to be removed from the store.
+   * @param entryKeys - The entry keys to be removed from the store.
    * @returns True if the operation is successful.
    */
-  confirmPendingMessages(messageKeys: Fr[]): Promise<boolean> {
+  confirmPendingMessages(entryKeys: Fr[]): Promise<boolean> {
     return this.db.transaction(() => {
-      for (const messageKey of messageKeys) {
-        const messageCtx = this.#messages.get(messageKey.toString());
+      for (const entryKey of entryKeys) {
+        if (entryKey.equals(Fr.ZERO)) {
+          continue;
+        }
+
+        const messageCtx = this.#messages.get(entryKey.toString());
         if (!messageCtx) {
-          throw new Error(`Message ${messageKey.toString()} not found`);
+          throw new Error(`Message ${entryKey.toString()} not found`);
         }
         messageCtx.confirmed = true;
 
-        void this.#messages.set(messageKey.toString(), messageCtx);
-        void this.#pendingMessagesByFee.update([messageCtx.fee, messageKey.toString()], -1);
+        void this.#messages.set(entryKey.toString(), messageCtx);
+        void this.#pendingMessagesByFee.update([messageCtx.fee, entryKey.toString()], -1);
       }
 
       return true;
@@ -130,18 +134,18 @@ export class MessageStore {
   }
 
   /**
-   * Gets the confirmed L1 to L2 message corresponding to the given message key.
-   * @param messageKey - The message key to look up.
+   * Gets the confirmed L1 to L2 message corresponding to the given entry key.
+   * @param entryKey - The entry key to look up.
    * @returns The requested L1 to L2 message or throws if not found.
    */
-  getConfirmedMessage(messageKey: Fr): L1ToL2Message {
-    const messageCtx = this.#messages.get(messageKey.toString());
+  getConfirmedMessage(entryKey: Fr): L1ToL2Message {
+    const messageCtx = this.#messages.get(entryKey.toString());
     if (!messageCtx) {
-      throw new Error(`Message ${messageKey.toString()} not found`);
+      throw new Error(`Message ${entryKey.toString()} not found`);
     }
 
     if (!messageCtx.confirmed) {
-      throw new Error(`Message ${messageKey.toString()} not confirmed`);
+      throw new Error(`Message ${entryKey.toString()} not confirmed`);
     }
 
     return L1ToL2Message.fromBuffer(messageCtx.message);
@@ -150,21 +154,21 @@ export class MessageStore {
   /**
    * Gets up to `limit` amount of pending L1 to L2 messages, sorted by fee
    * @param limit - The number of messages to return (by default NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).
-   * @returns The requested L1 to L2 message keys.
+   * @returns The requested L1 to L2 entry keys.
    */
-  getPendingMessageKeysByFee(limit: number): Fr[] {
-    const messageKeys: Fr[] = [];
+  getPendingEntryKeysByFee(limit: number): Fr[] {
+    const entryKeys: Fr[] = [];
 
-    for (const [[_, messageKey], count] of this.#pendingMessagesByFee.entries({
+    for (const [[_, entryKey], count] of this.#pendingMessagesByFee.entries({
       reverse: true,
     })) {
       // put `count` copies of this message in the result list
-      messageKeys.push(...Array(count).fill(Fr.fromString(messageKey)));
-      if (messageKeys.length >= limit) {
+      entryKeys.push(...Array(count).fill(Fr.fromString(entryKey)));
+      if (entryKeys.length >= limit) {
         break;
       }
     }
 
-    return messageKeys;
+    return entryKeys;
   }
 }

package/src/archiver/memory_archiver_store/l1_to_l2_message_store.ts

@@ -7,29 +7,29 @@ import { Fr } from '@aztec/foundation/fields';
  */
 export class L1ToL2MessageStore {
   /**
-   * A map containing the message key to the corresponding L1 to L2
+   * A map containing the entry key to the corresponding L1 to L2
    * messages (and the number of times the message has been seen).
    */
   protected store: Map<bigint, L1ToL2MessageAndCount> = new Map();
 
   constructor() {}
 
-  addMessage(messageKey: Fr, message: L1ToL2Message) {
-    const messageKeyBigInt = messageKey.toBigInt();
-    const msgAndCount = this.store.get(messageKeyBigInt);
+  addMessage(entryKey: Fr, message: L1ToL2Message) {
+    const entryKeyBigInt = entryKey.toBigInt();
+    const msgAndCount = this.store.get(entryKeyBigInt);
     if (msgAndCount) {
       msgAndCount.count++;
     } else {
-      this.store.set(messageKeyBigInt, { message, count: 1 });
+      this.store.set(entryKeyBigInt, { message, count: 1 });
     }
   }
 
-  getMessage(messageKey: Fr): L1ToL2Message | undefined {
-    return this.store.get(messageKey.value)?.message;
+  getMessage(entryKey: Fr): L1ToL2Message | undefined {
+    return this.store.get(entryKey.value)?.message;
   }
 
-  getMessageAndCount(messageKey: Fr): L1ToL2MessageAndCount | undefined {
-    return this.store.get(messageKey.value);
+  getMessageAndCount(entryKey: Fr): L1ToL2MessageAndCount | undefined {
+    return this.store.get(entryKey.value);
   }
 }
 
@@ -38,7 +38,7 @@ export class L1ToL2MessageStore {
  * for removing messages or fetching multiple messages.
  */
 export class PendingL1ToL2MessageStore extends L1ToL2MessageStore {
-  getMessageKeys(limit: number): Fr[] {
+  getEntryKeys(limit: number): Fr[] {
     if (limit < 1) {
       return [];
     }
@@ -57,21 +57,21 @@ export class PendingL1ToL2MessageStore extends L1ToL2MessageStore {
     return messages;
   }
 
-  removeMessage(messageKey: Fr) {
-    // ignore 0 - messageKey is a hash, so a 0 can probabilistically never occur. It is best to skip it.
-    if (messageKey.equals(Fr.ZERO)) {
+  removeMessage(entryKey: Fr) {
+    // ignore 0 - entryKey is a hash, so a 0 can probabilistically never occur. It is best to skip it.
+    if (entryKey.equals(Fr.ZERO)) {
       return;
     }
 
-    const messageKeyBigInt = messageKey.value;
-    const msgAndCount = this.store.get(messageKeyBigInt);
+    const entryKeyBigInt = entryKey.value;
+    const msgAndCount = this.store.get(entryKeyBigInt);
     if (!msgAndCount) {
-      throw new Error(`Unable to remove message: L1 to L2 Message with key ${messageKeyBigInt} not found in store`);
+      throw new Error(`Unable to remove message: L1 to L2 Message with key ${entryKeyBigInt} not found in store`);
     }
     if (msgAndCount.count > 1) {
       msgAndCount.count--;
     } else {
-      this.store.delete(messageKeyBigInt);
+      this.store.delete(entryKeyBigInt);
     }
   }
 }

package/src/archiver/memory_archiver_store/memory_archiver_store.ts

@@ -1,21 +1,23 @@
 import {
+  Body,
   ContractData,
   ExtendedContractData,
   ExtendedUnencryptedL2Log,
   GetUnencryptedLogsResponse,
-  INITIAL_L2_BLOCK_NUM,
   L1ToL2Message,
   L2Block,
   L2BlockContext,
   L2BlockL2Logs,
-  L2Tx,
   LogFilter,
   LogId,
   LogType,
+  TxEffect,
   TxHash,
+  TxReceipt,
+  TxStatus,
   UnencryptedL2Log,
 } from '@aztec/circuit-types';
-import { Fr, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/circuits.js';
+import { Fr, INITIAL_L2_BLOCK_NUM, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/types/contracts';
 
@@ -32,9 +34,14 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   private l2BlockContexts: L2BlockContext[] = [];
 
   /**
-   * An array containing all the L2 Txs in the L2 blocks that have been fetched so far.
+   * A mapping of body hash to body
    */
-  private l2Txs: L2Tx[] = [];
+  private l2BlockBodies: Map<string, Body> = new Map();
+
+  /**
+   * An array containing all the 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.
@@ -85,6 +92,10 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(this.contractClasses.get(id.toString()));
   }
 
+  public getContractClassIds(): Promise<Fr[]> {
+    return Promise.resolve(Array.from(this.contractClasses.keys()).map(key => Fr.fromString(key)));
+  }
+
   public getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
     return Promise.resolve(this.contractInstances.get(address.toString()));
   }
@@ -110,10 +121,39 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    */
   public addBlocks(blocks: L2Block[]): Promise<boolean> {
     this.l2BlockContexts.push(...blocks.map(block => new L2BlockContext(block)));
-    this.l2Txs.push(...blocks.flatMap(b => b.getTxs()));
+    this.txEffects.push(...blocks.flatMap(b => b.getTxs()));
+    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.
+   */
+  addBlockBodies(blockBodies: Body[]): Promise<boolean> {
+    for (const body of blockBodies) {
+      void this.l2BlockBodies.set(body.getCalldataHash().toString('hex'), body);
+    }
+
     return Promise.resolve(true);
   }
 
+  /**
+   * Gets block bodies that have the same txHashes as we supply.
+   *
+   * @param txsHashes - A list of txsHashes (body hashes).
+   * @returns The requested L2 block bodies
+   */
+  getBlockBodies(txsHashes: Buffer[]): Promise<Body[]> {
+    const blockBodies = txsHashes.map(txsHash => this.l2BlockBodies.get(txsHash.toString('hex')));
+
+    if (blockBodies.some(bodyBuffer => bodyBuffer === undefined)) {
+      throw new Error('Block body is undefined');
+    }
+
+    return Promise.resolve(blockBodies as Body[]);
+  }
+
   /**
    * Append new logs to the store's list.
    * @param encryptedLogs - The encrypted logs to be added to the store.
@@ -153,11 +193,11 @@ export class MemoryArchiverStore implements ArchiverDataStore {
 
   /**
    * Remove pending L1 to L2 messages from the store (if they were cancelled).
-   * @param messages - The message keys to be removed from the store.
+   * @param messages - The entry keys to be removed from the store.
    * @param l1BlockNumber - The L1 block number for which to remove the messages.
    * @returns True if the operation is successful (always in this implementation).
    */
-  public cancelPendingL1ToL2Messages(messages: Fr[], l1BlockNumber: bigint): Promise<boolean> {
+  public cancelPendingL1ToL2EntryKeys(messages: Fr[], l1BlockNumber: bigint): Promise<boolean> {
     if (l1BlockNumber <= this.lastL1BlockCancelledMessages) {
       return Promise.resolve(false);
     }
@@ -172,13 +212,17 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   /**
    * Messages that have been published in an L2 block are confirmed.
    * Add them to the confirmed store, also remove them from the pending store.
-   * @param messageKeys - The message keys to be removed from the store.
+   * @param entryKeys - The entry keys to be removed from the store.
    * @returns True if the operation is successful (always in this implementation).
    */
-  public confirmL1ToL2Messages(messageKeys: Fr[]): Promise<boolean> {
-    messageKeys.forEach(messageKey => {
-      this.confirmedL1ToL2Messages.addMessage(messageKey, this.pendingL1ToL2Messages.getMessage(messageKey)!);
-      this.pendingL1ToL2Messages.removeMessage(messageKey);
+  public confirmL1ToL2EntryKeys(entryKeys: Fr[]): Promise<boolean> {
+    entryKeys.forEach(entryKey => {
+      if (entryKey.equals(Fr.ZERO)) {
+        return;
+      }
+
+      this.confirmedL1ToL2Messages.addMessage(entryKey, this.pendingL1ToL2Messages.getMessage(entryKey)!);
+      this.pendingL1ToL2Messages.removeMessage(entryKey);
     });
     return Promise.resolve(true);
   }
@@ -228,33 +272,51 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   }
 
   /**
-   * 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 effect.
+   * @returns The requested tx effect.
+   */
+  public getTxEffect(txHash: TxHash): Promise<TxEffect | undefined> {
+    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 getL2Tx(txHash: TxHash): Promise<L2Tx | undefined> {
-    const l2Tx = this.l2Txs.find(tx => tx.txHash.equals(txHash));
-    return Promise.resolve(l2Tx);
+  public getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
+    for (const blockContext of this.l2BlockContexts) {
+      for (const currentTxHash of blockContext.getTxHashes()) {
+        if (currentTxHash.equals(txHash)) {
+          return Promise.resolve(
+            new TxReceipt(txHash, TxStatus.MINED, '', blockContext.block.hash().toBuffer(), blockContext.block.number),
+          );
+        }
+      }
+    }
+    return Promise.resolve(undefined);
   }
 
   /**
    * Gets up to `limit` amount of pending L1 to L2 messages, sorted by fee
    * @param limit - The number of messages to return (by default NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).
-   * @returns The requested L1 to L2 message keys.
+   * @returns The requested L1 to L2 entry keys.
    */
-  public getPendingL1ToL2MessageKeys(limit: number = NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP): Promise<Fr[]> {
-    return Promise.resolve(this.pendingL1ToL2Messages.getMessageKeys(limit));
+  public getPendingL1ToL2EntryKeys(limit: number = NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP): Promise<Fr[]> {
+    return Promise.resolve(this.pendingL1ToL2Messages.getEntryKeys(limit));
   }
 
   /**
-   * Gets the confirmed L1 to L2 message corresponding to the given message key.
-   * @param messageKey - The message key to look up.
+   * Gets the confirmed L1 to L2 message corresponding to the given entry key.
+   * @param entryKey - The entry key to look up.
    * @returns The requested L1 to L2 message or throws if not found.
    */
-  public getConfirmedL1ToL2Message(messageKey: Fr): Promise<L1ToL2Message> {
-    const message = this.confirmedL1ToL2Messages.getMessage(messageKey);
+  public getConfirmedL1ToL2Message(entryKey: Fr): Promise<L1ToL2Message> {
+    const message = this.confirmedL1ToL2Messages.getMessage(entryKey);
     if (!message) {
-      throw new Error(`L1 to L2 Message with key ${messageKey.toString()} not found in the confirmed messages store`);
+      throw new Error(`L1 to L2 Message with key ${entryKey.toString()} not found in the confirmed messages store`);
     }
     return Promise.resolve(message);
   }
@@ -396,7 +458,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
       return Promise.resolve(undefined);
     }
     for (const blockContext of this.l2BlockContexts) {
-      for (const contractData of blockContext.block.newContractData) {
+      for (const contractData of blockContext.block.body.txEffects.flatMap(txEffect => txEffect.contractData)) {
         if (contractData.contractAddress.equals(contractAddress)) {
           return Promise.resolve(contractData);
         }
@@ -416,7 +478,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
       return Promise.resolve([]);
     }
     const block: L2Block | undefined = this.l2BlockContexts[l2BlockNum - INITIAL_L2_BLOCK_NUM]?.block;
-    return Promise.resolve(block?.newContractData);
+    return Promise.resolve(block?.body.txEffects.flatMap(txEffect => txEffect.contractData));
   }
 
   /**

package/src/index.ts

@@ -30,6 +30,7 @@ async function main() {
   const archiver = new Archiver(
     publicClient,
     l1Contracts.rollupAddress,
+    l1Contracts.availabilityOracleAddress,
     l1Contracts.inboxAddress,
     l1Contracts.registryAddress,
     l1Contracts.contractDeploymentEmitterAddress,

package/src/rpc/archiver_client.ts

@@ -6,6 +6,8 @@ import {
   L1ToL2Message,
   L2Block,
   L2BlockL2Logs,
+  NullifierMembershipWitness,
+  TxReceipt,
 } from '@aztec/circuit-types';
 import { EthAddress, Fr } from '@aztec/circuits.js';
 import { createJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
@@ -26,7 +28,7 @@ export const createArchiverClient = (url: string, fetch = makeFetch([1, 2, 3], t
       L2Block,
       L2BlockL2Logs,
     },
-    {},
+    { TxReceipt, NullifierMembershipWitness },
     false,
     'archiver',
     fetch,