@aztec/pxe 0.0.1-commit.d431d1c → 0.0.1-commit.d58ff9d0

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,3 @@
-export declare const UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN = 20;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGFnZ2luZy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBU0EsZUFBTyxNQUFNLHNDQUFzQyxLQUFLLENBQUMifQ==
+export declare const UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN: number;
+export declare const INITIAL_CONSTRAINED_PROBE_LEN = 2;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGFnZ2luZy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBbUJBLGVBQU8sTUFBTSxzQ0FBc0MsUUFBK0IsQ0FBQztBQVVuRixlQUFPLE1BQU0sNkJBQTZCLElBQUksQ0FBQyJ9

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;AAUnF,eAAO,MAAM,6BAA6B,IAAI,CAAC"}

package/dest/tagging/constants.js

@@ -1,10 +1,28 @@
-// This window has to be as large as the largest expected number of logs emitted in a tx for a given directional app
-// tagging secret. If we get more tag indexes consumed than this window, an error is thrown in `PXE::proveTx` function.
-// This is set to a larger value than MAX_PRIVATE_LOGS_PER_TX (currently 64) because there could be more than
-// MAX_PRIVATE_LOGS_PER_TX indexes consumed in case the logs are squashed. This happens when the log contains a note
-// and the note is nullified in the same tx.
-//
-// Having a large window significantly slowed down `e2e_l1_with_wall_time` test as there we perform sync for more than
-// 1000 secrets. For this reason we set it to a relatively low value of 20. 20 should be sufficient for all the use
-// cases.
-export const UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN = 20;
+import { MAX_PRIVATE_LOGS_PER_TX } from '@aztec/constants';
+// This window bounds how far a sender's next tag index for a directional app tagging secret can run ahead of that
+// secret's highest finalized index before `PXE::proveTx` throws.
+//
+// MAX_PRIVATE_LOGS_PER_TX is a floor for ordinary transaction patterns: the private kernel accumulates every
+// surviving private log into a single tx-wide array of exactly this size, so a fresh secret's very first
+// ordinary tx can consume that many indexes before anything is finalized.
+//
+// The +20 on top is headroom for multiple pending ordinary txs to the same counterparty stacking up
+// before the first one is observed as mined. Only a run of near-MAX_PRIVATE_LOGS_PER_TX txs back-to-back would
+// exhaust this; ordinary transfers use far fewer logs per tx, so the same margin covers many more of those. Keep the
+// margin additive rather than another multiple of the floor. A larger window also makes recipient-side sync more
+// expensive, since discovery has to probe ahead of the last finalized index for every active secret.
+//
+// TODO(F-783): MAX_PRIVATE_LOGS_PER_TX is not a hard ceiling in general — a tx that creates and nullifies (squashes)
+// many notes/logs to the same secret can drive that secret's raw tag index arbitrarily higher, since indexes are
+// reserved at log emission time, before squashing is decided, and the kernel's reset/squash loop is not bounded by
+// MAX_PRIVATE_LOGS_PER_TX. No fixed window value closes that gap.
+export const UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN = MAX_PRIVATE_LOGS_PER_TX + 20;
+// The number of tags probed per constrained secret in the first round.
+//
+// The probe doubles each round (2, 4, 8, ..., capped at UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN) while every probed
+// index is a hit, stopping at the first missing tag. Constrained delivery is gapless, so a single missing tag proves
+// the stream has ended: at steady state this turns a full WINDOW_LEN probe into two tags. A secret K logs behind
+// catches up in ~log2(K) round-trips while the probe is still doubling (2, 4, 8, 16, 32), but once it saturates the cap
+// and advances WINDOW_LEN tags per round, deeper catch-up is linear at ~K/WINDOW_LEN rounds. Either way it beats both
+// the full window every round and one round per log.
+export const INITIAL_CONSTRAINED_PROBE_LEN = 2;

package/dest/tagging/get_all_logs_by_tags.d.ts

