@aztec/archiver 0.0.1-commit.c7c42ec → 0.0.1-commit.d1f2d6c

package/dest/{archiver/kv_archiver_store → store}/kv_archiver_store.js

@@ -12,7 +12,8 @@ export const ARCHIVER_DB_VERSION = 5;
 export const MAX_FUNCTION_SIGNATURES = 1000;
 export const MAX_FUNCTION_NAME_LEN = 256;
 /**
- * LMDB implementation of the ArchiverDataStore interface.
+ * LMDB-based data store for the archiver.
+ * Stores all archiver data including blocks, logs, contract classes/instances, and L1 to L2 messages.
  */ export class KVArchiverDataStore {
     db;
     static SCHEMA_VERSION = ARCHIVER_DB_VERSION;
@@ -23,17 +24,17 @@ export const MAX_FUNCTION_NAME_LEN = 256;
     #contractInstanceStore;
     functionNames;
     #log;
-    constructor(db, logsMaxPageSize = 1000){
+    constructor(db, logsMaxPageSize = 1000, l1Constants){
         this.db = db;
         this.functionNames = new Map();
         this.#log = createLogger('archiver:data-store');
-        this.#blockStore = new BlockStore(db);
+        this.#blockStore = new BlockStore(db, l1Constants);
         this.#logStore = new LogStore(db, this.#blockStore, logsMaxPageSize);
         this.#messageStore = new MessageStore(db);
         this.#contractClassStore = new ContractClassStore(db);
         this.#contractInstanceStore = new ContractInstanceStore(db);
     }
-    transactionAsync(callback) {
+    /** Opens a new transaction to the underlying store and runs all operations within it. */ transactionAsync(callback) {
         return this.db.transactionAsync(callback);
     }
     getBlockNumber() {
@@ -44,17 +45,20 @@ export const MAX_FUNCTION_NAME_LEN = 256;
         const timestamp = maybeTimestamp ?? header.globalVariables.timestamp;
         return this.getContractInstance(address, timestamp);
     }
-    async backupTo(path, compress = true) {
+    /** Backups the archiver db to the target folder. Returns the path to the db file. */ async backupTo(path, compress = true) {
         await this.db.backupTo(path, compress);
         return join(path, 'data.mdb');
     }
-    close() {
+    /** Closes the underlying data store. */ close() {
         return this.db.close();
     }
-    getDebugFunctionName(_address, selector) {
+    /** Computes the finalized block number based on the proven block number. */ getFinalizedL2BlockNumber() {
+        return this.#blockStore.getFinalizedL2BlockNumber();
+    }
+    /** Looks up a public function name given a selector. */ getDebugFunctionName(_address, selector) {
         return Promise.resolve(this.functionNames.get(selector.toString()));
     }
-    async registerContractFunctionSignatures(signatures) {
+    /** Register a public function signature, so it can be looked up by selector. */ async registerContractFunctionSignatures(signatures) {
         for (const sig of signatures){
             if (this.functionNames.size > MAX_FUNCTION_SIGNATURES) {
                 return;
@@ -67,19 +71,33 @@ export const MAX_FUNCTION_NAME_LEN = 256;
             }
         }
     }
-    getContractClass(id) {
+    /**
+   * Returns a contract class given its id, or undefined if not exists.
+   * @param id - Id of the contract class.
+   */ getContractClass(id) {
         return this.#contractClassStore.getContractClass(id);
     }
-    getContractClassIds() {
+    /** Returns the list of all class ids known by the archiver. */ getContractClassIds() {
         return this.#contractClassStore.getContractClassIds();
     }
-    getContractInstance(address, timestamp) {
+    /**
+   * Returns a contract instance given its address and the given timestamp, or undefined if not exists.
+   * @param address - Address of the contract.
+   * @param timestamp - Timestamp to get the contract instance at. Contract updates might change the instance.
+   * @returns The contract instance or undefined if not found.
+   */ getContractInstance(address, timestamp) {
         return this.#contractInstanceStore.getContractInstance(address, timestamp);
     }
     getContractInstanceDeploymentBlockNumber(address) {
         return this.#contractInstanceStore.getContractInstanceDeploymentBlockNumber(address);
     }
-    async addContractClasses(data, bytecodeCommitments, blockNumber) {
+    /**
+   * Add new contract classes from an L2 block to the store's list.
+   * @param data - List of contract classes to be added.
+   * @param bytecodeCommitments - Bytecode commitments for the contract classes.
+   * @param blockNumber - Number of the L2 block the contracts were registered in.
+   * @returns True if the operation is successful.
+   */ 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) {
@@ -88,16 +106,26 @@ export const MAX_FUNCTION_NAME_LEN = 256;
     getBytecodeCommitment(contractClassId) {
         return this.#contractClassStore.getBytecodeCommitment(contractClassId);
     }
-    addFunctions(contractClassId, privateFunctions, utilityFunctions) {
+    /** Adds private functions to a contract class. */ addFunctions(contractClassId, privateFunctions, utilityFunctions) {
         return this.#contractClassStore.addFunctions(contractClassId, privateFunctions, utilityFunctions);
     }
-    async addContractInstances(data, blockNumber) {
+    /**
+   * Add new contract instances from an L2 block to the store's list.
+   * @param data - List of contract instances to be added.
+   * @param blockNumber - Number of the L2 block the instances were deployed in.
+   * @returns True if the operation is successful.
+   */ async addContractInstances(data, blockNumber) {
         return (await Promise.all(data.map((c)=>this.#contractInstanceStore.addContractInstance(c, blockNumber)))).every(Boolean);
     }
     async deleteContractInstances(data, _blockNumber) {
         return (await Promise.all(data.map((c)=>this.#contractInstanceStore.deleteContractInstance(c)))).every(Boolean);
     }
-    async addContractInstanceUpdates(data, timestamp) {
+    /**
+   * Add new contract instance updates
+   * @param data - List of contract updates to be added.
+   * @param timestamp - Timestamp at which the updates were scheduled.
+   * @returns True if the operation is successful.
+   */ async addContractInstanceUpdates(data, timestamp) {
         return (await Promise.all(data.map((update, logIndex)=>this.#contractInstanceStore.addContractInstanceUpdate(update, timestamp, logIndex)))).every(Boolean);
     }
     async deleteContractInstanceUpdates(data, timestamp) {
@@ -110,10 +138,18 @@ export const MAX_FUNCTION_NAME_LEN = 256;
    */ addBlocks(blocks, opts = {}) {
         return this.#blockStore.addBlocks(blocks, opts);
     }
-    getRangeOfCheckpoints(from, limit) {
+    /**
+   * Returns an array of checkpoint objects
+   * @param from The first checkpoint number to be retrieved
+   * @param limit The maximum number of checkpoints to retrieve
+   * @returns The array of requested checkpoint data objects
+   */ getRangeOfCheckpoints(from, limit) {
         return this.#blockStore.getRangeOfCheckpoints(from, limit);
     }
-    getLatestBlockNumber() {
+    /**
+   * Returns the number of the latest block
+   * @returns The number of the latest block
+   */ getLatestBlockNumber() {
         return this.#blockStore.getLatestBlockNumber();
     }
     /**
@@ -125,43 +161,83 @@ export const MAX_FUNCTION_NAME_LEN = 256;
    */ unwindCheckpoints(from, checkpointsToUnwind) {
         return this.#blockStore.unwindCheckpoints(from, checkpointsToUnwind);
     }
-    addCheckpoints(checkpoints) {
+    /**
+   * Appends new checkpoints, and their blocks to the store's collection
+   * @param checkpoints The collection of checkpoints to be added
+   * @returns True if the operation is successful
+   */ addCheckpoints(checkpoints) {
         return this.#blockStore.addCheckpoints(checkpoints);
     }
-    getCheckpointedBlock(number) {
+    /**
+   * Returns the block for the given number, or undefined if not exists.
+   * @param number - The block number to return.
+   */ getCheckpointedBlock(number) {
         return this.#blockStore.getCheckpointedBlock(number);
     }
-    getCheckpointedBlockByHash(blockHash) {
+    /**
+   * Returns the block for the given hash, or undefined if not exists.
+   * @param blockHash - The block hash to return.
+   */ getCheckpointedBlockByHash(blockHash) {
         return this.#blockStore.getCheckpointedBlockByHash(blockHash);
     }
-    getCheckpointedBlockByArchive(archive) {
+    /**
+   * Returns the block for the given archive root, or undefined if not exists.
+   * @param archive - The archive root to return.
+   */ getCheckpointedBlockByArchive(archive) {
         return this.#blockStore.getCheckpointedBlockByArchive(archive);
     }
-    getBlock(number) {
+    /**
+   * Returns the block for the given number, or undefined if not exists.
+   * @param number - The block number to return.
+   */ getBlock(number) {
         return this.#blockStore.getBlock(number);
     }
-    getBlockByHash(blockHash) {
+    /**
+   * Returns the block for the given hash, or undefined if not exists.
+   * @param blockHash - The block hash to return.
+   */ getBlockByHash(blockHash) {
         return this.#blockStore.getBlockByHash(L2BlockHash.fromField(blockHash));
     }
-    getBlockByArchive(archive) {
+    /**
+   * Returns the block for the given archive root, or undefined if not exists.
+   * @param archive - The archive root to return.
+   */ getBlockByArchive(archive) {
         return this.#blockStore.getBlockByArchive(archive);
     }
-    getBlocks(from, limit) {
+    /**
+   * Gets up to `limit` amount of published L2 blocks starting from `from`.
+   * @param from - Number of the first block to return (inclusive).
+   * @param limit - The number of blocks to return.
+   * @returns The requested L2 blocks.
+   */ getBlocks(from, limit) {
         return toArray(this.#blockStore.getBlocks(from, limit));
     }
     /**
-   * Gets up to `limit` amount of L2 blocks headers starting from `from`.
-   *
+   * Gets up to `limit` amount of checkpointed L2 blocks starting from `from`.
+   * @param from - Number of the first block to return (inclusive).
+   * @param limit - The number of blocks to return.
+   * @returns The requested checkpointed L2 blocks.
+   */ getCheckpointedBlocks(from, limit) {
+        return toArray(this.#blockStore.getCheckpointedBlocks(from, limit));
+    }
+    /**
+   * Gets up to `limit` amount of L2 block 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
+   * @returns The requested L2 block headers.
    */ getBlockHeaders(start, limit) {
         return toArray(this.#blockStore.getBlockHeaders(start, limit));
     }
-    getBlockHeaderByHash(blockHash) {
+    /**
+   * Returns the block header for the given hash, or undefined if not exists.
+   * @param blockHash - The block hash to return.
+   */ getBlockHeaderByHash(blockHash) {
         return this.#blockStore.getBlockHeaderByHash(L2BlockHash.fromField(blockHash));
     }
-    getBlockHeaderByArchive(archive) {
+    /**
+   * Returns the block header for the given archive root, or undefined if not exists.
+   * @param archive - The archive root to return.
+   */ getBlockHeaderByArchive(archive) {
         return this.#blockStore.getBlockHeaderByArchive(archive);
     }
     /**
@@ -188,15 +264,19 @@ export const MAX_FUNCTION_NAME_LEN = 256;
     deleteLogs(blocks) {
         return this.#logStore.deleteLogs(blocks);
     }
-    getTotalL1ToL2MessageCount() {
+    /**
+   * Get the total number of L1 to L2 messages
+   * @returns The number of L1 to L2 messages in the store
+   */ getTotalL1ToL2MessageCount() {
         return this.#messageStore.getTotalL1ToL2MessageCount();
     }
-    getLastL1ToL2Message() {
+    /** Returns the last L1 to L2 message stored. */ getLastL1ToL2Message() {
         return this.#messageStore.getLastMessage();
     }
     /**
    * Append L1 to L2 messages to the store.
    * @param messages - The L1 to L2 messages to be added to the store.
+   * @returns True if the operation is successful.
    */ addL1ToL2Messages(messages) {
         return this.#messageStore.addL1ToL2Messages(messages);
     }
@@ -214,16 +294,27 @@ export const MAX_FUNCTION_NAME_LEN = 256;
    */ getL1ToL2Messages(checkpointNumber) {
         return this.#messageStore.getL1ToL2Messages(checkpointNumber);
     }
-    getPrivateLogsByTags(tags) {
+    /**
+   * Gets 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.
+   * @param tags - The tags to search for.
+   * @param page - The page number (0-indexed) for pagination. Returns at most 10 logs per tag per page.
+   */ getPrivateLogsByTags(tags, page) {
         try {
-            return this.#logStore.getPrivateLogsByTags(tags);
+            return this.#logStore.getPrivateLogsByTags(tags, page);
         } catch (err) {
             return Promise.reject(err);
         }
     }
-    getPublicLogsByTagsFromContract(contractAddress, tags) {
+    /**
+   * Gets 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.
+   * @param contractAddress - The contract address to search logs for.
+   * @param tags - The tags to search for.
+   * @param page - The page number (0-indexed) for pagination. Returns at most 10 logs per tag per page.
+   */ getPublicLogsByTagsFromContract(contractAddress, tags, page) {
         try {
-            return this.#logStore.getPublicLogsByTagsFromContract(contractAddress, tags);
+            return this.#logStore.getPublicLogsByTagsFromContract(contractAddress, tags, page);
         } catch (err) {
             return Promise.reject(err);
         }
@@ -250,23 +341,34 @@ export const MAX_FUNCTION_NAME_LEN = 256;
             return Promise.reject(err);
         }
     }
-    getProvenCheckpointNumber() {
+    /**
+   * Gets the number of the latest proven checkpoint processed.
+   * @returns The number of the latest proven checkpoint processed.
+   */ getProvenCheckpointNumber() {
         return this.#blockStore.getProvenCheckpointNumber();
     }
-    async setProvenCheckpointNumber(checkpointNumber) {
+    /**
+   * Stores the number of the latest proven checkpoint processed.
+   * @param checkpointNumber - The number of the latest proven checkpoint processed.
+   */ async setProvenCheckpointNumber(checkpointNumber) {
         await this.#blockStore.setProvenCheckpointNumber(checkpointNumber);
     }
     async setBlockSynchedL1BlockNumber(l1BlockNumber) {
         await this.#blockStore.setSynchedL1BlockNumber(l1BlockNumber);
     }
-    async setMessageSynchedL1Block(l1Block) {
+    /**
+   * Stores the l1 block that messages have been synched until
+   */ async setMessageSynchedL1Block(l1Block) {
         await this.#messageStore.setSynchedL1Block(l1Block);
     }
-    getProvenBlockNumber() {
+    /**
+   * Returns the number of the most recent proven block
+   * @returns The number of the most recent proven block
+   */ getProvenBlockNumber() {
         return this.#blockStore.getProvenBlockNumber();
     }
     /**
-   * Gets the last L1 block number processed by the archiver
+   * Gets the synch point of the archiver
    */ async getSynchPoint() {
         const [blocksSynchedTo, messagesSynchedTo] = await Promise.all([
             this.#blockStore.getSynchedL1BlockNumber(),
@@ -277,37 +379,68 @@ export const MAX_FUNCTION_NAME_LEN = 256;
             messagesSynchedTo
         };
     }
-    estimateSize() {
+    /** Estimates the size of the store in bytes. */ estimateSize() {
         return this.db.estimateSize();
     }
-    rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber) {
+    /** Deletes all L1 to L2 messages up until (excluding) the target checkpoint number. */ rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber) {
         return this.#messageStore.rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber);
     }
-    iterateL1ToL2Messages(range = {}) {
+    /** Returns an async iterator to all L1 to L2 messages on the range. */ iterateL1ToL2Messages(range = {}) {
         return this.#messageStore.iterateL1ToL2Messages(range);
     }
-    removeL1ToL2Messages(startIndex) {
+    /** Removes all L1 to L2 messages starting from the given index (inclusive). */ removeL1ToL2Messages(startIndex) {
         return this.#messageStore.removeL1ToL2Messages(startIndex);
     }
-    getPendingChainValidationStatus() {
+    /** Returns the last synced validation status of the pending chain. */ getPendingChainValidationStatus() {
         return this.#blockStore.getPendingChainValidationStatus();
     }
-    setPendingChainValidationStatus(status) {
+    /** Sets the last synced validation status of the pending chain. */ setPendingChainValidationStatus(status) {
         return this.#blockStore.setPendingChainValidationStatus(status);
     }
-    getCheckpointedL2BlockNumber() {
+    /**
+   * Gets the number of the latest L2 block processed.
+   * @returns The number of the latest L2 block processed.
+   */ getCheckpointedL2BlockNumber() {
         return this.#blockStore.getCheckpointedL2BlockNumber();
     }
-    getSynchedCheckpointNumber() {
+    /**
+   * Gets the number of the latest published checkpoint processed.
+   * @returns The number of the latest published checkpoint processed
+   */ getSynchedCheckpointNumber() {
         return this.#blockStore.getLatestCheckpointNumber();
     }
-    async setCheckpointSynchedL1BlockNumber(l1BlockNumber) {
+    /**
+   * Stores the l1 block number that checkpoints have been synched until
+   * @param l1BlockNumber  - The l1 block number
+   */ async setCheckpointSynchedL1BlockNumber(l1BlockNumber) {
         await this.#blockStore.setSynchedL1BlockNumber(l1BlockNumber);
     }
-    getBlocksForCheckpoint(checkpointNumber) {
+    /**
+   * Retrieves all blocks for the requested checkpoint
+   * @param checkpointNumber Retrieves all blocks for the given checkpoint
+   * @returns The collection of blocks for the requested checkpoint if available (undefined otherwise)
+   */ getBlocksForCheckpoint(checkpointNumber) {
         return this.#blockStore.getBlocksForCheckpoint(checkpointNumber);
     }
-    getCheckpointData(checkpointNumber) {
+    /**
+   * Returns checkpoint data for the requested checkpoint number
+   * @param checkpointNumber - The checkpoint requested
+   * @returns The checkpoint data or undefined if not found
+   */ getCheckpointData(checkpointNumber) {
         return this.#blockStore.getCheckpointData(checkpointNumber);
     }
+    /**
+   * Gets all blocks that have the given slot number.
+   * @param slotNumber - The slot number to search for.
+   * @returns All blocks with the given slot number.
+   */ getBlocksForSlot(slotNumber) {
+        return this.#blockStore.getBlocksForSlot(slotNumber);
+    }
+    /**
+   * Removes all blocks with block number > blockNumber.
+   * @param blockNumber - The block number to remove after.
+   * @returns The removed blocks (for event emission).
+   */ removeBlocksAfter(blockNumber) {
+        return this.#blockStore.unwindBlocksAfter(blockNumber);
+    }
 }

package/dest/store/log_store.d.ts

@@ -0,0 +1,54 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { L2Block } from '@aztec/stdlib/block';
+import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
+import { type LogFilter, type SiloedTag, Tag, 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>;
+    /**
+     * Gets 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.
+     * @param tags - The tags to search for.
+     * @param page - The page number (0-indexed) for pagination.
+     * @returns An array of log arrays, one per tag. Returns at most MAX_LOGS_PER_TAG logs per tag per page. If
+     * MAX_LOGS_PER_TAG logs are returned for a tag, the caller should fetch the next page to check for more logs.
+     */
+    getPrivateLogsByTags(tags: SiloedTag[], page?: number): Promise<TxScopedL2Log[][]>;
+    /**
+     * Gets 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.
+     * @param contractAddress - The contract address to search logs for.
+     * @param tags - The tags to search for.
+     * @param page - The page number (0-indexed) for pagination.
+     * @returns An array of log arrays, one per tag. Returns at most MAX_LOGS_PER_TAG logs per tag per page. If
+     * MAX_LOGS_PER_TAG logs are returned for a tag, the caller should fetch the next page to check for more logs.
+     */
+    getPublicLogsByTagsFromContract(contractAddress: AztecAddress, tags: Tag[], page?: number): 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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nX3N0b3JlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3RvcmUvbG9nX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU1BLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFpQixNQUFNLGlCQUFpQixDQUFDO0FBQ3hFLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ2hFLE9BQU8sRUFBRSxPQUFPLEVBQWUsTUFBTSxxQkFBcUIsQ0FBQztBQUUzRCxPQUFPLEtBQUssRUFBRSw0QkFBNEIsRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQzNHLE9BQU8sRUFJTCxLQUFLLFNBQVMsRUFHZCxLQUFLLFNBQVMsRUFDZCxHQUFHLEVBQ0gsYUFBYSxFQUNkLE1BQU0sb0JBQW9CLENBQUM7QUFFNUIsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFbkQ7O0dBRUc7QUFDSCxxQkFBYSxRQUFROztJQWFqQixPQUFPLENBQUMsRUFBRTtJQUNWLE9BQU8sQ0FBQyxVQUFVO0lBRnBCLFlBQ1UsRUFBRSxFQUFFLGlCQUFpQixFQUNyQixVQUFVLEVBQUUsVUFBVSxFQUM5QixlQUFlLEdBQUUsTUFBYSxFQVUvQjtJQTRNRDs7OztPQUlHO0lBQ0gsT0FBTyxDQUFDLE1BQU0sRUFBRSxPQUFPLEVBQUUsR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBUzNDO0lBZ0JELFVBQVUsQ0FBQyxNQUFNLEVBQUUsT0FBTyxFQUFFLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQTJCOUM7SUFFRDs7Ozs7OztPQU9HO0lBQ0csb0JBQW9CLENBQUMsSUFBSSxFQUFFLFNBQVMsRUFBRSxFQUFFLElBQUksR0FBRSxNQUFVLEdBQUcsT0FBTyxDQUFDLGFBQWEsRUFBRSxFQUFFLENBQUMsQ0FRMUY7SUFFRDs7Ozs7Ozs7T0FRRztJQUNHLCtCQUErQixDQUNuQyxlQUFlLEVBQUUsWUFBWSxFQUM3QixJQUFJLEVBQUUsR0FBRyxFQUFFLEVBQ1gsSUFBSSxHQUFFLE1BQVUsR0FDZixPQUFPLENBQUMsYUFBYSxFQUFFLEVBQUUsQ0FBQyxDQWE1QjtJQUVEOzs7O09BSUc7SUFDSCxhQUFhLENBQUMsTUFBTSxFQUFFLFNBQVMsR0FBRyxPQUFPLENBQUMscUJBQXFCLENBQUMsQ0FRL0Q7SUE2RUQ7Ozs7T0FJRztJQUNILG9CQUFvQixDQUFDLE1BQU0sRUFBRSxTQUFTLEdBQUcsT0FBTyxDQUFDLDRCQUE0QixDQUFDLENBUTdFO0NBNkdGIn0=

package/dest/store/log_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log_store.d.ts","sourceRoot":"","sources":["../../src/store/log_store.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,OAAO,EAAe,MAAM,qBAAqB,CAAC;AAE3D,OAAO,KAAK,EAAE,4BAA4B,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAC3G,OAAO,EAIL,KAAK,SAAS,EAGd,KAAK,SAAS,EACd,GAAG,EACH,aAAa,EACd,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;GAEG;AACH,qBAAa,QAAQ;;IAajB,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,UAAU;IAFpB,YACU,EAAE,EAAE,iBAAiB,EACrB,UAAU,EAAE,UAAU,EAC9B,eAAe,GAAE,MAAa,EAU/B;IA4MD;;;;OAIG;IACH,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAS3C;IAgBD,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CA2B9C;IAED;;;;;;;OAOG;IACG,oBAAoB,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,IAAI,GAAE,MAAU,GAAG,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC,CAQ1F;IAED;;;;;;;;OAQG;IACG,+BAA+B,CACnC,eAAe,EAAE,YAAY,EAC7B,IAAI,EAAE,GAAG,EAAE,EACX,IAAI,GAAE,MAAU,GACf,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC,CAa5B;IAED;;;;OAIG;IACH,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAQ/D;IA6ED;;;;OAIG;IACH,oBAAoB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAQ7E;CA6GF"}

package/dest/{archiver/kv_archiver_store → store}/log_store.js

@@ -1,9 +1,11 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { BlockNumber } from '@aztec/foundation/branded-types';
+import { filterAsync } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
 import { L2BlockHash } from '@aztec/stdlib/block';
+import { MAX_LOGS_PER_TAG } from '@aztec/stdlib/interfaces/api-limit';
 import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, PublicLog, TxScopedL2Log } from '@aztec/stdlib/logs';
 /**
  * A store for logs
@@ -95,60 +97,80 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
             publicTaggedLogs
         };
     }
+    async #addPrivateLogs(blocks) {
+        const newBlocks = await filterAsync(blocks, async (block)=>!await this.#privateLogKeysByBlock.hasAsync(block.number));
+        const { privateTaggedLogs } = this.#extractTaggedLogs(newBlocks);
+        const keysOfPrivateLogsToUpdate = Array.from(privateTaggedLogs.keys());
+        const currentPrivateTaggedLogs = await Promise.all(keysOfPrivateLogsToUpdate.map(async (key)=>({
+                tag: key,
+                logBuffers: await this.#privateLogsByTag.getAsync(key)
+            })));
+        for (const taggedLogBuffer of currentPrivateTaggedLogs){
+            if (taggedLogBuffer.logBuffers && taggedLogBuffer.logBuffers.length > 0) {
+                privateTaggedLogs.set(taggedLogBuffer.tag, taggedLogBuffer.logBuffers.concat(privateTaggedLogs.get(taggedLogBuffer.tag)));
+            }
+        }
+        for (const block of newBlocks){
+            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);
+        }
+    }
+    async #addPublicLogs(blocks) {
+        const newBlocks = await filterAsync(blocks, async (block)=>!await this.#publicLogKeysByBlock.hasAsync(block.number));
+        const { publicTaggedLogs } = this.#extractTaggedLogs(newBlocks);
+        const keysOfPublicLogsToUpdate = Array.from(publicTaggedLogs.keys());
+        const currentPublicTaggedLogs = await Promise.all(keysOfPublicLogsToUpdate.map(async (key)=>({
+                tag: key,
+                logBuffers: await this.#publicLogsByContractAndTag.getAsync(key)
+            })));
+        for (const taggedLogBuffer of currentPublicTaggedLogs){
+            if (taggedLogBuffer.logBuffers && taggedLogBuffer.logBuffers.length > 0) {
+                publicTaggedLogs.set(taggedLogBuffer.tag, taggedLogBuffer.logBuffers.concat(publicTaggedLogs.get(taggedLogBuffer.tag)));
+            }
+        }
+        for (const block of newBlocks){
+            const blockHash = await block.hash();
+            const publicTagsInBlock = [];
+            for (const [tag, logs] of publicTaggedLogs.entries()){
+                await this.#publicLogsByContractAndTag.set(tag, logs);
+                publicTagsInBlock.push(tag);
+            }
+            await this.#publicLogKeysByBlock.set(block.number, publicTagsInBlock);
+            const publicLogsInBlock = block.body.txEffects.map((txEffect, txIndex)=>[
+                    numToUInt32BE(txIndex),
+                    numToUInt32BE(txEffect.publicLogs.length),
+                    txEffect.publicLogs.map((log)=>log.toBuffer())
+                ].flat()).flat();
+            await this.#publicLogsByBlock.set(block.number, this.#packWithBlockHash(blockHash, publicLogsInBlock));
+        }
+    }
+    async #addContractClassLogs(blocks) {
+        const newBlocks = await filterAsync(blocks, async (block)=>!await this.#contractClassLogsByBlock.hasAsync(block.number));
+        for (const block of newBlocks){
+            const blockHash = await block.hash();
+            const contractClassLogsInBlock = block.body.txEffects.map((txEffect, txIndex)=>[
+                    numToUInt32BE(txIndex),
+                    numToUInt32BE(txEffect.contractClassLogs.length),
+                    txEffect.contractClassLogs.map((log)=>log.toBuffer())
+                ].flat()).flat();
+            await this.#contractClassLogsByBlock.set(block.number, this.#packWithBlockHash(blockHash, contractClassLogsInBlock));
+        }
+    }
     /**
    * 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 currentPrivateTaggedLogs = await Promise.all(keysOfPrivateLogsToUpdate.map(async (key)=>({
-                    tag: key,
-                    logBuffers: await this.#privateLogsByTag.getAsync(key)
-                })));
-            currentPrivateTaggedLogs.forEach((taggedLogBuffer)=>{
-                if (taggedLogBuffer.logBuffers && taggedLogBuffer.logBuffers.length > 0) {
-                    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 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.#publicLogKeysByBlock.set(block.number, publicKeysInBlock);
-                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, this.#packWithBlockHash(blockHash, publicLogsInBlock));
-                await this.#contractClassLogsByBlock.set(block.number, this.#packWithBlockHash(blockHash, contractClassLogsInBlock));
-            }
+            await Promise.all([
+                this.#addPrivateLogs(blocks),
+                this.#addPublicLogs(blocks),
+                this.#addContractClassLogs(blocks)
+            ]);
             return true;
         });
     }
@@ -185,21 +207,34 @@ import { ContractClassLog, ExtendedContractClassLog, ExtendedPublicLog, LogId, P
         });
     }
     /**
-   * Gets all private logs that match any of the `tags`. For each tag, an array of matching logs is returned. An empty
+   * Gets 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) {
+   * @param tags - The tags to search for.
+   * @param page - The page number (0-indexed) for pagination.
+   * @returns An array of log arrays, one per tag. Returns at most MAX_LOGS_PER_TAG logs per tag per page. If
+   * MAX_LOGS_PER_TAG logs are returned for a tag, the caller should fetch the next page to check for more logs.
+   */ async getPrivateLogsByTags(tags, page = 0) {
         const logs = await Promise.all(tags.map((tag)=>this.#privateLogsByTag.getAsync(tag.toString())));
-        return logs.map((logBuffers)=>logBuffers?.map((logBuffer)=>TxScopedL2Log.fromBuffer(logBuffer)) ?? []);
+        const start = page * MAX_LOGS_PER_TAG;
+        const end = start + MAX_LOGS_PER_TAG;
+        return logs.map((logBuffers)=>logBuffers?.slice(start, end).map((logBuffer)=>TxScopedL2Log.fromBuffer(logBuffer)) ?? []);
     }
     /**
-   * Gets all public logs that match any of the `tags` from the specified contract. For each tag, an array of matching
+   * Gets 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) {
+   * @param contractAddress - The contract address to search logs for.
+   * @param tags - The tags to search for.
+   * @param page - The page number (0-indexed) for pagination.
+   * @returns An array of log arrays, one per tag. Returns at most MAX_LOGS_PER_TAG logs per tag per page. If
+   * MAX_LOGS_PER_TAG logs are returned for a tag, the caller should fetch the next page to check for more logs.
+   */ async getPublicLogsByTagsFromContract(contractAddress, tags, page = 0) {
         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)) ?? []);
+        const start = page * MAX_LOGS_PER_TAG;
+        const end = start + MAX_LOGS_PER_TAG;
+        return logs.map((logBuffers)=>logBuffers?.slice(start, end).map((logBuffer)=>TxScopedL2Log.fromBuffer(logBuffer)) ?? []);
     }
     /**
    * Gets public logs based on the provided filter.