@aztec/archiver 0.30.1 → 0.32.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 { InboxLeaf, L2Block, L2BlockContext, LogId, LogType, TxHash } 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', () => {
@@ -318,11 +367,10 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         const targetTxIndex = randomInt(txsPerBlock);
         const targetFunctionLogIndex = randomInt(numPublicFunctionCalls);
         const targetLogIndex = randomInt(numUnencryptedLogs);
-        const targetContractAddress = UnencryptedL2Log.fromBuffer(
+        const targetContractAddress =
           blocks.retrievedData[targetBlockIndex].body.txEffects[targetTxIndex].unencryptedLogs.functionLogs[
             targetFunctionLogIndex
-          ].logs[targetLogIndex],
-        ).contractAddress;
+          ].logs[targetLogIndex].contractAddress;
 
         const response = await store.getUnencryptedLogs({ contractAddress: targetContractAddress });
 
@@ -339,11 +387,10 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         const targetTxIndex = randomInt(txsPerBlock);
         const targetFunctionLogIndex = randomInt(numPublicFunctionCalls);
         const targetLogIndex = randomInt(numUnencryptedLogs);
-        const targetSelector = UnencryptedL2Log.fromBuffer(
+        const targetSelector =
           blocks.retrievedData[targetBlockIndex].body.txEffects[targetTxIndex].unencryptedLogs.functionLogs[
             targetFunctionLogIndex
-          ].logs[targetLogIndex],
-        ).selector;
+          ].logs[targetLogIndex].selector;
 
         const response = await store.getUnencryptedLogs({ selector: targetSelector });
 

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

@@ -1,5 +1,7 @@
 import {
   Body,
+  EncryptedL2BlockL2Logs,
+  FromLogType,
   GetUnencryptedLogsResponse,
   InboxLeaf,
   L2Block,
@@ -9,12 +11,18 @@ import {
   TxEffect,
   TxHash,
   TxReceipt,
+  UnencryptedL2BlockL2Logs,
 } from '@aztec/circuit-types';
 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 +71,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);
   }
@@ -137,8 +153,8 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @returns True if the operation is successful.
    */
   addLogs(
-    encryptedLogs: L2BlockL2Logs | undefined,
-    unencryptedLogs: L2BlockL2Logs | undefined,
+    encryptedLogs: EncryptedL2BlockL2Logs | undefined,
+    unencryptedLogs: UnencryptedL2BlockL2Logs | undefined,
     blockNumber: number,
   ): Promise<boolean> {
     return this.#logStore.addLogs(encryptedLogs, unencryptedLogs, blockNumber);
@@ -154,12 +170,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));
   }
 
   /**
@@ -182,7 +199,11 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @param logType - Specifies whether to return encrypted or unencrypted logs.
    * @returns The requested logs.
    */