@@ -0,0 +1,48 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHash } from '@aztec/stdlib/block';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import { type LogResult, type SiloedTag, type Tag } from '@aztec/stdlib/logs';
+/** Optional block-range, effects opt-in, and pagination cap shared by both wrappers. */
+export type GetAllLogsByTagsOptions = {
+    /** Lower block bound, inclusive. */
+    fromBlock?: BlockNumber;
+    /** Upper block bound, exclusive. */
+    toBlock?: BlockNumber;
+    /**
+     * When set, each log also carries `noteHashes` and all `nullifiers` of its tx. Defaults to off — sender
+     * sync only needs `txHash`. The recipient-sync/log-service paths flip this on to build `PendingTaggedLog`
+     * / `LogRetrievalResponse` from note data.
+     */
+    includeEffects?: boolean;
+    /**
+     * Maximum number of logs returned per tag per round-trip. Capped at `MAX_LOGS_PER_TAG` on the node
+     * (rejected if higher). Defaults to `MAX_LOGS_PER_TAG`. Mainly useful for tests that need to force
+     * pagination at a small page size.
+     */
+    limitPerTag?: number;
+};
+/**
+ * Fetches all private logs for the given tags, automatically paginating per-tag via `afterLog` cursors.
+ *
+ * @param aztecNode - The Aztec node to query.
+ * @param tags - The siloed tags to search for.
+ * @param anchorBlockHash - Reference block for the Aztec node query, throws if block is not found there (typically
+ *   because of reorgs).
+ * @param options - Optional `fromBlock`/`toBlock` range and `includeEffects` opt-in.
+ * @returns An array of log arrays, one per tag, containing all logs across all pages.
+ */
+export declare function getAllPrivateLogsByTags<Opts extends GetAllLogsByTagsOptions = GetAllLogsByTagsOptions>(aztecNode: AztecNode, tags: SiloedTag[], anchorBlockHash: BlockHash, options?: Opts): Promise<LogResult<Opts>[][]>;
+/**
+ * Fetches all public logs for the given tags from a contract, automatically paginating per-tag via `afterLog` cursors.
+ *
+ * @param aztecNode - The Aztec node to query.
+ * @param contractAddress - The contract address to search logs for.
+ * @param tags - The tags to search for.
+ * @param anchorBlockHash - Reference block for the Aztec node query, throws if block is not found there (typically
+ *   because of reorgs).
+ * @param options - Optional `fromBlock`/`toBlock` range and `includeEffects` opt-in.
+ * @returns An array of log arrays, one per tag, containing all logs across all pages.
+ */
+export declare function getAllPublicLogsByTagsFromContract<Opts extends GetAllLogsByTagsOptions = GetAllLogsByTagsOptions>(aztecNode: AztecNode, contractAddress: AztecAddress, tags: Tag[], anchorBlockHash: BlockHash, options?: Opts): Promise<LogResult<Opts>[][]>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0X2FsbF9sb2dzX2J5X3RhZ3MuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90YWdnaW5nL2dldF9hbGxfbG9nc19ieV90YWdzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ25FLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ2hFLE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBRXJELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2pFLE9BQU8sRUFFTCxLQUFLLFNBQVMsRUFDZCxLQUFLLFNBQVMsRUFDZCxLQUFLLEdBQUcsRUFHVCxNQUFNLG9CQUFvQixDQUFDO0FBRTVCLHdGQUF3RjtBQUN4RixNQUFNLE1BQU0sdUJBQXVCLEdBQUc7SUFDcEMsb0NBQW9DO0lBQ3BDLFNBQVMsQ0FBQyxFQUFFLFdBQVcsQ0FBQztJQUN4QixvQ0FBb0M7SUFDcEMsT0FBTyxDQUFDLEVBQUUsV0FBVyxDQUFDO0lBQ3RCOzs7O09BSUc7SUFDSCxjQUFjLENBQUMsRUFBRSxPQUFPLENBQUM7SUFDekI7Ozs7T0FJRztJQUNILFdBQVcsQ0FBQyxFQUFFLE1BQU0sQ0FBQztDQUN0QixDQUFDO0FBMEJGOzs7Ozs7Ozs7R0FTRztBQUNILHdCQUFnQix1QkFBdUIsQ0FBQyxJQUFJLFNBQVMsdUJBQXVCLEdBQUcsdUJBQXVCLEVBQ3BHLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLElBQUksRUFBRSxTQUFTLEVBQUUsRUFDakIsZUFBZSxFQUFFLFNBQVMsRUFDMUIsT0FBTyxHQUFFLElBQWlCLEdBQ3pCLE9BQU8sQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLEVBQUUsRUFBRSxDQUFDLENBYTlCO0FBRUQ7Ozs7Ozs7Ozs7R0FVRztBQUNILHdCQUFnQixrQ0FBa0MsQ0FBQyxJQUFJLFNBQVMsdUJBQXVCLEdBQUcsdUJBQXVCLEVBQy9HLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLGVBQWUsRUFBRSxZQUFZLEVBQzdCLElBQUksRUFBRSxHQUFHLEVBQUUsRUFDWCxlQUFlLEVBQUUsU0FBUyxFQUMxQixPQUFPLEdBQUUsSUFBaUIsR0FDekIsT0FBTyxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FjOUIifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"get_all_logs_by_tags.d.ts","sourceRoot":"","sources":["../../src/tagging/get_all_logs_by_tags.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,GAAG,EAGT,MAAM,oBAAoB,CAAC;AAE5B,wFAAwF;AACxF,MAAM,MAAM,uBAAuB,GAAG;IACpC,oCAAoC;IACpC,SAAS,CAAC,EAAE,WAAW,CAAC;IACxB,oCAAoC;IACpC,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AA0BF;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,SAAS,uBAAuB,GAAG,uBAAuB,EACpG,SAAS,EAAE,SAAS,EACpB,IAAI,EAAE,SAAS,EAAE,EACjB,eAAe,EAAE,SAAS,EAC1B,OAAO,GAAE,IAAiB,GACzB,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,CAa9B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kCAAkC,CAAC,IAAI,SAAS,uBAAuB,GAAG,uBAAuB,EAC/G,SAAS,EAAE,SAAS,EACpB,eAAe,EAAE,YAAY,EAC7B,IAAI,EAAE,GAAG,EAAE,EACX,eAAe,EAAE,SAAS,EAC1B,OAAO,GAAE,IAAiB,GACzB,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,CAc9B"}

