@aztec/pxe 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/dest/storage/tagging_store/recipient_tagging_store.js

@@ -0,0 +1,111 @@
+/**
+ * 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.
+ */ export class RecipientTaggingStore {
+    storeName = 'recipient_tagging';
+    #store;
+    #highestAgedIndex;
+    #highestFinalizedIndex;
+    // jobId => secret => number
+    #highestAgedIndexForJob;
+    // jobId => secret => number
+    #highestFinalizedIndexForJob;
+    constructor(store){
+        this.#store = store;
+        this.#highestAgedIndex = this.#store.openMap('highest_aged_index');
+        this.#highestFinalizedIndex = this.#store.openMap('highest_finalized_index');
+        this.#highestAgedIndexForJob = new Map();
+        this.#highestFinalizedIndexForJob = new Map();
+    }
+    #getHighestAgedIndexForJob(jobId) {
+        let highestAgedIndexForJob = this.#highestAgedIndexForJob.get(jobId);
+        if (!highestAgedIndexForJob) {
+            highestAgedIndexForJob = new Map();
+            this.#highestAgedIndexForJob.set(jobId, highestAgedIndexForJob);
+        }
+        return highestAgedIndexForJob;
+    }
+    async #readHighestAgedIndex(jobId, secret) {
+        // Always issue DB read to keep IndexedDB transaction alive (they auto-commit when a new micro-task starts and there
+        // are no pending read requests). The staged value still takes precedence if it exists.
+        const dbValue = await this.#highestAgedIndex.getAsync(secret);
+        const staged = this.#getHighestAgedIndexForJob(jobId).get(secret);
+        return staged ?? dbValue;
+    }
+    #writeHighestAgedIndex(jobId, secret, index) {
+        this.#getHighestAgedIndexForJob(jobId).set(secret, index);
+    }
+    #getHighestFinalizedIndexForJob(jobId) {
+        let jobStagedHighestFinalizedIndex = this.#highestFinalizedIndexForJob.get(jobId);
+        if (!jobStagedHighestFinalizedIndex) {
+            jobStagedHighestFinalizedIndex = new Map();
+            this.#highestFinalizedIndexForJob.set(jobId, jobStagedHighestFinalizedIndex);
+        }
+        return jobStagedHighestFinalizedIndex;
+    }
+    async #readHighestFinalizedIndex(jobId, secret) {
+        // Always issue DB read to keep IndexedDB transaction alive (they auto-commit when a new micro-task starts and there
+        // are no pending read requests). The staged value still takes precedence if it exists.
+        const dbValue = await this.#highestFinalizedIndex.getAsync(secret);
+        const staged = this.#getHighestFinalizedIndexForJob(jobId).get(secret);
+        return staged ?? dbValue;
+    }
+    #writeHighestFinalizedIndex(jobId, secret, index) {
+        this.#getHighestFinalizedIndexForJob(jobId).set(secret, index);
+    }
+    /**
+   * Writes all job-specific in-memory data to persistent storage.
+   *
+   * @remark This method must run in a DB transaction context. It's designed to be called from JobCoordinator#commitJob.
+   */ async commit(jobId) {
+        const highestAgedIndexForJob = this.#highestAgedIndexForJob.get(jobId);
+        if (highestAgedIndexForJob) {
+            for (const [secret, index] of highestAgedIndexForJob.entries()){
+                await this.#highestAgedIndex.set(secret, index);
+            }
+        }
+        const highestFinalizedIndexForJob = this.#highestFinalizedIndexForJob.get(jobId);
+        if (highestFinalizedIndexForJob) {
+            for (const [secret, index] of highestFinalizedIndexForJob.entries()){
+                await this.#highestFinalizedIndex.set(secret, index);
+            }
+        }
+        return this.discardStaged(jobId);
+    }
+    discardStaged(jobId) {
+        this.#highestAgedIndexForJob.delete(jobId);
+        this.#highestFinalizedIndexForJob.delete(jobId);
+        return Promise.resolve();
+    }
+    getHighestAgedIndex(secret, jobId) {
+        return this.#store.transactionAsync(()=>this.#readHighestAgedIndex(jobId, secret.toString()));
+    }
+    updateHighestAgedIndex(secret, index, jobId) {
+        return this.#store.transactionAsync(async ()=>{
+            const currentIndex = await this.#readHighestAgedIndex(jobId, 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})`);
+            }
+            this.#writeHighestAgedIndex(jobId, secret.toString(), index);
+        });
+    }
+    getHighestFinalizedIndex(secret, jobId) {
+        return this.#store.transactionAsync(()=>this.#readHighestFinalizedIndex(jobId, secret.toString()));
+    }
+    updateHighestFinalizedIndex(secret, index, jobId) {
+        return this.#store.transactionAsync(async ()=>{
+            const currentIndex = await this.#readHighestFinalizedIndex(jobId, 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})`);
+            }
+            this.#writeHighestFinalizedIndex(jobId, secret.toString(), index);
+        });
+    }
+}

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

