@aztec/pxe 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

package/dest/storage/tagging_store/sender_tagging_store.js

@@ -1,5 +1,6 @@
-import { TxHash } from '@aztec/stdlib/tx';
-import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.js';
+import { allToCompletion } from '@aztec/foundation/promise';
+import { AppTaggingSecret, SiloedTag } from '@aztec/stdlib/logs';
+import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN, unfinalizedTaggingIndexesWindowEnd } 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
@@ -7,18 +8,17 @@ import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.
  */ export class SenderTaggingStore {
     storeName = 'sender_tagging';
     #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.
+    // 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 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.
+    // 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.
     //
-    // TODO(#17615): This assumes no logs are used in the non-revertible phase.
-    //
-    // directional app tagging secret => { pending index, txHash }[]
+    // directional app tagging secret => { lowestIndex, highestIndex, txHash }[]
     #pendingIndexes;
-    // jobId => directional app tagging secret => { pending index, txHash }[]
+    // 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
@@ -100,102 +100,119 @@ import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.
         return Promise.resolve();
     }
     /**
-   * 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.
+   * Stores pending index ranges, rejecting any range that disagrees with an already-stored one.
+   * @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 in
+   * callers that record indexes at prove time. Discovery from onchain logs must use `mergePendingIndexes` instead.
+   * @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) {
+        return this.#storePendingIndexes(ranges, txHash, jobId, false);
+    }
+    /**
+   * Stores pending index ranges, widening an existing entry for the same (secret, txHash) pair to the union of the
+   * stored and incoming ranges instead of throwing on a mismatch. Discovery from onchain logs needs this: it may see
+   * only the surviving (non-revertible phase) sub-range of a partially reverted tx recorded at prove time (the
+   * finalized receipt step of the sync resolves that difference), or indexes beyond a partially discovered entry
+   * when a tx from another PXE straddles a sync window boundary. Callers that record indexes at prove time must use
+   * `storePendingIndexes` instead, so that a range disagreement surfaces as a bug rather than being absorbed.
+   * @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 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, txHash, jobId) {
-        if (preTags.length === 0) {
+   * @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.
+   */ mergePendingIndexes(ranges, txHash, jobId) {
+        return this.#storePendingIndexes(ranges, txHash, jobId, true);
+    }
+    #storePendingIndexes(ranges, txHash, jobId, mergeExisting) {
+        if (ranges.length === 0) {
             return Promise.resolve();
         }
-        // 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) {
-            return Promise.reject(new Error(`Duplicate secrets found when storing pending indexes`));
-        }
         const txHashStr = txHash.toString();
         return this.#store.transactionAsync(async ()=>{
             // Prefetch all data, start reads during iteration to keep IndexedDB transaction alive
