@aztec/archiver 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/dest/archiver/kv_archiver_store/log_store.js

@@ -1,15 +1,21 @@
-import { INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS } from '@aztec/constants';
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
-import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, PrivateLog, PublicLog, TxScopedL2Log } from '@aztec/stdlib/logs';
+import { L2BlockHash } from '@aztec/stdlib/block';
+import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, PublicLog, TxScopedL2Log } from '@aztec/stdlib/logs';
 /**
  * A store for logs
  */ export class LogStore {
     db;
     blockStore;
-    #logsByTag;
-    #logTagsByBlock;
-    #privateLogsByBlock;
+    // `tag` --> private logs
+    #privateLogsByTag;
+    // `{contractAddress}_${tag}` --> public logs
+    #publicLogsByContractAndTag;
+    #privateLogKeysByBlock;
+    #publicLogKeysByBlock;
     #publicLogsByBlock;
     #contractClassLogsByBlock;
     #logsMaxPageSize;
@@ -18,100 +24,118 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
         this.db = db;
         this.blockStore = blockStore;
         this.#log = createLogger('archiver:log_store');
-        this.#logsByTag = db.openMap('archiver_tagged_logs_by_tag');
-        this.#logTagsByBlock = db.openMap('archiver_log_tags_by_block');
-        this.#privateLogsByBlock = db.openMap('archiver_private_logs_by_block');
+        this.#privateLogsByTag = db.openMap('archiver_private_tagged_logs_by_tag');
+        this.#publicLogsByContractAndTag = db.openMap('archiver_public_tagged_logs_by_tag');
+        this.#privateLogKeysByBlock = db.openMap('archiver_private_log_keys_by_block');
+        this.#publicLogKeysByBlock = db.openMap('archiver_public_log_keys_by_block');
         this.#publicLogsByBlock = db.openMap('archiver_public_logs_by_block');
         this.#contractClassLogsByBlock = db.openMap('archiver_contract_class_logs_by_block');
         this.#logsMaxPageSize = logsMaxPageSize;
     }
