@aztec/archiver 0.30.0 → 0.31.0

package/src/archiver/archiver_store_test_suite.ts

@@ -1,7 +1,12 @@
 import { InboxLeaf, L2Block, L2BlockContext, LogId, LogType, TxHash, UnencryptedL2Log } from '@aztec/circuit-types';
 import '@aztec/circuit-types/jest';
 import { AztecAddress, Fr, INITIAL_L2_BLOCK_NUM, L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/circuits.js';
-import { makeContractClassPublic } from '@aztec/circuits.js/testing';
+import {
+  makeContractClassPublic,
+  makeExecutablePrivateFunctionWithMembershipProof,
+  makeUnconstrainedFunctionWithMembershipProof,
+} from '@aztec/circuits.js/testing';
+import { times } from '@aztec/foundation/collection';
 import { randomBytes, randomInt } from '@aztec/foundation/crypto';
 import { ContractClassPublic, ContractInstanceWithAddress, SerializableContractInstance } from '@aztec/types/contracts';
 
@@ -81,19 +86,19 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       });
     });
 
-    describe('getSynchedL1BlockNumbers', () => {
+    describe('getSynchPoint', () => {
       it('returns 0n if no blocks have been added', async () => {
-        await expect(store.getSynchedL1BlockNumbers()).resolves.toEqual({
-          blocks: 0n,
-          messages: 0n,
+        await expect(store.getSynchPoint()).resolves.toEqual({
+          blocksSynchedTo: 0n,
+          messagesSynchedTo: 0n,
         });
       });
 
       it('returns the L1 block number in which the most recent L2 block was published', async () => {
         await store.addBlocks(blocks);
-        await expect(store.getSynchedL1BlockNumbers()).resolves.toEqual({
-          blocks: blocks.lastProcessedL1BlockNumber,
-          messages: 0n,
+        await expect(store.getSynchPoint()).resolves.toEqual({
+          blocksSynchedTo: blocks.lastProcessedL1BlockNumber,
+          messagesSynchedTo: 0n,
         });
       });
 
@@ -102,9 +107,9 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
           lastProcessedL1BlockNumber: 1n,
           retrievedData: [new InboxLeaf(0n, 0n, Fr.ZERO)],
         });
-        await expect(store.getSynchedL1BlockNumbers()).resolves.toEqual({
-          blocks: 0n,
-          messages: 1n,
+        await expect(store.getSynchPoint()).resolves.toEqual({
+          blocksSynchedTo: 0n,
+          messagesSynchedTo: 1n,
         });
       });
     });
@@ -206,6 +211,20 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
           await store.addL1ToL2Messages({ lastProcessedL1BlockNumber: 100n, retrievedData: msgs });
         }).rejects.toThrow(`Message index ${l1ToL2MessageSubtreeSize} out of subtree range`);
       });