package/dest/tagging/get_all_logs_by_tags.js

@@ -0,0 +1,59 @@
+import { MAX_RPC_LEN } from '@aztec/stdlib/interfaces/api-limit';
+import { queryAllPrivateLogsByTags, queryAllPublicLogsByTags } from '@aztec/stdlib/logs';
+/**
+ * Splits tags into chunks of MAX_RPC_LEN, paginates each chunk via the stdlib per-tag cursor helper,
+ * then stitches the results back into a single array preserving the original tag order.
+ */ async function getAllPagesInBatches(tags, fetchAllPagesForBatch) {
+    if (tags.length === 0) {
+        return [];
+    }
+    if (tags.length <= MAX_RPC_LEN) {
+        return fetchAllPagesForBatch(tags);
+    }
+    const batches = [];
+    for(let i = 0; i < tags.length; i += MAX_RPC_LEN){
+        batches.push(tags.slice(i, i + MAX_RPC_LEN));
+    }
+    const batchResults = await Promise.all(batches.map(fetchAllPagesForBatch));
+    return batchResults.flat();
+}
+/**
+ * Fetches all private logs for the given tags, automatically paginating per-tag via `afterLog` cursors.
+ *
+ * @param aztecNode - The Aztec node to query.
+ * @param tags - The siloed tags to search for.
+ * @param anchorBlockHash - Reference block for the Aztec node query, throws if block is not found there (typically
+ *   because of reorgs).
+ * @param options - Optional `fromBlock`/`toBlock` range and `includeEffects` opt-in.
+ * @returns An array of log arrays, one per tag, containing all logs across all pages.
+ */ export function getAllPrivateLogsByTags(aztecNode, tags, anchorBlockHash, options = {}) {
+    return getAllPagesInBatches(tags, (batch)=>queryAllPrivateLogsByTags(aztecNode, {
+            tags: batch,
+            referenceBlock: anchorBlockHash,
+            fromBlock: options.fromBlock,
+            toBlock: options.toBlock,
+            includeEffects: options.includeEffects ?? false,
+            limitPerTag: options.limitPerTag
+        }));
+}
+/**
+ * Fetches all public logs for the given tags from a contract, automatically paginating per-tag via `afterLog` cursors.
+ *
+ * @param aztecNode - The Aztec node to query.
+ * @param contractAddress - The contract address to search logs for.
+ * @param tags - The tags to search for.
+ * @param anchorBlockHash - Reference block for the Aztec node query, throws if block is not found there (typically
+ *   because of reorgs).
+ * @param options - Optional `fromBlock`/`toBlock` range and `includeEffects` opt-in.
+ * @returns An array of log arrays, one per tag, containing all logs across all pages.
+ */ export function getAllPublicLogsByTagsFromContract(aztecNode, contractAddress, tags, anchorBlockHash, options = {}) {
+    return getAllPagesInBatches(tags, (batch)=>queryAllPublicLogsByTags(aztecNode, {
+            contractAddress,
+            tags: batch,
+            referenceBlock: anchorBlockHash,
+            fromBlock: options.fromBlock,
+            toBlock: options.toBlock,
+            includeEffects: options.includeEffects ?? false,
+            limitPerTag: options.limitPerTag
+        }));
+}

