@aztec/archiver 0.0.1-commit.fce3e4f → 0.0.1-commit.fffb133c

package/dest/store/kv_archiver_store.js

@@ -0,0 +1,447 @@
+import { toArray } from '@aztec/foundation/iterable';
+import { createLogger } from '@aztec/foundation/log';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import { L2BlockHash } from '@aztec/stdlib/block';
+import { join } from 'path';
+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';
+export const ARCHIVER_DB_VERSION = 5;
+export const MAX_FUNCTION_SIGNATURES = 1000;
+export const MAX_FUNCTION_NAME_LEN = 256;
+/**
+ * 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;
+    #blockStore;
+    #logStore;
+    #messageStore;
+    #contractClassStore;
+    #contractInstanceStore;
+    functionNames;
+    #log;
+    constructor(db, logsMaxPageSize = 1000, l1Constants){
+        this.db = db;
+        this.functionNames = new Map();
+        this.#log = createLogger('archiver:data-store');
+        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);
+    }
+    /** Opens a new transaction to the underlying store and runs all operations within it. */ transactionAsync(callback) {
+        return this.db.transactionAsync(callback);
+    }
+    getBlockNumber() {
+        return this.#blockStore.getLatestL2BlockNumber();
+    }
+    async getContract(address, maybeTimestamp) {
+        const [header] = await this.getBlockHeaders(await this.getBlockNumber(), 1);
+        const timestamp = maybeTimestamp ?? header.globalVariables.timestamp;
+        return this.getContractInstance(address, timestamp);
+    }
+    /** 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');
+    }
+    /** Closes the underlying data store. */ close() {
+        return this.db.close();
+    }
+    /** 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()));
+    }
+    /** 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;
+            }
+            try {
+                const selector = await FunctionSelector.fromSignature(sig);
+                this.functionNames.set(selector.toString(), sig.slice(0, sig.indexOf('(')).slice(0, MAX_FUNCTION_NAME_LEN));
+            } catch  {
+                this.#log.warn(`Failed to parse signature: ${sig}. Ignoring`);
+            }
+        }
+    }
+    /**
+   * 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);
+    }
+    /** Returns the list of all class ids known by the archiver. */ getContractClassIds() {
+        return this.#contractClassStore.getContractClassIds();
+    }
+    /**
+   * 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);
+    }
+    /**
+   * 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) {
+        return (await Promise.all(data.map((c)=>this.#contractClassStore.deleteContractClasses(c, blockNumber)))).every(Boolean);
+    }
+    getBytecodeCommitment(contractClassId) {
+        return this.#contractClassStore.getBytecodeCommitment(contractClassId);
+    }
+    /** Adds private functions to a contract class. */ addFunctions(contractClassId, privateFunctions, utilityFunctions) {
+        return this.#contractClassStore.addFunctions(contractClassId, privateFunctions, utilityFunctions);
+    }
+    /**
+   * 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);
+    }
+    /**
+   * 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) {
+        return (await Promise.all(data.map((update, logIndex)=>this.#contractInstanceStore.deleteContractInstanceUpdate(update, timestamp, logIndex)))).every(Boolean);
+    }
+    /**
+   * Append new proposed blocks to the store's list.
+   * These are uncheckpointed blocks that have been proposed by the sequencer but not yet included in a checkpoint on L1.
+   * For checkpointed blocks (already published to L1), use addCheckpoints() instead.
+   * @param blocks - The proposed L2 blocks to be added to the store.
+   * @returns True if the operation is successful.
+   */ addProposedBlocks(blocks, opts = {}) {
+        return this.#blockStore.addProposedBlocks(blocks, opts);
+    }
+    /**
+   * 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);
+    }
+    /**
+   * Returns the number of the latest block
+   * @returns The number of the latest block
+   */ getLatestBlockNumber() {
+        return this.#blockStore.getLatestBlockNumber();
+    }
+    /**
+   * Removes all checkpoints with checkpoint number > checkpointNumber.
+   * Also removes ALL blocks (both checkpointed and uncheckpointed) after the last block of the given checkpoint.
+   * @param checkpointNumber - Remove all checkpoints strictly after this one.
+   */ removeCheckpointsAfter(checkpointNumber) {
+        return this.#blockStore.removeCheckpointsAfter(checkpointNumber);
+    }
+    /**
+   * 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);
+    }
+    /**
+   * 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);
+    }
+    /**
+   * 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);
+    }
+    /**
+   * 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);
+    }
+    /**
+   * 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);
+    }
+    /**
+   * 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));
+    }
+    /**
+   * 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);
+    }
+    /**
+   * 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 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 block headers.
+   */ getBlockHeaders(start, limit) {
+        return toArray(this.#blockStore.getBlockHeaders(start, limit));
+    }
+    /**
+   * 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));
+    }
+    /**
+   * 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);
+    }
+    /**
+   * Gets a tx effect.
+   * @param txHash - The hash of the tx corresponding to the tx effect.
+   * @returns The requested tx effect with block info (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);
+    }
+    /**
+   * 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();
+    }
+    /** 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);
+    }
+    /**
+   * 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 checkpoint.
+   * @param checkpointNumber - Checkpoint number to get messages for.
+   * @returns The L1 to L2 messages/leaves of the messages subtree (throws if not found).
+   */ getL1ToL2Messages(checkpointNumber) {
+        return this.#messageStore.getL1ToL2Messages(checkpointNumber);
+    }
+    /**
+   * 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, page);
+        } catch (err) {
+            return Promise.reject(err);
+        }
+    }
+    /**
+   * 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, page);
+        } 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 proven checkpoint processed.
+   * @returns The number of the latest proven checkpoint processed.
+   */ getProvenCheckpointNumber() {
+        return this.#blockStore.getProvenCheckpointNumber();
+    }
+    /**
+   * 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);
+    }
+    /**
+   * Stores the l1 block that messages have been synched until
+   */ async setMessageSynchedL1Block(l1Block) {
+        await this.#messageStore.setSynchedL1Block(l1Block);
+    }
+    /**
+   * 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 synch point of the archiver
+   */ async getSynchPoint() {
+        const [blocksSynchedTo, messagesSynchedTo] = await Promise.all([
+            this.#blockStore.getSynchedL1BlockNumber(),
+            this.#messageStore.getSynchedL1Block()
+        ]);
+        return {
+            blocksSynchedTo,
+            messagesSynchedTo
+        };
+    }
+    /** Estimates the size of the store in bytes. */ estimateSize() {
+        return this.db.estimateSize();
+    }
+    /** Deletes all L1 to L2 messages up until (excluding) the target checkpoint number. */ rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber) {
+        return this.#messageStore.rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber);
+    }
+    /** Returns an async iterator to all L1 to L2 messages on the range. */ iterateL1ToL2Messages(range = {}) {
+        return this.#messageStore.iterateL1ToL2Messages(range);
+    }
+    /** Removes all L1 to L2 messages starting from the given index (inclusive). */ removeL1ToL2Messages(startIndex) {
+        return this.#messageStore.removeL1ToL2Messages(startIndex);
+    }
+    /** Returns the last synced validation status of the pending chain. */ getPendingChainValidationStatus() {
+        return this.#blockStore.getPendingChainValidationStatus();
+    }
+    /** Sets the last synced validation status of the pending chain. */ setPendingChainValidationStatus(status) {
+        return this.#blockStore.setPendingChainValidationStatus(status);
+    }
+    /**
+   * Gets the number of the latest L2 block processed.
+   * @returns The number of the latest L2 block processed.
+   */ getCheckpointedL2BlockNumber() {
+        return this.#blockStore.getCheckpointedL2BlockNumber();
+    }
+    /**
+   * Gets the number of the latest published checkpoint processed.
+   * @returns The number of the latest published checkpoint processed
+   */ getSynchedCheckpointNumber() {
+        return this.#blockStore.getLatestCheckpointNumber();
+    }
+    /**
+   * 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);
+    }
+    /**
+   * 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);
+    }
+    /**
+   * 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.
+   * Does not remove any associated checkpoints.
+   * @param blockNumber - The block number to remove after.
+   * @returns The removed blocks (for event emission).
+   */ removeBlocksAfter(blockNumber) {
+        return this.#blockStore.removeBlocksAfter(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"}