-            const preTagReadPromises = preTags.map(({ secret, index })=>{
-                const secretStr = secret.toString();
-                return {
-                    secret,
-                    secretStr,
-                    index,
-                    pending: this.#readPendingIndexes(jobId, secretStr),
-                    finalized: this.#readLastFinalizedIndex(jobId, secretStr)
-                };
-            });
+            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 preTagData = await Promise.all(preTagReadPromises.map(async (item)=>({
+            const rangeData = await allToCompletion(rangeReadPromises.map(async (item)=>({
                     ...item,
                     pendingData: await item.pending,
                     finalizedIndex: await item.finalized
                 })));
             // Process in memory and validate
-            for (const { secretStr, index, pendingData, finalizedIndex } of preTagData){
-                // First we check that for any secret the highest used index in tx is not further than window length from
-                // the highest finalized index.
-                if (index > (finalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN) {
-                    throw new Error(`Highest used index ${index} 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!`);
+            for (const { range, secretStr, pendingData, finalizedIndex } of rangeData){
+                const windowEnd = unfinalizedTaggingIndexesWindowEnd(finalizedIndex);
+                if (range.highestIndex >= windowEnd) {
+                    throw windowExceededError(range.highestIndex, windowEnd, finalizedIndex);
                 }
-                // Throw if the new pending index is lower than or equal to the last finalized index
-                if (finalizedIndex !== undefined && index <= finalizedIndex) {
-                    throw new Error(`Cannot store pending index ${index} for secret ${secretStr}: ` + `it is lower than or equal to the last finalized index ${finalizedIndex}`);
+                // 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 this secret + txHash combination already exists
-                const existingForSecretAndTx = pendingData.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
-                    this.#writePendingIndexes(jobId, secretStr, [
+                // Check if an entry with the same txHash already exists
+                const existingEntry = pendingData.find((entry)=>entry.txHash === txHashStr);
+                let updatedPending;
+                if (!existingEntry) {
+                    updatedPending = [
                         ...pendingData,
                         {
-                            index,
+                            lowestIndex: range.lowestIndex,
+                            highestIndex: range.highestIndex,
                             txHash: txHashStr
                         }
-                    ]);
+                    ];
+                } else if (mergeExisting) {
+                    // Widen the entry to the union of both ranges, never shrink it: replacing would drop prove-time
+                    // indexes the chain doesn't show (partially reverted tx), and skipping would drop onchain indexes
+                    // discovered in a later sync window (tx straddling the window boundary).
+                    const lowestIndex = Math.min(existingEntry.lowestIndex, range.lowestIndex);
+                    const highestIndex = Math.max(existingEntry.highestIndex, range.highestIndex);
+                    if (lowestIndex !== existingEntry.lowestIndex || highestIndex !== existingEntry.highestIndex) {
+                        updatedPending = pendingData.map((entry)=>entry === existingEntry ? {
+                                lowestIndex,
+                                highestIndex,
+                                txHash: entry.txHash
+                            } : entry);
+                    }
+                } else if (existingEntry.lowestIndex !== range.lowestIndex || existingEntry.highestIndex !== range.highestIndex) {
+                    // Different ranges for the same (secret, txHash) indicate a bug in callers that record indexes at prove
+                    // time.
+                    throw new Error(`Conflicting range for secret ${secretStr} and txHash ${txHashStr}: ` + `existing [${existingEntry.lowestIndex}, ${existingEntry.highestIndex}] vs ` + `new [${range.lowestIndex}, ${range.highestIndex}]`);
+                }
+                // Remaining cases (a merge whose union equals the stored range, or an identical range without
+                // mergeExisting): duplicate evidence, nothing to write.
+                if (updatedPending) {
+                    this.#writePendingIndexes(jobId, secretStr, updatedPending);
                 }
             }
         });
     }
     /**
-   * Returns the transaction hashes of all pending transactions that contain indexes within a specified range
-   * for a given directional app tagging secret.
+   * Returns the pending txs whose highest index falls within [startIndex, endIndex) for a given directional app
+   * tagging secret. The highest index is what decides whether a tx belongs to the window, so it alone is matched
+   * against the bounds, and it is also the only index a caller needs: a tx whose highest index is onchain has every
+   * lower one onchain too. A secret holds at most one entry per tx hash, so no tx hash appears twice in the result.
    * @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) {
+   */ getPendingTxs(secret, startIndex, endIndex, jobId) {
         return this.#store.transactionAsync(async ()=>{
             const existing = await this.#readPendingIndexes(jobId, 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);
+            return existing.filter((entry)=>entry.highestIndex >= startIndex && entry.highestIndex < endIndex).map((entry)=>({
+                    txHash: entry.txHash,
+                    highestIndex: entry.highestIndex
+                }));
         });
     }
     /**
@@ -215,17 +232,16 @@ import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.
         return this.#store.transactionAsync(async ()=>{
             const pendingPromise = this.#readPendingIndexes(jobId, secretStr);
             const finalizedPromise = this.#readLastFinalizedIndex(jobId, secretStr);
-            const [pendingTxScopedIndexes, lastFinalized] = await Promise.all([
+            const [pendingEntries, lastFinalized] = await allToCompletion([
                 pendingPromise,
                 finalizedPromise
             ]);
-            const pendingIndexes = pendingTxScopedIndexes.map((entry)=>entry.index);
-            if (pendingTxScopedIndexes.length === 0) {
+            if (pendingEntries.length === 0) {
                 return lastFinalized;
             }
-            // 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);
+            // 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));
         });
     }
     /**
@@ -251,7 +267,9 @@ import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.
             const secrets = [
                 ...secretReadPromises.keys()
             ];
-            const pendingDataResults = await Promise.all(secretReadPromises.values());
+            const pendingDataResults = await allToCompletion([
+                ...secretReadPromises.values()
+            ]);
             // Process in memory
             for(let i = 0; i < secrets.length; i++){
                 const secret = secrets[i];
@@ -269,14 +287,7 @@ import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.
             }
         });
     }
-    /**
-   * Updates pending indexes corresponding to the given transaction hashes to be finalized and prunes any lower pending
-   * indexes.
-   */ finalizePendingIndexes(txHashes, jobId) {
-        if (txHashes.length === 0) {
-            return Promise.resolve();
-        }
-        const txHashStrings = new Set(txHashes.map((tx)=>tx.toString()));
+    /** 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();
@@ -299,50 +310,120 @@ import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.
             const secrets = [
                 ...secretDataPromises.keys()
             ];
-            const dataResults = await Promise.all(secrets.map(async (secret)=>({
+            const dataResults = await allToCompletion(secrets.map(async (secret)=>({
                     secret,
                     pendingData: await secretDataPromises.get(secret).pending,
                     lastFinalized: await secretDataPromises.get(secret).finalized
                 })));
-            // Process all txHashes for each secret in memory
-            for (const { secret, pendingData, lastFinalized } of dataResults){
-                if (!pendingData || pendingData.length === 0) {
+            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. Applies to every secret the txs used, so the caller must hold tx-level evidence that the whole tx
+   * finalized. Callers holding evidence about a single secret must use {@link finalizePendingIndexesOfSecret} instead.
+   */ finalizePendingIndexes(txHashes, jobId) {
+        return this.#finalizePendingIndexes(txHashes, jobId);
+    }
+    /**
+   * Same as {@link finalizePendingIndexes}, but restricted to the pending indexes of a single secret.
+   *
+   * Finalizing every secret off single-secret evidence would be unsound: a tx whose execution partially reverted can
+   * have all of one secret's tags onchain and none of another's, and the second secret's indexes must not be recorded
+   * as finalized when they never reached the chain.
+   */ finalizePendingIndexesOfSecret(secret, txHashes, jobId) {
+        return this.#finalizePendingIndexes(txHashes, jobId, secret.toString());
+    }
+    async #finalizePendingIndexes(txHashes, jobId, onlySecret) {
+        if (txHashes.length === 0) {
+            return;
+        }
+        const txHashStrings = new Set(txHashes.map((tx)=>tx.toString()));
+        const secretsWithData = (await this.#getSecretsWithPendingData(jobId)).filter(({ secret })=>onlySecret === undefined || secret === onlySecret);
+        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;
                 }
-                let currentPending = pendingData;
-                let currentFinalized = lastFinalized;
-                // Process all txHashes for this secret
-                for (const txHashStr of txHashStrings){
-                    const matchingIndexes = currentPending.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}`);
-                    }
-                    const newFinalized = matchingIndexes[0];
-                    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.index > currentFinalized);
+                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}`);
                 }
