@aztec/archiver 0.28.1 → 0.30.0

package/src/archiver/kv_archiver_store/message_store.ts

@@ -1,168 +1,66 @@
-import { L1ToL2Message, NewInboxLeaf } from '@aztec/circuit-types';
-import { Fr, L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/circuits.js';
+import { InboxLeaf } from '@aztec/circuit-types';
+import {
+  Fr,
+  INITIAL_L2_BLOCK_NUM,
+  L1_TO_L2_MSG_SUBTREE_HEIGHT,
+  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+} from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { AztecCounter, AztecKVStore, AztecMap, AztecSingleton } from '@aztec/kv-store';
+import { AztecKVStore, AztecMap, AztecSingleton } from '@aztec/kv-store';
 
-/**
- * A message stored in the database
- */
-type Message = {
-  /** The L1ToL2Message */
-  message: Buffer;
-  /** The message's fee */
-  fee: number;
-  /** Has it _ever_ been confirmed? */
-  confirmed: boolean;
-};
+import { DataRetrieval } from '../data_retrieval.js';
 
 /**
  * LMDB implementation of the ArchiverDataStore interface.
  */
 export class MessageStore {
-  #newMessages: AztecMap<string, Buffer>;
-  #lastL1BlockNewMessages: AztecSingleton<bigint>;
-  // TODO(#4492): Nuke the following when purging the old inbox
-  #pendingMessagesByFee: AztecCounter<[number, string]>;
-  #messages: AztecMap<string, Message>;
-  #lastL1BlockAddingMessages: AztecSingleton<bigint>;
-  #lastL1BlockCancellingMessages: AztecSingleton<bigint>;
+  #l1ToL2Messages: AztecMap<string, Buffer>;
+  #l1ToL2MessageIndices: AztecMap<string, bigint>;
+  #lastL1BlockMessages: AztecSingleton<bigint>;
 
   #log = createDebugLogger('aztec:archiver:message_store');
 
   #l1ToL2MessagesSubtreeSize = 2 ** L1_TO_L2_MSG_SUBTREE_HEIGHT;
 
   constructor(private db: AztecKVStore) {
-    this.#newMessages = db.openMap('archiver_l1_to_l2_new_messages');
-    this.#messages = db.openMap('archiver_l1_to_l2_messages');
-    this.#pendingMessagesByFee = db.openCounter('archiver_messages_by_fee');
-    this.#lastL1BlockNewMessages = db.openSingleton('archiver_last_l1_block_new_messages');
-    this.#lastL1BlockAddingMessages = db.openSingleton('archiver_last_l1_block_adding_messages');
-    this.#lastL1BlockCancellingMessages = db.openSingleton('archiver_last_l1_block_cancelling_messages');
+    this.#l1ToL2Messages = db.openMap('archiver_l1_to_l2_messages');
+    this.#l1ToL2MessageIndices = db.openMap('archiver_l1_to_l2_message_indices');
+    this.#lastL1BlockMessages = db.openSingleton('archiver_last_l1_block_new_messages');
   }
 
   /**
-   * Gets the last L1 block number that emitted new messages and the block that cancelled messages.
+   * Gets the last L1 block number that emitted new messages.
    * @returns The last L1 block number processed
    */
-  getL1BlockNumber() {
-    return {
-      newMessages: this.#lastL1BlockNewMessages.get() ?? 0n,
-      // TODO(#4492): Nuke the following when purging the old inbox
-      addedMessages: this.#lastL1BlockAddingMessages.get() ?? 0n,
-      cancelledMessages: this.#lastL1BlockCancellingMessages.get() ?? 0n,
-    };
+  getSynchedL1BlockNumber(): bigint {
+    return this.#lastL1BlockMessages.get() ?? 0n;
   }
 
   /**
-   * Append new L1 to L2 messages to the store.
-   * @param messages - The L1 to L2 messages to be added to the store.
-   * @param lastMessageL1BlockNumber - The L1 block number in which the last message was emitted.
+   * 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.
    * @returns True if the operation is successful.
    */
-  addNewL1ToL2Messages(messages: NewInboxLeaf[], lastMessageL1BlockNumber: bigint): Promise<boolean> {
+  addL1ToL2Messages(messages: DataRetrieval<InboxLeaf>): Promise<boolean> {
     return this.db.transaction(() => {
-      const lastL1BlockNumber = this.#lastL1BlockNewMessages.get() ?? 0n;
-      if (lastL1BlockNumber >= lastMessageL1BlockNumber) {
+      const lastL1BlockNumber = this.#lastL1BlockMessages.get() ?? 0n;
+      if (lastL1BlockNumber >= messages.lastProcessedL1BlockNumber) {
         return false;
       }
 
-      void this.#lastL1BlockNewMessages.set(lastMessageL1BlockNumber);
+      void this.#lastL1BlockMessages.set(messages.lastProcessedL1BlockNumber);
 
-      for (const message of messages) {
+      for (const message of messages.retrievedData) {
         if (message.index >= this.#l1ToL2MessagesSubtreeSize) {
           throw new Error(`Message index ${message.index} out of subtree range`);
         }
         const key = `${message.blockNumber}-${message.index}`;
-        void this.#newMessages.setIfNotExists(key, message.leaf.toBuffer());
-      }
-
-      return true;
-    });
-  }
-
-  /**
-   * Append new pending L1 to L2 messages to the store.
-   * @param messages - The L1 to L2 messages to be added to the store.
-   * @param l1BlockNumber - The L1 block number for which to add the messages.
-   * @returns True if the operation is successful.
-   */
-  addPendingMessages(messages: L1ToL2Message[], l1BlockNumber: bigint): Promise<boolean> {
-    return this.db.transaction(() => {
-      const lastL1BlockNumber = this.#lastL1BlockAddingMessages.get() ?? 0n;
-      if (lastL1BlockNumber >= l1BlockNumber) {
-        return false;
-      }
-
-      void this.#lastL1BlockAddingMessages.set(l1BlockNumber);
-
-      for (const message of messages) {
-        const entryKey = message.entryKey?.toString();
-        if (!entryKey) {
-          throw new Error('Message does not have an entry key');
-        }
-
-        void this.#messages.setIfNotExists(entryKey, {
-          message: message.toBuffer(),
-          fee: message.fee,
-          confirmed: false,
-        });
-
-        void this.#pendingMessagesByFee.update([message.fee, entryKey], 1);
-      }
-
-      return true;
-    });
-  }
-
-  /**
-   * Remove pending L1 to L2 messages from the store (if they were cancelled).
-   * @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(entryKeys: Fr[], l1BlockNumber: bigint): Promise<boolean> {
-    return this.db.transaction(() => {
-      const lastL1BlockNumber = this.#lastL1BlockCancellingMessages.get() ?? 0n;
-      if (lastL1BlockNumber >= l1BlockNumber) {
-        return false;
-      }
-
-      void this.#lastL1BlockCancellingMessages.set(l1BlockNumber);
-
-      for (const entryKey of entryKeys) {
-        const messageCtx = this.#messages.get(entryKey.toString());
-        if (!messageCtx) {
-          throw new Error(`Message ${entryKey.toString()} not found`);
-        }
-
-        void this.#pendingMessagesByFee.update([messageCtx.fee, entryKey.toString()], -1);
-      }
-
-      return true;
-    });
-  }
-
-  /**
-   * 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 entry keys to be removed from the store.
-   * @returns True if the operation is successful.
-   */
-  confirmPendingMessages(entryKeys: Fr[]): Promise<boolean> {
-    return this.db.transaction(() => {
-      for (const entryKey of entryKeys) {
-        if (entryKey.equals(Fr.ZERO)) {
-          continue;
-        }
-
-        const messageCtx = this.#messages.get(entryKey.toString());
-        if (!messageCtx) {
-          throw new Error(`Message ${entryKey.toString()} not found`);
-        }
-        messageCtx.confirmed = true;
+        void this.#l1ToL2Messages.setIfNotExists(key, message.leaf.toBuffer());
 
-        void this.#messages.set(entryKey.toString(), messageCtx);
-        void this.#pendingMessagesByFee.update([messageCtx.fee, entryKey.toString()], -1);
+        const indexInTheWholeTree =
+          (message.blockNumber - BigInt(INITIAL_L2_BLOCK_NUM)) * BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP) +
+          message.index;
+        void this.#l1ToL2MessageIndices.setIfNotExists(message.leaf.toString(), indexInTheWholeTree);
       }
 
       return true;
@@ -170,51 +68,22 @@ export class MessageStore {
   }
 
   /**
-   * 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.
+   * Gets the L1 to L2 message index in the L1 to L2 message tree.
+   * @param l1ToL2Message - The L1 to L2 message.
+   * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
    */
-  getConfirmedMessage(entryKey: Fr): L1ToL2Message {
-    const messageCtx = this.#messages.get(entryKey.toString());
-    if (!messageCtx) {
-      throw new Error(`Message ${entryKey.toString()} not found`);
-    }
-
-    if (!messageCtx.confirmed) {
-      throw new Error(`Message ${entryKey.toString()} not confirmed`);
-    }
-
-    return L1ToL2Message.fromBuffer(messageCtx.message);
-  }
-
-  /**
-   * 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 entry keys.
-   */
-  getPendingEntryKeysByFee(limit: number): Fr[] {
-    const entryKeys: Fr[] = [];
-
-    for (const [[_, entryKey], count] of this.#pendingMessagesByFee.entries({
-      reverse: true,
-    })) {
-      // put `count` copies of this message in the result list
-      entryKeys.push(...Array(count).fill(Fr.fromString(entryKey)));
-      if (entryKeys.length >= limit) {
-        break;
-      }
-    }
-
-    return entryKeys;
+  public getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined> {
+    const index = this.#l1ToL2MessageIndices.get(l1ToL2Message.toString());
+    return Promise.resolve(index);
   }
 
-  getNewL1ToL2Messages(blockNumber: bigint): Fr[] {
+  getL1ToL2Messages(blockNumber: bigint): Fr[] {
     const messages: Fr[] = [];
     let undefinedMessageFound = false;
     for (let messageIndex = 0; messageIndex < this.#l1ToL2MessagesSubtreeSize; messageIndex++) {
       // This is inefficient but probably fine for now.
       const key = `${blockNumber}-${messageIndex}`;
-      const message = this.#newMessages.get(key);
+      const message = this.#l1ToL2Messages.get(key);
       if (message) {
         if (undefinedMessageFound) {
           throw new Error(`L1 to L2 message gap found in block ${blockNumber}`);

package/src/archiver/memory_archiver_store/l1_to_l2_message_store.ts

@@ -1,13 +1,15 @@
-import { L1ToL2Message, NewInboxLeaf } from '@aztec/circuit-types';
-import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/circuits.js/constants';
+import { InboxLeaf } from '@aztec/circuit-types';
+import {
+  INITIAL_L2_BLOCK_NUM,
+  L1_TO_L2_MSG_SUBTREE_HEIGHT,
+  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+} from '@aztec/circuits.js/constants';
 import { Fr } from '@aztec/foundation/fields';
 
 /**
- * A simple in-memory implementation of an L1 to L2 message store
- * that handles message duplication.
- * TODO(#4492): Clean this up
+ * A simple in-memory implementation of an L1 to L2 message store.
  */
-export class NewL1ToL2MessageStore {
+export class L1ToL2MessageStore {
   /**
    * A map containing the entry key to the corresponding L1 to L2
    * messages (and the number of times the message has been seen).
@@ -18,7 +20,7 @@ export class NewL1ToL2MessageStore {
 
   constructor() {}
 
-  addMessage(message: NewInboxLeaf) {
+  addMessage(message: InboxLeaf) {
     if (message.index >= this.#l1ToL2MessagesSubtreeSize) {
       throw new Error(`Message index ${message.index} out of subtree range`);
     }
@@ -46,93 +48,22 @@ export class NewL1ToL2MessageStore {
     }
     return messages;
   }
-}
 
-/**
- * A simple in-memory implementation of an L1 to L2 message store
- * that handles message duplication.
- */
-export class L1ToL2MessageStore {
   /**
-   * A map containing the entry key to the corresponding L1 to L2
-   * messages (and the number of times the message has been seen).
+   * Gets the L1 to L2 message index in the L1 to L2 message tree.
+   * @param l1ToL2Message - The L1 to L2 message.
+   * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
    */
-  protected store: Map<bigint, L1ToL2MessageAndCount> = new Map();
-
-  constructor() {}
-
-  addMessage(entryKey: Fr, message: L1ToL2Message) {
-    const entryKeyBigInt = entryKey.toBigInt();
-    const msgAndCount = this.store.get(entryKeyBigInt);
-    if (msgAndCount) {
-      msgAndCount.count++;
-    } else {
-      this.store.set(entryKeyBigInt, { message, count: 1 });
-    }
-  }
-
-  getMessage(entryKey: Fr): L1ToL2Message | undefined {
-    return this.store.get(entryKey.value)?.message;
-  }
-
-  getMessageAndCount(entryKey: Fr): L1ToL2MessageAndCount | undefined {
-    return this.store.get(entryKey.value);
-  }
-}
-
-/**
- * Specifically for the store that will hold pending messages
- * for removing messages or fetching multiple messages.
- */
-export class PendingL1ToL2MessageStore extends L1ToL2MessageStore {
-  getEntryKeys(limit: number): Fr[] {
-    if (limit < 1) {
-      return [];
-    }
-    // fetch `limit` number of messages from the store with the highest fee.
-    // Note the store has multiple of the same message. So if a message has count 2, include both of them in the result:
-    const messages: Fr[] = [];
-    const sortedMessages = Array.from(this.store.values()).sort((a, b) => b.message.fee - a.message.fee);
-    for (const messageAndCount of sortedMessages) {
-      for (let i = 0; i < messageAndCount.count; i++) {
-        messages.push(messageAndCount.message.entryKey!);
-        if (messages.length === limit) {
-          return messages;
-        }
+  getMessageIndex(l1ToL2Message: Fr): bigint | undefined {
+    for (const [key, message] of this.store.entries()) {
+      if (message.equals(l1ToL2Message)) {
+        const [blockNumber, messageIndex] = key.split('-');
+        const indexInTheWholeTree =
+          (BigInt(blockNumber) - BigInt(INITIAL_L2_BLOCK_NUM)) * BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP) +
+          BigInt(messageIndex);
+        return indexInTheWholeTree;
       }
     }
-    return messages;
-  }
-
-  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 entryKeyBigInt = entryKey.value;
-    const msgAndCount = this.store.get(entryKeyBigInt);
-    if (!msgAndCount) {
-      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(entryKeyBigInt);
-    }
+    return undefined;
   }
 }
-
-/**
- * Useful to keep track of the number of times a message has been seen.
- */
-type L1ToL2MessageAndCount = {
-  /**
-   * The message.
-   */
-  message: L1ToL2Message;
-  /**
-   * The number of times the message has been seen.
-   */
-  count: number;
-};

package/src/archiver/memory_archiver_store/memory_archiver_store.ts

@@ -1,28 +1,27 @@
 import {
   Body,
-  ExtendedContractData,
   ExtendedUnencryptedL2Log,
   GetUnencryptedLogsResponse,
-  L1ToL2Message,
+  InboxLeaf,
   L2Block,
   L2BlockContext,
   L2BlockL2Logs,
   LogFilter,
   LogId,
   LogType,
-  NewInboxLeaf,
   TxEffect,
   TxHash,
   TxReceipt,
   TxStatus,
   UnencryptedL2Log,
 } from '@aztec/circuit-types';
-import { Fr, INITIAL_L2_BLOCK_NUM, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/circuits.js';
+import { Fr, INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/types/contracts';
 
-import { ArchiverDataStore } from '../archiver_store.js';
-import { L1ToL2MessageStore, NewL1ToL2MessageStore, PendingL1ToL2MessageStore } from './l1_to_l2_message_store.js';
+import { ArchiverDataStore, ArchiverL1SynchPoint } from '../archiver_store.js';
+import { DataRetrieval } from '../data_retrieval.js';
+import { L1ToL2MessageStore } from './l1_to_l2_message_store.js';
 
 /**
  * Simple, in-memory implementation of an archiver data store.
@@ -56,36 +55,16 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   private unencryptedLogsPerBlock: L2BlockL2Logs[] = [];
 
   /**
-   * A sparse array containing all the extended contract data that have been fetched so far.
+   * Contains all L1 to L2 messages.
    */
-  private extendedContractDataByBlock: (ExtendedContractData[] | undefined)[] = [];
-
-  /**
-   * A mapping of contract address to extended contract data.
-   */
-  private extendedContractData: Map<string, ExtendedContractData> = new Map();
-
-  // TODO(#4492): Nuke the other message stores
-  private newL1ToL2Messages = new NewL1ToL2MessageStore();
-
-  /**
-   * Contains all the confirmed L1 to L2 messages (i.e. messages that were consumed in an L2 block)
-   * It is a map of entryKey to the corresponding L1 to L2 message and the number of times it has appeared
-   */
-  private confirmedL1ToL2Messages: L1ToL2MessageStore = new L1ToL2MessageStore();
-
-  /**
-   * Contains all the pending L1 to L2 messages (accounts for duplication of messages)
-   */
-  private pendingL1ToL2Messages: PendingL1ToL2MessageStore = new PendingL1ToL2MessageStore();
+  private l1ToL2Messages = new L1ToL2MessageStore();
 
   private contractClasses: Map<string, ContractClassPublic> = new Map();
 
   private contractInstances: Map<string, ContractInstanceWithAddress> = new Map();
 
+  private lastL1BlockNewBlocks: bigint = 0n;
   private lastL1BlockNewMessages: bigint = 0n;
-  private lastL1BlockAddedMessages: bigint = 0n;
-  private lastL1BlockCancelledMessages: bigint = 0n;
 
   constructor(
     /** The max number of logs that can be obtained in 1 "getUnencryptedLogs" call. */
@@ -120,12 +99,13 @@ export class MemoryArchiverStore implements ArchiverDataStore {
 
   /**
    * Append new blocks to the store's list.
-   * @param blocks - The L2 blocks to be added to the store.
-   * @returns True if the operation is successful (always in this implementation).
+   * @param blocks - The L2 blocks to be added to the store and the last processed L1 block.
+   * @returns True if the operation is successful.
    */
-  public addBlocks(blocks: L2Block[]): Promise<boolean> {
-    this.l2BlockContexts.push(...blocks.map(block => new L2BlockContext(block)));
-    this.txEffects.push(...blocks.flatMap(b => b.getTxs()));
+  public addBlocks(blocks: DataRetrieval<L2Block>): Promise<boolean> {
+    this.lastL1BlockNewBlocks = blocks.lastProcessedL1BlockNumber;
+    this.l2BlockContexts.push(...blocks.retrievedData.map(block => new L2BlockContext(block)));
+    this.txEffects.push(...blocks.retrievedData.flatMap(b => b.getTxs()));
     return Promise.resolve(true);
   }
 
@@ -178,97 +158,29 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   }
 
   /**
-   * Append new L1 to L2 messages to the store.
-   * @param messages - The L1 to L2 messages to be added to the store.
-   * @param lastMessageL1BlockNumber - The L1 block number in which the last message was emitted.
+   * 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.
    * @returns True if the operation is successful.
    */
-  public addNewL1ToL2Messages(messages: NewInboxLeaf[], lastMessageL1BlockNumber: bigint): Promise<boolean> {
-    if (lastMessageL1BlockNumber <= this.lastL1BlockNewMessages) {
-      return Promise.resolve(false);
-    }
-
-    this.lastL1BlockNewMessages = lastMessageL1BlockNumber;
-    for (const message of messages) {
-      this.newL1ToL2Messages.addMessage(message);
-    }
-    return Promise.resolve(true);
-  }
-
-  /**
-   * Append new pending L1 to L2 messages to the store.
-   * @param messages - The L1 to L2 messages to be added to the store.
-   * @param l1BlockNumber - The L1 block number for which to add the messages.
-   * @returns True if the operation is successful (always in this implementation).
-   */
-  public addPendingL1ToL2Messages(messages: L1ToL2Message[], l1BlockNumber: bigint): Promise<boolean> {
-    if (l1BlockNumber <= this.lastL1BlockAddedMessages) {
+  public addL1ToL2Messages(messages: DataRetrieval<InboxLeaf>): Promise<boolean> {
+    if (messages.lastProcessedL1BlockNumber <= this.lastL1BlockNewMessages) {
       return Promise.resolve(false);
     }
 
-    this.lastL1BlockAddedMessages = l1BlockNumber;
-    for (const message of messages) {
-      this.pendingL1ToL2Messages.addMessage(message.entryKey!, message);
-    }
-    return Promise.resolve(true);
-  }
-
-  /**
-   * Remove pending L1 to L2 messages from the store (if they were cancelled).
-   * @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 cancelPendingL1ToL2EntryKeys(messages: Fr[], l1BlockNumber: bigint): Promise<boolean> {
-    if (l1BlockNumber <= this.lastL1BlockCancelledMessages) {
-      return Promise.resolve(false);
+    this.lastL1BlockNewMessages = messages.lastProcessedL1BlockNumber;
+    for (const message of messages.retrievedData) {
+      this.l1ToL2Messages.addMessage(message);
     }
-
-    this.lastL1BlockCancelledMessages = l1BlockNumber;
-    messages.forEach(entryKey => {
-      this.pendingL1ToL2Messages.removeMessage(entryKey);
-    });
-    return Promise.resolve(true);
-  }
-
-  /**
-   * 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 entry keys to be removed from the store.
-   * @returns True if the operation is successful (always in this implementation).
-   */
-  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);
   }
 
   /**
-   * Store new extended contract data from an L2 block to the store's list.
-   * @param data - List of contracts' data to be added.
-   * @param blockNum - Number of the L2 block the contract data was deployed in.
-   * @returns True if the operation is successful (always in this implementation).
+   * Gets the L1 to L2 message index in the L1 to L2 message tree.
+   * @param l1ToL2Message - The L1 to L2 message.
+   * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
    */
-  public addExtendedContractData(data: ExtendedContractData[], blockNum: number): Promise<boolean> {
-    // Add to the contracts mapping
-    for (const contractData of data) {
-      const key = contractData.contractData.contractAddress.toString();
-      this.extendedContractData.set(key, contractData);
-    }
-
-    // Add the index per block
-    if (this.extendedContractDataByBlock[blockNum]?.length) {
-      this.extendedContractDataByBlock[blockNum]?.push(...data);
-    } else {
-      this.extendedContractDataByBlock[blockNum] = [...data];
-    }
-    return Promise.resolve(true);
+  public getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined> {
+    return Promise.resolve(this.l1ToL2Messages.getMessageIndex(l1ToL2Message));
   }
 
   /**
@@ -322,34 +234,12 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   }
 
   /**
-   * 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 entry keys.
-   */
-  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 entry key.
-   * @param entryKey - The entry key to look up.
-   * @returns The requested L1 to L2 message or throws if not found.
-   */
-  public getConfirmedL1ToL2Message(entryKey: Fr): Promise<L1ToL2Message> {
-    const message = this.confirmedL1ToL2Messages.getMessage(entryKey);
-    if (!message) {
-      throw new Error(`L1 to L2 Message with key ${entryKey.toString()} not found in the confirmed messages store`);
-    }
-    return Promise.resolve(message);
-  }
-
-  /**
-   * Gets new L1 to L2 message (to be) included in a given block.
+   * Gets L1 to L2 message (to be) included in a given block.
    * @param blockNumber - L2 block number to get messages for.
    * @returns The L1 to L2 messages/leaves of the messages subtree (throws if not found).
    */
-  getNewL1ToL2Messages(blockNumber: bigint): Promise<Fr[]> {
-    return Promise.resolve(this.newL1ToL2Messages.getMessages(blockNumber));
+  getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]> {
+    return Promise.resolve(this.l1ToL2Messages.getMessages(blockNumber));
   }
 
   /**
@@ -456,39 +346,21 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     });
   }
 
-  /**
-   * Get the extended contract data for this contract.
-   * TODO(palla/purge-old-contract-deploy): Delete me?
-   * @param contractAddress - The contract data address.
-   * @returns The extended contract data or undefined if not found.
-   */
-  getExtendedContractData(contractAddress: AztecAddress): Promise<ExtendedContractData | undefined> {
-    const result = this.extendedContractData.get(contractAddress.toString());
-    return Promise.resolve(result);
-  }
-
   /**
    * Gets the number of the latest L2 block processed.
    * @returns The number of the latest L2 block processed.
    */
-  public getBlockNumber(): Promise<number> {
+  public getSynchedL2BlockNumber(): Promise<number> {
     if (this.l2BlockContexts.length === 0) {
       return Promise.resolve(INITIAL_L2_BLOCK_NUM - 1);
     }
     return Promise.resolve(this.l2BlockContexts[this.l2BlockContexts.length - 1].block.number);
   }
 
-  public getL1BlockNumber() {
-    const addedBlock = this.l2BlockContexts[this.l2BlockContexts.length - 1]?.block?.getL1BlockNumber() ?? 0n;
-    const newMessages = this.lastL1BlockNewMessages;
-    const addedMessages = this.lastL1BlockAddedMessages;
-    const cancelledMessages = this.lastL1BlockCancelledMessages;
-
+  public getSynchedL1BlockNumbers(): Promise<ArchiverL1SynchPoint> {
     return Promise.resolve({
-      addedBlock,
-      newMessages,
-      addedMessages,
-      cancelledMessages,
+      blocks: this.lastL1BlockNewBlocks,
+      messages: this.lastL1BlockNewMessages,
     });
   }
 }