-  getLogs(start: number, limit: number, logType: LogType): Promise<L2BlockL2Logs[]> {
+  getLogs<TLogType extends LogType>(
+    start: number,
+    limit: number,
+    logType: TLogType,
+  ): Promise<L2BlockL2Logs<FromLogType<TLogType>>[]> {
     try {
       return Promise.resolve(Array.from(this.#logStore.getLogs(start, limit, logType)));
     } catch (err) {
@@ -214,12 +235,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/log_store.ts

@@ -1,10 +1,13 @@
 import {
+  EncryptedL2BlockL2Logs,
   ExtendedUnencryptedL2Log,
+  FromLogType,
   GetUnencryptedLogsResponse,
   L2BlockL2Logs,
   LogFilter,
   LogId,
   LogType,
+  UnencryptedL2BlockL2Logs,
   UnencryptedL2Log,
 } from '@aztec/circuit-types';
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js/constants';
@@ -37,8 +40,8 @@ export class LogStore {
    * @returns True if the operation is successful.
    */
   addLogs(
-    encryptedLogs: L2BlockL2Logs | undefined,
-    unencryptedLogs: L2BlockL2Logs | undefined,
+    encryptedLogs: EncryptedL2BlockL2Logs | undefined,
+    unencryptedLogs: UnencryptedL2BlockL2Logs | undefined,
     blockNumber: number,
   ): Promise<boolean> {
     return this.db.transaction(() => {
@@ -61,10 +64,15 @@ export class LogStore {
    * @param logType - Specifies whether to return encrypted or unencrypted logs.
    * @returns The requested logs.
    */
-  *getLogs(start: number, limit: number, logType: LogType): IterableIterator<L2BlockL2Logs> {
+  *getLogs<TLogType extends LogType>(
+    start: number,
+    limit: number,
+    logType: TLogType,
+  ): IterableIterator<L2BlockL2Logs<FromLogType<TLogType>>> {
     const logMap = logType === LogType.ENCRYPTED ? this.#encryptedLogs : this.#unencryptedLogs;
+    const L2BlockL2Logs = logType === LogType.ENCRYPTED ? EncryptedL2BlockL2Logs : UnencryptedL2BlockL2Logs;
     for (const buffer of logMap.values({ start, limit })) {
-      yield L2BlockL2Logs.fromBuffer(buffer);
+      yield L2BlockL2Logs.fromBuffer(buffer) as L2BlockL2Logs<FromLogType<TLogType>>;
     }
   }
 
@@ -94,7 +102,7 @@ export class LogStore {
     }
 
     const unencryptedLogsInBlock = this.#getBlockLogs(blockNumber, LogType.UNENCRYPTED);
-    const txLogs = unencryptedLogsInBlock.txLogs[txIndex].unrollLogs().map(log => UnencryptedL2Log.fromBuffer(log));
+    const txLogs = unencryptedLogsInBlock.txLogs[txIndex].unrollLogs();
 
     const logs: ExtendedUnencryptedL2Log[] = [];
     const maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
@@ -118,9 +126,9 @@ export class LogStore {
 
     let maxLogsHit = false;
     loopOverBlocks: for (const [blockNumber, logBuffer] of this.#unencryptedLogs.entries({ start, end })) {
-      const unencryptedLogsInBlock = L2BlockL2Logs.fromBuffer(logBuffer);
+      const unencryptedLogsInBlock = UnencryptedL2BlockL2Logs.fromBuffer(logBuffer);
       for (let txIndex = filter.afterLog?.txIndex ?? 0; txIndex < unencryptedLogsInBlock.txLogs.length; txIndex++) {
-        const txLogs = unencryptedLogsInBlock.txLogs[txIndex].unrollLogs().map(log => UnencryptedL2Log.fromBuffer(log));
+        const txLogs = unencryptedLogsInBlock.txLogs[txIndex].unrollLogs();
         maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
         if (maxLogsHit) {
           this.#log(`Max logs hit at block ${blockNumber}`);
@@ -161,14 +169,19 @@ export class LogStore {
     return maxLogsHit;
   }
 
-  #getBlockLogs(blockNumber: number, logType: LogType): L2BlockL2Logs {
+  #getBlockLogs<TLogType extends LogType>(
+    blockNumber: number,
+    logType: TLogType,
+  ): L2BlockL2Logs<FromLogType<TLogType>> {
     const logMap = logType === LogType.ENCRYPTED ? this.#encryptedLogs : this.#unencryptedLogs;
+    const L2BlockL2Logs: typeof EncryptedL2BlockL2Logs | typeof UnencryptedL2BlockL2Logs =
+      logType === LogType.ENCRYPTED ? EncryptedL2BlockL2Logs : UnencryptedL2BlockL2Logs;
     const buffer = logMap.get(blockNumber);
 
     if (!buffer) {
-      return new L2BlockL2Logs([]);
+      return new L2BlockL2Logs([]) as L2BlockL2Logs<FromLogType<TLogType>>;
     }
 
-    return L2BlockL2Logs.fromBuffer(buffer);
+    return L2BlockL2Logs.fromBuffer(buffer) as L2BlockL2Logs<FromLogType<TLogType>>;
   }
 }

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);
   }