@aztec/archiver 0.28.1 → 0.30.0

package/src/archiver/archiver.ts

@@ -1,10 +1,5 @@
 import {
-  ContractData,
-  ContractDataSource,
-  EncodedContractFunction,
-  ExtendedContractData,
   GetUnencryptedLogsResponse,
-  L1ToL2Message,
   L1ToL2MessageSource,
   L2Block,
   L2BlockL2Logs,
@@ -25,26 +20,23 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
-import { RollupAbi } from '@aztec/l1-artifacts';
 import { ClassRegistererAddress } from '@aztec/protocol-contracts/class-registerer';
-import { InstanceDeployerAddress } from '@aztec/protocol-contracts/instance-deployer';
 import {
-  ContractClass,
   ContractClassPublic,
-  ContractInstance,
+  ContractDataSource,
   ContractInstanceWithAddress,
+  PublicFunction,
 } from '@aztec/types/contracts';
 
-import { Chain, HttpTransport, PublicClient, createPublicClient, getAddress, getContract, http } from 'viem';
+import { Chain, HttpTransport, PublicClient, createPublicClient, http } from 'viem';
 
 import { ArchiverDataStore } from './archiver_store.js';
 import { ArchiverConfig } from './config.js';
 import {
+  DataRetrieval,
   retrieveBlockBodiesFromAvailabilityOracle,
   retrieveBlockMetadataFromRollup,
-  retrieveNewCancelledL1ToL2Messages,
-  retrieveNewL1ToL2Messages,
-  retrieveNewPendingL1ToL2Messages,
+  retrieveL1ToL2Messages,
 } from './data_retrieval.js';
 
 /**
@@ -73,7 +65,6 @@ export class Archiver implements ArchiveSource {
    * @param publicClient - A client for interacting with the Ethereum node.
    * @param rollupAddress - Ethereum address of the rollup contract.
    * @param inboxAddress - Ethereum address of the inbox contract.
-   * @param newInboxAddress - Ethereum address of the new inbox contract.
    * @param registryAddress - Ethereum address of the registry contract.
    * @param pollingIntervalMs - The interval for polling for L1 logs (in milliseconds).
    * @param store - An archiver data store for storage & retrieval of blocks, encrypted logs & contract data.
@@ -84,7 +75,6 @@ export class Archiver implements ArchiveSource {
     private readonly rollupAddress: EthAddress,
     private readonly availabilityOracleAddress: EthAddress,
     private readonly inboxAddress: EthAddress,
-    private readonly newInboxAddress: EthAddress,
     private readonly registryAddress: EthAddress,
     private readonly store: ArchiverDataStore,
     private readonly pollingIntervalMs = 10_000,
@@ -110,23 +100,11 @@ export class Archiver implements ArchiveSource {
       pollingInterval: config.viemPollingIntervalMS,
     });
 
-    // TODO(#4492): Nuke this once the old inbox is purged
-    let newInboxAddress!: EthAddress;
-    {
-      const rollup = getContract({
-        address: getAddress(config.l1Contracts.rollupAddress.toString()),
-        abi: RollupAbi,
-        client: publicClient,
-      });
-      newInboxAddress = EthAddress.fromString(await rollup.read.NEW_INBOX());
-    }
-
     const archiver = new Archiver(
       publicClient,
       config.l1Contracts.rollupAddress,
       config.l1Contracts.availabilityOracleAddress,
       config.l1Contracts.inboxAddress,
-      newInboxAddress,
       config.l1Contracts.registryAddress,
       archiverStore,
       config.archiverPollingIntervalMS,
@@ -170,15 +148,10 @@ export class Archiver implements ArchiveSource {
      *
      * This code does not handle reorgs.
      */
-    const lastL1Blocks = await this.store.getL1BlockNumber();
+    const lastL1Blocks = await this.store.getSynchedL1BlockNumbers();
     const currentL1BlockNumber = await this.publicClient.getBlockNumber();
 
-    if (
-      currentL1BlockNumber <= lastL1Blocks.addedBlock &&
-      currentL1BlockNumber <= lastL1Blocks.newMessages &&
-      currentL1BlockNumber <= lastL1Blocks.addedMessages &&
-      currentL1BlockNumber <= lastL1Blocks.cancelledMessages
-    ) {
+    if (currentL1BlockNumber <= lastL1Blocks.blocks && currentL1BlockNumber <= lastL1Blocks.messages) {
       // chain hasn't moved forward
       // or it's been rolled back
       return;
@@ -205,122 +178,82 @@ export class Archiver implements ArchiveSource {
 
     // ********** Events that are processed per L1 block **********
 
-    // TODO(#4492): Nuke the following when purging the old inbox
-    // Process l1ToL2Messages, these are consumed as time passes, not each block
-    const retrievedPendingL1ToL2Messages = await retrieveNewPendingL1ToL2Messages(
-      this.publicClient,
-      this.inboxAddress,
-      blockUntilSynced,
-      lastL1Blocks.addedMessages + 1n,
-      currentL1BlockNumber,
-    );
-    const retrievedCancelledL1ToL2Messages = await retrieveNewCancelledL1ToL2Messages(
+    // ********** Events that are processed per L2 block **********
+
+    const retrievedL1ToL2Messages = await retrieveL1ToL2Messages(
       this.publicClient,
       this.inboxAddress,
       blockUntilSynced,
-      lastL1Blocks.cancelledMessages + 1n,
+      lastL1Blocks.messages + 1n,
       currentL1BlockNumber,
     );
 
-    // group pending messages and cancelled messages by their L1 block number
-    const messagesByBlock = new Map<bigint, [L1ToL2Message[], Fr[]]>();
-    for (const [message, blockNumber] of retrievedPendingL1ToL2Messages.retrievedData) {
-      const messages = messagesByBlock.get(blockNumber) || [[], []];
-      messages[0].push(message);
-      messagesByBlock.set(blockNumber, messages);
-    }
-
-    for (const [entryKey, blockNumber] of retrievedCancelledL1ToL2Messages.retrievedData) {
-      const messages = messagesByBlock.get(blockNumber) || [[], []];
-      messages[1].push(entryKey);
-      messagesByBlock.set(blockNumber, messages);
-    }
-
-    // process messages from each L1 block in sequence
-    const l1BlocksWithMessages = Array.from(messagesByBlock.keys()).sort((a, b) => (a < b ? -1 : a === b ? 0 : 1));
-    for (const l1Block of l1BlocksWithMessages) {
-      const [newMessages, cancelledMessages] = messagesByBlock.get(l1Block)!;
+    if (retrievedL1ToL2Messages.retrievedData.length !== 0) {
       this.log(
-        `Adding ${newMessages.length} new messages and ${cancelledMessages.length} cancelled messages in L1 block ${l1Block}`,
+        `Retrieved ${retrievedL1ToL2Messages.retrievedData.length} new L1 -> L2 messages between L1 blocks ${
+          lastL1Blocks.messages + 1n
+        } and ${currentL1BlockNumber}.`,
       );
-      await this.store.addPendingL1ToL2Messages(newMessages, l1Block);
-      await this.store.cancelPendingL1ToL2EntryKeys(cancelledMessages, l1Block);
     }
 
-    // ********** Events that are processed per L2 block **********
-
-    const retrievedNewL1ToL2Messages = await retrieveNewL1ToL2Messages(
-      this.publicClient,
-      this.newInboxAddress,
-      blockUntilSynced,
-      lastL1Blocks.newMessages + 1n,
-      currentL1BlockNumber,
-    );
-    await this.store.addNewL1ToL2Messages(
-      retrievedNewL1ToL2Messages.retrievedData,
-      // -1n because the function expects the last block in which the message was emitted and not the one after next
-      // TODO(#4492): Check whether this could be cleaned up - `nextEthBlockNumber` value doesn't seem to be used much
-      retrievedNewL1ToL2Messages.nextEthBlockNumber - 1n,
-    );
+    await this.store.addL1ToL2Messages(retrievedL1ToL2Messages);
 
     // Read all data from chain and then write to our stores at the end
-    const nextExpectedL2BlockNum = BigInt((await this.store.getBlockNumber()) + 1);
+    const nextExpectedL2BlockNum = BigInt((await this.store.getSynchedL2BlockNumber()) + 1);
 
     const retrievedBlockBodies = await retrieveBlockBodiesFromAvailabilityOracle(
       this.publicClient,
       this.availabilityOracleAddress,
       blockUntilSynced,
-      lastL1Blocks.addedBlock + 1n,
+      lastL1Blocks.blocks + 1n,
       currentL1BlockNumber,
     );
 
     const blockBodies = retrievedBlockBodies.retrievedData.map(([blockBody]) => blockBody);
-
     await this.store.addBlockBodies(blockBodies);
 
-    const retrievedBlockMetadata = await retrieveBlockMetadataFromRollup(
-      this.publicClient,
-      this.rollupAddress,
-      blockUntilSynced,
-      lastL1Blocks.addedBlock + 1n,
-      currentL1BlockNumber,
-      nextExpectedL2BlockNum,
-    );
-
-    const retrievedBodyHashes = retrievedBlockMetadata.retrievedData.map(
-      ([header]) => header.contentCommitment.txsEffectsHash,
-    );
+    // Now that we have block bodies we will retrieve block metadata and build L2 blocks from the bodies and
+    // the metadata
+    let retrievedBlocks: DataRetrieval<L2Block>;
+    {
+      const retrievedBlockMetadata = await retrieveBlockMetadataFromRollup(
+        this.publicClient,
+        this.rollupAddress,
+        blockUntilSynced,
+        lastL1Blocks.blocks + 1n,
+        currentL1BlockNumber,
+        nextExpectedL2BlockNum,
+      );
 
-    const blockBodiesFromStore = await this.store.getBlockBodies(retrievedBodyHashes);
+      const retrievedBodyHashes = retrievedBlockMetadata.retrievedData.map(
+        ([header]) => header.contentCommitment.txsEffectsHash,
+      );
 
-    if (retrievedBlockMetadata.retrievedData.length !== blockBodiesFromStore.length) {
-      throw new Error('Block headers length does not equal block bodies length');
-    }
+      const blockBodiesFromStore = await this.store.getBlockBodies(retrievedBodyHashes);
 
-    const retrievedBlocks = {
-      retrievedData: retrievedBlockMetadata.retrievedData.map(
-        (blockMetadata, i) =>
-          new L2Block(blockMetadata[1], blockMetadata[0], blockBodiesFromStore[i], blockMetadata[2]),
-      ),
-    };
+      if (retrievedBlockMetadata.retrievedData.length !== blockBodiesFromStore.length) {
+        throw new Error('Block headers length does not equal block bodies length');
+      }
 
-    if (retrievedBlocks.retrievedData.length === 0) {
-      return;
-    } else {
-      this.log(
-        `Retrieved ${retrievedBlocks.retrievedData.length} new L2 blocks between L1 blocks ${
-          lastL1Blocks.addedBlock + 1n
-        } and ${currentL1BlockNumber}.`,
+      const blocks = retrievedBlockMetadata.retrievedData.map(
+        (blockMetadata, i) => new L2Block(blockMetadata[1], blockMetadata[0], blockBodiesFromStore[i]),
       );
-    }
 
-    // create the block number -> block hash mapping to ensure we retrieve the appropriate events
-    const blockNumberToBodyHash: { [key: number]: Buffer | undefined } = {};
-    retrievedBlocks.retrievedData.forEach((block: L2Block) => {
-      blockNumberToBodyHash[block.number] = block.header.contentCommitment.txsEffectsHash;
-    });
-
-    this.log(`Retrieved ${retrievedBlocks.retrievedData.length} block(s) from chain`);
+      if (blocks.length === 0) {
+        return;
+      } else {
+        this.log(
+          `Retrieved ${blocks.length} new L2 blocks between L1 blocks ${
+            lastL1Blocks.blocks + 1n
+          } and ${currentL1BlockNumber}.`,
+        );
+      }
+
+      retrievedBlocks = {
+        lastProcessedL1BlockNumber: retrievedBlockMetadata.lastProcessedL1BlockNumber,
+        retrievedData: blocks,
+      };
+    }
 
     await Promise.all(
       retrievedBlocks.retrievedData.map(block => {
@@ -343,14 +276,7 @@ export class Archiver implements ArchiveSource {
       }),
     );
 
-    // from retrieved L2Blocks, confirm L1 to L2 messages that have been published
-    // from each l2block fetch all entryKeys in a flattened array:
-    this.log(`Confirming l1 to l2 messages in store`);
-    for (const block of retrievedBlocks.retrievedData) {
-      await this.store.confirmL1ToL2EntryKeys(block.body.l1ToL2Messages);
-    }
-
-    await this.store.addBlocks(retrievedBlocks.retrievedData);
+    await this.store.addBlocks(retrievedBlocks);
   }
 
   /**
@@ -372,34 +298,13 @@ export class Archiver implements ArchiveSource {
    * @param allLogs - All logs emitted in a bunch of blocks.
    */
   private async storeDeployedContractInstances(allLogs: UnencryptedL2Log[], blockNum: number) {
-    const contractInstances = ContractInstanceDeployedEvent.fromLogs(allLogs, InstanceDeployerAddress).map(e =>
-      e.toContractInstance(),
-    );
+    const contractInstances = ContractInstanceDeployedEvent.fromLogs(allLogs).map(e => e.toContractInstance());
     if (contractInstances.length > 0) {
       contractInstances.forEach(c => this.log(`Storing contract instance at ${c.address.toString()}`));
       await this.store.addContractInstances(contractInstances, blockNum);
     }
   }
 
-  /**
-   * Stores extended contract data as classes and instances.
-   * Temporary solution until we source this data from the contract class registerer and instance deployer.
-   * @param contracts - The extended contract data to be stored.
-   * @param l2BlockNum - The L2 block number to which the contract data corresponds.
-   * TODO(palla/purge-old-contract-deploy): Delete this method
-   */
-  async storeContractDataAsClassesAndInstances(contracts: ExtendedContractData[], l2BlockNum: number) {
-    const classesAndInstances = contracts.map(extendedContractDataToContractClassAndInstance);
-    await this.store.addContractClasses(
-      classesAndInstances.map(([c, _]) => c),
-      l2BlockNum,
-    );
-    await this.store.addContractInstances(
-      classesAndInstances.map(([_, i]) => i),
-      l2BlockNum,
-    );
-  }
-
   /**
    * Stops the archiver.
    * @returns A promise signalling completion of the stop process.
@@ -438,7 +343,7 @@ export class Archiver implements ArchiveSource {
   public async getBlock(number: number): Promise<L2Block | undefined> {
     // If the number provided is -ve, then return the latest block.
     if (number < 0) {
-      number = await this.store.getBlockNumber();
+      number = await this.store.getSynchedL2BlockNumber();
     }
     const blocks = await this.store.getBlocks(number, 1);
     return blocks.length === 0 ? undefined : blocks[0];
@@ -452,72 +357,25 @@ export class Archiver implements ArchiveSource {
     return this.store.getSettledTxReceipt(txHash);
   }
 
-  /**
-   * Get the extended contract data for this contract.
-   * @param contractAddress - The contract data address.
-   * @returns The extended contract data or undefined if not found.
-   */
-  public async getExtendedContractData(contractAddress: AztecAddress): Promise<ExtendedContractData | undefined> {
-    return (
-      (await this.store.getExtendedContractData(contractAddress)) ?? this.makeExtendedContractDataFor(contractAddress)
-    );
-  }
-
-  /**
-   * Temporary method for creating a fake extended contract data out of classes and instances registered in the node.
-   * Used as a fallback if the extended contract data is not found.
-   * TODO(palla/purge-old-contract-deploy): Use proper classes
-   */
-  private async makeExtendedContractDataFor(address: AztecAddress): Promise<ExtendedContractData | undefined> {
-    const instance = await this.store.getContractInstance(address);
-    if (!instance) {
-      return undefined;
-    }
-
-    const contractClass = await this.store.getContractClass(instance.contractClassId);
-    if (!contractClass) {
-      this.log.warn(`Class ${instance.contractClassId.toString()} for address ${address.toString()} not found`);
-      return undefined;
-    }
-
-    return ExtendedContractData.fromClassAndInstance(contractClass, instance);
-  }
-
-  /**
-   * Lookup the contract data for this contract.
-   * Contains contract address & the ethereum portal address.
-   * @param contractAddress - The contract data address.
-   * @returns ContractData with the portal address (if we didn't throw an error).
-   */
-  public getContractData(contractAddress: AztecAddress): Promise<ContractData | undefined> {
-    return this.makeContractDataFor(contractAddress);
-  }
-
-  /**
-   * Temporary method for creating a fake contract data out of classes and instances registered in the node.
-   * Used as a fallback if the extended contract data is not found.
-   */
-  private async makeContractDataFor(address: AztecAddress): Promise<ContractData | undefined> {
-    const instance = await this.store.getContractInstance(address);
-    if (!instance) {
-      return undefined;
-    }
-
-    return new ContractData(address, instance.portalContractAddress);
-  }
-
   /**
    * Gets the public function data for a contract.
-   * @param contractAddress - The contract address containing the function to fetch.
+   * @param address - The contract address containing the function to fetch.
    * @param selector - The function selector of the function to fetch.
    * @returns The public function data (if found).
    */
   public async getPublicFunction(
-    contractAddress: AztecAddress,
+    address: AztecAddress,
     selector: FunctionSelector,
-  ): Promise<EncodedContractFunction | undefined> {
-    const contractData = await this.getExtendedContractData(contractAddress);
-    return contractData?.getPublicFunction(selector);
+  ): Promise<PublicFunction | undefined> {
+    const instance = await this.getContract(address);
+    if (!instance) {
+      throw new Error(`Contract ${address.toString()} not found`);
+    }
+    const contractClass = await this.getContractClass(instance.contractClassId);
+    if (!contractClass) {
+      throw new Error(`Contract class ${instance.contractClassId.toString()} for ${address.toString()} not found`);
+    }
+    return contractClass.publicFunctions.find(f => f.selector.equals(selector));
   }
 
   /**
@@ -545,7 +403,7 @@ export class Archiver implements ArchiveSource {
    * @returns The number of the latest L2 block processed by the block source implementation.
    */
   public getBlockNumber(): Promise<number> {
-    return this.store.getBlockNumber();
+    return this.store.getSynchedL2BlockNumber();
   }
 
   public getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
@@ -557,69 +415,24 @@ export class Archiver implements ArchiveSource {
   }
 
   /**
-   * Gets up to `limit` amount of pending L1 to L2 messages.
-   * @param limit - The number of messages to return.
-   * @returns The requested L1 to L2 messages' keys.
-   */
-  getPendingL1ToL2EntryKeys(limit: number): Promise<Fr[]> {
-    return this.store.getPendingL1ToL2EntryKeys(limit);
-  }
-
-  /**
-   * Gets the confirmed/consumed L1 to L2 message associated with the given entry key
-   * @param entryKey - The entry key.
-   * @returns The L1 to L2 message (throws if not found).
+   * 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).
    */
-  getConfirmedL1ToL2Message(entryKey: Fr): Promise<L1ToL2Message> {
-    return this.store.getConfirmedL1ToL2Message(entryKey);
+  getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]> {
+    return this.store.getL1ToL2Messages(blockNumber);
   }
 
   /**
-   * Gets new 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).
+   * 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).
    */
-  getNewL1ToL2Messages(blockNumber: bigint): Promise<Fr[]> {
-    return this.store.getNewL1ToL2Messages(blockNumber);
+  getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined> {
+    return this.store.getL1ToL2MessageIndex(l1ToL2Message);
   }
 
   getContractClassIds(): Promise<Fr[]> {
     return this.store.getContractClassIds();
   }
 }
-
-/**
- * Converts ExtendedContractData into contract classes and instances.
- * Note that the conversion is not correct, since there is some data missing from the broadcasted ExtendedContractData.
- * The archiver will trust the ids broadcasted instead of trying to recompute them.
- * Eventually this function and ExtendedContractData altogether will be removed.
- */
-function extendedContractDataToContractClassAndInstance(
-  data: ExtendedContractData,
-): [ContractClassPublic, ContractInstanceWithAddress] {
-  const contractClass: ContractClass = {
-    version: 1,
-    artifactHash: Fr.ZERO,
-    publicFunctions: data.publicFunctions.map(f => ({
-      selector: f.selector,
-      bytecode: f.bytecode,
-      isInternal: f.isInternal,
-    })),
-    privateFunctions: [],
-    packedBytecode: data.bytecode,
-  };
-  const contractClassId = data.contractClassId;
-  const contractInstance: ContractInstance = {
-    version: 1,
-    salt: data.saltedInitializationHash,
-    contractClassId,
-    initializationHash: data.saltedInitializationHash,
-    portalContractAddress: data.contractData.portalContractAddress,
-    publicKeysHash: data.publicKeyHash,
-  };
-  const address = data.contractData.contractAddress;
-  return [
-    { ...contractClass, id: contractClassId, privateFunctionsRoot: Fr.ZERO },
-    { ...contractInstance, address },
-  ];
-}

package/src/archiver/archiver_store.ts

@@ -1,13 +1,11 @@
 import {
   Body,
-  ExtendedContractData,
   GetUnencryptedLogsResponse,
-  L1ToL2Message,
+  InboxLeaf,
   L2Block,
   L2BlockL2Logs,
   LogFilter,
   LogType,
-  NewInboxLeaf,
   TxEffect,
   TxHash,
   TxReceipt,
@@ -16,19 +14,16 @@ import { Fr } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/types/contracts';
 
+import { DataRetrieval } from './data_retrieval.js';
+
 /**
  * Represents the latest L1 block processed by the archiver for various objects in L2.
  */
 export type ArchiverL1SynchPoint = {
   /** The last L1 block that added a new L2 block.  */
-  addedBlock: bigint;
-  /** The last L1 block that added messages from the new inbox. */
-  // TODO(#4492): Clean this up and fix the naming
-  newMessages: bigint;
-  /** The last L1 block that added pending messages */
-  addedMessages: bigint;
-  /** The last L1 block that cancelled messages */
-  cancelledMessages: bigint;
+  blocks: bigint;
+  /** The last L1 block that added L1 -> L2 messages from the Inbox. */
+  messages: bigint;
 };
 
 /**
@@ -38,10 +33,10 @@ export type ArchiverL1SynchPoint = {
 export interface ArchiverDataStore {
   /**
    * Append new blocks to the store's list.
-   * @param blocks - The L2 blocks to be added to the store.
+   * @param blocks - The L2 blocks to be added to the store and the last processed L1 block.
    * @returns True if the operation is successful.
    */
-  addBlocks(blocks: L2Block[]): Promise<boolean>;
+  addBlocks(blocks: DataRetrieval<L2Block>): Promise<boolean>;
 
   /**
    * Append new block bodies to the store's list.
@@ -94,59 +89,25 @@ export interface ArchiverDataStore {
   ): Promise<boolean>;
 
   /**
-   * 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.
-   * @returns True if the operation is successful.
-   */
-  addNewL1ToL2Messages(messages: NewInboxLeaf[], lastMessageL1BlockNumber: bigint): Promise<boolean>;
-
-  /**
-   * 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 block number of the L1 block that added the messages.
-   * @returns True if the operation is successful.
-   * TODO(#4492): Nuke the following when purging the old inbox
-   */
-  addPendingL1ToL2Messages(messages: L1ToL2Message[], l1BlockNumber: bigint): Promise<boolean>;
-
-  /**
-   * 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 block number of the L1 block that cancelled the messages.
+   * 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.
-   * TODO(#4492): Nuke the following when purging the old inbox
    */
-  cancelPendingL1ToL2EntryKeys(entryKeys: Fr[], l1BlockNumber: bigint): Promise<boolean>;
+  addL1ToL2Messages(messages: DataRetrieval<InboxLeaf>): Promise<boolean>;
 
   /**
-   * 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.
-   */
-  confirmL1ToL2EntryKeys(entryKeys: Fr[]): Promise<boolean>;
-
-  /**
-   * Gets up to `limit` amount of pending L1 to L2 messages, sorted by fee
-   * @param limit - The number of entries to return (by default NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).
-   * @returns The requested L1 to L2 entry keys.
-   */
-  getPendingL1ToL2EntryKeys(limit: number): Promise<Fr[]>;
-
-  /**
-   * 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 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).
    */
-  getConfirmedL1ToL2Message(entryKey: Fr): Promise<L1ToL2Message>;
+  getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]>;
 
   /**
-   * Gets new 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).
+   * 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).
    */
-  getNewL1ToL2Messages(blockNumber: bigint): Promise<Fr[]>;
+  getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined>;
 
   /**
    * Gets up to `limit` amount of logs starting from `from`.
@@ -164,31 +125,16 @@ export interface ArchiverDataStore {
    */
   getUnencryptedLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse>;
 
-  /**
-   * Add 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.
-   */
-  addExtendedContractData(data: ExtendedContractData[], blockNum: number): Promise<boolean>;
-
-  /**
-   * Get the extended contract data for this contract.
-   * @param contractAddress - The contract data address.
-   * @returns The extended contract data or undefined if not found.
-   */
-  getExtendedContractData(contractAddress: AztecAddress): Promise<ExtendedContractData | undefined>;
-
   /**
    * Gets the number of the latest L2 block processed.
    * @returns The number of the latest L2 block processed.
    */
-  getBlockNumber(): Promise<number>;
+  getSynchedL2BlockNumber(): Promise<number>;
 
   /**
-   * Gets the last L1 block number processed by the archiver
+   * Gets the synch point of the archiver
    */
-  getL1BlockNumber(): Promise<ArchiverL1SynchPoint>;
+  getSynchedL1BlockNumbers(): Promise<ArchiverL1SynchPoint>;
 
   /**
    * Add new contract classes from an L2 block to the store's list.