@aztec/archiver 0.0.0-test.0

package/dest/archiver/kv_archiver_store/log_store.js

@@ -0,0 +1,364 @@
+import { INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS } from '@aztec/constants';
+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';
+/**
+ * A store for logs
+ */ export class LogStore {
+    db;
+    blockStore;
+    #logsByTag;
+    #logTagsByBlock;
+    #privateLogsByBlock;
+    #publicLogsByBlock;
+    #contractClassLogsByBlock;
+    #logsMaxPageSize;
+    #log;
+    constructor(db, blockStore, logsMaxPageSize = 1000){
+        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.#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)=>{
+            const txHash = txEffect.txHash;
+            const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
+            txEffect.privateLogs.forEach((log)=>{
+                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);
+            });
+        });
+        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);
+            });
+        });
+        return taggedLogs;
+    }
+    /**
+   * 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()){
+                const currentLogs = acc.get(tag) ?? [];
+                acc.set(tag, currentLogs.concat(logs));
+            }
+            return acc;
+        });
+        const tagsToUpdate = Array.from(taggedLogsToAdd.keys());
+        return this.db.transactionAsync(async ()=>{
+            const currentTaggedLogs = await Promise.all(tagsToUpdate.map(async (tag)=>({
+                    tag,
+                    logBuffers: await this.#logsByTag.getAsync(tag)
+                })));
+            currentTaggedLogs.forEach((taggedLogBuffer)=>{
+                if (taggedLogBuffer.logBuffers && taggedLogBuffer.logBuffers.length > 0) {
+                    taggedLogsToAdd.set(taggedLogBuffer.tag, taggedLogBuffer.logBuffers.concat(taggedLogsToAdd.get(taggedLogBuffer.tag)));
+                }
+            });
+            for (const block of blocks){
+                const tagsInBlock = [];
+                for (const [tag, logs] of taggedLogsToAdd.entries()){
+                    await this.#logsByTag.set(tag, logs);
+                    tagsInBlock.push(tag);
+                }
+                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));
+                const publicLogsInBlock = block.body.txEffects.map((txEffect, txIndex)=>[
+                        numToUInt32BE(txIndex),
+                        numToUInt32BE(txEffect.publicLogs.length),
+                        txEffect.publicLogs.map((log)=>log.toBuffer())
+                    ].flat()).flat();
+                const contractClassLogsInBlock = block.body.txEffects.map((txEffect, txIndex)=>[
+                        numToUInt32BE(txIndex),
+                        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));
+            }
+            return true;
+        });
+    }
+    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((block)=>Promise.all([
+                    this.#privateLogsByBlock.delete(block.number),
+                    this.#publicLogsByBlock.delete(block.number),
+                    this.#logTagsByBlock.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 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 public logs based on the provided filter.
+   * @param filter - The filter to apply to the logs.
+   * @returns The requested logs.
+   */ getPublicLogs(filter) {
+        if (filter.afterLog) {
+            return this.#filterPublicLogsBetweenBlocks(filter);
+        } else if (filter.txHash) {
+            return this.#filterPublicLogsOfTx(filter);
+        } else {
+            return this.#filterPublicLogsBetweenBlocks(filter);
+        }
+    }
+    async #filterPublicLogsOfTx(filter) {
+        if (!filter.txHash) {
+            throw new Error('Missing txHash');
+        }
+        const [blockNumber, txIndex] = await this.blockStore.getTxLocation(filter.txHash) ?? [];
+        if (typeof blockNumber !== 'number' || typeof txIndex !== 'number') {
+            return {
+                logs: [],
+                maxLogsHit: false
+            };
+        }
+        const buffer = await this.#publicLogsByBlock.getAsync(blockNumber) ?? Buffer.alloc(0);
+        const publicLogsInBlock = [
+            []
+        ];
+        const reader = new BufferReader(buffer);
+        while(reader.remainingBytes() > 0){
+            const indexOfTx = reader.readNumber();
+            const numLogsInTx = reader.readNumber();
+            publicLogsInBlock[indexOfTx] = [];
+            for(let i = 0; i < numLogsInTx; i++){
+                publicLogsInBlock[indexOfTx].push(reader.readObject(PublicLog));
+            }
+        }
+        const txLogs = publicLogsInBlock[txIndex];
+        const logs = [];
+        const maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+        return {
+            logs,
+            maxLogsHit
+        };
+    }
+    async #filterPublicLogsBetweenBlocks(filter) {
+        const start = filter.afterLog?.blockNumber ?? Math.max(filter.fromBlock ?? INITIAL_L2_BLOCK_NUM, INITIAL_L2_BLOCK_NUM);
+        const end = filter.toBlock;
+        if (typeof end === 'number' && end < start) {
+            return {
+                logs: [],
+                maxLogsHit: true
+            };
+        }
+        const logs = [];
+        let maxLogsHit = false;
+        loopOverBlocks: for await (const [blockNumber, logBuffer] of this.#publicLogsByBlock.entriesAsync({
+            start,
+            end
+        })){
+            const publicLogsInBlock = [
+                []
+            ];
+            const reader = new BufferReader(logBuffer);
+            while(reader.remainingBytes() > 0){
+                const indexOfTx = reader.readNumber();
+                const numLogsInTx = reader.readNumber();
+                publicLogsInBlock[indexOfTx] = [];
+                for(let i = 0; i < numLogsInTx; i++){
+                    publicLogsInBlock[indexOfTx].push(reader.readObject(PublicLog));
+                }
+            }
+            for(let txIndex = filter.afterLog?.txIndex ?? 0; txIndex < publicLogsInBlock.length; txIndex++){
+                const txLogs = publicLogsInBlock[txIndex];
+                maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+                if (maxLogsHit) {
+                    this.#log.debug(`Max logs hit at block ${blockNumber}`);
+                    break loopOverBlocks;
+                }
+            }
+        }
+        return {
+            logs,
+            maxLogsHit
+        };
+    }
+    /**
+   * Gets contract class logs based on the provided filter.
+   * @param filter - The filter to apply to the logs.
+   * @returns The requested logs.
+   */ getContractClassLogs(filter) {
+        if (filter.afterLog) {
+            return this.#filterContractClassLogsBetweenBlocks(filter);
+        } else if (filter.txHash) {
+            return this.#filterContractClassLogsOfTx(filter);
+        } else {
+            return this.#filterContractClassLogsBetweenBlocks(filter);
+        }
+    }
+    async #filterContractClassLogsOfTx(filter) {
+        if (!filter.txHash) {
+            throw new Error('Missing txHash');
+        }
+        const [blockNumber, txIndex] = await this.blockStore.getTxLocation(filter.txHash) ?? [];
+        if (typeof blockNumber !== 'number' || typeof txIndex !== 'number') {
+            return {
+                logs: [],
+                maxLogsHit: false
+            };
+        }
+        const contractClassLogsBuffer = await this.#contractClassLogsByBlock.getAsync(blockNumber) ?? Buffer.alloc(0);
+        const contractClassLogsInBlock = [
+            []
+        ];
+        const reader = new BufferReader(contractClassLogsBuffer);
+        while(reader.remainingBytes() > 0){
+            const indexOfTx = reader.readNumber();
+            const numLogsInTx = reader.readNumber();
+            contractClassLogsInBlock[indexOfTx] = [];
+            for(let i = 0; i < numLogsInTx; i++){
+                contractClassLogsInBlock[indexOfTx].push(reader.readObject(ContractClassLog));
+            }
+        }
+        const txLogs = contractClassLogsInBlock[txIndex];
+        const logs = [];
+        const maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+        return {
+            logs,
+            maxLogsHit
+        };
+    }
+    async #filterContractClassLogsBetweenBlocks(filter) {
+        const start = filter.afterLog?.blockNumber ?? Math.max(filter.fromBlock ?? INITIAL_L2_BLOCK_NUM, INITIAL_L2_BLOCK_NUM);
+        const end = filter.toBlock;
+        if (typeof end === 'number' && end < start) {
+            return {
+                logs: [],
+                maxLogsHit: true
+            };
+        }
+        const logs = [];
+        let maxLogsHit = false;
+        loopOverBlocks: for await (const [blockNumber, logBuffer] of this.#contractClassLogsByBlock.entriesAsync({
+            start,
+            end
+        })){
+            const contractClassLogsInBlock = [
+                []
+            ];
+            const reader = new BufferReader(logBuffer);
+            while(reader.remainingBytes() > 0){
+                const indexOfTx = reader.readNumber();
+                const numLogsInTx = reader.readNumber();
+                contractClassLogsInBlock[indexOfTx] = [];
+                for(let i = 0; i < numLogsInTx; i++){
+                    contractClassLogsInBlock[indexOfTx].push(reader.readObject(ContractClassLog));
+                }
+            }
+            for(let txIndex = filter.afterLog?.txIndex ?? 0; txIndex < contractClassLogsInBlock.length; txIndex++){
+                const txLogs = contractClassLogsInBlock[txIndex];
+                maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+                if (maxLogsHit) {
+                    this.#log.debug(`Max logs hit at block ${blockNumber}`);
+                    break loopOverBlocks;
+                }
+            }
+        }
+        return {
+            logs,
+            maxLogsHit
+        };
+    }
+    #accumulateLogs(results, blockNumber, 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));
+                } else {
+                    results.push(new ExtendedPublicLog(new LogId(blockNumber, txIndex, logIndex), log));
+                }
+                if (results.length >= this.#logsMaxPageSize) {
+                    maxLogsHit = true;
+                    break;
+                }
+            }
+        }
+        return maxLogsHit;
+    }
+}

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