-    #extractTaggedLogsFromPrivate(block) {
-        const taggedLogs = new Map();
-        const dataStartIndexForBlock = block.header.state.partial.noteHashTree.nextAvailableLeafIndex - block.body.txEffects.length * MAX_NOTE_HASHES_PER_TX;
-        block.body.txEffects.forEach((txEffect, txIndex)=>{
+    /**
+   * Extracts tagged logs from a single block, grouping them into private and public maps.
+   *
+   * @param block - The L2 block to extract logs from.
+   * @returns An object containing the private and public tagged logs for the block.
+   */ #extractTaggedLogsFromBlock(block) {
+        // SiloedTag (as string) -> array of log buffers.
+        const privateTaggedLogs = new Map();
+        // "{contractAddress}_{tag}" (as string) -> array of log buffers.
+        const publicTaggedLogs = new Map();
+        block.body.txEffects.forEach((txEffect)=>{
             const txHash = txEffect.txHash;
-            const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
             txEffect.privateLogs.forEach((log)=>{
+                // Private logs use SiloedTag (already siloed by kernel)
                 const tag = log.fields[0];
-                const currentLogs = taggedLogs.get(tag.toString()) ?? [];
-                currentLogs.push(new TxScopedL2Log(txHash, dataStartIndexForTx, block.number, /* isFromPublic */ false, log.toBuffer()).toBuffer());
-                taggedLogs.set(tag.toString(), currentLogs);
+                this.#log.debug(`Found private log with tag ${tag.toString()} in block ${block.number}`);
+                const currentLogs = privateTaggedLogs.get(tag.toString()) ?? [];
+                currentLogs.push(new TxScopedL2Log(txHash, block.number, block.timestamp, log.getEmittedFields(), txEffect.noteHashes, txEffect.nullifiers[0]).toBuffer());
+                privateTaggedLogs.set(tag.toString(), currentLogs);
             });
-        });
-        return taggedLogs;
-    }
-    #extractTaggedLogsFromPublic(block) {
-        const taggedLogs = new Map();
-        const dataStartIndexForBlock = block.header.state.partial.noteHashTree.nextAvailableLeafIndex - block.body.txEffects.length * MAX_NOTE_HASHES_PER_TX;
-        block.body.txEffects.forEach((txEffect, txIndex)=>{
-            const txHash = txEffect.txHash;
-            const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
             txEffect.publicLogs.forEach((log)=>{
-                // Check that each log stores 2 lengths in its first field. If not, it's not a tagged log:
-                const firstFieldBuf = log.log[0].toBuffer();
-                // See macros/note/mod/ and see how finalization_log[0] is constructed, to understand this monstrosity. (It wasn't me).
-                // Search the codebase for "disgusting encoding" to see other hardcoded instances of this encoding, that you might need to change if you ever find yourself here.
-                if (!firstFieldBuf.subarray(0, 27).equals(Buffer.alloc(27)) || firstFieldBuf[29] !== 0) {
-                    // See parseLogFromPublic - the first field of a tagged log is 5 bytes structured:
-                    // [ publicLen[0], publicLen[1], 0, privateLen[0], privateLen[1]]
-                    this.#log.warn(`Skipping public log with invalid first field: ${log.log[0]}`);
-                    return;
-                }
-                // Check that the length values line up with the log contents
-                const publicValuesLength = firstFieldBuf.subarray(-5).readUint16BE();
-                const privateValuesLength = firstFieldBuf.subarray(-5).readUint16BE(3);
-                // Add 1 for the first field holding lengths
-                const totalLogLength = 1 + publicValuesLength + privateValuesLength;
-                // Note that zeroes can be valid log values, so we can only assert that we do not go over the given length
-                if (totalLogLength > PUBLIC_LOG_DATA_SIZE_IN_FIELDS || log.log.slice(totalLogLength).find((f)=>!f.isZero())) {
-                    this.#log.warn(`Skipping invalid tagged public log with first field: ${log.log[0]}`);
-                    return;
-                }
-                // The first elt stores lengths as above => tag is in fields[1]
-                const tag = log.log[1];
-                this.#log.debug(`Found tagged public log with tag ${tag.toString()} in block ${block.number}`);
-                const currentLogs = taggedLogs.get(tag.toString()) ?? [];
-                currentLogs.push(new TxScopedL2Log(txHash, dataStartIndexForTx, block.number, /* isFromPublic */ true, log.toBuffer()).toBuffer());
-                taggedLogs.set(tag.toString(), currentLogs);
+                // Public logs use Tag directly (not siloed) and are stored with contract address
+                const tag = log.fields[0];
+                const contractAddress = log.contractAddress;
+                const key = `${contractAddress.toString()}_${tag.toString()}`;
+                this.#log.debug(`Found public log with tag ${tag.toString()} from contract ${contractAddress.toString()} in block ${block.number}`);
+                const currentLogs = publicTaggedLogs.get(key) ?? [];
+                currentLogs.push(new TxScopedL2Log(txHash, block.number, block.timestamp, log.getEmittedFields(), txEffect.noteHashes, txEffect.nullifiers[0]).toBuffer());
+                publicTaggedLogs.set(key, currentLogs);
             });
         });
-        return taggedLogs;
+        return {
+            privateTaggedLogs,
+            publicTaggedLogs
+        };
     }
     /**
-   * Append new logs to the store's list.
-   * @param blocks - The blocks for which to add the logs.
-   * @returns True if the operation is successful.
-   */ addLogs(blocks) {
-        const taggedLogsToAdd = blocks.flatMap((block)=>[
-                this.#extractTaggedLogsFromPrivate(block),
-                this.#extractTaggedLogsFromPublic(block)
-            ]).reduce((acc, val)=>{
-            for (const [tag, logs] of val.entries()){
+   * Extracts and aggregates tagged logs from a list of blocks.
+   * @param blocks - The blocks to extract logs from.
+   * @returns A map from tag (as string) to an array of serialized private logs belonging to that tag, and a map from
+   * "{contractAddress}_{tag}" (as string) to an array of serialized public logs belonging to that key.
+   */ #extractTaggedLogs(blocks) {
+        const taggedLogsInBlocks = blocks.map((block)=>this.#extractTaggedLogsFromBlock(block));
+        // Now we merge the maps from each block into a single map.
+        const privateTaggedLogs = taggedLogsInBlocks.reduce((acc, { privateTaggedLogs })=>{
+            for (const [tag, logs] of privateTaggedLogs.entries()){
                 const currentLogs = acc.get(tag) ?? [];
                 acc.set(tag, currentLogs.concat(logs));
             }
             return acc;
-        });
-        const tagsToUpdate = Array.from(taggedLogsToAdd.keys());
+        }, new Map());
+        const publicTaggedLogs = taggedLogsInBlocks.reduce((acc, { publicTaggedLogs })=>{
+            for (const [key, logs] of publicTaggedLogs.entries()){
+                const currentLogs = acc.get(key) ?? [];
+                acc.set(key, currentLogs.concat(logs));
+            }
+            return acc;
+        }, new Map());
+        return {
+            privateTaggedLogs,
+            publicTaggedLogs
+        };
+    }
+    /**
+   * Append new logs to the store's list.
+   * @param blocks - The blocks for which to add the logs.
+   * @returns True if the operation is successful.
+   */ addLogs(blocks) {
+        const { privateTaggedLogs, publicTaggedLogs } = this.#extractTaggedLogs(blocks);
+        const keysOfPrivateLogsToUpdate = Array.from(privateTaggedLogs.keys());
+        const keysOfPublicLogsToUpdate = Array.from(publicTaggedLogs.keys());
         return this.db.transactionAsync(async ()=>{
-            const currentTaggedLogs = await Promise.all(tagsToUpdate.map(async (tag)=>({
-                    tag,
-                    logBuffers: await this.#logsByTag.getAsync(tag)
+            const currentPrivateTaggedLogs = await Promise.all(keysOfPrivateLogsToUpdate.map(async (key)=>({
+                    tag: key,
+                    logBuffers: await this.#privateLogsByTag.getAsync(key)
                 })));
-            currentTaggedLogs.forEach((taggedLogBuffer)=>{
+            currentPrivateTaggedLogs.forEach((taggedLogBuffer)=>{
                 if (taggedLogBuffer.logBuffers && taggedLogBuffer.logBuffers.length > 0) {
-                    taggedLogsToAdd.set(taggedLogBuffer.tag, taggedLogBuffer.logBuffers.concat(taggedLogsToAdd.get(taggedLogBuffer.tag)));
+                    privateTaggedLogs.set(taggedLogBuffer.tag, taggedLogBuffer.logBuffers.concat(privateTaggedLogs.get(taggedLogBuffer.tag)));
+                }
+            });
+            const currentPublicTaggedLogs = await Promise.all(keysOfPublicLogsToUpdate.map(async (key)=>({
+                    key,
+                    logBuffers: await this.#publicLogsByContractAndTag.getAsync(key)
+                })));
+            currentPublicTaggedLogs.forEach((taggedLogBuffer)=>{
+                if (taggedLogBuffer.logBuffers && taggedLogBuffer.logBuffers.length > 0) {
+                    publicTaggedLogs.set(taggedLogBuffer.key, taggedLogBuffer.logBuffers.concat(publicTaggedLogs.get(taggedLogBuffer.key)));
                 }
             });
             for (const block of blocks){
-                const tagsInBlock = [];
-                for (const [tag, logs] of taggedLogsToAdd.entries()){
-                    await this.#logsByTag.set(tag, logs);
-                    tagsInBlock.push(tag);
+                const blockHash = await block.hash();
+                const privateTagsInBlock = [];
+                for (const [tag, logs] of privateTaggedLogs.entries()){
+                    await this.#privateLogsByTag.set(tag, logs);
+                    privateTagsInBlock.push(tag);
+                }
+                await this.#privateLogKeysByBlock.set(block.number, privateTagsInBlock);
+                const publicKeysInBlock = [];
+                for (const [key, logs] of publicTaggedLogs.entries()){
+                    await this.#publicLogsByContractAndTag.set(key, logs);
+                    publicKeysInBlock.push(key);
                 }
-                await this.#logTagsByBlock.set(block.number, tagsInBlock);
-                const privateLogsInBlock = block.body.txEffects.map((txEffect)=>txEffect.privateLogs).flat().map((log)=>log.toBuffer());
-                await this.#privateLogsByBlock.set(block.number, Buffer.concat(privateLogsInBlock));
+                await this.#publicLogKeysByBlock.set(block.number, publicKeysInBlock);
                 const publicLogsInBlock = block.body.txEffects.map((txEffect, txIndex)=>[
                         numToUInt32BE(txIndex),
                         numToUInt32BE(txEffect.publicLogs.length),
@@ -122,53 +146,60 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
                         numToUInt32BE(txEffect.contractClassLogs.length),
                         txEffect.contractClassLogs.map((log)=>log.toBuffer())
                     ].flat()).flat();
-                await this.#publicLogsByBlock.set(block.number, Buffer.concat(publicLogsInBlock));
-                await this.#contractClassLogsByBlock.set(block.number, Buffer.concat(contractClassLogsInBlock));
+                await this.#publicLogsByBlock.set(block.number, this.#packWithBlockHash(blockHash, publicLogsInBlock));
+                await this.#contractClassLogsByBlock.set(block.number, this.#packWithBlockHash(blockHash, contractClassLogsInBlock));
             }
             return true;
         });
     }
+    #packWithBlockHash(blockHash, data) {
+        return Buffer.concat([
+            blockHash.toBuffer(),
+            ...data
+        ]);
+    }
+    #unpackBlockHash(reader) {
+        const blockHash = reader.remainingBytes() > 0 ? reader.readObject(Fr) : undefined;
+        if (!blockHash) {
+            throw new Error('Failed to read block hash from log entry buffer');
+        }
+        return L2BlockHash.fromField(blockHash);
+    }
     deleteLogs(blocks) {
         return this.db.transactionAsync(async ()=>{
-            const tagsToDelete = (await Promise.all(blocks.map(async (block)=>{
-                const tags = await this.#logTagsByBlock.getAsync(block.number);
-                return tags ?? [];
-            }))).flat();
+            await Promise.all(blocks.map(async (block)=>{
+                // Delete private logs
+                const privateKeys = await this.#privateLogKeysByBlock.getAsync(block.number) ?? [];
+                await Promise.all(privateKeys.map((tag)=>this.#privateLogsByTag.delete(tag)));
+                // Delete public logs
+                const publicKeys = await this.#publicLogKeysByBlock.getAsync(block.number) ?? [];
+                await Promise.all(publicKeys.map((key)=>this.#publicLogsByContractAndTag.delete(key)));
+            }));
             await Promise.all(blocks.map((block)=>Promise.all([
-                    this.#privateLogsByBlock.delete(block.number),
                     this.#publicLogsByBlock.delete(block.number),
-                    this.#logTagsByBlock.delete(block.number)
+                    this.#privateLogKeysByBlock.delete(block.number),
+                    this.#publicLogKeysByBlock.delete(block.number),
+                    this.#contractClassLogsByBlock.delete(block.number)
                 ])));
-            await Promise.all(tagsToDelete.map((tag)=>this.#logsByTag.delete(tag.toString())));
             return true;
         });
     }
     /**
-   * Retrieves all private logs from up to `limit` blocks, starting from the block number `start`.
-   * @param start - The block number from which to begin retrieving logs.
-   * @param limit - The maximum number of blocks to retrieve logs from.
-   * @returns An array of private logs from the specified range of blocks.
-   */ async getPrivateLogs(start, limit) {
-        const logs = [];
-        for await (const buffer of this.#privateLogsByBlock.valuesAsync({
-            start,
-            limit
-        })){
-            const reader = new BufferReader(buffer);
-            while(reader.remainingBytes() > 0){
-                logs.push(reader.readObject(PrivateLog));
-            }
-        }
-        return logs;
+   * Gets all private logs that match any of the `tags`. For each tag, an array of matching logs is returned. An empty
+   * array implies no logs match that tag.
+   */ async getPrivateLogsByTags(tags) {
+        const logs = await Promise.all(tags.map((tag)=>this.#privateLogsByTag.getAsync(tag.toString())));
+        return logs.map((logBuffers)=>logBuffers?.map((logBuffer)=>TxScopedL2Log.fromBuffer(logBuffer)) ?? []);
     }
     /**
-   * Gets all logs that match any of the received tags (i.e. logs with their first field equal to a tag).
-   * @param tags - The tags to filter the logs by.
-   * @returns For each received tag, an array of matching logs is returned. An empty array implies no logs match
-   * that tag.
-   */ async getLogsByTags(tags) {
-        const logs = await Promise.all(tags.map((tag)=>this.#logsByTag.getAsync(tag.toString())));
-        return logs.map((noteLogBuffers)=>noteLogBuffers?.map((noteLogBuffer)=>TxScopedL2Log.fromBuffer(noteLogBuffer)) ?? []);
+   * Gets all public logs that match any of the `tags` from the specified contract. For each tag, an array of matching
+   * logs is returned. An empty array implies no logs match that tag.
+   */ async getPublicLogsByTagsFromContract(contractAddress, tags) {
+        const logs = await Promise.all(tags.map((tag)=>{
+            const key = `${contractAddress.toString()}_${tag.value.toString()}`;
+            return this.#publicLogsByContractAndTag.getAsync(key);
+        }));
+        return logs.map((logBuffers)=>logBuffers?.map((logBuffer)=>TxScopedL2Log.fromBuffer(logBuffer)) ?? []);
     }
     /**
    * Gets public logs based on the provided filter.
@@ -199,6 +230,7 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
             []
         ];
         const reader = new BufferReader(buffer);
+        const blockHash = this.#unpackBlockHash(reader);
         while(reader.remainingBytes() > 0){
             const indexOfTx = reader.readNumber();
             const numLogsInTx = reader.readNumber();
@@ -209,7 +241,7 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
         }
         const txLogs = publicLogsInBlock[txIndex];
         const logs = [];
-        const maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+        const maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
         return {
             logs,
             maxLogsHit
@@ -234,6 +266,7 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
                 []
             ];
             const reader = new BufferReader(logBuffer);
+            const blockHash = this.#unpackBlockHash(reader);
             while(reader.remainingBytes() > 0){
                 const indexOfTx = reader.readNumber();
                 const numLogsInTx = reader.readNumber();
@@ -244,7 +277,7 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
             }
             for(let txIndex = filter.afterLog?.txIndex ?? 0; txIndex < publicLogsInBlock.length; txIndex++){
                 const txLogs = publicLogsInBlock[txIndex];
-                maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+                maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
                 if (maxLogsHit) {
                     this.#log.debug(`Max logs hit at block ${blockNumber}`);
                     break loopOverBlocks;
@@ -285,6 +318,7 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
             []
         ];
         const reader = new BufferReader(contractClassLogsBuffer);
+        const blockHash = this.#unpackBlockHash(reader);
         while(reader.remainingBytes() > 0){
             const indexOfTx = reader.readNumber();
             const numLogsInTx = reader.readNumber();
@@ -295,7 +329,7 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
         }
         const txLogs = contractClassLogsInBlock[txIndex];
         const logs = [];
-        const maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+        const maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
         return {
             logs,
             maxLogsHit
@@ -320,6 +354,7 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
                 []
             ];
             const reader = new BufferReader(logBuffer);
+            const blockHash = this.#unpackBlockHash(reader);
             while(reader.remainingBytes() > 0){
                 const indexOfTx = reader.readNumber();
                 const numLogsInTx = reader.readNumber();
@@ -330,7 +365,7 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
             }
             for(let txIndex = filter.afterLog?.txIndex ?? 0; txIndex < contractClassLogsInBlock.length; txIndex++){
                 const txLogs = contractClassLogsInBlock[txIndex];
-                maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+                maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
                 if (maxLogsHit) {
                     this.#log.debug(`Max logs hit at block ${blockNumber}`);
                     break loopOverBlocks;
@@ -342,16 +377,18 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
             maxLogsHit
         };
     }
-    #accumulateLogs(results, blockNumber, txIndex, txLogs, filter) {
+    #accumulateLogs(results, blockNumber, blockHash, txIndex, txLogs, filter = {}) {
         let maxLogsHit = false;
         let logIndex = typeof filter.afterLog?.logIndex === 'number' ? filter.afterLog.logIndex + 1 : 0;
         for(; logIndex < txLogs.length; logIndex++){
             const log = txLogs[logIndex];
             if (!filter.contractAddress || log.contractAddress.equals(filter.contractAddress)) {
                 if (log instanceof ContractClassLog) {
-                    results.push(new ExtendedContractClassLog(new LogId(blockNumber, txIndex, logIndex), log));
+                    results.push(new ExtendedContractClassLog(new LogId(BlockNumber(blockNumber), blockHash, txIndex, logIndex), log));
+                } else if (log instanceof PublicLog) {
+                    results.push(new ExtendedPublicLog(new LogId(BlockNumber(blockNumber), blockHash, txIndex, logIndex), log));
                 } else {
-                    results.push(new ExtendedPublicLog(new LogId(blockNumber, txIndex, logIndex), log));
+                    throw new Error('Unknown log type');
                 }
                 if (results.length >= this.#logsMaxPageSize) {
                     maxLogsHit = true;

package/dest/archiver/kv_archiver_store/message_store.d.ts

@@ -1,33 +1,40 @@
-import { Fr } from '@aztec/foundation/fields';
-import type { AztecAsyncKVStore } from '@aztec/kv-store';
-import { InboxLeaf } from '@aztec/stdlib/messaging';
-import type { DataRetrieval } from '../structs/data_retrieval.js';
-/**
- * LMDB implementation of the ArchiverDataStore interface.
- */
+import type { L1BlockId } from '@aztec/ethereum/l1-types';
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type AztecAsyncKVStore, type CustomRange } from '@aztec/kv-store';
+import { type InboxMessage } from '../structs/inbox_message.js';
+export declare class MessageStoreError extends Error {
+    readonly inboxMessage: InboxMessage;
+    constructor(message: string, inboxMessage: InboxMessage);
+}
 export declare class MessageStore {
     #private;
     private db;
     constructor(db: AztecAsyncKVStore);
     getTotalL1ToL2MessageCount(): Promise<bigint>;
-    /**
-     * Gets the last L1 block number that emitted new messages.
-     * @returns The last L1 block number processed
-     */
-    getSynchedL1BlockNumber(): Promise<bigint | undefined>;
-    setSynchedL1BlockNumber(l1BlockNumber: bigint): Promise<void>;
+    /** Gets the last L1 block synced. */
+    getSynchedL1Block(): Promise<L1BlockId | undefined>;
+    /** Sets the last L1 block synced */
+    setSynchedL1Block(l1Block: L1BlockId): Promise<void>;
     /**
      * 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.
+     * Requires new messages to be in order and strictly after the last message added.
+     * Throws if out of order messages are added or if the rolling hash is invalid.
      */
-    addL1ToL2Messages(messages: DataRetrieval<InboxLeaf>): Promise<boolean>;
+    addL1ToL2Messages(messages: InboxMessage[]): Promise<void>;
     /**
      * 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).
      */
     getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined>;
-    getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]>;
+    getLastMessage(): Promise<InboxMessage | undefined>;
+    getL1ToL2Messages(checkpointNumber: CheckpointNumber): Promise<Fr[]>;
+    iterateL1ToL2Messages(range?: CustomRange<bigint>): AsyncIterableIterator<InboxMessage>;
+    removeL1ToL2Messages(startIndex: bigint): Promise<void>;
+    rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber: CheckpointNumber): Promise<void>;
+    private indexToKey;
+    private leafToIndexKey;
+    private increaseTotalMessageCount;
 }
-//# sourceMappingURL=message_store.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZV9zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FyY2hpdmVyL2t2X2FyY2hpdmVyX3N0b3JlL21lc3NhZ2Vfc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDMUQsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFbkUsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBSXBELE9BQU8sRUFDTCxLQUFLLGlCQUFpQixFQUd0QixLQUFLLFdBQVcsRUFFakIsTUFBTSxpQkFBaUIsQ0FBQztBQUd6QixPQUFPLEVBQ0wsS0FBSyxZQUFZLEVBSWxCLE1BQU0sNkJBQTZCLENBQUM7QUFFckMscUJBQWEsaUJBQWtCLFNBQVEsS0FBSzthQUd4QixZQUFZLEVBQUUsWUFBWTtJQUY1QyxZQUNFLE9BQU8sRUFBRSxNQUFNLEVBQ0MsWUFBWSxFQUFFLFlBQVksRUFJM0M7Q0FDRjtBQUVELHFCQUFhLFlBQVk7O0lBWVgsT0FBTyxDQUFDLEVBQUU7SUFBdEIsWUFBb0IsRUFBRSxFQUFFLGlCQUFpQixFQUt4QztJQUVZLDBCQUEwQixJQUFJLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FFekQ7SUFFRCxxQ0FBcUM7SUFDeEIsaUJBQWlCLElBQUksT0FBTyxDQUFDLFNBQVMsR0FBRyxTQUFTLENBQUMsQ0FRL0Q7SUFFRCxvQ0FBb0M7SUFDdkIsaUJBQWlCLENBQUMsT0FBTyxFQUFFLFNBQVMsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBR2hFO0lBRUQ7Ozs7T0FJRztJQUNJLGlCQUFpQixDQUFDLFFBQVEsRUFBRSxZQUFZLEVBQUUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBNkZoRTtJQUVEOzs7O09BSUc7SUFDSSxxQkFBcUIsQ0FBQyxhQUFhLEVBQUUsRUFBRSxHQUFHLE9BQU8sQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLENBRTNFO0lBRVksY0FBYyxJQUFJLE9BQU8sQ0FBQyxZQUFZLEdBQUcsU0FBUyxDQUFDLENBRy9EO0lBRVksaUJBQWlCLENBQUMsZ0JBQWdCLEVBQUUsZ0JBQWdCLEdBQUcsT0FBTyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBdUJoRjtJQUVhLHFCQUFxQixDQUFDLEtBQUssR0FBRSxXQUFXLENBQUMsTUFBTSxDQUFNLEdBQUcscUJBQXFCLENBQUMsWUFBWSxDQUFDLENBS3hHO0lBRU0sb0JBQW9CLENBQUMsVUFBVSxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBZ0I3RDtJQUVNLGtDQUFrQyxDQUFDLHNCQUFzQixFQUFFLGdCQUFnQixHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FJakc7SUFFRCxPQUFPLENBQUMsVUFBVTtJQUlsQixPQUFPLENBQUMsY0FBYztZQUlSLHlCQUF5QjtDQVN4QyJ9

package/dest/archiver/kv_archiver_store/message_store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"message_store.d.ts","sourceRoot":"","sources":["../../../src/archiver/kv_archiver_store/message_store.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,KAAK,EAAE,iBAAiB,EAAsC,MAAM,iBAAiB,CAAC;AAC7F,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAElE;;GAEG;AACH,qBAAa,YAAY;;IAUX,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,iBAAiB;IAOnC,0BAA0B,IAAI,OAAO,CAAC,MAAM,CAAC;IAInD;;;OAGG;IACH,uBAAuB,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAIhD,uBAAuB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAInE;;;;OAIG;IACH,iBAAiB,CAAC,QAAQ,EAAE,aAAa,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;IAsBvE;;;;OAIG;IACH,qBAAqB,CAAC,aAAa,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAI/D,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,EAAE,CAAC;CAqB5D"}
+{"version":3,"file":"message_store.d.ts","sourceRoot":"","sources":["../../../src/archiver/kv_archiver_store/message_store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAEnE,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAIpD,OAAO,EACL,KAAK,iBAAiB,EAGtB,KAAK,WAAW,EAEjB,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACL,KAAK,YAAY,EAIlB,MAAM,6BAA6B,CAAC;AAErC,qBAAa,iBAAkB,SAAQ,KAAK;aAGxB,YAAY,EAAE,YAAY;IAF5C,YACE,OAAO,EAAE,MAAM,EACC,YAAY,EAAE,YAAY,EAI3C;CACF;AAED,qBAAa,YAAY;;IAYX,OAAO,CAAC,EAAE;IAAtB,YAAoB,EAAE,EAAE,iBAAiB,EAKxC;IAEY,0BAA0B,IAAI,OAAO,CAAC,MAAM,CAAC,CAEzD;IAED,qCAAqC;IACxB,iBAAiB,IAAI,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAQ/D;IAED,oCAAoC;IACvB,iBAAiB,CAAC,OAAO,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAGhE;IAED;;;;OAIG;IACI,iBAAiB,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA6FhE;IAED;;;;OAIG;IACI,qBAAqB,CAAC,aAAa,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAE3E;IAEY,cAAc,IAAI,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAG/D;IAEY,iBAAiB,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,EAAE,EAAE,CAAC,CAuBhF;IAEa,qBAAqB,CAAC,KAAK,GAAE,WAAW,CAAC,MAAM,CAAM,GAAG,qBAAqB,CAAC,YAAY,CAAC,CAKxG;IAEM,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAgB7D;IAEM,kCAAkC,CAAC,sBAAsB,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAIjG;IAED,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,cAAc;YAIR,yBAAyB;CASxC"}