+
+      it('correctly handles duplicate messages', async () => {
+        const messageHash = Fr.random();
+
+        const msgs = [new InboxLeaf(1n, 0n, messageHash), new InboxLeaf(2n, 0n, messageHash)];
+
+        await store.addL1ToL2Messages({ lastProcessedL1BlockNumber: 100n, retrievedData: msgs });
+
+        const index1 = (await store.getL1ToL2MessageIndex(messageHash, 0n))!;
+        const index2 = await store.getL1ToL2MessageIndex(messageHash, index1 + 1n);
+
+        expect(index2).toBeDefined();
+        expect(index2).toBeGreaterThan(index1);
+      });
     });
 
     describe('contractInstances', () => {
@@ -242,6 +261,36 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       it('returns undefined if contract class is not found', async () => {
         await expect(store.getContractClass(Fr.random())).resolves.toBeUndefined();
       });
+
+      it('adds new private functions', async () => {
+        const fns = times(3, makeExecutablePrivateFunctionWithMembershipProof);
+        await store.addFunctions(contractClass.id, fns, []);
+        const stored = await store.getContractClass(contractClass.id);
+        expect(stored?.privateFunctions).toEqual(fns);
+      });
+
+      it('does not duplicate private functions', async () => {
+        const fns = times(3, makeExecutablePrivateFunctionWithMembershipProof);
+        await store.addFunctions(contractClass.id, fns.slice(0, 1), []);
+        await store.addFunctions(contractClass.id, fns, []);
+        const stored = await store.getContractClass(contractClass.id);
+        expect(stored?.privateFunctions).toEqual(fns);
+      });
+
+      it('adds new unconstrained functions', async () => {
+        const fns = times(3, makeUnconstrainedFunctionWithMembershipProof);
+        await store.addFunctions(contractClass.id, [], fns);
+        const stored = await store.getContractClass(contractClass.id);
+        expect(stored?.unconstrainedFunctions).toEqual(fns);
+      });
+
+      it('does not duplicate unconstrained functions', async () => {
+        const fns = times(3, makeUnconstrainedFunctionWithMembershipProof);
+        await store.addFunctions(contractClass.id, [], fns.slice(0, 1));
+        await store.addFunctions(contractClass.id, [], fns);
+        const stored = await store.getContractClass(contractClass.id);
+        expect(stored?.unconstrainedFunctions).toEqual(fns);
+      });
     });
 
     describe('getUnencryptedLogs', () => {

package/src/archiver/data_retrieval.ts

@@ -6,10 +6,10 @@ import { PublicClient } from 'viem';
 
 import {
   getL2BlockProcessedLogs,
-  getLeafInsertedLogs,
+  getMessageSentLogs,
   getTxsPublishedLogs,
   processL2BlockProcessedLogs,
-  processLeafInsertedLogs,
+  processMessageSentLogs,
   processTxsPublishedLogs,
 } from './eth_log_handlers.js';
 
@@ -132,14 +132,14 @@ export async function retrieveL1ToL2Messages(
     if (searchStartBlock > searchEndBlock) {
       break;
     }
-    const leafInsertedLogs = await getLeafInsertedLogs(publicClient, inboxAddress, searchStartBlock, searchEndBlock);
-    if (leafInsertedLogs.length === 0) {
+    const messageSentLogs = await getMessageSentLogs(publicClient, inboxAddress, searchStartBlock, searchEndBlock);
+    if (messageSentLogs.length === 0) {
       break;
     }
-    const l1ToL2Messages = processLeafInsertedLogs(leafInsertedLogs);
+    const l1ToL2Messages = processMessageSentLogs(messageSentLogs);
     retrievedL1ToL2Messages.push(...l1ToL2Messages);
     // handles the case when there are no new messages:
-    searchStartBlock = (leafInsertedLogs.findLast(msgLog => !!msgLog)?.blockNumber || searchStartBlock) + 1n;
+    searchStartBlock = (messageSentLogs.findLast(msgLog => !!msgLog)?.blockNumber || searchStartBlock) + 1n;
   } while (blockUntilSynced && searchStartBlock <= searchEndBlock);
   return { lastProcessedL1BlockNumber: searchStartBlock - 1n, retrievedData: retrievedL1ToL2Messages };
 }

package/src/archiver/eth_log_handlers.ts

@@ -8,17 +8,17 @@ import { AvailabilityOracleAbi, InboxAbi, RollupAbi } from '@aztec/l1-artifacts'
 import { Hex, Log, PublicClient, decodeFunctionData, getAbiItem, getAddress, hexToBytes } from 'viem';
 
 /**
- * Processes newly received LeafInserted (L1 to L2) logs.
- * @param logs - LeafInserted logs.
- * @returns Array of all processed LeafInserted logs
+ * Processes newly received MessageSent (L1 to L2) logs.
+ * @param logs - MessageSent logs.
+ * @returns Array of all processed MessageSent logs
  */
-export function processLeafInsertedLogs(
-  logs: Log<bigint, number, false, undefined, true, typeof InboxAbi, 'LeafInserted'>[],
+export function processMessageSentLogs(
+  logs: Log<bigint, number, false, undefined, true, typeof InboxAbi, 'MessageSent'>[],
 ): InboxLeaf[] {
   const leaves: InboxLeaf[] = [];
   for (const log of logs) {
-    const { blockNumber, index, value } = log.args;
-    leaves.push(new InboxLeaf(blockNumber, index, Fr.fromString(value)));
+    const { l2BlockNumber, index, hash } = log.args;
+    leaves.push(new InboxLeaf(l2BlockNumber, index, Fr.fromString(hash)));
   }
   return leaves;
 }
@@ -91,7 +91,7 @@ async function getBlockMetadataFromRollupTx(
   if (functionName !== 'process') {
     throw new Error(`Unexpected method called ${functionName}`);
   }
-  const [headerHex, archiveRootHex] = args! as readonly [Hex, Hex, Hex, Hex];
+  const [headerHex, archiveRootHex] = args! as readonly [Hex, Hex, Hex];
 
   const header = Header.fromBuffer(Buffer.from(hexToBytes(headerHex)));
 
@@ -191,24 +191,24 @@ export function getTxsPublishedLogs(
 }
 
 /**
- * Get relevant `LeafInserted` logs emitted by Inbox on chain.
+ * Get relevant `MessageSent` logs emitted by Inbox on chain.
  * @param publicClient - The viem public client to use for transaction retrieval.
  * @param inboxAddress - The address of the inbox contract.
  * @param fromBlock - First block to get logs from (inclusive).
  * @param toBlock - Last block to get logs from (inclusive).
- * @returns An array of `LeafInserted` logs.
+ * @returns An array of `MessageSent` logs.
  */
-export function getLeafInsertedLogs(
+export function getMessageSentLogs(
   publicClient: PublicClient,
   inboxAddress: EthAddress,
   fromBlock: bigint,
   toBlock: bigint,
-): Promise<Log<bigint, number, false, undefined, true, typeof InboxAbi, 'LeafInserted'>[]> {
+): Promise<Log<bigint, number, false, undefined, true, typeof InboxAbi, 'MessageSent'>[]> {
   return publicClient.getLogs({
     address: getAddress(inboxAddress.toString()),
     event: getAbiItem({
       abi: InboxAbi,
-      name: 'LeafInserted',
+      name: 'MessageSent',
     }),
     fromBlock,
     toBlock: toBlock + 1n, // the toBlock argument in getLogs is exclusive

package/src/archiver/kv_archiver_store/block_store.ts

@@ -134,7 +134,15 @@ export class BlockStore {
     }
 
     const block = this.getBlock(blockNumber)!;
-    return new TxReceipt(txHash, TxStatus.MINED, '', block.hash().toBuffer(), block.number);
+    const tx = block.getTx(txIndex);
+
+    return new TxReceipt(
+      txHash,
+      tx.revertCode.isOK() ? TxStatus.MINED : TxStatus.REVERTED,
+      '',
+      block.hash().toBuffer(),
+      block.number,
+    );
   }
 
   /**

package/src/archiver/kv_archiver_store/contract_class_store.ts

@@ -1,7 +1,11 @@
-import { Fr, FunctionSelector } from '@aztec/circuits.js';
+import { Fr, FunctionSelector, Vector } from '@aztec/circuits.js';
 import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/serialize';
 import { AztecKVStore, AztecMap } from '@aztec/kv-store';
-import { ContractClassPublic } from '@aztec/types/contracts';
+import {
+  ContractClassPublic,
+  ExecutablePrivateFunctionWithMembershipProof,
+  UnconstrainedFunctionWithMembershipProof,
+} from '@aztec/types/contracts';
 
 /**
  * LMDB implementation of the ArchiverDataStore interface.
@@ -9,7 +13,7 @@ import { ContractClassPublic } from '@aztec/types/contracts';
 export class ContractClassStore {
   #contractClasses: AztecMap<string, Buffer>;
 
-  constructor(db: AztecKVStore) {
+  constructor(private db: AztecKVStore) {
     this.#contractClasses = db.openMap('archiver_contract_classes');
   }
 
@@ -25,44 +29,128 @@ export class ContractClassStore {
   getContractClassIds(): Fr[] {
     return Array.from(this.#contractClasses.keys()).map(key => Fr.fromString(key));
   }
+
+  async addFunctions(
+    contractClassId: Fr,
+    newPrivateFunctions: ExecutablePrivateFunctionWithMembershipProof[],
+    newUnconstrainedFunctions: UnconstrainedFunctionWithMembershipProof[],
+  ): Promise<boolean> {
+    await this.db.transaction(() => {
+      const existingClassBuffer = this.#contractClasses.get(contractClassId.toString());
+      if (!existingClassBuffer) {
+        throw new Error(`Unknown contract class ${contractClassId} when adding private functions to store`);
+      }
+
+      const existingClass = deserializeContractClassPublic(existingClassBuffer);
+      const { privateFunctions: existingPrivateFns, unconstrainedFunctions: existingUnconstrainedFns } = existingClass;
+
+      const updatedClass: Omit<ContractClassPublic, 'id'> = {
+        ...existingClass,
+        privateFunctions: [
+          ...existingPrivateFns,
+          ...newPrivateFunctions.filter(newFn => !existingPrivateFns.some(f => f.selector.equals(newFn.selector))),
+        ],
+        unconstrainedFunctions: [
+          ...existingUnconstrainedFns,
+          ...newUnconstrainedFunctions.filter(
+            newFn => !existingUnconstrainedFns.some(f => f.selector.equals(newFn.selector)),
+          ),
+        ],
+      };
+      void this.#contractClasses.set(contractClassId.toString(), serializeContractClassPublic(updatedClass));
+    });
+    return Promise.resolve(true);
+  }
 }
 
-export function serializeContractClassPublic(contractClass: ContractClassPublic): Buffer {
+function serializeContractClassPublic(contractClass: Omit<ContractClassPublic, 'id'>): Buffer {
   return serializeToBuffer(
     numToUInt8(contractClass.version),
     contractClass.artifactHash,
-    contractClass.privateFunctions?.length ?? 0,
-    contractClass.privateFunctions?.map(f => serializeToBuffer(f.selector, f.vkHash, f.isInternal)) ?? [],
     contractClass.publicFunctions.length,
-    contractClass.publicFunctions?.map(f =>
-      serializeToBuffer(f.selector, f.bytecode.length, f.bytecode, f.isInternal),
-    ) ?? [],
+    contractClass.publicFunctions?.map(f => serializeToBuffer(f.selector, f.bytecode.length, f.bytecode)) ?? [],
+    contractClass.privateFunctions.length,
+    contractClass.privateFunctions.map(serializePrivateFunction),
+    contractClass.unconstrainedFunctions.length,
+    contractClass.unconstrainedFunctions.map(serializeUnconstrainedFunction),
     contractClass.packedBytecode.length,
     contractClass.packedBytecode,
     contractClass.privateFunctionsRoot,
   );
 }
 
-export function deserializeContractClassPublic(buffer: Buffer): Omit<ContractClassPublic, 'id'> {
+function serializePrivateFunction(fn: ExecutablePrivateFunctionWithMembershipProof): Buffer {
+  return serializeToBuffer(
+    fn.selector,
+    fn.vkHash,
+    fn.bytecode.length,
+    fn.bytecode,
+    fn.functionMetadataHash,
+    fn.artifactMetadataHash,
+    fn.unconstrainedFunctionsArtifactTreeRoot,
+    new Vector(fn.privateFunctionTreeSiblingPath),
+    fn.privateFunctionTreeLeafIndex,
+    new Vector(fn.artifactTreeSiblingPath),
+    fn.artifactTreeLeafIndex,
+  );
+}
+
+function serializeUnconstrainedFunction(fn: UnconstrainedFunctionWithMembershipProof): Buffer {
+  return serializeToBuffer(
+    fn.selector,
+    fn.bytecode.length,
+    fn.bytecode,
+    fn.functionMetadataHash,
+    fn.artifactMetadataHash,
+    fn.privateFunctionsArtifactTreeRoot,
+    new Vector(fn.artifactTreeSiblingPath),
+    fn.artifactTreeLeafIndex,
+  );
+}
+
+function deserializeContractClassPublic(buffer: Buffer): Omit<ContractClassPublic, 'id'> {
   const reader = BufferReader.asReader(buffer);
   return {
     version: reader.readUInt8() as 1,
     artifactHash: reader.readObject(Fr),
-    privateFunctions: reader.readVector({
-      fromBuffer: reader => ({
-        selector: reader.readObject(FunctionSelector),
-        vkHash: reader.readObject(Fr),
-        isInternal: reader.readBoolean(),
-      }),
-    }),
     publicFunctions: reader.readVector({
       fromBuffer: reader => ({
         selector: reader.readObject(FunctionSelector),
         bytecode: reader.readBuffer(),
-        isInternal: reader.readBoolean(),
       }),
     }),
+    privateFunctions: reader.readVector({ fromBuffer: deserializePrivateFunction }),
+    unconstrainedFunctions: reader.readVector({ fromBuffer: deserializeUnconstrainedFunction }),
     packedBytecode: reader.readBuffer(),
     privateFunctionsRoot: reader.readObject(Fr),
   };
 }
+
+function deserializePrivateFunction(buffer: Buffer | BufferReader): ExecutablePrivateFunctionWithMembershipProof {
+  const reader = BufferReader.asReader(buffer);
+  return {
+    selector: reader.readObject(FunctionSelector),
+    vkHash: reader.readObject(Fr),
+    bytecode: reader.readBuffer(),
+    functionMetadataHash: reader.readObject(Fr),
+    artifactMetadataHash: reader.readObject(Fr),
+    unconstrainedFunctionsArtifactTreeRoot: reader.readObject(Fr),
+    privateFunctionTreeSiblingPath: reader.readVector(Fr),
+    privateFunctionTreeLeafIndex: reader.readNumber(),
+    artifactTreeSiblingPath: reader.readVector(Fr),
+    artifactTreeLeafIndex: reader.readNumber(),
+  };
+}
+
+function deserializeUnconstrainedFunction(buffer: Buffer | BufferReader): UnconstrainedFunctionWithMembershipProof {
+  const reader = BufferReader.asReader(buffer);
+  return {
+    selector: reader.readObject(FunctionSelector),
+    bytecode: reader.readBuffer(),
+    functionMetadataHash: reader.readObject(Fr),
+    artifactMetadataHash: reader.readObject(Fr),
+    privateFunctionsArtifactTreeRoot: reader.readObject(Fr),
+    artifactTreeSiblingPath: reader.readVector(Fr),
+    artifactTreeLeafIndex: reader.readNumber(),
+  };
+}

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -14,7 +14,12 @@ import { Fr } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { AztecKVStore } from '@aztec/kv-store';
-import { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/types/contracts';
+import {
+  ContractClassPublic,
+  ContractInstanceWithAddress,
+  ExecutablePrivateFunctionWithMembershipProof,
+  UnconstrainedFunctionWithMembershipProof,
+} from '@aztec/types/contracts';
 
 import { ArchiverDataStore, ArchiverL1SynchPoint } from '../archiver_store.js';
 import { DataRetrieval } from '../data_retrieval.js';
@@ -63,6 +68,14 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     return (await Promise.all(data.map(c => this.#contractClassStore.addContractClass(c)))).every(Boolean);
   }
 
+  addFunctions(
+    contractClassId: Fr,
+    privateFunctions: ExecutablePrivateFunctionWithMembershipProof[],
+    unconstrainedFunctions: UnconstrainedFunctionWithMembershipProof[],
+  ): Promise<boolean> {
+    return this.#contractClassStore.addFunctions(contractClassId, privateFunctions, unconstrainedFunctions);
+  }
+
   async addContractInstances(data: ContractInstanceWithAddress[], _blockNumber: number): Promise<boolean> {
     return (await Promise.all(data.map(c => this.#contractInstanceStore.addContractInstance(c)))).every(Boolean);
   }
@@ -154,12 +167,13 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   }
 
   /**
-   * Gets the L1 to L2 message index in the L1 to L2 message tree.
+   * Gets the first L1 to L2 message index in the L1 to L2 message tree which is greater than or equal to `startIndex`.
    * @param l1ToL2Message - The L1 to L2 message.
+   * @param startIndex - The index to start searching from.
    * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
    */
-  public getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined> {
-    return Promise.resolve(this.#messageStore.getL1ToL2MessageIndex(l1ToL2Message));
+  getL1ToL2MessageIndex(l1ToL2Message: Fr, startIndex: bigint): Promise<bigint | undefined> {
+    return Promise.resolve(this.#messageStore.getL1ToL2MessageIndex(l1ToL2Message, startIndex));
   }
 
   /**
@@ -214,12 +228,10 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   /**
    * Gets the last L1 block number processed by the archiver
    */
-  getSynchedL1BlockNumbers(): Promise<ArchiverL1SynchPoint> {
-    const blocks = this.#blockStore.getSynchedL1BlockNumber();
-    const messages = this.#messageStore.getSynchedL1BlockNumber();
+  getSynchPoint(): Promise<ArchiverL1SynchPoint> {
     return Promise.resolve({
-      blocks,
-      messages,
+      blocksSynchedTo: this.#blockStore.getSynchedL1BlockNumber(),
+      messagesSynchedTo: this.#messageStore.getSynchedL1BlockNumber(),
     });
   }
 }

package/src/archiver/kv_archiver_store/message_store.ts

@@ -15,7 +15,7 @@ import { DataRetrieval } from '../data_retrieval.js';
  */
 export class MessageStore {
   #l1ToL2Messages: AztecMap<string, Buffer>;
-  #l1ToL2MessageIndices: AztecMap<string, bigint>;
+  #l1ToL2MessageIndices: AztecMap<string, bigint[]>; // We store array of bigints here because there can be duplicate messages
   #lastL1BlockMessages: AztecSingleton<bigint>;
 
   #log = createDebugLogger('aztec:archiver:message_store');
@@ -60,7 +60,10 @@ export class MessageStore {
         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);
+
+        const indices = this.#l1ToL2MessageIndices.get(message.leaf.toString()) ?? [];
+        indices.push(indexInTheWholeTree);
+        void this.#l1ToL2MessageIndices.set(message.leaf.toString(), indices);
       }
 
       return true;
@@ -68,12 +71,14 @@ export class MessageStore {
   }
 
   /**
-   * Gets the L1 to L2 message index in the L1 to L2 message tree.
+   * Gets the first L1 to L2 message index in the L1 to L2 message tree which is greater than or equal to `startIndex`.
    * @param l1ToL2Message - The L1 to L2 message.
+   * @param startIndex - The index to start searching from.
    * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
    */
-  public getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined> {
-    const index = this.#l1ToL2MessageIndices.get(l1ToL2Message.toString());
+  getL1ToL2MessageIndex(l1ToL2Message: Fr, startIndex: bigint): Promise<bigint | undefined> {
+    const indices = this.#l1ToL2MessageIndices.get(l1ToL2Message.toString()) ?? [];
+    const index = indices.find(i => i >= startIndex);
     return Promise.resolve(index);
   }
 

package/src/archiver/memory_archiver_store/l1_to_l2_message_store.ts

@@ -11,8 +11,7 @@ import { Fr } from '@aztec/foundation/fields';
  */
 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).
+   * A map pointing from a key in a "blockNum-messageIndex" format to the corresponding L1 to L2 message hash.
    */
   protected store: Map<string, Fr> = new Map();
 
@@ -50,17 +49,21 @@ export class L1ToL2MessageStore {
   }
 
   /**
-   * Gets the L1 to L2 message index in the L1 to L2 message tree.
+   * Gets the first L1 to L2 message index in the L1 to L2 message tree which is greater than or equal to `startIndex`.
    * @param l1ToL2Message - The L1 to L2 message.
+   * @param startIndex - The index to start searching from.
    * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
    */
-  getMessageIndex(l1ToL2Message: Fr): bigint | undefined {
+  getMessageIndex(l1ToL2Message: Fr, startIndex: bigint): bigint | undefined {
     for (const [key, message] of this.store.entries()) {
       if (message.equals(l1ToL2Message)) {
-        const [blockNumber, messageIndex] = key.split('-');
+        const keyParts = key.split('-');
+        const [blockNumber, messageIndex] = [BigInt(keyParts[0]), BigInt(keyParts[1])];
         const indexInTheWholeTree =
-          (BigInt(blockNumber) - BigInt(INITIAL_L2_BLOCK_NUM)) * BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP) +
-          BigInt(messageIndex);
+          (blockNumber - BigInt(INITIAL_L2_BLOCK_NUM)) * BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP) + messageIndex;
+        if (indexInTheWholeTree < startIndex) {
+          continue;
+        }
         return indexInTheWholeTree;
       }
     }

package/src/archiver/memory_archiver_store/memory_archiver_store.ts

@@ -17,7 +17,12 @@ import {
 } from '@aztec/circuit-types';
 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 {
+  ContractClassPublic,
+  ContractInstanceWithAddress,
+  ExecutablePrivateFunctionWithMembershipProof,
+  UnconstrainedFunctionWithMembershipProof,
+} from '@aztec/types/contracts';
 
 import { ArchiverDataStore, ArchiverL1SynchPoint } from '../archiver_store.js';
 import { DataRetrieval } from '../data_retrieval.js';
@@ -61,6 +66,10 @@ export class MemoryArchiverStore implements ArchiverDataStore {
 
   private contractClasses: Map<string, ContractClassPublic> = new Map();
 
+  private privateFunctions: Map<string, ExecutablePrivateFunctionWithMembershipProof[]> = new Map();
+
+  private unconstrainedFunctions: Map<string, UnconstrainedFunctionWithMembershipProof[]> = new Map();
+
   private contractInstances: Map<string, ContractInstanceWithAddress> = new Map();
 
   private lastL1BlockNewBlocks: bigint = 0n;
@@ -72,7 +81,14 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   ) {}
 
   public getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
-    return Promise.resolve(this.contractClasses.get(id.toString()));
+    const contractClass = this.contractClasses.get(id.toString());
+    return Promise.resolve(
+      contractClass && {
+        ...contractClass,
+        privateFunctions: this.privateFunctions.get(id.toString()) ?? [],
+        unconstrainedFunctions: this.unconstrainedFunctions.get(id.toString()) ?? [],
+      },
+    );
   }
 
   public getContractClassIds(): Promise<Fr[]> {
@@ -83,6 +99,28 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(this.contractInstances.get(address.toString()));
   }
 
+  public addFunctions(
+    contractClassId: Fr,
+    newPrivateFunctions: ExecutablePrivateFunctionWithMembershipProof[],
+    newUnconstrainedFunctions: UnconstrainedFunctionWithMembershipProof[],
+  ): Promise<boolean> {
+    const privateFunctions = this.privateFunctions.get(contractClassId.toString()) ?? [];
+    const unconstrainedFunctions = this.unconstrainedFunctions.get(contractClassId.toString()) ?? [];
+    const updatedPrivateFunctions = [
+      ...privateFunctions,
+      ...newPrivateFunctions.filter(newFn => !privateFunctions.find(f => f.selector.equals(newFn.selector))),
+    ];
+    const updatedUnconstrainedFunctions = [
+      ...unconstrainedFunctions,
+      ...newUnconstrainedFunctions.filter(
+        newFn => !unconstrainedFunctions.find(f => f.selector.equals(newFn.selector)),
+      ),
+    ];
+    this.privateFunctions.set(contractClassId.toString(), updatedPrivateFunctions);
+    this.unconstrainedFunctions.set(contractClassId.toString(), updatedUnconstrainedFunctions);
+    return Promise.resolve(true);
+  }
+
   public addContractClasses(data: ContractClassPublic[], _blockNumber: number): Promise<boolean> {
     for (const contractClass of data) {
       this.contractClasses.set(contractClass.id.toString(), contractClass);
@@ -175,12 +213,13 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   }
 
   /**
-   * Gets the L1 to L2 message index in the L1 to L2 message tree.
+   * Gets the first L1 to L2 message index in the L1 to L2 message tree which is greater than or equal to `startIndex`.
    * @param l1ToL2Message - The L1 to L2 message.
+   * @param startIndex - The index to start searching from.
    * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
    */
-  public getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined> {
-    return Promise.resolve(this.l1ToL2Messages.getMessageIndex(l1ToL2Message));
+  getL1ToL2MessageIndex(l1ToL2Message: Fr, startIndex: bigint): Promise<bigint | undefined> {
+    return Promise.resolve(this.l1ToL2Messages.getMessageIndex(l1ToL2Message, startIndex));
   }
 
   /**
@@ -357,10 +396,10 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(this.l2BlockContexts[this.l2BlockContexts.length - 1].block.number);
   }
 
-  public getSynchedL1BlockNumbers(): Promise<ArchiverL1SynchPoint> {
+  public getSynchPoint(): Promise<ArchiverL1SynchPoint> {
     return Promise.resolve({
-      blocks: this.lastL1BlockNewBlocks,
-      messages: this.lastL1BlockNewMessages,
+      blocksSynchedTo: this.lastL1BlockNewBlocks,
+      messagesSynchedTo: this.lastL1BlockNewMessages,
     });
   }
 }