@@ -0,0 +1,33 @@
+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.
+ */
+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>;
+    /**
+     * 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.
+     */
+    addL1ToL2Messages(messages: DataRetrieval<InboxLeaf>): Promise<boolean>;
+    /**
+     * 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[]>;
+}
+//# sourceMappingURL=message_store.d.ts.map

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

@@ -0,0 +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"}

package/dest/archiver/kv_archiver_store/message_store.js

@@ -0,0 +1,85 @@
+import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { InboxLeaf } from '@aztec/stdlib/messaging';
+/**
+ * LMDB implementation of the ArchiverDataStore interface.
+ */ export class MessageStore {
+    db;
+    #l1ToL2Messages;
+    #l1ToL2MessageIndices;
+    #lastSynchedL1Block;
+    #totalMessageCount;
+    #log;
+    #l1ToL2MessagesSubtreeSize;
+    constructor(db){
+        this.db = db;
+        this.#log = createLogger('archiver:message_store');
+        this.#l1ToL2MessagesSubtreeSize = 2 ** L1_TO_L2_MSG_SUBTREE_HEIGHT;
+        this.#l1ToL2Messages = db.openMap('archiver_l1_to_l2_messages');
+        this.#l1ToL2MessageIndices = db.openMap('archiver_l1_to_l2_message_indices');
+        this.#lastSynchedL1Block = db.openSingleton('archiver_last_l1_block_new_messages');
+        this.#totalMessageCount = db.openSingleton('archiver_l1_to_l2_message_count');
+    }
+    async getTotalL1ToL2MessageCount() {
+        return await this.#totalMessageCount.getAsync() ?? 0n;
+    }
+    /**
+   * Gets the last L1 block number that emitted new messages.
+   * @returns The last L1 block number processed
+   */ getSynchedL1BlockNumber() {
+        return this.#lastSynchedL1Block.getAsync();
+    }
+    async setSynchedL1BlockNumber(l1BlockNumber) {
+        await this.#lastSynchedL1Block.set(l1BlockNumber);
+    }
+    /**
+   * 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.
+   */ addL1ToL2Messages(messages) {
+        return this.db.transactionAsync(async ()=>{
+            const lastL1BlockNumber = await this.#lastSynchedL1Block.getAsync() ?? 0n;
+            if (lastL1BlockNumber >= messages.lastProcessedL1BlockNumber) {
+                return false;
+            }
+            await this.#lastSynchedL1Block.set(messages.lastProcessedL1BlockNumber);
+            for (const message of messages.retrievedData){
+                const key = `${message.index}`;
+                await this.#l1ToL2Messages.set(key, message.leaf.toBuffer());
+                await this.#l1ToL2MessageIndices.set(message.leaf.toString(), message.index);
+            }
+            const lastTotalMessageCount = await this.getTotalL1ToL2MessageCount();
+            await this.#totalMessageCount.set(lastTotalMessageCount + BigInt(messages.retrievedData.length));
+            return true;
+        });
+    }
+    /**
+   * 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) {
+        return this.#l1ToL2MessageIndices.getAsync(l1ToL2Message.toString());
+    }
+    async getL1ToL2Messages(blockNumber) {
+        const messages = [];
+        let undefinedMessageFound = false;
+        const startIndex = Number(InboxLeaf.smallestIndexFromL2Block(blockNumber));
+        for(let i = startIndex; i < startIndex + this.#l1ToL2MessagesSubtreeSize; i++){
+            // This is inefficient but probably fine for now.
+            const key = `${i}`;
+            const message = await this.#l1ToL2Messages.getAsync(key);
+            if (message) {
+                if (undefinedMessageFound) {
+                    throw new Error(`L1 to L2 message gap found in block ${blockNumber}`);
+                }
+                messages.push(Fr.fromBuffer(message));
+            } else {
+                undefinedMessageFound = true;
+            // We continue iterating over messages here to verify that there are no more messages after the undefined one.
+            // --> If this was the case this would imply there is some issue with log fetching.
+            }
+        }
+        return messages;
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { InBlock, L2Block } from '@aztec/stdlib/block';
+export declare class NullifierStore {
+    #private;
+    private db;
+    constructor(db: AztecAsyncKVStore);
+    addNullifiers(blocks: L2Block[]): Promise<boolean>;
+    deleteNullifiers(blocks: L2Block[]): Promise<boolean>;
+    findNullifiersIndexesWithBlock(blockNumber: number, nullifiers: Fr[]): Promise<(InBlock<bigint> | undefined)[]>;
+}
+//# sourceMappingURL=nullifier_store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nullifier_store.d.ts","sourceRoot":"","sources":["../../../src/archiver/kv_archiver_store/nullifier_store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE5D,qBAAa,cAAc;;IAMb,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,iBAAiB;IAMnC,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IA0BlD,gBAAgB,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAerD,8BAA8B,CAClC,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,EAAE,EAAE,GACf,OAAO,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC,EAAE,CAAC;CAkC5C"}

package/dest/archiver/kv_archiver_store/nullifier_store.js

@@ -0,0 +1,73 @@
+import { MAX_NULLIFIERS_PER_TX } from '@aztec/constants';
+import { createLogger } from '@aztec/foundation/log';
+export class NullifierStore {
+    db;
+    #nullifiersToBlockNumber;
+    #nullifiersToBlockHash;
+    #nullifiersToIndex;
+    #log;
+    constructor(db){
+        this.db = db;
+        this.#log = createLogger('archiver:log_store');
+        this.#nullifiersToBlockNumber = db.openMap('archiver_nullifiers_to_block_number');
+        this.#nullifiersToBlockHash = db.openMap('archiver_nullifiers_to_block_hash');
+        this.#nullifiersToIndex = db.openMap('archiver_nullifiers_to_index');
+    }
+    async addNullifiers(blocks) {
+        const blockHashes = await Promise.all(blocks.map((block)=>block.hash()));
+        await this.db.transactionAsync(async ()=>{
+            await Promise.all(blocks.map((block, i)=>{
+                const dataStartIndexForBlock = block.header.state.partial.nullifierTree.nextAvailableLeafIndex - block.body.txEffects.length * MAX_NULLIFIERS_PER_TX;
+                return Promise.all(block.body.txEffects.map((txEffects, txIndex)=>{
+                    const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NULLIFIERS_PER_TX;
+                    return Promise.all(txEffects.nullifiers.map(async (nullifier, nullifierIndex)=>{
+                        await this.#nullifiersToBlockNumber.set(nullifier.toString(), block.number);
+                        await this.#nullifiersToBlockHash.set(nullifier.toString(), blockHashes[i].toString());
+                        await this.#nullifiersToIndex.set(nullifier.toString(), dataStartIndexForTx + nullifierIndex);
+                    }));
+                }));
+            }));
+        });
+        return true;
+    }
+    async deleteNullifiers(blocks) {
+        await this.db.transactionAsync(async ()=>{
+            for (const block of blocks){
+                for (const nullifier of block.body.txEffects.flatMap((tx)=>tx.nullifiers)){
+                    await Promise.all([
+                        this.#nullifiersToBlockNumber.delete(nullifier.toString()),
+                        this.#nullifiersToBlockHash.delete(nullifier.toString()),
+                        this.#nullifiersToIndex.delete(nullifier.toString())
+                    ]);
+                }
+            }
+        });
+        return true;
+    }
+    async findNullifiersIndexesWithBlock(blockNumber, nullifiers) {
+        const asStrings = nullifiers.map((x)=>x.toString());
+        const maybeNullifiers = await Promise.all(asStrings.map(async (nullifier)=>{
+            const [data, l2BlockNumber, l2BlockHash] = await Promise.all([
+                this.#nullifiersToIndex.getAsync(nullifier),
+                this.#nullifiersToBlockNumber.getAsync(nullifier),
+                this.#nullifiersToBlockHash.getAsync(nullifier)
+            ]);
+            return {
+                data,
+                l2BlockNumber,
+                l2BlockHash
+            };
+        }));
+        return maybeNullifiers.map(({ data, l2BlockNumber, l2BlockHash })=>{
+            if (data === undefined || l2BlockNumber === undefined || l2BlockHash === undefined || l2BlockNumber > blockNumber) {
+                return undefined;
+            } else {
+                return {
+                    data: BigInt(data),
+                    l2BlockNumber,
+                    l2BlockHash
+                };
+            }
+        });
+    }
+}

package/dest/archiver/memory_archiver_store/l1_to_l2_message_store.d.ts

@@ -0,0 +1,23 @@
+import type { Fr } from '@aztec/foundation/fields';
+import { InboxLeaf } from '@aztec/stdlib/messaging';
+/**
+ * A simple in-memory implementation of an L1 to L2 message store.
+ */
+export declare class L1ToL2MessageStore {
+    #private;
+    /**
+     * A map pointing from a key in a "messageIndex" format to the corresponding L1 to L2 message hash.
+     */
+    protected store: Map<string, Fr>;
+    constructor();
+    getTotalL1ToL2MessageCount(): bigint;
+    addMessage(message: InboxLeaf): void;
+    getMessages(blockNumber: bigint): Fr[];
+    /**
+     * 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).
+     */
+    getMessageIndex(l1ToL2Message: Fr): bigint | undefined;
+}
+//# sourceMappingURL=l1_to_l2_message_store.d.ts.map

package/dest/archiver/memory_archiver_store/l1_to_l2_message_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l1_to_l2_message_store.d.ts","sourceRoot":"","sources":["../../../src/archiver/memory_archiver_store/l1_to_l2_message_store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD;;GAEG;AACH,qBAAa,kBAAkB;;IAC7B;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,CAAa;;IAM7C,0BAA0B,IAAI,MAAM;IAIpC,UAAU,CAAC,OAAO,EAAE,SAAS;IAI7B,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,EAAE,EAAE;IAsBtC;;;;OAIG;IACH,eAAe,CAAC,aAAa,EAAE,EAAE,GAAG,MAAM,GAAG,SAAS;CAQvD"}

package/dest/archiver/memory_archiver_store/l1_to_l2_message_store.js

@@ -0,0 +1,49 @@
+import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
+import { InboxLeaf } from '@aztec/stdlib/messaging';
+/**
+ * A simple in-memory implementation of an L1 to L2 message store.
+ */ export class L1ToL2MessageStore {
+    /**
+   * A map pointing from a key in a "messageIndex" format to the corresponding L1 to L2 message hash.
+   */ store = new Map();
+    #l1ToL2MessagesSubtreeSize = 2 ** L1_TO_L2_MSG_SUBTREE_HEIGHT;
+    constructor(){}
+    getTotalL1ToL2MessageCount() {
+        return BigInt(this.store.size);
+    }
+    addMessage(message) {
+        this.store.set(`${message.index}`, message.leaf);
+    }
+    getMessages(blockNumber) {
+        const messages = [];
+        let undefinedMessageFound = false;
+        const startIndex = Number(InboxLeaf.smallestIndexFromL2Block(blockNumber));
+        for(let i = startIndex; i < startIndex + this.#l1ToL2MessagesSubtreeSize; i++){
+            // This is inefficient but probably fine for now.
+            const message = this.store.get(`${i}`);
+            if (message) {
+                if (undefinedMessageFound) {
+                    throw new Error(`L1 to L2 message gap found in block ${blockNumber}`);
+                }
+                messages.push(message);
+            } else {
+                undefinedMessageFound = true;
+            // We continue iterating over messages here to verify that there are no more messages after the undefined one.
+            // --> If this was the case this would imply there is some issue with log fetching.
+            }
+        }
+        return messages;
+    }
+    /**
+   * 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).
+   */ getMessageIndex(l1ToL2Message) {
+        for (const [key, message] of this.store.entries()){
+            if (message.equals(l1ToL2Message)) {
+                return BigInt(key);
+            }
+        }
+        return undefined;
+    }
+}