@aztec/pxe 0.0.1-commit.9593d84 → 0.0.1-commit.96bb3f7

package/dest/storage/private_event_store/private_event_store.d.ts

@@ -0,0 +1,56 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { EventSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type InTx, TxHash } from '@aztec/stdlib/tx';
+import type { PackedPrivateEvent } from '../../pxe.js';
+export type PrivateEventStoreFilter = {
+    contractAddress: AztecAddress;
+    fromBlock: number;
+    toBlock: number;
+    scopes: AztecAddress[];
+    txHash?: TxHash;
+};
+type PrivateEventMetadata = InTx & {
+    contractAddress: AztecAddress;
+    scope: AztecAddress;
+};
+/**
+ * Stores decrypted private event logs.
+ */
+export declare class PrivateEventStore {
+    #private;
+    logger: import("@aztec/foundation/log").Logger;
+    constructor(store: AztecAsyncKVStore);
+    /**
+     * Store a private event log.
+     * @param eventSelector - The event selector of the event.
+     * @param msgContent - The content of the event.
+     * @param eventCommitmentIndex - The index of the event commitment in the nullifier tree.
+     * @param metadata
+     *  contractAddress - The address of the contract that emitted the event.
+     *  scope - The address to which the event is scoped.
+     *  txHash - The transaction hash of the event log.
+     *  blockNumber - The block number in which the event was emitted.
+     */
+    storePrivateEventLog(eventSelector: EventSelector, randomness: Fr, msgContent: Fr[], eventCommitmentIndex: number, metadata: PrivateEventMetadata): Promise<void>;
+    /**
+     * Returns the private events given search parameters.
+     * @param eventSelector - The event selector to filter by.
+     * @param filter - Filtering criteria:
+     *  contractAddress: The address of the contract to get events from.
+     *  fromBlock: The block number to search from (inclusive).
+     *  toBlock: The block number to search upto (exclusive).
+     *  scope: - The addresses that decrypted the logs.
+     * @returns - The event log contents, augmented with metadata about
+     *  the transaction and block it the event was included in .
+     */
+    getPrivateEvents(eventSelector: EventSelector, filter: PrivateEventStoreFilter): Promise<PackedPrivateEvent[]>;
+    /**
+     * Rolls back private events that were stored after a given `blockNumber` and up to `synchedBlockNumber` (the block
+     * number up to which PXE managed to sync before the reorg happened).
+     */
+    rollbackEventsAfterBlock(blockNumber: number, synchedBlockNumber: number): Promise<void>;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZV9ldmVudF9zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2UvcHJpdmF0ZV9ldmVudF9zdG9yZS9wcml2YXRlX2V2ZW50X3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUdwRCxPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBaUIsTUFBTSxpQkFBaUIsQ0FBQztBQUN4RSxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN2RCxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUVoRSxPQUFPLEVBQUUsS0FBSyxJQUFJLEVBQUUsTUFBTSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFckQsT0FBTyxLQUFLLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFdkQsTUFBTSxNQUFNLHVCQUF1QixHQUFHO0lBQ3BDLGVBQWUsRUFBRSxZQUFZLENBQUM7SUFDOUIsU0FBUyxFQUFFLE1BQU0sQ0FBQztJQUNsQixPQUFPLEVBQUUsTUFBTSxDQUFDO0lBQ2hCLE1BQU0sRUFBRSxZQUFZLEVBQUUsQ0FBQztJQUN2QixNQUFNLENBQUMsRUFBRSxNQUFNLENBQUM7Q0FDakIsQ0FBQztBQWFGLEtBQUssb0JBQW9CLEdBQUcsSUFBSSxHQUFHO0lBQ2pDLGVBQWUsRUFBRSxZQUFZLENBQUM7SUFDOUIsS0FBSyxFQUFFLFlBQVksQ0FBQztDQUNyQixDQUFDO0FBRUY7O0dBRUc7QUFDSCxxQkFBYSxpQkFBaUI7O0lBVzVCLE1BQU0seUNBQXVDO0lBRTdDLFlBQVksS0FBSyxFQUFFLGlCQUFpQixFQU1uQztJQU1EOzs7Ozs7Ozs7O09BVUc7SUFDSCxvQkFBb0IsQ0FDbEIsYUFBYSxFQUFFLGFBQWEsRUFDNUIsVUFBVSxFQUFFLEVBQUUsRUFDZCxVQUFVLEVBQUUsRUFBRSxFQUFFLEVBQ2hCLG9CQUFvQixFQUFFLE1BQU0sRUFDNUIsUUFBUSxFQUFFLG9CQUFvQixHQUM3QixPQUFPLENBQUMsSUFBSSxDQUFDLENBa0NmO0lBRUQ7Ozs7Ozs7Ozs7T0FVRztJQUNVLGdCQUFnQixDQUMzQixhQUFhLEVBQUUsYUFBYSxFQUM1QixNQUFNLEVBQUUsdUJBQXVCLEdBQzlCLE9BQU8sQ0FBQyxrQkFBa0IsRUFBRSxDQUFDLENBd0MvQjtJQUVEOzs7T0FHRztJQUNVLHdCQUF3QixDQUFDLFdBQVcsRUFBRSxNQUFNLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FxQ3BHO0NBQ0YifQ==

package/dest/storage/private_event_store/private_event_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"private_event_store.d.ts","sourceRoot":"","sources":["../../../src/storage/private_event_store/private_event_store.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAGpD,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,MAAM,MAAM,uBAAuB,GAAG;IACpC,eAAe,EAAE,YAAY,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAaF,KAAK,oBAAoB,GAAG,IAAI,GAAG;IACjC,eAAe,EAAE,YAAY,CAAC;IAC9B,KAAK,EAAE,YAAY,CAAC;CACrB,CAAC;AAEF;;GAEG;AACH,qBAAa,iBAAiB;;IAW5B,MAAM,yCAAuC;IAE7C,YAAY,KAAK,EAAE,iBAAiB,EAMnC;IAMD;;;;;;;;;;OAUG;IACH,oBAAoB,CAClB,aAAa,EAAE,aAAa,EAC5B,UAAU,EAAE,EAAE,EACd,UAAU,EAAE,EAAE,EAAE,EAChB,oBAAoB,EAAE,MAAM,EAC5B,QAAQ,EAAE,oBAAoB,GAC7B,OAAO,CAAC,IAAI,CAAC,CAkCf;IAED;;;;;;;;;;OAUG;IACU,gBAAgB,CAC3B,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,uBAAuB,GAC9B,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAwC/B;IAED;;;OAGG;IACU,wBAAwB,CAAC,WAAW,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAqCpG;CACF"}

package/dest/storage/private_event_store/private_event_store.js

@@ -0,0 +1,158 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { L2BlockHash } from '@aztec/stdlib/block';
+import { TxHash } from '@aztec/stdlib/tx';
+/**
+ * Stores decrypted private event logs.
+ */ export class PrivateEventStore {
+    #store;
+    /** Map storing the actual private event log entries, keyed by eventCommitmentIndex */ #eventLogs;
+    /** Map from contractAddress_scope_eventSelector to eventCommitmentIndex[] for efficient lookup */ #eventsByContractScopeSelector;
+    /** Map from block number to eventCommitmentIndex[] for rollback support */ #eventsByBlockNumber;
+    /** Map from eventCommitmentIndex to boolean indicating if log has been seen. */ #seenLogs;
+    logger = createLogger('private_event_store');
+    constructor(store){
+        this.#store = store;
+        this.#eventLogs = this.#store.openMap('private_event_logs');
+        this.#eventsByContractScopeSelector = this.#store.openMap('events_by_contract_scope_selector');
+        this.#seenLogs = this.#store.openMap('seen_logs');
+        this.#eventsByBlockNumber = this.#store.openMap('events_by_block_number');
+    }
+    #keyFor(contractAddress, scope, eventSelector) {
+        return `${contractAddress.toString()}_${scope.toString()}_${eventSelector.toString()}`;
+    }
+    /**
+   * Store a private event log.
+   * @param eventSelector - The event selector of the event.
+   * @param msgContent - The content of the event.
+   * @param eventCommitmentIndex - The index of the event commitment in the nullifier tree.
+   * @param metadata
+   *  contractAddress - The address of the contract that emitted the event.
+   *  scope - The address to which the event is scoped.
+   *  txHash - The transaction hash of the event log.
+   *  blockNumber - The block number in which the event was emitted.
+   */ storePrivateEventLog(eventSelector, randomness, msgContent, eventCommitmentIndex, metadata) {
+        const { contractAddress, scope, txHash, l2BlockNumber, l2BlockHash } = metadata;
+        return this.#store.transactionAsync(async ()=>{
+            const key = this.#keyFor(contractAddress, scope, eventSelector);
+            // Check if this exact log has already been stored using eventCommitmentIndex as unique identifier
+            const hasBeenSeen = await this.#seenLogs.getAsync(eventCommitmentIndex);
+            if (hasBeenSeen) {
+                this.logger.verbose('Ignoring duplicate event log', {
+                    txHash: txHash.toString(),
+                    eventCommitmentIndex
+                });
+                return;
+            }
+            this.logger.verbose('storing private event log', {
+                contractAddress,
+                scope,
+                msgContent,
+                l2BlockNumber
+            });
+            await this.#eventLogs.set(eventCommitmentIndex, {
+                randomness,
+                msgContent: serializeToBuffer(msgContent),
+                l2BlockNumber,
+                l2BlockHash: l2BlockHash.toBuffer(),
+                eventCommitmentIndex,
+                txHash: txHash.toBuffer(),
+                lookupKey: key
+            });
+            const existingIndices = await this.#eventsByContractScopeSelector.getAsync(key) || [];
+            await this.#eventsByContractScopeSelector.set(key, [
+                ...existingIndices,
+                eventCommitmentIndex
+            ]);
+            const existingBlockIndices = await this.#eventsByBlockNumber.getAsync(l2BlockNumber) || [];
+            await this.#eventsByBlockNumber.set(l2BlockNumber, [
+                ...existingBlockIndices,
+                eventCommitmentIndex
+            ]);
+            // Mark this log as seen using eventCommitmentIndex
+            await this.#seenLogs.set(eventCommitmentIndex, true);
+        });
+    }
+    /**
+   * Returns the private events given search parameters.
+   * @param eventSelector - The event selector to filter by.
+   * @param filter - Filtering criteria:
+   *  contractAddress: The address of the contract to get events from.
+   *  fromBlock: The block number to search from (inclusive).
+   *  toBlock: The block number to search upto (exclusive).
+   *  scope: - The addresses that decrypted the logs.
+   * @returns - The event log contents, augmented with metadata about
+   *  the transaction and block it the event was included in .
+   */ async getPrivateEvents(eventSelector, filter) {
+        const events = [];
+        for (const scope of filter.scopes){
+            const key = this.#keyFor(filter.contractAddress, scope, eventSelector);
+            const eventCommitmentIndices = await this.#eventsByContractScopeSelector.getAsync(key) || [];
+            for (const eventCommitmentIndex of eventCommitmentIndices){
+                const entry = await this.#eventLogs.getAsync(eventCommitmentIndex);
+                if (!entry || entry.l2BlockNumber < filter.fromBlock || entry.l2BlockNumber >= filter.toBlock) {
+                    continue;
+                }
+                // Convert buffer back to Fr array
+                const reader = BufferReader.asReader(entry.msgContent);
+                const numFields = entry.msgContent.length / Fr.SIZE_IN_BYTES;
+                const msgContent = reader.readArray(numFields, Fr);
+                const txHash = TxHash.fromBuffer(entry.txHash);
+                const l2BlockHash = L2BlockHash.fromBuffer(entry.l2BlockHash);
+                if (filter.txHash && !txHash.equals(filter.txHash)) {
+                    continue;
+                }
+                events.push({
+                    eventCommitmentIndex: entry.eventCommitmentIndex,
+                    event: {
+                        packedEvent: msgContent,
+                        l2BlockNumber: BlockNumber(entry.l2BlockNumber),
+                        txHash,
+                        l2BlockHash,
+                        eventSelector
+                    }
+                });
+            }
+        }
+        // Sort by eventCommitmentIndex only
+        events.sort((a, b)=>a.eventCommitmentIndex - b.eventCommitmentIndex);
+        return events.map((ev)=>ev.event);
+    }
+    /**
+   * Rolls back private events that were stored after a given `blockNumber` and up to `synchedBlockNumber` (the block
+   * number up to which PXE managed to sync before the reorg happened).
+   */ async rollbackEventsAfterBlock(blockNumber, synchedBlockNumber) {
+        await this.#store.transactionAsync(async ()=>{
+            let removedCount = 0;
+            for(let block = blockNumber + 1; block <= synchedBlockNumber; block++){
+                const indices = await this.#eventsByBlockNumber.getAsync(block);
+                if (indices) {
+                    await this.#eventsByBlockNumber.delete(block);
+                    for (const eventCommitmentIndex of indices){
+                        const entry = await this.#eventLogs.getAsync(eventCommitmentIndex);
+                        if (!entry) {
+                            throw new Error(`Event log not found for eventCommitmentIndex ${eventCommitmentIndex}`);
+                        }
+                        await this.#eventLogs.delete(eventCommitmentIndex);
+                        await this.#seenLogs.delete(eventCommitmentIndex);
+                        // Update #eventsByContractScopeSelector using the stored lookupKey
+                        const existingIndices = await this.#eventsByContractScopeSelector.getAsync(entry.lookupKey);
+                        if (!existingIndices || existingIndices.length === 0) {
+                            throw new Error(`No indices found in #eventsByContractScopeSelector for key ${entry.lookupKey}`);
+                        }
+                        const filteredIndices = existingIndices.filter((idx)=>idx !== eventCommitmentIndex);
+                        if (filteredIndices.length === 0) {
+                            await this.#eventsByContractScopeSelector.delete(entry.lookupKey);
+                        } else {
+                            await this.#eventsByContractScopeSelector.set(entry.lookupKey, filteredIndices);
+                        }
+                        removedCount++;
+                    }
+                }
+            }
+            this.logger.verbose(`Rolled back ${removedCount} private events after block ${blockNumber}`);
+        });
+    }
+}