package/dest/tagging/index.d.ts

@@ -4,13 +4,15 @@
  * The objective of the sender sync algorithm is to determine which tags have already been used by a sender, thereby
  * deciding which tag should be used next.
  *
- * The objective of the recipient sync algorithm is to load and process the corresponding logs.
+ * The objective of the recipient sync algorithm is to fetch and sync the corresponding logs.
  *
  * @module tagging
  */
-export { loadPrivateLogsForSenderRecipientPair } from './recipient_sync/load_private_logs_for_sender_recipient_pair.js';
+export { syncTaggedPrivateLogs } from './recipient_sync/sync_tagged_private_logs.js';
 export { syncSenderTaggingIndexes } from './sender_sync/sync_sender_tagging_indexes.js';
-export { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from './constants.js';
-export { DirectionalAppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';
-export { type PreTag } from '@aztec/stdlib/logs';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90YWdnaW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7R0FTRztBQUVILE9BQU8sRUFBRSxxQ0FBcUMsRUFBRSxNQUFNLGlFQUFpRSxDQUFDO0FBQ3hILE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBQ3hGLE9BQU8sRUFBRSxzQ0FBc0MsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBR3hFLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxHQUFHLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDakYsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFFLE1BQU0sb0JBQW9CLENBQUMifQ==
+export { persistSenderTaggingIndexRangesForTx } from './persist_sender_tagging_index_ranges.js';
+export { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN, INITIAL_CONSTRAINED_PROBE_LEN } from './constants.js';
+export { getAllPrivateLogsByTags, getAllPublicLogsByTagsFromContract } from './get_all_logs_by_tags.js';
+export { AppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';
+export { type PreTag, type TaggingIndexRange } from '@aztec/stdlib/logs';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90YWdnaW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7R0FTRztBQUVILE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBQ3JGLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBQ3hGLE9BQU8sRUFBRSxvQ0FBb0MsRUFBRSxNQUFNLDBDQUEwQyxDQUFDO0FBQ2hHLE9BQU8sRUFBRSxzQ0FBc0MsRUFBRSw2QkFBNkIsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3ZHLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxrQ0FBa0MsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBR3hHLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxHQUFHLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDdEUsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFFLEtBQUssaUJBQWlCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQyJ9

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tagging/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,qCAAqC,EAAE,MAAM,iEAAiE,CAAC;AACxH,OAAO,EAAE,wBAAwB,EAAE,MAAM,8CAA8C,CAAC;AACxF,OAAO,EAAE,sCAAsC,EAAE,MAAM,gBAAgB,CAAC;AAGxE,OAAO,EAAE,2BAA2B,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACjF,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tagging/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,EAAE,wBAAwB,EAAE,MAAM,8CAA8C,CAAC;AACxF,OAAO,EAAE,oCAAoC,EAAE,MAAM,0CAA0C,CAAC;AAChG,OAAO,EAAE,sCAAsC,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAC;AACvG,OAAO,EAAE,uBAAuB,EAAE,kCAAkC,EAAE,MAAM,2BAA2B,CAAC;AAGxG,OAAO,EAAE,gBAAgB,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACtE,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC"}

package/dest/tagging/index.js

@@ -4,11 +4,13 @@
  * The objective of the sender sync algorithm is to determine which tags have already been used by a sender, thereby
  * deciding which tag should be used next.
  *
- * The objective of the recipient sync algorithm is to load and process the corresponding logs.
+ * The objective of the recipient sync algorithm is to fetch and sync the corresponding logs.
  *
  * @module tagging
- */ export { loadPrivateLogsForSenderRecipientPair } from './recipient_sync/load_private_logs_for_sender_recipient_pair.js';
+ */ export { syncTaggedPrivateLogs } from './recipient_sync/sync_tagged_private_logs.js';
 export { syncSenderTaggingIndexes } from './sender_sync/sync_sender_tagging_indexes.js';
-export { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from './constants.js';
+export { persistSenderTaggingIndexRangesForTx } from './persist_sender_tagging_index_ranges.js';
+export { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN, INITIAL_CONSTRAINED_PROBE_LEN } from './constants.js';
+export { getAllPrivateLogsByTags, getAllPublicLogsByTagsFromContract } from './get_all_logs_by_tags.js';
 // Re-export tagging-related types from stdlib
-export { DirectionalAppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';
+export { AppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';

package/dest/tagging/persist_sender_tagging_index_ranges.d.ts

@@ -0,0 +1,29 @@
+import type { Logger } from '@aztec/foundation/log';
+import type { PrivateKernelTailCircuitPublicInputs } from '@aztec/stdlib/kernel';
+import type { TaggingIndexRange } from '@aztec/stdlib/logs';
+import type { TxHash } from '@aztec/stdlib/tx';
+import type { SenderTaggingStore } from '../storage/tagging_store/sender_tagging_store.js';
+/**
+ * Persists the tagging index ranges that a tx used as a sender, after reconciling them against the kernel's surviving
+ * private logs.
+ *
+ * The tagging index cache reserves an index for every log emission attempted during private execution, but the kernel
+ * may then squash some of those logs (e.g. when a note is created and nullified within the same tx). This function
+ * shrinks the recorded ranges to match the actual on-chain footprint before writing them, so that what we persist is
+ * consistent with what the network will see.
+ *
+ * @remarks Storing the recorded ranges in the DB may not be seen as necessary because we sync from chain before sending
+ * new logs, but the sync can only see logs already included in blocks. If we sent another transaction before this one
+ * was included from the same PXE, and that transaction contained a log with a tag derived from the same secret, we
+ * would reuse the tag and the transactions would be linked. Persisting in the DB prevents that linkage.
+ *
+ * @param store - The sender tagging store.
+ * @param recordedRanges - The tagging index ranges as recorded during private execution (pre-squash).
+ * @param publicInputs - The final kernel public inputs, used to determine which private logs survived squashing.
+ * @param getTxHash - Lazy accessor for the tx hash. Called only when there is something to persist, since computing
+ * the tx hash is expensive.
+ * @param jobId - Job context for staged writes to the store. See `JobCoordinator` for more details.
+ * @param log - Logger.
+ */
+export declare function persistSenderTaggingIndexRangesForTx(store: SenderTaggingStore, recordedRanges: TaggingIndexRange[], publicInputs: PrivateKernelTailCircuitPublicInputs, getTxHash: () => Promise<TxHash>, jobId: string, log: Logger): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVyc2lzdF9zZW5kZXJfdGFnZ2luZ19pbmRleF9yYW5nZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90YWdnaW5nL3BlcnNpc3Rfc2VuZGVyX3RhZ2dpbmdfaW5kZXhfcmFuZ2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3BELE9BQU8sS0FBSyxFQUFFLG9DQUFvQyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDakYsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUM1RCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUUvQyxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGtEQUFrRCxDQUFDO0FBRzNGOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FxQkc7QUFDSCx3QkFBc0Isb0NBQW9DLENBQ3hELEtBQUssRUFBRSxrQkFBa0IsRUFDekIsY0FBYyxFQUFFLGlCQUFpQixFQUFFLEVBQ25DLFlBQVksRUFBRSxvQ0FBb0MsRUFDbEQsU0FBUyxFQUFFLE1BQU0sT0FBTyxDQUFDLE1BQU0sQ0FBQyxFQUNoQyxLQUFLLEVBQUUsTUFBTSxFQUNiLEdBQUcsRUFBRSxNQUFNLEdBQ1YsT0FBTyxDQUFDLElBQUksQ0FBQyxDQW1CZiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"persist_sender_tagging_index_ranges.d.ts","sourceRoot":"","sources":["../../src/tagging/persist_sender_tagging_index_ranges.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,oCAAoC,EAAE,MAAM,sBAAsB,CAAC;AACjF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kDAAkD,CAAC;AAG3F;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,oCAAoC,CACxD,KAAK,EAAE,kBAAkB,EACzB,cAAc,EAAE,iBAAiB,EAAE,EACnC,YAAY,EAAE,oCAAoC,EAClD,SAAS,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,EAChC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,IAAI,CAAC,CAmBf"}

package/dest/tagging/persist_sender_tagging_index_ranges.js

@@ -0,0 +1,42 @@
+import { reconcileTaggingIndexRangesAgainstSurvivingTags } from './reconcile_tagging_index_ranges.js';
+/**
+ * Persists the tagging index ranges that a tx used as a sender, after reconciling them against the kernel's surviving
+ * private logs.
+ *
+ * The tagging index cache reserves an index for every log emission attempted during private execution, but the kernel
+ * may then squash some of those logs (e.g. when a note is created and nullified within the same tx). This function
+ * shrinks the recorded ranges to match the actual on-chain footprint before writing them, so that what we persist is
+ * consistent with what the network will see.
+ *
+ * @remarks Storing the recorded ranges in the DB may not be seen as necessary because we sync from chain before sending
+ * new logs, but the sync can only see logs already included in blocks. If we sent another transaction before this one
+ * was included from the same PXE, and that transaction contained a log with a tag derived from the same secret, we
+ * would reuse the tag and the transactions would be linked. Persisting in the DB prevents that linkage.
+ *
+ * @param store - The sender tagging store.
+ * @param recordedRanges - The tagging index ranges as recorded during private execution (pre-squash).
+ * @param publicInputs - The final kernel public inputs, used to determine which private logs survived squashing.
+ * @param getTxHash - Lazy accessor for the tx hash. Called only when there is something to persist, since computing
+ * the tx hash is expensive.
+ * @param jobId - Job context for staged writes to the store. See `JobCoordinator` for more details.
+ * @param log - Logger.
+ */ export async function persistSenderTaggingIndexRangesForTx(store, recordedRanges, publicInputs, getTxHash, jobId, log) {
+    if (recordedRanges.length === 0) {
+        log.debug(`No tagging index ranges used in the tx`);
+        return;
+    }
+    const survivingTags = new Set(publicInputs.getNonEmptyPrivateLogs().map((privateLog)=>privateLog.fields[0].toString()));
+    const reconciledRanges = await reconcileTaggingIndexRangesAgainstSurvivingTags(recordedRanges, survivingTags);
+    if (reconciledRanges.length === 0) {
+        log.debug(`All tagging index ranges used in the tx were squashed by the kernel`, {
+            recordedRanges
+        });
+        return;
+    }
+    const txHash = await getTxHash();
+    await store.storePendingIndexes(reconciledRanges, txHash, jobId);
+    log.debug(`Stored used tagging index ranges as sender for the tx`, {
+        recordedRanges,
+        reconciledRanges
+    });
+}

package/dest/tagging/recipient_sync/sync_tagged_private_logs.d.ts

@@ -0,0 +1,74 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { AppTaggingSecret, LogResult } from '@aztec/stdlib/logs';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+import type { RecipientTaggingStore } from '../../storage/tagging_store/recipient_tagging_store.js';
+/**
+ * Fetches and syncs tagged private logs for multiple sender-recipient pairs, batching tag queries across all secrets
+ * into shared RPC calls. Handles both constrained and unconstrained secrets, which differ in their scan strategy
+ * but share the same batching infrastructure.
+ *
+ * # Unconstrained secrets
+ *
+ * For each unconstrained secret we sync logs that correspond to the tagging index range
+ * (highestAgedIndex, highestFinalizedIndex + WINDOW_LEN]
+ *
+ * highestAgedIndex is the highest index that was used in a tx that is included in a block at least
+ *                  `MAX_TX_LIFETIME` seconds ago.
+ * highestFinalizedIndex is the highest index that was used in a tx that is included in a finalized block.
+ *
+ * "(" denotes an open end of the range - the index is not included in the range.
+ * "]" denotes a closed end of the range - the index is included in the range.
+ *
+ * ## Explanation of highestAgedIndex
+ *
+ * highestAgedIndex is chosen such that for all tagging indexes `i <= highestAgedIndex` we know that no new logs can
+ * ever appear.
+ *
+ * This relies on the "maximum inclusion timestamp" rule enforced by the kernel and rollup circuits:
+ * - a transaction's maximum inclusion timestamp is at most `MAX_TX_LIFETIME` seconds after
+ *   the timestamp of its anchor block; and
+ * - a rollup only includes transactions whose inclusion timestamp is >= the L2 block's timestamp.
+ *
+ * Suppose some device used index `I` in a transaction anchored to block `B_N` at time `N`, and that block is now at
+ * least `MAX_TX_LIFETIME` seconds in the past. Then there is no possibility of any *other* device
+ * trying to use an index <= `I` while anchoring to a *newer* block than `B_N` because if we were anchoring to
+ * a newer block than `B_N` then we would already have seen the log with index `I` and hence the device would have
+ * chosen a larger index.
+ *    If that *other* device would anchor to a block older than `B_N` then that tx could never be included in a block
+ * because it would already have been expired.
+ *
+ * Therefore, once we see that index `I` has been used in a block that is at least `MAX_TX_LIFETIME`
+ * seconds old, we can safely stop syncing logs for all indexes <= `I` and set highestAgedIndex = `I`.
+ *
+ * ## Explanation of the upper bound `highestFinalizedIndex + WINDOW_LEN`
+ *
+ * When a sender chooses a tagging index, they will select an index that is at most `WINDOW_LEN` greater than
+ * the highest finalized index. If that index was already used, they will throw an error. For this reason we
+ * don't have to look further than `highestFinalizedIndex + WINDOW_LEN`.
+ *
+ * # Constrained secrets
+ *
+ * Constrained delivery enforces a contiguous index sequence (each send proves the predecessor's nullifier,
+ * chaining back to the handshake), so there is only one sender and indexes are sequential. This means:
+ * - The lower bound is `highestFinalizedIndex + 1`. The `highestAgedIndex` mechanism is unnecessary because
+ *   the nullifier chain prevents out-of-order index usage: no device can fill in a lower index after a higher
+ *   one is already on-chain.
+ * - Because the sequence is gapless, the scan stops at the first missing index: that gap proves the sequence has
+ *   ended and no further logs exist. We exploit this with a doubling first-miss probe (see
+ *   `INITIAL_CONSTRAINED_PROBE_LEN` in ../constants.ts), so a
+ *   steady-state sync with no new logs costs two tags instead of the whole window. The probe length is in-memory
+ *   state scoped to one sync call, so every sync restarts at the initial probe.
+ * - The upper bound is the same as unconstrained: `highestFinalizedIndex + WINDOW_LEN`. Advancing the probe is
+ *   decoupled from persisting the finalized index, so unfinalized logs at the top of the run are still fetched
+ *   while only the finalized prefix is persisted.
+ *
+ * # Batching across secrets
+ *
+ * Instead of running one RPC call per secret, we merge tags from all pending secrets (both constrained and
+ * unconstrained) into a single flat array, make one batched `getAllPrivateLogsByTags` call (which internally
+ * chunks at MAX_RPC_LEN), then split results back per secret using tracked offsets. Only secrets whose window
+ * advanced are kept for the next iteration.
+ */
+export declare function syncTaggedPrivateLogs(secrets: AppTaggingSecret[], aztecNode: AztecNode, taggingStore: RecipientTaggingStore, anchorBlockHeader: BlockHeader, finalizedBlockNumber: BlockNumber, jobId: string): Promise<LogResult[]>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luY190YWdnZWRfcHJpdmF0ZV9sb2dzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGFnZ2luZy9yZWNpcGllbnRfc3luYy9zeW5jX3RhZ2dlZF9wcml2YXRlX2xvZ3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRzlELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2pFLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLFNBQVMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXRFLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRXBELE9BQU8sS0FBSyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFLcEc7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQWtFRztBQUNILHdCQUFzQixxQkFBcUIsQ0FDekMsT0FBTyxFQUFFLGdCQUFnQixFQUFFLEVBQzNCLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLFlBQVksRUFBRSxxQkFBcUIsRUFDbkMsaUJBQWlCLEVBQUUsV0FBVyxFQUM5QixvQkFBb0IsRUFBRSxXQUFXLEVBQ2pDLEtBQUssRUFBRSxNQUFNLEdBQ1osT0FBTyxDQUFDLFNBQVMsRUFBRSxDQUFDLENBcUR0QiJ9

package/dest/tagging/recipient_sync/sync_tagged_private_logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync_tagged_private_logs.d.ts","sourceRoot":"","sources":["../../../src/tagging/recipient_sync/sync_tagged_private_logs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAG9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wDAAwD,CAAC;AAKpG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,gBAAgB,EAAE,EAC3B,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,qBAAqB,EACnC,iBAAiB,EAAE,WAAW,EAC9B,oBAAoB,EAAE,WAAW,EACjC,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,SAAS,EAAE,CAAC,CAqDtB"}