@@ -0,0 +1,78 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { AppTaggingSecret, type TaggingIndexRange } from '@aztec/stdlib/logs';
+import { TxEffect, TxHash } from '@aztec/stdlib/tx';
+import type { StagedStore } from '../../job_coordinator/job_coordinator.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 data stores separate for sender and recipient because
+ * the algorithms are completely disjoint and there is not data reuse between the two.
+ */
+export declare class SenderTaggingStore implements StagedStore {
+    #private;
+    readonly storeName = "sender_tagging";
+    constructor(store: AztecAsyncKVStore);
+    /**
+     * Writes all job-specific in-memory data to persistent storage.
+     *
+     * @remark This method must run in a DB transaction context. It's designed to be called from JobCoordinator#commitJob.
+     */
+    commit(jobId: string): Promise<void>;
+    discardStaged(jobId: string): Promise<void>;
+    /**
+     * Stores pending index ranges.
+     * @remarks If the same (secret, txHash) pair already exists in the db with an equal range, it's a no-op. This is
+     * expected to happen because whenever we start sync we start from the last finalized index and we can have pending
+     * ranges already stored from previous syncs. If the ranges differ, it throws an error as that indicates a bug.
+     * @param ranges - The tagging index ranges containing the directional app tagging secrets and the index ranges that are
+     * to be stored in the db.
+     * @param txHash - The tx in which the tagging indexes were used in private logs.
+     * @param jobId - job context for staged writes to this store. See `JobCoordinator` for more details.
+     * @throws If the highestIndex is further than window length from the highest finalized index for the same secret.
+     * @throws If the lowestIndex is lower than or equal to the last finalized index for the same secret.
+     * @throws If a different range already exists for the same (secret, txHash) pair.
+     */
+    storePendingIndexes(ranges: TaggingIndexRange[], txHash: TxHash, jobId: string): Promise<void>;
+    /**
+     * Returns the transaction hashes of all pending transactions that contain highest indexes within a specified range
+     * for a given directional app tagging secret. We check based on the highest indexes only as that is the relevant
+     * information for the caller of this function.
+     * @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: AppTaggingSecret, startIndex: number, endIndex: number, jobId: string): 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: AppTaggingSecret, jobId: string): 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: AppTaggingSecret, jobId: string): Promise<number | undefined>;
+    /**
+     * Drops all pending indexes corresponding to the given transaction hashes.
+     */
+    dropPendingIndexes(txHashes: TxHash[], jobId: string): Promise<void>;
+    /**
+     * Updates pending indexes corresponding to the given transaction hashes to be finalized and prunes any lower pending
+     * indexes.
+     */
+    finalizePendingIndexes(txHashes: TxHash[], jobId: string): Promise<void>;
+    /**
+     * Handles finalization of pending indexes for a transaction whose execution was partially reverted.
+     * Recomputes the siloed tags for each pending index of the given tx and checks which ones appear in the
+     * TxEffect's private logs (i.e., which ones made it onchain). Those that survived are finalized; those that
+     * didn't are dropped.
+     * @param txEffect - The tx effect of the partially reverted transaction.
+     * @param jobId - job context for staged writes to this store. See `JobCoordinator` for more details.
+     */
+    finalizePendingIndexesOfAPartiallyRevertedTx(txEffect: TxEffect, jobId: string): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VuZGVyX3RhZ2dpbmdfc3RvcmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL3RhZ2dpbmdfc3RvcmUvc2VuZGVyX3RhZ2dpbmdfc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQWlCLE1BQU0saUJBQWlCLENBQUM7QUFDeEUsT0FBTyxFQUFFLGdCQUFnQixFQUFhLEtBQUssaUJBQWlCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUN6RixPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRXBELE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLDBDQUEwQyxDQUFDO0FBTTVFOzs7O0dBSUc7QUFDSCxxQkFBYSxrQkFBbUIsWUFBVyxXQUFXOztJQUNwRCxRQUFRLENBQUMsU0FBUyxvQkFBb0I7SUE0QnRDLFlBQVksS0FBSyxFQUFFLGlCQUFpQixFQVFuQztJQTRDRDs7OztPQUlHO0lBQ0csTUFBTSxDQUFDLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQW9CekM7SUFFRCxhQUFhLENBQUMsS0FBSyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBSTFDO0lBRUQ7Ozs7Ozs7Ozs7OztPQVlHO0lBQ0gsbUJBQW1CLENBQUMsTUFBTSxFQUFFLGlCQUFpQixFQUFFLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FpRTdGO0lBRUQ7Ozs7Ozs7OztPQVNHO0lBQ0gsMkJBQTJCLENBQ3pCLE1BQU0sRUFBRSxnQkFBZ0IsRUFDeEIsVUFBVSxFQUFFLE1BQU0sRUFDbEIsUUFBUSxFQUFFLE1BQU0sRUFDaEIsS0FBSyxFQUFFLE1BQU0sR0FDWixPQUFPLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FRbkI7SUFFRDs7OztPQUlHO0lBQ0gscUJBQXFCLENBQUMsTUFBTSxFQUFFLGdCQUFnQixFQUFFLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUMsQ0FFMUY7SUFFRDs7Ozs7T0FLRztJQUNILGdCQUFnQixDQUFDLE1BQU0sRUFBRSxnQkFBZ0IsRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLENBaUJyRjtJQUVEOztPQUVHO0lBQ0gsa0JBQWtCLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxFQUFFLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQTJDbkU7SUE0Q0Q7OztPQUdHO0lBQ0csc0JBQXNCLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxFQUFFLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQXNEN0U7SUFFRDs7Ozs7OztPQU9HO0lBQ0csNENBQTRDLENBQUMsUUFBUSxFQUFFLFFBQVEsRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FnRG5HO0NBQ0YifQ==

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":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAa,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACzF,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0CAA0C,CAAC;AAM5E;;;;GAIG;AACH,qBAAa,kBAAmB,YAAW,WAAW;;IACpD,QAAQ,CAAC,SAAS,oBAAoB;IA4BtC,YAAY,KAAK,EAAE,iBAAiB,EAQnC;IA4CD;;;;OAIG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBzC;IAED,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI1C;IAED;;;;;;;;;;;;OAYG;IACH,mBAAmB,CAAC,MAAM,EAAE,iBAAiB,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAiE7F;IAED;;;;;;;;;OASG;IACH,2BAA2B,CACzB,MAAM,EAAE,gBAAgB,EACxB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,MAAM,EAAE,CAAC,CAQnB;IAED;;;;OAIG;IACH,qBAAqB,CAAC,MAAM,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAE1F;IAED;;;;;OAKG;IACH,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAiBrF;IAED;;OAEG;IACH,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA2CnE;IA4CD;;;OAGG;IACG,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAsD7E;IAED;;;;;;;OAOG;IACG,4CAA4C,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAgDnG;CACF"}