package/dest/storage/tagging_store/index.d.ts

@@ -0,0 +1,4 @@
+export { SenderTaggingStore } from './sender_tagging_store.js';
+export { SenderAddressBookStore } from './sender_address_book_store.js';
+export { RecipientTaggingStore } from './recipient_tagging_store.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL3RhZ2dpbmdfc3RvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDL0QsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDeEUsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sOEJBQThCLENBQUMifQ==

package/dest/storage/tagging_store/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_store/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC"}

package/dest/storage/tagging_store/index.js

@@ -0,0 +1,3 @@
+export { SenderTaggingStore } from './sender_tagging_store.js';
+export { SenderAddressBookStore } from './sender_address_book_store.js';
+export { RecipientTaggingStore } from './recipient_tagging_store.js';

package/dest/storage/tagging_store/recipient_tagging_store.d.ts

@@ -0,0 +1,21 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+/**
+ * Data provider of tagging data used when syncing the logs as a recipient. The sender counterpart of this class
+ * is called SenderTaggingStore. We have the providers separate for the sender and recipient because
+ * the algorithms are completely disjoint and there is not data reuse between the two.
+ *
+ * @dev Chain reorgs do not need to be handled here because both the finalized and aged indexes refer to finalized
+ * blocks, which by definition cannot be affected by reorgs.
+ *
+ * TODO(benesjan): Relocate to yarn-project/pxe/src/storage/tagging_store
+ */
+export declare class RecipientTaggingStore {
+    #private;
+    constructor(store: AztecAsyncKVStore);
+    getHighestAgedIndex(secret: DirectionalAppTaggingSecret): Promise<number | undefined>;
+    updateHighestAgedIndex(secret: DirectionalAppTaggingSecret, index: number): Promise<void>;
+    getHighestFinalizedIndex(secret: DirectionalAppTaggingSecret): Promise<number | undefined>;
+    updateHighestFinalizedIndex(secret: DirectionalAppTaggingSecret, index: number): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVjaXBpZW50X3RhZ2dpbmdfc3RvcmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL3RhZ2dpbmdfc3RvcmUvcmVjaXBpZW50X3RhZ2dpbmdfc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQWlCLE1BQU0saUJBQWlCLENBQUM7QUFDeEUsT0FBTyxLQUFLLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUV0RTs7Ozs7Ozs7O0dBU0c7QUFDSCxxQkFBYSxxQkFBcUI7O0lBTWhDLFlBQVksS0FBSyxFQUFFLGlCQUFpQixFQUtuQztJQUVELG1CQUFtQixDQUFDLE1BQU0sRUFBRSwyQkFBMkIsR0FBRyxPQUFPLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQyxDQUVwRjtJQUVLLHNCQUFzQixDQUFDLE1BQU0sRUFBRSwyQkFBMkIsRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FPOUY7SUFFRCx3QkFBd0IsQ0FBQyxNQUFNLEVBQUUsMkJBQTJCLEdBQUcsT0FBTyxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUMsQ0FFekY7SUFFSywyQkFBMkIsQ0FBQyxNQUFNLEVBQUUsMkJBQTJCLEVBQUUsS0FBSyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBUW5HO0NBQ0YifQ==

package/dest/storage/tagging_store/recipient_tagging_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recipient_tagging_store.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_store/recipient_tagging_store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEtE;;;;;;;;;GASG;AACH,qBAAa,qBAAqB;;IAMhC,YAAY,KAAK,EAAE,iBAAiB,EAKnC;IAED,mBAAmB,CAAC,MAAM,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAEpF;IAEK,sBAAsB,CAAC,MAAM,EAAE,2BAA2B,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAO9F;IAED,wBAAwB,CAAC,MAAM,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAEzF;IAEK,2BAA2B,CAAC,MAAM,EAAE,2BAA2B,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQnG;CACF"}

package/dest/storage/tagging_store/recipient_tagging_store.js

@@ -0,0 +1,42 @@
+/**
+ * Data provider of tagging data used when syncing the logs as a recipient. The sender counterpart of this class
+ * is called SenderTaggingStore. We have the providers separate for the sender and recipient because
+ * the algorithms are completely disjoint and there is not data reuse between the two.
+ *
+ * @dev Chain reorgs do not need to be handled here because both the finalized and aged indexes refer to finalized
+ * blocks, which by definition cannot be affected by reorgs.
+ *
+ * TODO(benesjan): Relocate to yarn-project/pxe/src/storage/tagging_store
+ */ export class RecipientTaggingStore {
+    #store;
+    #highestAgedIndex;
+    #highestFinalizedIndex;
+    constructor(store){
+        this.#store = store;
+        this.#highestAgedIndex = this.#store.openMap('highest_aged_index');
+        this.#highestFinalizedIndex = this.#store.openMap('highest_finalized_index');
+    }
+    getHighestAgedIndex(secret) {
+        return this.#highestAgedIndex.getAsync(secret.toString());
+    }
+    async updateHighestAgedIndex(secret, index) {
+        const currentIndex = await this.#highestAgedIndex.getAsync(secret.toString());
+        if (currentIndex !== undefined && index <= currentIndex) {
+            // Log sync should never set a lower highest aged index.
+            throw new Error(`New highest aged index (${index}) must be higher than the current one (${currentIndex})`);
+        }
+        await this.#highestAgedIndex.set(secret.toString(), index);
+    }
+    getHighestFinalizedIndex(secret) {
+        return this.#highestFinalizedIndex.getAsync(secret.toString());
+    }
+    async updateHighestFinalizedIndex(secret, index) {
+        const currentIndex = await this.#highestFinalizedIndex.getAsync(secret.toString());
+        if (currentIndex !== undefined && index < currentIndex) {
+            // Log sync should never set a lower highest finalized index but it can happen that it would try to set the same
+            // one because we are loading logs from highest aged index + 1 and not from the highest finalized index.
+            throw new Error(`New highest finalized index (${index}) must be higher than the current one (${currentIndex})`);
+        }
+        await this.#highestFinalizedIndex.set(secret.toString(), index);
+    }
+}

package/dest/storage/tagging_store/sender_address_book_store.d.ts

@@ -0,0 +1,14 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+/**
+ * Stores sender addresses. During recipient log synchronization, these senders are used, along with a given recipient,
+ * to derive directional app tagging secrets that are then used to sync the logs.
+ */
+export declare class SenderAddressBookStore {
+    #private;
+    constructor(store: AztecAsyncKVStore);
+    addSender(address: AztecAddress): Promise<boolean>;
+    getSenders(): Promise<AztecAddress[]>;
+    removeSender(address: AztecAddress): Promise<boolean>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VuZGVyX2FkZHJlc3NfYm9va19zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2UvdGFnZ2luZ19zdG9yZS9zZW5kZXJfYWRkcmVzc19ib29rX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFpQixNQUFNLGlCQUFpQixDQUFDO0FBQ3hFLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUUzRDs7O0dBR0c7QUFDSCxxQkFBYSxzQkFBc0I7O0lBSWpDLFlBQVksS0FBSyxFQUFFLGlCQUFpQixFQUluQztJQUVLLFNBQVMsQ0FBQyxPQUFPLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FRdkQ7SUFFSyxVQUFVLElBQUksT0FBTyxDQUFDLFlBQVksRUFBRSxDQUFDLENBRTFDO0lBRUssWUFBWSxDQUFDLE9BQU8sRUFBRSxZQUFZLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQVExRDtDQUNGIn0=

package/dest/storage/tagging_store/sender_address_book_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sender_address_book_store.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_store/sender_address_book_store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D;;;GAGG;AACH,qBAAa,sBAAsB;;IAIjC,YAAY,KAAK,EAAE,iBAAiB,EAInC;IAEK,SAAS,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAQvD;IAEK,UAAU,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAE1C;IAEK,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAQ1D;CACF"}

package/dest/storage/tagging_store/sender_address_book_store.js

@@ -0,0 +1,30 @@
+import { toArray } from '@aztec/foundation/iterable';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+/**
+ * Stores sender addresses. During recipient log synchronization, these senders are used, along with a given recipient,
+ * to derive directional app tagging secrets that are then used to sync the logs.
+ */ export class SenderAddressBookStore {
+    #store;
+    #addressBook;
+    constructor(store){
+        this.#store = store;
+        this.#addressBook = this.#store.openMap('address_book');
+    }
+    async addSender(address) {
+        if (await this.#addressBook.hasAsync(address.toString())) {
+            return false;
+        }
+        await this.#addressBook.set(address.toString(), true);
+        return true;
+    }
+    async getSenders() {
+        return (await toArray(this.#addressBook.keysAsync())).map(AztecAddress.fromString);
+    }
+    async removeSender(address) {
+        if (!await this.#addressBook.hasAsync(address.toString())) {
+            return false;
+        }
+        await this.#addressBook.delete(address.toString());
+        return true;
+    }
+}

package/dest/storage/tagging_store/sender_tagging_store.d.ts

@@ -0,0 +1,67 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
+import { TxHash } from '@aztec/stdlib/tx';
+/**
+ * Data provider of tagging data used when syncing the sender tagging indexes. The recipient counterpart of this class
+ * is called RecipientTaggingStore. We have the providers separate for the sender and recipient because
+ * the algorithms are completely disjoint and there is not data reuse between the two.
+ */
+export declare class SenderTaggingStore {
+    #private;
+    constructor(store: AztecAsyncKVStore);
+    /**
+     * Stores pending indexes.
+     * @remarks Ignores the index if the same preTag + txHash combination already exists in the db with the same index.
+     * This is expected to happen because whenever we start sync we start from the last finalized index and we can have
+     * pending indexes already stored from previous syncs.
+     * @param preTags - The pre-tags containing the directional app tagging secrets and the indexes that are to be
+     * stored in the db.
+     * @param txHash - The tx in which the pretags were used in private logs.
+     * @throws If any two pre-tags contain the same directional app tagging secret. This is enforced because we care
+     * only about the highest index for a given secret that was used in the tx. Hence this check is a good way to catch
+     * bugs.
+     * @throws If the newly stored pending index is further than window length from the highest finalized index for the
+     * same secret. This is enforced in order to give a guarantee to a recipient that he doesn't need to look further than
+     * window length ahead of the highest finalized index.
+     * @throws If a secret + txHash pair already exists in the db with a different index value. It should never happen
+     * that we would attempt to store a different index for a given secret-txHash pair because we always store just the
+     * highest index for a given secret-txHash pair. Hence this is a good way to catch bugs.
+     * @throws If the newly stored pending index is lower than or equal to the last finalized index for the same secret.
+     * This is enforced because this should never happen if the syncing is done correctly as we look for logs from higher
+     * indexes than finalized ones.
+     */
+    storePendingIndexes(preTags: PreTag[], txHash: TxHash): Promise<void>;
+    /**
+     * Returns the transaction hashes of all pending transactions that contain indexes within a specified range
+     * for a given directional app tagging secret.
+     * @param secret - The directional app tagging secret to query pending indexes for.
+     * @param startIndex - The lower bound of the index range (inclusive).
+     * @param endIndex - The upper bound of the index range (exclusive).
+     * @returns An array of unique transaction hashes for pending transactions that contain indexes in the range
+     * [startIndex, endIndex). Returns an empty array if no pending indexes exist in the range.
+     */
+    getTxHashesOfPendingIndexes(secret: DirectionalAppTaggingSecret, startIndex: number, endIndex: number): Promise<TxHash[]>;
+    /**
+     * Returns the last (highest) finalized index for a given secret.
+     * @param secret - The secret to get the last finalized index for.
+     * @returns The last (highest) finalized index for the given secret.
+     */
+    getLastFinalizedIndex(secret: DirectionalAppTaggingSecret): Promise<number | undefined>;
+    /**
+     * Returns the last used index for a given directional app tagging secret, considering both finalized and pending
+     * indexes.
+     * @param secret - The directional app tagging secret to query the last used index for.
+     * @returns The last used index.
+     */
+    getLastUsedIndex(secret: DirectionalAppTaggingSecret): Promise<number | undefined>;
+    /**
+     * Drops all pending indexes corresponding to the given transaction hashes.
+     */
+    dropPendingIndexes(txHashes: TxHash[]): Promise<void>;
+    /**
+     * Updates pending indexes corresponding to the given transaction hashes to be finalized and prunes any lower pending
+     * indexes.
+     */
+    finalizePendingIndexes(txHashes: TxHash[]): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VuZGVyX3RhZ2dpbmdfc3RvcmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL3RhZ2dpbmdfc3RvcmUvc2VuZGVyX3RhZ2dpbmdfc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQWlCLE1BQU0saUJBQWlCLENBQUM7QUFDeEUsT0FBTyxLQUFLLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDOUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBSTFDOzs7O0dBSUc7QUFDSCxxQkFBYSxrQkFBa0I7O0lBa0I3QixZQUFZLEtBQUssRUFBRSxpQkFBaUIsRUFLbkM7SUFFRDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7T0FvQkc7SUFDRyxtQkFBbUIsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQUUsTUFBTSxFQUFFLE1BQU0saUJBaUQxRDtJQUVEOzs7Ozs7OztPQVFHO0lBQ0csMkJBQTJCLENBQy9CLE1BQU0sRUFBRSwyQkFBMkIsRUFDbkMsVUFBVSxFQUFFLE1BQU0sRUFDbEIsUUFBUSxFQUFFLE1BQU0sR0FDZixPQUFPLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FNbkI7SUFFRDs7OztPQUlHO0lBQ0gscUJBQXFCLENBQUMsTUFBTSxFQUFFLDJCQUEyQixHQUFHLE9BQU8sQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLENBRXRGO0lBRUQ7Ozs7O09BS0c7SUFDRyxnQkFBZ0IsQ0FBQyxNQUFNLEVBQUUsMkJBQTJCLEdBQUcsT0FBTyxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUMsQ0FZdkY7SUFFRDs7T0FFRztJQUNHLGtCQUFrQixDQUFDLFFBQVEsRUFBRSxNQUFNLEVBQUUsaUJBcUIxQztJQUVEOzs7T0FHRztJQUNHLHNCQUFzQixDQUFDLFFBQVEsRUFBRSxNQUFNLEVBQUUsaUJBcUQ5QztDQUNGIn0=

package/dest/storage/tagging_store/sender_tagging_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sender_tagging_store.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_store/sender_tagging_store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC9E,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAI1C;;;;GAIG;AACH,qBAAa,kBAAkB;;IAkB7B,YAAY,KAAK,EAAE,iBAAiB,EAKnC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,iBAiD1D;IAED;;;;;;;;OAQG;IACG,2BAA2B,CAC/B,MAAM,EAAE,2BAA2B,EACnC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,EAAE,CAAC,CAMnB;IAED;;;;OAIG;IACH,qBAAqB,CAAC,MAAM,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAEtF;IAED;;;;;OAKG;IACG,gBAAgB,CAAC,MAAM,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAYvF;IAED;;OAEG;IACG,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,iBAqB1C;IAED;;;OAGG;IACG,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,iBAqD9C;CACF"}

package/dest/storage/tagging_store/sender_tagging_store.js

@@ -0,0 +1,196 @@
+import { toArray } from '@aztec/foundation/iterable';
+import { TxHash } from '@aztec/stdlib/tx';
+import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.js';
+/**
+ * Data provider of tagging data used when syncing the sender tagging indexes. The recipient counterpart of this class
+ * is called RecipientTaggingStore. We have the providers separate for the sender and recipient because
+ * the algorithms are completely disjoint and there is not data reuse between the two.
+ */ export class SenderTaggingStore {
+    #store;
+    // Stores the pending indexes for each directional app tagging secret. Pending here means that the tx that contained
+    // the private logs with tags corresponding to these indexes has not been finalized yet.
+    //
+    // We don't store just the highest index because if their transaction is dropped we'd then need the information about
+    // the lower pending indexes. For each secret-tx pair however we only store the largest index used in that tx, since
+    // the smaller ones are irrelevant due to tx atomicity.
+    //
+    // TODO(#17615): This assumes no logs are used in the non-revertible phase.
+    #pendingIndexes;
+    // Stores the last (highest) finalized index for each directional app tagging secret. We care only about the last
+    // index because unlike the pending indexes, it will never happen that a finalized index would be removed and hence
+    // we don't need to store the history.
+    #lastFinalizedIndexes;
+    constructor(store){
+        this.#store = store;
+        this.#pendingIndexes = this.#store.openMap('pending_indexes');
+        this.#lastFinalizedIndexes = this.#store.openMap('last_finalized_indexes');
+    }
+    /**
+   * Stores pending indexes.
+   * @remarks Ignores the index if the same preTag + txHash combination already exists in the db with the same index.
+   * This is expected to happen because whenever we start sync we start from the last finalized index and we can have
+   * pending indexes already stored from previous syncs.
+   * @param preTags - The pre-tags containing the directional app tagging secrets and the indexes that are to be
+   * stored in the db.
+   * @param txHash - The tx in which the pretags were used in private logs.
+   * @throws If any two pre-tags contain the same directional app tagging secret. This is enforced because we care
+   * only about the highest index for a given secret that was used in the tx. Hence this check is a good way to catch
+   * bugs.
+   * @throws If the newly stored pending index is further than window length from the highest finalized index for the
+   * same secret. This is enforced in order to give a guarantee to a recipient that he doesn't need to look further than
+   * window length ahead of the highest finalized index.
+   * @throws If a secret + txHash pair already exists in the db with a different index value. It should never happen
+   * that we would attempt to store a different index for a given secret-txHash pair because we always store just the
+   * highest index for a given secret-txHash pair. Hence this is a good way to catch bugs.
+   * @throws If the newly stored pending index is lower than or equal to the last finalized index for the same secret.
+   * This is enforced because this should never happen if the syncing is done correctly as we look for logs from higher
+   * indexes than finalized ones.
+   */ async storePendingIndexes(preTags, txHash) {
+        // The secrets in pre-tags should be unique because we always store just the highest index per given secret-txHash
+        // pair. Below we check that this is the case.
+        const secretsSet = new Set(preTags.map((preTag)=>preTag.secret.toString()));
+        if (secretsSet.size !== preTags.length) {
+            throw new Error(`Duplicate secrets found when storing pending indexes`);
+        }
+        for (const { secret, index } of preTags){
+            // First we check that for any secret the highest used index in tx is not further than window length from
+            // the highest finalized index.
+            const finalizedIndex = await this.getLastFinalizedIndex(secret) ?? 0;
+            if (index > finalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN) {
+                throw new Error(`Highest used index ${index} is further than window length from the highest finalized index ${finalizedIndex}.
+          Tagging window length ${UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN} is configured too low. Contact the Aztec team
+          to increase it!`);
+            }
+            // Throw if the new pending index is lower than or equal to the last finalized index
+            const secretStr = secret.toString();
+            const lastFinalizedIndex = await this.#lastFinalizedIndexes.getAsync(secretStr);
+            if (lastFinalizedIndex !== undefined && index <= lastFinalizedIndex) {
+                throw new Error(`Cannot store pending index ${index} for secret ${secretStr}: ` + `it is lower than or equal to the last finalized index ${lastFinalizedIndex}`);
+            }
+            // Check if this secret + txHash combination already exists
+            const txHashStr = txHash.toString();
+            const existingForSecret = await this.#pendingIndexes.getAsync(secretStr) ?? [];
+            const existingForSecretAndTx = existingForSecret.find((entry)=>entry.txHash === txHashStr);
+            if (existingForSecretAndTx) {
+                // If it exists with a different index, throw an error
+                if (existingForSecretAndTx.index !== index) {
+                    throw new Error(`Cannot store index ${index} for secret ${secretStr} and txHash ${txHashStr}: ` + `a different index ${existingForSecretAndTx.index} already exists for this secret-txHash pair`);
+                }
+            // If it exists with the same index, ignore the update (no-op)
+            } else {
+                // If it doesn't exist, add it
+                await this.#pendingIndexes.set(secretStr, [
+                    ...existingForSecret,
+                    {
+                        index,
+                        txHash: txHashStr
+                    }
+                ]);
+            }
+        }
+    }
+    /**
+   * Returns the transaction hashes of all pending transactions that contain indexes within a specified range
+   * for a given directional app tagging secret.
+   * @param secret - The directional app tagging secret to query pending indexes for.
+   * @param startIndex - The lower bound of the index range (inclusive).
+   * @param endIndex - The upper bound of the index range (exclusive).
+   * @returns An array of unique transaction hashes for pending transactions that contain indexes in the range
+   * [startIndex, endIndex). Returns an empty array if no pending indexes exist in the range.
+   */ async getTxHashesOfPendingIndexes(secret, startIndex, endIndex) {
+        const existing = await this.#pendingIndexes.getAsync(secret.toString()) ?? [];
+        const txHashes = existing.filter((entry)=>entry.index >= startIndex && entry.index < endIndex).map((entry)=>entry.txHash);
+        return Array.from(new Set(txHashes)).map(TxHash.fromString);
+    }
+    /**
+   * Returns the last (highest) finalized index for a given secret.
+   * @param secret - The secret to get the last finalized index for.
+   * @returns The last (highest) finalized index for the given secret.
+   */ getLastFinalizedIndex(secret) {
+        return this.#lastFinalizedIndexes.getAsync(secret.toString());
+    }
+    /**
+   * Returns the last used index for a given directional app tagging secret, considering both finalized and pending
+   * indexes.
+   * @param secret - The directional app tagging secret to query the last used index for.
+   * @returns The last used index.
+   */ async getLastUsedIndex(secret) {
+        const secretStr = secret.toString();
+        const pendingTxScopedIndexes = await this.#pendingIndexes.getAsync(secretStr) ?? [];
+        const pendingIndexes = pendingTxScopedIndexes.map((entry)=>entry.index);
+        if (pendingTxScopedIndexes.length === 0) {
+            return this.#lastFinalizedIndexes.getAsync(secretStr);
+        }
+        // As the last used index we return the highest one from the pending indexes. Note that this value will be always
+        // higher than the last finalized index because we prune lower pending indexes when a tx is finalized.
+        return Math.max(...pendingIndexes);
+    }
+    /**
+   * Drops all pending indexes corresponding to the given transaction hashes.
+   */ async dropPendingIndexes(txHashes) {
+        if (txHashes.length === 0) {
+            return;
+        }
+        const txHashStrs = new Set(txHashes.map((txHash)=>txHash.toString()));
+        const allSecrets = await toArray(this.#pendingIndexes.keysAsync());
+        for (const secret of allSecrets){
+            const pendingData = await this.#pendingIndexes.getAsync(secret);
+            if (pendingData) {
+                const filtered = pendingData.filter((item)=>!txHashStrs.has(item.txHash));
+                if (filtered.length === 0) {
+                    await this.#pendingIndexes.delete(secret);
+                } else if (filtered.length !== pendingData.length) {
+                    // Some items were filtered out, so update the pending data
+                    await this.#pendingIndexes.set(secret, filtered);
+                }
+            // else: No items were filtered out (txHashes not found for this secret) --> no-op
+            }
+        }
+    }
+    /**
+   * Updates pending indexes corresponding to the given transaction hashes to be finalized and prunes any lower pending
+   * indexes.
+   */ async finalizePendingIndexes(txHashes) {
+        if (txHashes.length === 0) {
+            return;
+        }
+        for (const txHash of txHashes){
+            const txHashStr = txHash.toString();
+            const allSecrets = await toArray(this.#pendingIndexes.keysAsync());
+            for (const secret of allSecrets){
+                const pendingData = await this.#pendingIndexes.getAsync(secret);
+                if (!pendingData) {
+                    continue;
+                }
+                const matchingIndexes = pendingData.filter((item)=>item.txHash === txHashStr).map((item)=>item.index);
+                if (matchingIndexes.length === 0) {
+                    continue;
+                }
+                if (matchingIndexes.length > 1) {
+                    // We should always just store the highest pending index for a given tx hash and secret because the lower
+                    // values are irrelevant.
+                    throw new Error(`Multiple pending indexes found for tx hash ${txHashStr} and secret ${secret}`);
+                }
+                let lastFinalized = await this.#lastFinalizedIndexes.getAsync(secret);
+                const newFinalized = matchingIndexes[0];
+                if (newFinalized < (lastFinalized ?? 0)) {
+                    // This should never happen because when last finalized index was finalized we should have pruned the lower
+                    // pending indexes.
+                    throw new Error(`New finalized index ${newFinalized} is smaller than the current last finalized index ${lastFinalized}`);
+                }
+                await this.#lastFinalizedIndexes.set(secret, newFinalized);
+                lastFinalized = newFinalized;
+                // When we add pending indexes, we ensure they are higher than the last finalized index. However, because we
+                // cannot control the order in which transactions are finalized, there may be pending indexes that are now
+                // obsolete because they are lower than the most recently finalized index. For this reason, we prune these
+                // outdated pending indexes.
+                const remainingItemsOfHigherIndex = pendingData.filter((item)=>item.index > (lastFinalized ?? 0));
+                if (remainingItemsOfHigherIndex.length === 0) {
+                    await this.#pendingIndexes.delete(secret);
+                } else {
+                    await this.#pendingIndexes.set(secret, remainingItemsOfHigherIndex);
+                }
+            }
+        }
+    }
+}

package/dest/tagging/constants.d.ts

@@ -1,2 +1,2 @@
-export declare const WINDOW_HALF_SIZE = 10;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGFnZ2luZy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsZUFBTyxNQUFNLGdCQUFnQixLQUFLLENBQUMifQ==
+export declare const UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN = 20;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGFnZ2luZy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBU0EsZUFBTyxNQUFNLHNDQUFzQyxLQUFLLENBQUMifQ==

package/dest/tagging/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/tagging/constants.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,gBAAgB,KAAK,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/tagging/constants.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,sCAAsC,KAAK,CAAC"}