-                // Write final state if changed
-                if (currentFinalized !== lastFinalized) {
-                    this.#writeLastFinalizedIndex(jobId, secret, currentFinalized);
+                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}`);
                 }
-                if (currentPending !== pendingData) {
-                    this.#writePendingIndexes(jobId, secret, currentPending);
+                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);
+        }
     }
 }
+/** Builds the error thrown when a pending tag index is at or past the unfinalized tagging window end. */ export function windowExceededError(highestIndex, windowEnd, finalizedIndex) {
+    const finalizedDescription = finalizedIndex === undefined ? 'no index finalized yet' : `highest finalized index ${finalizedIndex}`;
+    return new Error(`Highest used index ${highestIndex} is at or past the window end ${windowEnd} (${finalizedDescription}). ` + `Tagging window length ${UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN} is configured too low. ` + `Contact the Aztec team to increase it!`);
+}

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"}

package/dest/storage/tagging_store/tagging_secret_sources_store.js

@@ -0,0 +1,105 @@
+import { Point } from '@aztec/foundation/curves/grumpkin';
+import { toArray } from '@aztec/foundation/iterable';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+/**
+ * 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 class TaggingSecretSourcesStore {
+    #store;
+    #senders;
+    #sharedSecretsByRecipient;
+    constructor(store){
+        this.#store = store;
+        this.#senders = this.#store.openMap('senders');
+        this.#sharedSecretsByRecipient = this.#store.openMultiMap('recipient_shared_secrets');
+    }
+    addSender(address) {
+        return this.#store.transactionAsync(async ()=>{
+            if (await this.#senders.hasAsync(address.toString())) {
+                return false;
+            }
+            await this.#senders.set(address.toString(), true);
+            return true;
+        });
+    }
+    getSenders() {
+        return this.#store.transactionAsync(async ()=>{
+            return (await toArray(this.#senders.keysAsync())).map(AztecAddress.fromStringUnsafe);
+        });
+    }
+    removeSender(address) {
+        return this.#store.transactionAsync(async ()=>{
+            if (!await this.#senders.hasAsync(address.toString())) {
+                return false;
+            }
+            await this.#senders.delete(address.toString());
+            return true;
+        });
+    }
+    /**
+   * 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, kind, secret) {
+        return this.#store.transactionAsync(async ()=>{
+            const secretStr = secret.toString();
+            // MultiMap.set silently ignores an identical (key, value), so we scan to report whether this is a new secret.
+            for await (const existing of this.#sharedSecretsByRecipient.getValuesAsync(recipient.toString())){
+                if (existing.secret === secretStr) {
+                    if (existing.kind !== kind) {
+                        throw new Error(`Secret already registered for recipient with kind '${existing.kind}', cannot re-register it as '${kind}'.`);
+                    }
+                    return false;
+                }
+            }
+            await this.#sharedSecretsByRecipient.set(recipient.toString(), {
+                kind,
+                secret: secretStr
+            });
+            return true;
+        });
+    }
+    /** Returns the pre-shared tagging secrets registered for a given recipient. */ getSharedSecretsForRecipient(recipient) {
+        return this.#store.transactionAsync(async ()=>{
+            return (await toArray(this.#sharedSecretsByRecipient.getValuesAsync(recipient.toString()))).map(deserializeSharedSecret);
+        });
+    }
+    /** Returns every registered pre-shared tagging secret, each paired with the recipient it is scoped to. */ getAllSharedSecrets() {
+        return this.#store.transactionAsync(async ()=>{
+            const entries = await toArray(this.#sharedSecretsByRecipient.entriesAsync());
+            return entries.map(([recipient, entry])=>({
+                    recipient: AztecAddress.fromStringUnsafe(recipient),
+                    ...deserializeSharedSecret(entry)
+                }));
+        });
+    }
+    /**
+   * 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, kind, secret) {
+        return this.#store.transactionAsync(async ()=>{
+            const secretStr = secret.toString();
+            for await (const existing of this.#sharedSecretsByRecipient.getValuesAsync(recipient.toString())){
+                if (existing.kind === kind && existing.secret === secretStr) {
+                    await this.#sharedSecretsByRecipient.deleteValue(recipient.toString(), existing);
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+}
+function deserializeSharedSecret(entry) {
+    return {
+        kind: entry.kind,
+        secret: Point.fromString(entry.secret)
+    };
+}

package/dest/tagging/constants.d.ts

@@ -1,2 +1,11 @@
-export declare const UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN = 20;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGFnZ2luZy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBU0EsZUFBTyxNQUFNLHNDQUFzQyxLQUFLLENBQUMifQ==
+export declare const UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN: number;
+/**
+ * Exclusive upper bound of the tag indexes that can exist for a secret whose highest finalized index is
+ * `finalizedIndex` (undefined when nothing is finalized yet). The sender store refuses pending indexes at or past it,
+ * and both sender and recipient sync scan exactly up to it. Every absolute window bound must come from this helper:
+ * a site with a wider or narrower bound lets a tx land at an index the syncs never scan, so two stores sharing the
+ * secret could later pick a colliding index.
+ */
+export declare function unfinalizedTaggingIndexesWindowEnd(finalizedIndex: number | undefined): number;
+export declare const INITIAL_CONSTRAINED_PROBE_LEN = 2;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGFnZ2luZy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBbUJBLGVBQU8sTUFBTSxzQ0FBc0MsUUFBK0IsQ0FBQztBQUVuRjs7Ozs7O0dBTUc7QUFDSCx3QkFBZ0Isa0NBQWtDLENBQUMsY0FBYyxFQUFFLE1BQU0sR0FBRyxTQUFTLEdBQUcsTUFBTSxDQUc3RjtBQVVELGVBQU8sTUFBTSw2QkFBNkIsSUFBSSxDQUFDIn0=

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

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/tagging/constants.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,sCAAsC,KAAK,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/tagging/constants.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,sCAAsC,QAA+B,CAAC;AAEnF;;;;;;GAMG;AACH,wBAAgB,kCAAkC,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAG7F;AAUD,eAAO,MAAM,6BAA6B,IAAI,CAAC"}