@aztec/archiver 0.0.0-test.1 → 0.0.1-commit.023c3e5

package/dest/archiver/kv_archiver_store/kv_archiver_store.js

@@ -1,254 +0,0 @@
-import { toArray } from '@aztec/foundation/iterable';
-import { createLogger } from '@aztec/foundation/log';
-import { FunctionSelector } from '@aztec/stdlib/abi';
-import { BlockStore } from './block_store.js';
-import { ContractClassStore } from './contract_class_store.js';
-import { ContractInstanceStore } from './contract_instance_store.js';
-import { LogStore } from './log_store.js';
-import { MessageStore } from './message_store.js';
-import { NullifierStore } from './nullifier_store.js';
-/**
- * LMDB implementation of the ArchiverDataStore interface.
- */ export class KVArchiverDataStore {
-    db;
-    static SCHEMA_VERSION = 1;
-    #blockStore;
-    #logStore;
-    #nullifierStore;
-    #messageStore;
-    #contractClassStore;
-    #contractInstanceStore;
-    functionNames;
-    #log;
-    constructor(db, logsMaxPageSize = 1000){
-        this.db = db;
-        this.functionNames = new Map();
-        this.#log = createLogger('archiver:data-store');
-        this.#blockStore = new BlockStore(db);
-        this.#logStore = new LogStore(db, this.#blockStore, logsMaxPageSize);
-        this.#messageStore = new MessageStore(db);
-        this.#contractClassStore = new ContractClassStore(db);
-        this.#contractInstanceStore = new ContractInstanceStore(db);
-        this.#nullifierStore = new NullifierStore(db);
-    }
-    // TODO:  These function names are in memory only as they are for development/debugging. They require the full contract
-    //        artifact supplied to the node out of band. This should be reviewed and potentially removed as part of
-    //        the node api cleanup process.
-    getContractFunctionName(_address, selector) {
-        return Promise.resolve(this.functionNames.get(selector.toString()));
-    }
-    async registerContractFunctionSignatures(_address, signatures) {
-        for (const sig of signatures){
-            try {
-                const selector = await FunctionSelector.fromSignature(sig);
-                this.functionNames.set(selector.toString(), sig.slice(0, sig.indexOf('(')));
-            } catch  {
-                this.#log.warn(`Failed to parse signature: ${sig}. Ignoring`);
-            }
-        }
-    }
-    getContractClass(id) {
-        return this.#contractClassStore.getContractClass(id);
-    }
-    getContractClassIds() {
-        return this.#contractClassStore.getContractClassIds();
-    }
-    async getContractInstance(address) {
-        const contract = this.#contractInstanceStore.getContractInstance(address, await this.getSynchedL2BlockNumber());
-        return contract;
-    }
-    async addContractClasses(data, bytecodeCommitments, blockNumber) {
-        return (await Promise.all(data.map((c, i)=>this.#contractClassStore.addContractClass(c, bytecodeCommitments[i], blockNumber)))).every(Boolean);
-    }
-    async deleteContractClasses(data, blockNumber) {
-        return (await Promise.all(data.map((c)=>this.#contractClassStore.deleteContractClasses(c, blockNumber)))).every(Boolean);
-    }
-    getBytecodeCommitment(contractClassId) {
-        return this.#contractClassStore.getBytecodeCommitment(contractClassId);
-    }
-    addFunctions(contractClassId, privateFunctions, unconstrainedFunctions) {
-        return this.#contractClassStore.addFunctions(contractClassId, privateFunctions, unconstrainedFunctions);
-    }
-    async addContractInstances(data, _blockNumber) {
-        return (await Promise.all(data.map((c)=>this.#contractInstanceStore.addContractInstance(c)))).every(Boolean);
-    }
-    async deleteContractInstances(data, _blockNumber) {
-        return (await Promise.all(data.map((c)=>this.#contractInstanceStore.deleteContractInstance(c)))).every(Boolean);
-    }
-    async addContractInstanceUpdates(data, blockNumber) {
-        return (await Promise.all(data.map((update, logIndex)=>this.#contractInstanceStore.addContractInstanceUpdate(update, blockNumber, logIndex)))).every(Boolean);
-    }
-    async deleteContractInstanceUpdates(data, blockNumber) {
-        return (await Promise.all(data.map((update, logIndex)=>this.#contractInstanceStore.deleteContractInstanceUpdate(update, blockNumber, logIndex)))).every(Boolean);
-    }
-    /**
-   * Append new blocks to the store's list.
-   * @param blocks - The L2 blocks to be added to the store and the last processed L1 block.
-   * @returns True if the operation is successful.
-   */ addBlocks(blocks) {
-        return this.#blockStore.addBlocks(blocks);
-    }
-    /**
-   * Unwinds blocks from the database
-   * @param from -  The tip of the chain, passed for verification purposes,
-   *                ensuring that we don't end up deleting something we did not intend
-   * @param blocksToUnwind - The number of blocks we are to unwind
-   * @returns True if the operation is successful
-   */ unwindBlocks(from, blocksToUnwind) {
-        return this.#blockStore.unwindBlocks(from, blocksToUnwind);
-    }
-    /**
-   * Gets up to `limit` amount of L2 blocks starting from `from`.
-   *
-   * @param start - Number of the first block to return (inclusive).
-   * @param limit - The number of blocks to return.
-   * @returns The requested L2 blocks
-   */ getBlocks(start, limit) {
-        return toArray(this.#blockStore.getBlocks(start, limit));
-    }
-    /**
-   * Gets up to `limit` amount of L2 blocks headers starting from `from`.
-   *
-   * @param start - Number of the first block to return (inclusive).
-   * @param limit - The number of blocks to return.
-   * @returns The requested L2 blocks
-   */ getBlockHeaders(start, limit) {
-        return toArray(this.#blockStore.getBlockHeaders(start, limit));
-    }
-    /**
-   * Gets a tx effect.
-   * @param txHash - The txHash of the tx corresponding to the tx effect.
-   * @returns The requested tx effect (or undefined if not found).
-   */ getTxEffect(txHash) {
-        return this.#blockStore.getTxEffect(txHash);
-    }
-    /**
-   * Gets a receipt of a settled tx.
-   * @param txHash - The hash of a tx we try to get the receipt for.
-   * @returns The requested tx receipt (or undefined if not found).
-   */ getSettledTxReceipt(txHash) {
-        return this.#blockStore.getSettledTxReceipt(txHash);
-    }
-    /**
-   * 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) {
-        return this.#logStore.addLogs(blocks);
-    }
-    deleteLogs(blocks) {
-        return this.#logStore.deleteLogs(blocks);
-    }
-    /**
-   * Append new nullifiers to the store's list.
-   * @param blocks - The blocks for which to add the nullifiers.
-   * @returns True if the operation is successful.
-   */ addNullifiers(blocks) {
-        return this.#nullifierStore.addNullifiers(blocks);
-    }
-    deleteNullifiers(blocks) {
-        return this.#nullifierStore.deleteNullifiers(blocks);
-    }
-    findNullifiersIndexesWithBlock(blockNumber, nullifiers) {
-        return this.#nullifierStore.findNullifiersIndexesWithBlock(blockNumber, nullifiers);
-    }
-    getTotalL1ToL2MessageCount() {
-        return this.#messageStore.getTotalL1ToL2MessageCount();
-    }
-    /**
-   * 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.#messageStore.addL1ToL2Messages(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).
-   */ getL1ToL2MessageIndex(l1ToL2Message) {
-        return this.#messageStore.getL1ToL2MessageIndex(l1ToL2Message);
-    }
-    /**
-   * Gets L1 to L2 message (to be) included in a given block.
-   * @param blockNumber - L2 block number to get messages for.
-   * @returns The L1 to L2 messages/leaves of the messages subtree (throws if not found).
-   */ getL1ToL2Messages(blockNumber) {
-        return this.#messageStore.getL1ToL2Messages(blockNumber);
-    }
-    /**
-   * Retrieves all private logs from up to `limit` blocks, starting from the block number `from`.
-   * @param from - 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.
-   */ getPrivateLogs(from, limit) {
-        return this.#logStore.getPrivateLogs(from, limit);
-    }
-    /**
-   * 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.
-   */ getLogsByTags(tags) {
-        try {
-            return this.#logStore.getLogsByTags(tags);
-        } catch (err) {
-            return Promise.reject(err);
-        }
-    }
-    /**
-   * Gets public logs based on the provided filter.
-   * @param filter - The filter to apply to the logs.
-   * @returns The requested logs.
-   */ getPublicLogs(filter) {
-        try {
-            return this.#logStore.getPublicLogs(filter);
-        } catch (err) {
-            return Promise.reject(err);
-        }
-    }
-    /**
-   * Gets contract class logs based on the provided filter.
-   * @param filter - The filter to apply to the logs.
-   * @returns The requested logs.
-   */ getContractClassLogs(filter) {
-        try {
-            return this.#logStore.getContractClassLogs(filter);
-        } catch (err) {
-            return Promise.reject(err);
-        }
-    }
-    /**
-   * Gets the number of the latest L2 block processed.
-   * @returns The number of the latest L2 block processed.
-   */ getSynchedL2BlockNumber() {
-        return this.#blockStore.getSynchedL2BlockNumber();
-    }
-    getProvenL2BlockNumber() {
-        return this.#blockStore.getProvenL2BlockNumber();
-    }
-    async setProvenL2BlockNumber(blockNumber) {
-        await this.#blockStore.setProvenL2BlockNumber(blockNumber);
-    }
-    async setBlockSynchedL1BlockNumber(l1BlockNumber) {
-        await this.#blockStore.setSynchedL1BlockNumber(l1BlockNumber);
-    }
-    async setMessageSynchedL1BlockNumber(l1BlockNumber) {
-        await this.#messageStore.setSynchedL1BlockNumber(l1BlockNumber);
-    }
-    /**
-   * Gets the last L1 block number processed by the archiver
-   */ async getSynchPoint() {
-        const [blocksSynchedTo, messagesSynchedTo] = await Promise.all([
-            this.#blockStore.getSynchedL1BlockNumber(),
-            this.#messageStore.getSynchedL1BlockNumber()
-        ]);
-        return {
-            blocksSynchedTo,
-            messagesSynchedTo
-        };
-    }
-    estimateSize() {
-        return this.db.estimateSize();
-    }
-}

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

@@ -1,49 +0,0 @@
-import type { Fr } from '@aztec/foundation/fields';
-import type { AztecAsyncKVStore } from '@aztec/kv-store';
-import type { L2Block } from '@aztec/stdlib/block';
-import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
-import { type LogFilter, PrivateLog, TxScopedL2Log } from '@aztec/stdlib/logs';
-import type { BlockStore } from './block_store.js';
-/**
- * A store for logs
- */
-export declare class LogStore {
-    #private;
-    private db;
-    private blockStore;
-    constructor(db: AztecAsyncKVStore, blockStore: BlockStore, logsMaxPageSize?: number);
-    /**
-     * 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: L2Block[]): Promise<boolean>;
-    deleteLogs(blocks: L2Block[]): Promise<boolean>;
-    /**
-     * 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.
-     */
-    getPrivateLogs(start: number, limit: number): Promise<PrivateLog[]>;
-    /**
-     * 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.
-     */
-    getLogsByTags(tags: Fr[]): Promise<TxScopedL2Log[][]>;
-    /**
-     * Gets public logs based on the provided filter.
-     * @param filter - The filter to apply to the logs.
-     * @returns The requested logs.
-     */
-    getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse>;
-    /**
-     * Gets contract class logs based on the provided filter.
-     * @param filter - The filter to apply to the logs.
-     * @returns The requested logs.
-     */
-    getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse>;
-}
-//# sourceMappingURL=log_store.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"log_store.d.ts","sourceRoot":"","sources":["../../../src/archiver/kv_archiver_store/log_store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAGnD,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,EAAE,4BAA4B,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAC3G,OAAO,EAIL,KAAK,SAAS,EAEd,UAAU,EAEV,aAAa,EACd,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;GAEG;AACH,qBAAa,QAAQ;;IASP,OAAO,CAAC,EAAE;IAAqB,OAAO,CAAC,UAAU;gBAAzC,EAAE,EAAE,iBAAiB,EAAU,UAAU,EAAE,UAAU,EAAE,eAAe,GAAE,MAAa;IAsFzG;;;;OAIG;IACH,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAkE5C,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IA0B/C;;;;;OAKG;IACG,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAWzE;;;;;OAKG;IACG,aAAa,CAAC,IAAI,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC;IAO3D;;;;OAIG;IACH,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,qBAAqB,CAAC;IA+EhE;;;;OAIG;IACH,oBAAoB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,4BAA4B,CAAC;CA6G/E"}

package/dest/archiver/kv_archiver_store/log_store.js

@@ -1,364 +0,0 @@
-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;
-    }
-}