package/dest/storage/tagging_store/sender_tagging_store.js

@@ -0,0 +1,374 @@
+import { AppTaggingSecret, SiloedTag } from '@aztec/stdlib/logs';
+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 data stores separate for sender and recipient because
+ * the algorithms are completely disjoint and there is not data reuse between the two.
+ */ export class SenderTaggingStore {
+    storeName = 'sender_tagging';
+    #store;
+    // Stores the pending index ranges 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 store the full range (lowestIndex, highestIndex) for each secret-tx pair because transactions can partially
+    // revert, in which case only some logs (from the non-revertible phase) survive onchain. By storing the range,
+    // we can expand it and check each individual siloed tag against the TxEffect to determine which indexes made it
+    // onchain.
+    //
+    // directional app tagging secret => { lowestIndex, highestIndex, txHash }[]
+    #pendingIndexes;
+    // jobId => directional app tagging secret => { lowestIndex, highestIndex, txHash }[]
+    #pendingIndexesForJob;
+    // 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.
+    //
+    // directional app tagging secret => highest finalized index
+    #lastFinalizedIndexes;
+    // jobId => directional app tagging secret => highest finalized index
+    #lastFinalizedIndexesForJob;
+    constructor(store){
+        this.#store = store;
+        this.#pendingIndexes = this.#store.openMap('pending_indexes');
+        this.#lastFinalizedIndexes = this.#store.openMap('last_finalized_indexes');
+        this.#pendingIndexesForJob = new Map();
+        this.#lastFinalizedIndexesForJob = new Map();
+    }
+    #getPendingIndexesForJob(jobId) {
+        let pendingIndexesForJob = this.#pendingIndexesForJob.get(jobId);
+        if (!pendingIndexesForJob) {
+            pendingIndexesForJob = new Map();
+            this.#pendingIndexesForJob.set(jobId, pendingIndexesForJob);
+        }
+        return pendingIndexesForJob;
+    }
+    #getLastFinalizedIndexesForJob(jobId) {
+        let jobStagedLastFinalizedIndexes = this.#lastFinalizedIndexesForJob.get(jobId);
+        if (!jobStagedLastFinalizedIndexes) {
+            jobStagedLastFinalizedIndexes = new Map();
+            this.#lastFinalizedIndexesForJob.set(jobId, jobStagedLastFinalizedIndexes);
+        }
+        return jobStagedLastFinalizedIndexes;
+    }
+    async #readPendingIndexes(jobId, secret) {
+        // Always issue DB read to keep IndexedDB transaction alive (they auto-commit when a new micro-task starts and there
+        // are no pending read requests). The staged value still takes precedence if it exists.
+        const dbValue = await this.#pendingIndexes.getAsync(secret);
+        const staged = this.#getPendingIndexesForJob(jobId).get(secret);
+        return staged !== undefined ? staged : dbValue ?? [];
+    }
+    #writePendingIndexes(jobId, secret, pendingIndexes) {
+        this.#getPendingIndexesForJob(jobId).set(secret, pendingIndexes);
+    }
+    async #readLastFinalizedIndex(jobId, secret) {
+        // Always issue DB read to keep IndexedDB transaction alive (they auto-commit when a new micro-task starts and there
+        // are no pending read requests). The staged value still takes precedence if it exists.
+        const dbValue = await this.#lastFinalizedIndexes.getAsync(secret);
+        const staged = this.#getLastFinalizedIndexesForJob(jobId).get(secret);
+        return staged ?? dbValue;
+    }
+    #writeLastFinalizedIndex(jobId, secret, lastFinalizedIndex) {
+        this.#getLastFinalizedIndexesForJob(jobId).set(secret, lastFinalizedIndex);
+    }
+    /**
+   * Writes all job-specific in-memory data to persistent storage.
+   *
+   * @remark This method must run in a DB transaction context. It's designed to be called from JobCoordinator#commitJob.
+   */ async commit(jobId) {
+        const pendingIndexesForJob = this.#pendingIndexesForJob.get(jobId);
+        if (pendingIndexesForJob) {
+            for (const [secret, pendingIndexes] of pendingIndexesForJob.entries()){
+                if (pendingIndexes.length === 0) {
+                    await this.#pendingIndexes.delete(secret);
+                } else {
+                    await this.#pendingIndexes.set(secret, pendingIndexes);
+                }
+            }
+        }
+        const lastFinalizedIndexesForJob = this.#lastFinalizedIndexesForJob.get(jobId);
+        if (lastFinalizedIndexesForJob) {
+            for (const [secret, lastFinalizedIndex] of lastFinalizedIndexesForJob.entries()){
+                await this.#lastFinalizedIndexes.set(secret, lastFinalizedIndex);
+            }
+        }
+        return this.discardStaged(jobId);
+    }
+    discardStaged(jobId) {
+        this.#pendingIndexesForJob.delete(jobId);
+        this.#lastFinalizedIndexesForJob.delete(jobId);
+        return Promise.resolve();
+    }
+    /**
+   * Stores pending index ranges.
+   * @remarks If the same (secret, txHash) pair already exists in the db with an equal range, it's a no-op. This is
+   * expected to happen because whenever we start sync we start from the last finalized index and we can have pending
+   * ranges already stored from previous syncs. If the ranges differ, it throws an error as that indicates a bug.
+   * @param ranges - The tagging index ranges containing the directional app tagging secrets and the index ranges that are
+   * to be stored in the db.
+   * @param txHash - The tx in which the tagging indexes were used in private logs.
+   * @param jobId - job context for staged writes to this store. See `JobCoordinator` for more details.
+   * @throws If the highestIndex is further than window length from the highest finalized index for the same secret.
+   * @throws If the lowestIndex is lower than or equal to the last finalized index for the same secret.
+   * @throws If a different range already exists for the same (secret, txHash) pair.
+   */ storePendingIndexes(ranges, txHash, jobId) {
+        if (ranges.length === 0) {
+            return Promise.resolve();
+        }
+        const txHashStr = txHash.toString();
+        return this.#store.transactionAsync(async ()=>{
+            // Prefetch all data, start reads during iteration to keep IndexedDB transaction alive
+            const rangeReadPromises = ranges.map((range)=>({
+                    range,
+                    secretStr: range.extendedSecret.toString(),
+                    pending: this.#readPendingIndexes(jobId, range.extendedSecret.toString()),
+                    finalized: this.#readLastFinalizedIndex(jobId, range.extendedSecret.toString())
+                }));
+            // Await all reads together
+            const rangeData = await Promise.all(rangeReadPromises.map(async (item)=>({
+                    ...item,
+                    pendingData: await item.pending,
+                    finalizedIndex: await item.finalized
+                })));
+            // Process in memory and validate
+            for (const { range, secretStr, pendingData, finalizedIndex } of rangeData){
+                // Check that the highest index is not further than window length from the highest finalized index.
+                if (range.highestIndex > (finalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN) {
+                    throw new Error(`Highest used index ${range.highestIndex} is further than window length from the highest finalized index ${finalizedIndex ?? 0}.
+            Tagging window length ${UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN} is configured too low. Contact the Aztec team
+            to increase it!`);
+                }
+                // Throw if the lowest index is lower than or equal to the last finalized index
+                if (finalizedIndex !== undefined && range.lowestIndex <= finalizedIndex) {
+                    throw new Error(`Cannot store pending index range [${range.lowestIndex}, ${range.highestIndex}] for secret ${secretStr}: ` + `lowestIndex is lower than or equal to the last finalized index ${finalizedIndex}`);
+                }
+                // Check if an entry with the same txHash already exists
+                const existingEntry = pendingData.find((entry)=>entry.txHash === txHashStr);
+                if (existingEntry) {
+                    // Assert that the ranges are equal — different ranges for the same (secret, txHash) indicates a bug
+                    if (existingEntry.lowestIndex !== range.lowestIndex || existingEntry.highestIndex !== range.highestIndex) {
+                        throw new Error(`Conflicting range for secret ${secretStr} and txHash ${txHashStr}: ` + `existing [${existingEntry.lowestIndex}, ${existingEntry.highestIndex}] vs ` + `new [${range.lowestIndex}, ${range.highestIndex}]`);
+                    }
+                // Exact duplicate — skip
+                } else {
+                    this.#writePendingIndexes(jobId, secretStr, [
+                        ...pendingData,
+                        {
+                            lowestIndex: range.lowestIndex,
+                            highestIndex: range.highestIndex,
+                            txHash: txHashStr
+                        }
+                    ]);
+                }
+            }
+        });
+    }
+    /**
+   * Returns the transaction hashes of all pending transactions that contain highest indexes within a specified range
+   * for a given directional app tagging secret. We check based on the highest indexes only as that is the relevant
+   * information for the caller of this function.
+   * @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, startIndex, endIndex, jobId) {
+        return this.#store.transactionAsync(async ()=>{
+            const existing = await this.#readPendingIndexes(jobId, secret.toString());
+            const txHashes = existing.filter((entry)=>entry.highestIndex >= startIndex && entry.highestIndex < 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, jobId) {
+        return this.#store.transactionAsync(()=>this.#readLastFinalizedIndex(jobId, 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.
+   */ getLastUsedIndex(secret, jobId) {
+        const secretStr = secret.toString();
+        return this.#store.transactionAsync(async ()=>{
+            const pendingPromise = this.#readPendingIndexes(jobId, secretStr);
+            const finalizedPromise = this.#readLastFinalizedIndex(jobId, secretStr);
+            const [pendingEntries, lastFinalized] = await Promise.all([
+                pendingPromise,
+                finalizedPromise
+            ]);
+            if (pendingEntries.length === 0) {
+                return lastFinalized;
+            }
+            // As the last used index we return the highest one from the pending index ranges. 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(...pendingEntries.map((entry)=>entry.highestIndex));
+        });
+    }
+    /**
+   * Drops all pending indexes corresponding to the given transaction hashes.
+   */ dropPendingIndexes(txHashes, jobId) {
+        if (txHashes.length === 0) {
+            return Promise.resolve();
+        }
+        const txHashStrings = new Set(txHashes.map((txHash)=>txHash.toString()));
+        return this.#store.transactionAsync(async ()=>{
+            // Prefetch all data, start reads during iteration to keep IndexedDB transaction alive
+            const secretReadPromises = new Map();
+            for await (const secret of this.#pendingIndexes.keysAsync()){
+                secretReadPromises.set(secret, this.#readPendingIndexes(jobId, secret));
+            }
+            // Add staged-only secrets (sync, no DB)
+            for (const secret of this.#getPendingIndexesForJob(jobId).keys()){
+                if (!secretReadPromises.has(secret)) {
+                    secretReadPromises.set(secret, Promise.resolve(this.#getPendingIndexesForJob(jobId).get(secret) ?? []));
+                }
+            }
+            // Await all reads together
+            const secrets = [
+                ...secretReadPromises.keys()
+            ];
+            const pendingDataResults = await Promise.all(secretReadPromises.values());
+            // Process in memory
+            for(let i = 0; i < secrets.length; i++){
+                const secret = secrets[i];
+                const pendingData = pendingDataResults[i];
+                if (pendingData && pendingData.length > 0) {
+                    const filtered = pendingData.filter((item)=>!txHashStrings.has(item.txHash));
+                    if (filtered.length === 0) {
+                        this.#writePendingIndexes(jobId, secret, []);
+                    } else if (filtered.length !== pendingData.length) {
+                        // Some items were filtered out, so update the pending data
+                        this.#writePendingIndexes(jobId, secret, filtered);
+                    }
+                // else: No items were filtered out (txHashes not found for this secret) --> no-op
+                }
+            }
+        });
+    }
+    /** Prefetches all pending and finalized index data for every secret (from both DB and staged writes). */ #getSecretsWithPendingData(jobId) {
+        return this.#store.transactionAsync(async ()=>{
+            // Prefetch all data, start reads during iteration to keep IndexedDB transaction alive
+            const secretDataPromises = new Map();
+            for await (const secret of this.#pendingIndexes.keysAsync()){
+                secretDataPromises.set(secret, {
+                    pending: this.#readPendingIndexes(jobId, secret),
+                    finalized: this.#readLastFinalizedIndex(jobId, secret)
+                });
+            }
+            // Add staged-only secrets (sync, no DB)
+            for (const secret of this.#getPendingIndexesForJob(jobId).keys()){
+                if (!secretDataPromises.has(secret)) {
+                    secretDataPromises.set(secret, {
+                        pending: Promise.resolve(this.#getPendingIndexesForJob(jobId).get(secret) ?? []),
+                        finalized: Promise.resolve(this.#getLastFinalizedIndexesForJob(jobId).get(secret))
+                    });
+                }
+            }
+            // Await all reads together
+            const secrets = [
+                ...secretDataPromises.keys()
+            ];
+            const dataResults = await Promise.all(secrets.map(async (secret)=>({
+                    secret,
+                    pendingData: await secretDataPromises.get(secret).pending,
+                    lastFinalized: await secretDataPromises.get(secret).finalized
+                })));
+            return dataResults.filter((r)=>r.pendingData.length > 0);
+        });
+    }
+    /**
+   * Updates pending indexes corresponding to the given transaction hashes to be finalized and prunes any lower pending
+   * indexes.
+   */ async finalizePendingIndexes(txHashes, jobId) {
+        if (txHashes.length === 0) {
+            return;
+        }
+        const txHashStrings = new Set(txHashes.map((tx)=>tx.toString()));
+        const secretsWithData = await this.#getSecretsWithPendingData(jobId);
+        for (const { secret, pendingData, lastFinalized } of secretsWithData){
+            let currentPending = pendingData;
+            let currentFinalized = lastFinalized;
+            // Process all txHashes for this secret
+            for (const txHashStr of txHashStrings){
+                const matchingEntries = currentPending.filter((item)=>item.txHash === txHashStr);
+                if (matchingEntries.length === 0) {
+                    continue;
+                }
+                if (matchingEntries.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 entries found for tx hash ${txHashStr} and secret ${secret}`);
+                }
+                const newFinalized = matchingEntries[0].highestIndex;
+                if (newFinalized < (currentFinalized ?? 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 ${currentFinalized}`);
+                }
+                currentFinalized = 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.
+                currentPending = currentPending.filter((item)=>item.highestIndex > currentFinalized);
+            }
+            // Write final state if changed
+            if (currentFinalized !== lastFinalized) {
+                this.#writeLastFinalizedIndex(jobId, secret, currentFinalized);
+            }
+            if (currentPending !== pendingData) {
+                this.#writePendingIndexes(jobId, secret, currentPending);
+            }
+        }
+    }
+    /**
+   * Handles finalization of pending indexes for a transaction whose execution was partially reverted.
+   * Recomputes the siloed tags for each pending index of the given tx and checks which ones appear in the
+   * TxEffect's private logs (i.e., which ones made it onchain). Those that survived are finalized; those that
+   * didn't are dropped.
+   * @param txEffect - The tx effect of the partially reverted transaction.
+   * @param jobId - job context for staged writes to this store. See `JobCoordinator` for more details.
+   */ async finalizePendingIndexesOfAPartiallyRevertedTx(txEffect, jobId) {
+        const txHashStr = txEffect.txHash.toString();
+        // Build a set of all siloed tag values that made it onchain (first field of each private log).
+        const onChainTags = new Set(txEffect.privateLogs.map((log)=>log.fields[0].toString()));
+        const secretsWithData = await this.#getSecretsWithPendingData(jobId);
+        for (const { secret, pendingData, lastFinalized } of secretsWithData){
+            const matchingEntries = pendingData.filter((item)=>item.txHash === txHashStr);
+            if (matchingEntries.length === 0) {
+                continue;
+            }
+            if (matchingEntries.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 entries found for tx hash ${txHashStr} and secret ${secret}`);
+            }
+            const pendingEntry = matchingEntries[0];
+            // Expand each matching entry's range and recompute siloed tags for each index.
+            const appTaggingSecret = AppTaggingSecret.fromString(secret);
+            let highestSurvivingIndex;
+            for(let index = pendingEntry.lowestIndex; index <= pendingEntry.highestIndex; index++){
+                const siloedTag = await SiloedTag.compute({
+                    extendedSecret: appTaggingSecret,
+                    index
+                });
+                if (onChainTags.has(siloedTag.value.toString())) {
+                    highestSurvivingIndex = highestSurvivingIndex !== undefined ? Math.max(highestSurvivingIndex, index) : index;
+                }
+            }
+            // Remove all entries for this txHash from pending (both surviving and non-surviving).
+            let currentPending = pendingData.filter((item)=>item.txHash !== txHashStr);
+            if (highestSurvivingIndex !== undefined) {
+                const newFinalized = Math.max(lastFinalized ?? 0, highestSurvivingIndex);
+                this.#writeLastFinalizedIndex(jobId, secret, newFinalized);
+                // Prune pending indexes that are now <= the finalized index.
+                currentPending = currentPending.filter((item)=>item.highestIndex > newFinalized);
+            }
+            this.#writePendingIndexes(jobId, secret, currentPending);
+        }
+    }
+}

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

@@ -0,0 +1,51 @@
+import { Point } from '@aztec/foundation/curves/grumpkin';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+/**
+ * The kinds of shared secret an entry can hold.
+ */
+export type SharedSecretKind = 'arbitrary-secret' | 'handshake';
+/** A shared secret registered for a recipient, with the kind that determines which tag streams it backs. */
+export type SharedSecret = {
+    kind: SharedSecretKind;
+    secret: Point;
+};
+/**
+ * Stores the sources from which directional app tagging secrets are derived during recipient log synchronization.
+ *
+ * Two kinds of source are held:
+ * - Sender addresses: combined with a recipient to derive a shared tagging secret via ECDH. These are global (not
+ *   scoped to a recipient) because the per-recipient binding comes from re-mixing the recipient's keys during
+ *   derivation, so each account only ever derives secrets meant for it.
+ * - Pre-shared tagging secrets: shared secret points registered directly, bypassing ECDH. These are scoped to a
+ *   specific recipient, since the derivation of the directional app tagging secret does not require any secret
+ *   recipient data: given the original secret anyone can derive a recipient's app-siloed directional tagging secret,
+ *   and so these must not be reused across recipients to preserve privacy. Each carries the {@link SharedSecretKind}
+ *   it was registered through, which determines the tag streams it is scanned under.
+ */
+export declare class TaggingSecretSourcesStore {
+    #private;
+    constructor(store: AztecAsyncKVStore);
+    addSender(address: AztecAddress): Promise<boolean>;
+    getSenders(): Promise<AztecAddress[]>;
+    removeSender(address: AztecAddress): Promise<boolean>;
+    /**
+     * Registers a pre-shared tagging secret scoped to a recipient.
+     * @returns true if the secret was newly added, false if it was already registered for that recipient.
+     */
+    addSharedSecret(recipient: AztecAddress, kind: SharedSecretKind, secret: Point): Promise<boolean>;
+    /** Returns the pre-shared tagging secrets registered for a given recipient. */
+    getSharedSecretsForRecipient(recipient: AztecAddress): Promise<SharedSecret[]>;
+    /** Returns every registered pre-shared tagging secret, each paired with the recipient it is scoped to. */
+    getAllSharedSecrets(): Promise<{
+        recipient: AztecAddress;
+        kind: SharedSecretKind;
+        secret: Point;
+    }[]>;
+    /**
+     * Removes a pre-shared tagging secret scoped to a recipient. Both the secret and its kind must match.
+     * @returns true if the secret was registered and removed, false if it was not registered for that recipient.
+     */
+    removeSharedSecret(recipient: AztecAddress, kind: SharedSecretKind, secret: Point): Promise<boolean>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFnZ2luZ19zZWNyZXRfc291cmNlc19zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2UvdGFnZ2luZ19zdG9yZS90YWdnaW5nX3NlY3JldF9zb3VyY2VzX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUUxRCxPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBcUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM1RixPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFFM0Q7O0dBRUc7QUFDSCxNQUFNLE1BQU0sZ0JBQWdCLEdBQUcsa0JBQWtCLEdBQUcsV0FBVyxDQUFDO0FBRWhFLDRHQUE0RztBQUM1RyxNQUFNLE1BQU0sWUFBWSxHQUFHO0lBQUUsSUFBSSxFQUFFLGdCQUFnQixDQUFDO0lBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQTtDQUFFLENBQUM7QUFFckU7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gscUJBQWEseUJBQXlCOztJQUtwQyxZQUFZLEtBQUssRUFBRSxpQkFBaUIsRUFLbkM7SUFFRCxTQUFTLENBQUMsT0FBTyxFQUFFLFlBQVksR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBVWpEO0lBRUQsVUFBVSxJQUFJLE9BQU8sQ0FBQyxZQUFZLEVBQUUsQ0FBQyxDQUlwQztJQUVELFlBQVksQ0FBQyxPQUFPLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FVcEQ7SUFFRDs7O09BR0c7SUFDSCxlQUFlLENBQUMsU0FBUyxFQUFFLFlBQVksRUFBRSxJQUFJLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxFQUFFLEtBQUssR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBbUJoRztJQUVELCtFQUErRTtJQUMvRSw0QkFBNEIsQ0FBQyxTQUFTLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxZQUFZLEVBQUUsQ0FBQyxDQU03RTtJQUVELDBHQUEwRztJQUMxRyxtQkFBbUIsSUFBSSxPQUFPLENBQUM7UUFBRSxTQUFTLEVBQUUsWUFBWSxDQUFDO1FBQUMsSUFBSSxFQUFFLGdCQUFnQixDQUFDO1FBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQTtLQUFFLEVBQUUsQ0FBQyxDQVFuRztJQUVEOzs7T0FHRztJQUNILGtCQUFrQixDQUFDLFNBQVMsRUFBRSxZQUFZLEVBQUUsSUFBSSxFQUFFLGdCQUFnQixFQUFFLE1BQU0sRUFBRSxLQUFLLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQVluRztDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"tagging_secret_sources_store.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_store/tagging_secret_sources_store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAE1D,OAAO,KAAK,EAAE,iBAAiB,EAAqC,MAAM,iBAAiB,CAAC;AAC5F,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,kBAAkB,GAAG,WAAW,CAAC;AAEhE,4GAA4G;AAC5G,MAAM,MAAM,YAAY,GAAG;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,KAAK,CAAA;CAAE,CAAC;AAErE;;;;;;;;;;;;GAYG;AACH,qBAAa,yBAAyB;;IAKpC,YAAY,KAAK,EAAE,iBAAiB,EAKnC;IAED,SAAS,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAUjD;IAED,UAAU,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAIpC;IAED,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAUpD;IAED;;;OAGG;IACH,eAAe,CAAC,SAAS,EAAE,YAAY,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAmBhG;IAED,+EAA+E;IAC/E,4BAA4B,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAM7E;IAED,0GAA0G;IAC1G,mBAAmB,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,YAAY,CAAC;QAAC,IAAI,EAAE,gBAAgB,CAAC;QAAC,MAAM,EAAE,KAAK,CAAA;KAAE,EAAE,CAAC,CAQnG;IAED;;;OAGG;IACH,kBAAkB,CAAC,SAAS,EAAE,YAAY,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAYnG;CACF"}