@aztec/pxe 0.0.1-commit.321f6a9 → 0.0.1-commit.330febf

package/dest/storage/tagging_store/sender_tagging_store.js

@@ -1,6 +1,5 @@
 import { AppTaggingSecret, SiloedTag } from '@aztec/stdlib/logs';
-import { TxHash } from '@aztec/stdlib/tx';
-import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.js';
+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
@@ -152,11 +151,9 @@ import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.
                 })));
             // 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!`);
+                const windowEnd = unfinalizedTaggingIndexesWindowEnd(finalizedIndex);
+                if (range.highestIndex >= windowEnd) {
+                    throw windowExceededError(range.highestIndex, windowEnd, finalizedIndex);
                 }
                 // Throw if the lowest index is lower than or equal to the last finalized index
                 if (finalizedIndex !== undefined && range.lowestIndex <= finalizedIndex) {
@@ -201,19 +198,20 @@ import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.
         });
     }
     /**
-   * 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.
+   * 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.highestIndex >= startIndex && entry.highestIndex < 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
+                }));
         });
     }
     /**
@@ -319,13 +317,26 @@ 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.
-   */ async finalizePendingIndexes(txHashes, jobId) {
+   * 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);
+        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;
@@ -409,3 +420,7 @@ import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.
         }
     }
 }
+/** 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/tagging/constants.d.ts

@@ -1,3 +1,11 @@
 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGFnZ2luZy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBbUJBLGVBQU8sTUFBTSxzQ0FBc0MsUUFBK0IsQ0FBQztBQVVuRixlQUFPLE1BQU0sNkJBQTZCLElBQUksQ0FBQyJ9
+//# 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":"AAmBA,eAAO,MAAM,sCAAsC,QAA+B,CAAC;AAUnF,eAAO,MAAM,6BAA6B,IAAI,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"}

package/dest/tagging/constants.js

@@ -17,6 +17,16 @@ import { MAX_PRIVATE_LOGS_PER_TX } from '@aztec/constants';
 // 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;
+/**
+ * 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 function unfinalizedTaggingIndexesWindowEnd(finalizedIndex) {
+    const windowStart = finalizedIndex === undefined ? 0 : finalizedIndex + 1;
+    return windowStart + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN;
+}
 // 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

package/dest/tagging/get_all_logs_by_tags.d.ts

@@ -1,8 +1,29 @@
-import type { BlockNumber } from '@aztec/foundation/branded-types';
+import { 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';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+/**
+ * The block a tag query is anchored to.
+ *
+ * Both fields come from one header (see {@link logQueryAnchorOf}), which is what keeps the bound and the reorg check
+ * talking about the same block.
+ */
+export type LogQueryAnchor = {
+    /**
+     * Hash of the anchor block, naming the chain the query must be answered on: the node throws if that block is gone,
+     * which is how a reorg surfaces.
+     */
+    hash: BlockHash;
+    /** Height of the anchor block, bounding the query to blocks at or below it. */
+    number: BlockNumber;
+};
+/**
+ * The {@link LogQueryAnchor} naming `anchorBlockHeader`: its hash and its height. Callers build it once and reuse
+ * it across every query anchored to that block, so the header is hashed only once.
+ */
+export declare function logQueryAnchorOf(anchorBlockHeader: BlockHeader): Promise<LogQueryAnchor>;
 /** Optional block-range, effects opt-in, and pagination cap shared by both wrappers. */
 export type GetAllLogsByTagsOptions = {
     /** Lower block bound, inclusive. */
@@ -27,22 +48,22 @@ export type GetAllLogsByTagsOptions = {
  *
  * @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 anchor - Block the query is anchored to: results stop there, and the call throws if that block is not found
+ *   (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>[][]>;
+export declare function getAllPrivateLogsByTags<Opts extends GetAllLogsByTagsOptions = GetAllLogsByTagsOptions>(aztecNode: AztecNode, tags: SiloedTag[], anchor: LogQueryAnchor, 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 anchor - Block the query is anchored to: results stop there, and the call throws if that block is not found
+ *   (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==
+export declare function getAllPublicLogsByTagsFromContract<Opts extends GetAllLogsByTagsOptions = GetAllLogsByTagsOptions>(aztecNode: AztecNode, contractAddress: AztecAddress, tags: Tag[], anchor: LogQueryAnchor, options?: Opts): Promise<LogResult<Opts>[][]>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0X2FsbF9sb2dzX2J5X3RhZ3MuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90YWdnaW5nL2dldF9hbGxfbG9nc19ieV90YWdzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUM5RCxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVyRCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEVBRUwsS0FBSyxTQUFTLEVBQ2QsS0FBSyxTQUFTLEVBQ2QsS0FBSyxHQUFHLEVBR1QsTUFBTSxvQkFBb0IsQ0FBQztBQUM1QixPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUVwRDs7Ozs7R0FLRztBQUNILE1BQU0sTUFBTSxjQUFjLEdBQUc7SUFDM0I7OztPQUdHO0lBQ0gsSUFBSSxFQUFFLFNBQVMsQ0FBQztJQUNoQiwrRUFBK0U7SUFDL0UsTUFBTSxFQUFFLFdBQVcsQ0FBQztDQUNyQixDQUFDO0FBRUY7OztHQUdHO0FBQ0gsd0JBQXNCLGdCQUFnQixDQUFDLGlCQUFpQixFQUFFLFdBQVcsR0FBRyxPQUFPLENBQUMsY0FBYyxDQUFDLENBRTlGO0FBRUQsd0ZBQXdGO0FBQ3hGLE1BQU0sTUFBTSx1QkFBdUIsR0FBRztJQUNwQyxvQ0FBb0M7SUFDcEMsU0FBUyxDQUFDLEVBQUUsV0FBVyxDQUFDO0lBQ3hCLG9DQUFvQztJQUNwQyxPQUFPLENBQUMsRUFBRSxXQUFXLENBQUM7SUFDdEI7Ozs7T0FJRztJQUNILGNBQWMsQ0FBQyxFQUFFLE9BQU8sQ0FBQztJQUN6Qjs7OztPQUlHO0lBQ0gsV0FBVyxDQUFDLEVBQUUsTUFBTSxDQUFDO0NBQ3RCLENBQUM7QUEwQkY7Ozs7Ozs7OztHQVNHO0FBQ0gsd0JBQWdCLHVCQUF1QixDQUFDLElBQUksU0FBUyx1QkFBdUIsR0FBRyx1QkFBdUIsRUFDcEcsU0FBUyxFQUFFLFNBQVMsRUFDcEIsSUFBSSxFQUFFLFNBQVMsRUFBRSxFQUNqQixNQUFNLEVBQUUsY0FBYyxFQUN0QixPQUFPLEdBQUUsSUFBaUIsR0FDekIsT0FBTyxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FhOUI7QUFFRDs7Ozs7Ozs7OztHQVVHO0FBQ0gsd0JBQWdCLGtDQUFrQyxDQUFDLElBQUksU0FBUyx1QkFBdUIsR0FBRyx1QkFBdUIsRUFDL0csU0FBUyxFQUFFLFNBQVMsRUFDcEIsZUFBZSxFQUFFLFlBQVksRUFDN0IsSUFBSSxFQUFFLEdBQUcsRUFBRSxFQUNYLE1BQU0sRUFBRSxjQUFjLEVBQ3RCLE9BQU8sR0FBRSxJQUFpQixHQUN6QixPQUFPLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQWM5QiJ9

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

@@ -1 +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"}
+{"version":3,"file":"get_all_logs_by_tags.d.ts","sourceRoot":"","sources":["../../src/tagging/get_all_logs_by_tags.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,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;AAC5B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B;;;OAGG;IACH,IAAI,EAAE,SAAS,CAAC;IAChB,+EAA+E;IAC/E,MAAM,EAAE,WAAW,CAAC;CACrB,CAAC;AAEF;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,iBAAiB,EAAE,WAAW,GAAG,OAAO,CAAC,cAAc,CAAC,CAE9F;AAED,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,MAAM,EAAE,cAAc,EACtB,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,MAAM,EAAE,cAAc,EACtB,OAAO,GAAE,IAAiB,GACzB,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,CAc9B"}

package/dest/tagging/get_all_logs_by_tags.js

@@ -1,5 +1,15 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { MAX_RPC_LEN } from '@aztec/stdlib/interfaces/api-limit';
 import { queryAllPrivateLogsByTags, queryAllPublicLogsByTags } from '@aztec/stdlib/logs';
+/**
+ * The {@link LogQueryAnchor} naming `anchorBlockHeader`: its hash and its height. Callers build it once and reuse
+ * it across every query anchored to that block, so the header is hashed only once.
+ */ export async function logQueryAnchorOf(anchorBlockHeader) {
+    return {
+        hash: await anchorBlockHeader.hash(),
+        number: anchorBlockHeader.getBlockNumber()
+    };
+}
 /**
  * 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.
@@ -22,16 +32,16 @@ import { queryAllPrivateLogsByTags, queryAllPublicLogsByTags } from '@aztec/stdl
  *
  * @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 anchor - Block the query is anchored to: results stop there, and the call throws if that block is not found
+ *   (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 = {}) {
+ */ export function getAllPrivateLogsByTags(aztecNode, tags, anchor, options = {}) {
     return getAllPagesInBatches(tags, (batch)=>queryAllPrivateLogsByTags(aztecNode, {
             tags: batch,
-            referenceBlock: anchorBlockHash,
+            referenceBlock: anchor.hash,
             fromBlock: options.fromBlock,
-            toBlock: options.toBlock,
+            toBlock: exclusiveUpperBound(anchor, options.toBlock),
             includeEffects: options.includeEffects ?? false,
             limitPerTag: options.limitPerTag
         }));
@@ -42,18 +52,27 @@ import { queryAllPrivateLogsByTags, queryAllPublicLogsByTags } from '@aztec/stdl
  * @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 anchor - Block the query is anchored to: results stop there, and the call throws if that block is not found
+ *   (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 = {}) {
+ */ export function getAllPublicLogsByTagsFromContract(aztecNode, contractAddress, tags, anchor, options = {}) {
     return getAllPagesInBatches(tags, (batch)=>queryAllPublicLogsByTags(aztecNode, {
             contractAddress,
             tags: batch,
-            referenceBlock: anchorBlockHash,
+            referenceBlock: anchor.hash,
             fromBlock: options.fromBlock,
-            toBlock: options.toBlock,
+            toBlock: exclusiveUpperBound(anchor, options.toBlock),
             includeEffects: options.includeEffects ?? false,
             limitPerTag: options.limitPerTag
         }));
 }
+/**
+ * Exclusive upper block bound for a query anchored at `anchor`: one past the anchor block, or the caller's own
+ * `toBlock` when that is tighter.
+ *
+ * The bound is spelled out in the request rather than left implicit in `referenceBlock`, so the request itself
+ * names a fixed block range that no later block can widen.
+ */ function exclusiveUpperBound(anchor, toBlock) {
+    return BlockNumber(Math.min(toBlock ?? Infinity, anchor.number + 1));
+}

package/dest/tagging/index.d.ts

@@ -12,7 +12,7 @@ export { syncTaggedPrivateLogs } from './recipient_sync/sync_tagged_private_logs
 export { syncSenderTaggingIndexes } from './sender_sync/sync_sender_tagging_indexes.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';
+export { type LogQueryAnchor, getAllPrivateLogsByTags, getAllPublicLogsByTagsFromContract, logQueryAnchorOf, } 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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90YWdnaW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7R0FTRztBQUVILE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBQ3JGLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBQ3hGLE9BQU8sRUFBRSxvQ0FBb0MsRUFBRSxNQUFNLDBDQUEwQyxDQUFDO0FBQ2hHLE9BQU8sRUFBRSxzQ0FBc0MsRUFBRSw2QkFBNkIsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3ZHLE9BQU8sRUFDTCxLQUFLLGNBQWMsRUFDbkIsdUJBQXVCLEVBQ3ZCLGtDQUFrQyxFQUNsQyxnQkFBZ0IsR0FDakIsTUFBTSwyQkFBMkIsQ0FBQztBQUduQyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsR0FBRyxFQUFFLFNBQVMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3RFLE9BQU8sRUFBRSxLQUFLLE1BQU0sRUFBRSxLQUFLLGlCQUFpQixFQUFFLE1BQU0sb0JBQW9CLENBQUMifQ==

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,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"}
+{"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,EACL,KAAK,cAAc,EACnB,uBAAuB,EACvB,kCAAkC,EAClC,gBAAgB,GACjB,MAAM,2BAA2B,CAAC;AAGnC,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

@@ -11,6 +11,6 @@
 export { syncSenderTaggingIndexes } from './sender_sync/sync_sender_tagging_indexes.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';
+export { getAllPrivateLogsByTags, getAllPublicLogsByTagsFromContract, logQueryAnchorOf } from './get_all_logs_by_tags.js';
 // Re-export tagging-related types from stdlib
 export { AppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';

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

@@ -1,4 +1,4 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
+import type { 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';
@@ -71,4 +71,4 @@ import type { RecipientTaggingStore } from '../../storage/tagging_store/recipien
  * 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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luY190YWdnZWRfcHJpdmF0ZV9sb2dzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGFnZ2luZy9yZWNpcGllbnRfc3luYy9zeW5jX3RhZ2dlZF9wcml2YXRlX2xvZ3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFbkUsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDakUsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFdEUsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFcEQsT0FBTyxLQUFLLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx3REFBd0QsQ0FBQztBQVNwRzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBa0VHO0FBQ0gsd0JBQXNCLHFCQUFxQixDQUN6QyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsRUFDM0IsU0FBUyxFQUFFLFNBQVMsRUFDcEIsWUFBWSxFQUFFLHFCQUFxQixFQUNuQyxpQkFBaUIsRUFBRSxXQUFXLEVBQzlCLG9CQUFvQixFQUFFLFdBQVcsRUFDakMsS0FBSyxFQUFFLE1BQU0sR0FDWixPQUFPLENBQUMsU0FBUyxFQUFFLENBQUMsQ0FvRHRCIn0=

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

@@ -1 +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"}
+{"version":3,"file":"sync_tagged_private_logs.d.ts","sourceRoot":"","sources":["../../../src/tagging/recipient_sync/sync_tagged_private_logs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAEnE,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;AASpG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,CAoDtB"}

package/dest/tagging/recipient_sync/sync_tagged_private_logs.js

@@ -1,8 +1,7 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
 import { isDefined } from '@aztec/foundation/types';
 import { AppTaggingSecretKind, SiloedTag } from '@aztec/stdlib/logs';
-import { INITIAL_CONSTRAINED_PROBE_LEN, UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
-import { getAllPrivateLogsByTags } from '../get_all_logs_by_tags.js';
+import { INITIAL_CONSTRAINED_PROBE_LEN, UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN, unfinalizedTaggingIndexesWindowEnd } from '../constants.js';
+import { getAllPrivateLogsByTags, logQueryAnchorOf } from '../get_all_logs_by_tags.js';
 import { findHighestIndexes } from './utils/find_highest_indexes.js';
 /**
  * Fetches and syncs tagged private logs for multiple sender-recipient pairs, batching tag queries across all secrets
@@ -74,15 +73,14 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
     if (secrets.length === 0) {
         return [];
     }
-    const anchorBlockNumber = anchorBlockHeader.getBlockNumber();
-    const anchorBlockHash = await anchorBlockHeader.hash();
+    const anchor = await logQueryAnchorOf(anchorBlockHeader);
     const currentTimestamp = anchorBlockHeader.globalVariables.timestamp;
     // Read stored indexes from the db and compute the initial [start, end) range for each secret
     let pending = await getIndexRangesForSecrets(secrets, taggingStore, jobId);
     const allLogs = [];
     while(pending.length > 0){
         // Compute tags for all pending secrets and fetch logs in batched RPC calls
-        const logsPerSecret = await fetchLogsForSecrets(pending, aztecNode, anchorBlockNumber, anchorBlockHash);
+        const logsPerSecret = await fetchLogsForSecrets(pending, aztecNode, anchor);
         const nextRound = await Promise.all(pending.map(async (pendingSecret, i)=>{
             const logsFoundWithSecret = logsPerSecret[i];
             if (logsFoundWithSecret.length === 0) {
@@ -101,7 +99,7 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
 /** Reads stored indexes for each secret and computes the initial index range to query. */ function getIndexRangesForSecrets(secrets, taggingStore, jobId) {
     return Promise.all(secrets.map(async (secret)=>{
         const currentHighestFinalizedIndex = await taggingStore.getHighestFinalizedIndex(secret, jobId);
-        const boundEnd = (currentHighestFinalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
+        const boundEnd = unfinalizedTaggingIndexesWindowEnd(currentHighestFinalizedIndex);
         if (secret.kind === AppTaggingSecretKind.CONSTRAINED) {
             // Constrained streams are gapless and resume at the finalized index, so probe a small initial window and stop
             // at the first missing tag instead of always fetching the full window. The probe grows each round up to the
@@ -130,7 +128,7 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
 /**
  * Computes siloed tags for all pending secrets' index ranges, fetches logs in one batched RPC call,
  * and returns the results grouped back per secret.
- */ async function fetchLogsForSecrets(pending, aztecNode, anchorBlockNumber, anchorBlockHash) {
+ */ async function fetchLogsForSecrets(pending, aztecNode, anchor) {
     // Determine the index range for each secret
     const indexesPerSecret = pending.map(({ start, end })=>Array.from({
             length: end - start
@@ -141,13 +139,11 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
                 index
             })))));
     const allTags = tagsPerSecret.flat();
-    // getAllPrivateLogsByTags handles MAX_RPC_LEN chunking internally. Recipient sync builds `PendingTaggedLog` from
-    // each log's note hashes and first nullifier, so we opt into effects. The `toBlock` cap (anchor block + 1,
-    // exclusive) tells the node to skip any logs in blocks past the anchor — the same guard previously enforced
-    // by an in-memory filter on the response.
-    const allResults = await getAllPrivateLogsByTags(aztecNode, allTags, anchorBlockHash, {
-        includeEffects: true,
-        toBlock: BlockNumber(anchorBlockNumber + 1)
+    // getAllPrivateLogsByTags handles MAX_RPC_LEN chunking internally, and bounds the query at the anchor block so
+    // logs from later blocks are never returned. Recipient sync builds `PendingTaggedLog` from each log's note hashes
+    // and first nullifier, so we opt into effects.
+    const allResults = await getAllPrivateLogsByTags(aztecNode, allTags, anchor, {
+        includeEffects: true
     });
     // Split flat results back per secret using the known lengths
     const logsPerSecret = [];
@@ -190,7 +186,7 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
     // Gating this on finalization would drop logs in unfinalized blocks, which sit at the top of the contiguous run.
     // The bound re-anchors to any finalized index found this round.
     const probeFullyConsumed = firstMissingIndex >= pending.end;
-    const boundEnd = highestFinalizedIndex !== undefined ? Math.max(pending.boundEnd, highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1) : pending.boundEnd;
+    const boundEnd = highestFinalizedIndex !== undefined ? Math.max(pending.boundEnd, unfinalizedTaggingIndexesWindowEnd(highestFinalizedIndex)) : pending.boundEnd;
     // Double the probe each round, capped at the window (see INITIAL_CONSTRAINED_PROBE_LEN in ../constants.ts).
     // The queried range is already bounded by boundEnd (a probe can never reach
     // more than WINDOW_LEN past the finalized frontier); this cap just keeps the stored length from growing unbounded
@@ -228,7 +224,7 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
     await taggingStore.updateHighestFinalizedIndex(pending.secret, highestFinalizedIndex, jobId);
     // For the next iteration we want to look only at indexes for which we have not yet fetched logs while
     // ensuring that we do not look further than WINDOW_LEN ahead of the highest finalized index.
-    const end = highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
+    const end = unfinalizedTaggingIndexesWindowEnd(highestFinalizedIndex);
     return {
         kind: AppTaggingSecretKind.UNCONSTRAINED,
         secret: pending.secret,

package/dest/tagging/sender_sync/sync_sender_tagging_indexes.d.ts

@@ -1,16 +1,19 @@
-import type { BlockHash } from '@aztec/stdlib/block';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
 import type { AppTaggingSecret } from '@aztec/stdlib/logs';
 import type { SenderTaggingStore } from '../../storage/tagging_store/sender_tagging_store.js';
+import type { LogQueryAnchor } from '../get_all_logs_by_tags.js';
 /**
  * Syncs tagging indexes. This function needs to be called whenever a private log is being sent.
  *
  * @param secret - The sender-side tagging `AppTaggingSecret`.
+ * @param finalizedBlockNumber - The locally-synced finalized tip, used to tell whether the block a discovered log
+ * sits in is finalized.
  * @remarks When syncing the indexes as sender we don't care about the log contents - we only care about the highest
  * pending and highest finalized indexes as that guides the next index choice when sending a log. The next index choice
  * is simply the highest pending index plus one (or finalized if pending is undefined).
  * @dev This function looks for new indexes, adds them to pending, then it checks status of each pending index and
  * updates its status accordingly.
  */
-export declare function syncSenderTaggingIndexes(secret: AppTaggingSecret, aztecNode: AztecNode, taggingStore: SenderTaggingStore, anchorBlockHash: BlockHash, jobId: string): Promise<void>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luY19zZW5kZXJfdGFnZ2luZ19pbmRleGVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGFnZ2luZy9zZW5kZXJfc3luYy9zeW5jX3NlbmRlcl90YWdnaW5nX2luZGV4ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDckQsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDakUsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUUzRCxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHFEQUFxRCxDQUFDO0FBUzlGOzs7Ozs7Ozs7R0FTRztBQUNILHdCQUFzQix3QkFBd0IsQ0FDNUMsTUFBTSxFQUFFLGdCQUFnQixFQUN4QixTQUFTLEVBQUUsU0FBUyxFQUNwQixZQUFZLEVBQUUsa0JBQWtCLEVBQ2hDLGVBQWUsRUFBRSxTQUFTLEVBQzFCLEtBQUssRUFBRSxNQUFNLEdBQ1osT0FBTyxDQUFDLElBQUksQ0FBQyxDQXdHZiJ9
+export declare function syncSenderTaggingIndexes(secret: AppTaggingSecret, aztecNode: AztecNode, taggingStore: SenderTaggingStore, finalizedBlockNumber: BlockNumber, anchor: LogQueryAnchor, jobId: string): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luY19zZW5kZXJfdGFnZ2luZ19pbmRleGVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGFnZ2luZy9zZW5kZXJfc3luYy9zeW5jX3NlbmRlcl90YWdnaW5nX2luZGV4ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDbkUsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDakUsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUUzRCxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHFEQUFxRCxDQUFDO0FBRTlGLE9BQU8sS0FBSyxFQUFFLGNBQWMsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBSWpFOzs7Ozs7Ozs7OztHQVdHO0FBQ0gsd0JBQXNCLHdCQUF3QixDQUM1QyxNQUFNLEVBQUUsZ0JBQWdCLEVBQ3hCLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLFlBQVksRUFBRSxrQkFBa0IsRUFDaEMsb0JBQW9CLEVBQUUsV0FBVyxFQUNqQyxNQUFNLEVBQUUsY0FBYyxFQUN0QixLQUFLLEVBQUUsTUFBTSxHQUNaLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0EwRWYifQ==

package/dest/tagging/sender_sync/sync_sender_tagging_indexes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sync_sender_tagging_indexes.d.ts","sourceRoot":"","sources":["../../../src/tagging/sender_sync/sync_sender_tagging_indexes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qDAAqD,CAAC;AAS9F;;;;;;;;;GASG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,gBAAgB,EACxB,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,kBAAkB,EAChC,eAAe,EAAE,SAAS,EAC1B,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAwGf"}
+{"version":3,"file":"sync_sender_tagging_indexes.d.ts","sourceRoot":"","sources":["../../../src/tagging/sender_sync/sync_sender_tagging_indexes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qDAAqD,CAAC;AAE9F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAIjE;;;;;;;;;;;GAWG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,gBAAgB,EACxB,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,kBAAkB,EAChC,oBAAoB,EAAE,WAAW,EACjC,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CA0Ef"}

package/dest/tagging/sender_sync/sync_sender_tagging_indexes.js

@@ -1,16 +1,18 @@
-import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
-import { EMPTY_STATUS_CHANGE, getStatusChangeOfPending, mergeStatusChanges } from './utils/get_status_change_of_pending.js';
+import { unfinalizedTaggingIndexesWindowEnd } from '../constants.js';
 import { loadAndStoreNewTaggingIndexes } from './utils/load_and_store_new_tagging_indexes.js';
+import { resolvePendingTxs } from './utils/resolve_pending_txs.js';
 /**
  * Syncs tagging indexes. This function needs to be called whenever a private log is being sent.
  *
  * @param secret - The sender-side tagging `AppTaggingSecret`.
+ * @param finalizedBlockNumber - The locally-synced finalized tip, used to tell whether the block a discovered log
+ * sits in is finalized.
  * @remarks When syncing the indexes as sender we don't care about the log contents - we only care about the highest
  * pending and highest finalized indexes as that guides the next index choice when sending a log. The next index choice
  * is simply the highest pending index plus one (or finalized if pending is undefined).
  * @dev This function looks for new indexes, adds them to pending, then it checks status of each pending index and
  * updates its status accordingly.
- */ export async function syncSenderTaggingIndexes(secret, aztecNode, taggingStore, anchorBlockHash, jobId) {
+ */ export async function syncSenderTaggingIndexes(secret, aztecNode, taggingStore, finalizedBlockNumber, anchor, jobId) {
     // # Explanation of how syncing works
     //
     // When choosing an index, we select: highest pending index + 1 (or highest finalized index + 1 if no pending).
@@ -26,46 +28,30 @@ import { loadAndStoreNewTaggingIndexes } from './utils/load_and_store_new_taggin
     // than WINDOW_LEN from the highest finalized index.
     //
     // # Note on performance
-    // Each window advance requires two queries (logs + tx status). For example, syncing indexes 0–500 with a window of
-    // 100 takes at least 10 round trips (5 windows × 2 queries).
+    // A window advance usually takes a single logs query: the finalization status of most txs the logs surface is
+    // derived from the log block numbers and the locally-synced finalized tip, without a per-tx node call. See
+    // `resolvePendingTxs` for the txs that the logs cannot settle and what they cost.
     const finalizedIndex = await taggingStore.getLastFinalizedIndex(secret, jobId);
     let start = finalizedIndex === undefined ? 0 : finalizedIndex + 1;
-    let end = start + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN;
+    // The loop only extends the window when the finalized index moves,
+    // so this first window must cover the entire permitted range on its own.
+    let end = unfinalizedTaggingIndexesWindowEnd(finalizedIndex);
     let previousFinalizedIndex = finalizedIndex;
     let newFinalizedIndex = undefined;
     while(true){
-        // Pending tx hashes already in the store for this window (from prior syncs or txs this PXE itself sent).
-        // Reading these before issuing any RPC lets us fetch their receipts in parallel with the logs query below.
-        const knownPendingTxHashes = await taggingStore.getTxHashesOfPendingIndexes(secret, start, end, jobId);
-        // Fire the logs query and the known-pending receipts query in parallel
-        const [, statusOfKnown] = await Promise.all([
-            loadAndStoreNewTaggingIndexes(secret, start, end, aztecNode, taggingStore, anchorBlockHash, jobId),
-            knownPendingTxHashes.length > 0 ? getStatusChangeOfPending(knownPendingTxHashes, aztecNode) : Promise.resolve(EMPTY_STATUS_CHANGE)
-        ]);
-        // Re-read pending tx hashes after the logs query writes any newly-discovered ones to the store.
-        const allPendingTxHashes = await taggingStore.getTxHashesOfPendingIndexes(secret, start, end, jobId);
-        if (allPendingTxHashes.length === 0) {
+        const txsInLogs = await loadAndStoreNewTaggingIndexes(secret, start, end, aztecNode, taggingStore, anchor, jobId);
+        // Pending txs for this window: prior syncs, txs this PXE itself sent, and what the logs just stored.
+        const pendingTxs = await taggingStore.getPendingTxs(secret, start, end, jobId);
+        if (pendingTxs.length === 0) {
             break;
         }
-        // Receipts for pending tx hashes that the logs query just surfaced still need a sequential follow-up call.
-        // `mergePendingIndexes` is idempotent on (secret, txHash), so a re-discovered hash stays classified as known
-        // and is not re-fetched here.
-        const knownSet = new Set(knownPendingTxHashes.map((h)=>h.toString()));
-        const newPendingTxHashes = allPendingTxHashes.filter((h)=>!knownSet.has(h.toString()));
-        const statusOfNew = newPendingTxHashes.length > 0 ? await getStatusChangeOfPending(newPendingTxHashes, aztecNode) : EMPTY_STATUS_CHANGE;
-        const { txHashesToFinalize, txHashesToDrop, txHashesWithExecutionReverted } = mergeStatusChanges(statusOfKnown, statusOfNew);
-        await taggingStore.dropPendingIndexes(txHashesToDrop, jobId);
-        await taggingStore.finalizePendingIndexes(txHashesToFinalize, jobId);
-        if (txHashesWithExecutionReverted.length > 0) {
-            const receipts = await Promise.all(txHashesWithExecutionReverted.map((txHash)=>aztecNode.getTxReceipt(txHash, {
-                    includeTxEffect: true
-                })));
-            for (const receipt of receipts){
-                if (!receipt.isMined() || !receipt.txEffect) {
-                    throw new Error('TxEffect not found for execution-reverted tx. This is either a bug or a reorg has occurred.');
-                }
-                await taggingStore.finalizePendingIndexesOfAPartiallyRevertedTx(receipt.txEffect, jobId);
-            }
+        const { txHashesFinalizedFromLogs, txHashesFinalizedFromReceipts, txHashesDropped, receiptsWithExecutionReverted } = await resolvePendingTxs(pendingTxs, txsInLogs, finalizedBlockNumber, aztecNode);
+        await taggingStore.dropPendingIndexes(txHashesDropped, jobId);
+        // The logs are queried per secret, so they only evidence this one's indexes. A receipt covers the whole tx.
+        await taggingStore.finalizePendingIndexesOfSecret(secret, txHashesFinalizedFromLogs, jobId);
+        await taggingStore.finalizePendingIndexes(txHashesFinalizedFromReceipts, jobId);
+        for (const receipt of receiptsWithExecutionReverted){
+            await taggingStore.finalizePendingIndexesOfAPartiallyRevertedTx(receipt.txEffect, jobId);
         }
         // We check if the finalized index has been updated.
         newFinalizedIndex = await taggingStore.getLastFinalizedIndex(secret, jobId);
@@ -81,8 +67,7 @@ import { loadAndStoreNewTaggingIndexes } from './utils/load_and_store_new_taggin
             //    Previous window: [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
             //    New window:                                             [21, 22, 23]
             const previousEnd = end;
-            // Add 1 because `end` is exclusive and the known finalized index is not included in the window.
-            end = newFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
+            end = unfinalizedTaggingIndexesWindowEnd(newFinalizedIndex);
             start = previousEnd;
             previousFinalizedIndex = newFinalizedIndex;
         } else {

package/dest/tagging/sender_sync/utils/classify_pending_txs.d.ts

@@ -0,0 +1,22 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import { TxHash } from '@aztec/stdlib/tx';
+import type { PendingTx } from '../../../storage/tagging_store/sender_tagging_store.js';
+import type { TxInLogs } from './load_and_store_new_tagging_indexes.js';
+/** A sync window's pending txs, grouped by what the window's logs evidence about each of them. */
+export type LogClassification = {
+    txHashesFinalized: TxHash[];
+    txHashesWithExecutionReverted: TxHash[];
+    txHashesAbsent: TxHash[];
+};
+/** Groups a window's pending txs by what its logs say about them. */
+export declare function classifyPendingTxsFromLogs(pendingTxs: PendingTx[], txsInLogs: Map<string, TxInLogs>, finalizedBlockNumber: BlockNumber): LogClassification;
+/** A batch of pending txs grouped by what their receipts report about them. */
+export type ReceiptClassification = {
+    txHashesFinalized: TxHash[];
+    txHashesDropped: TxHash[];
+    txHashesWithExecutionReverted: TxHash[];
+};
+/** Groups pending txs by what their receipts say, for the txs the logs could not resolve. */
+export declare function classifyPendingTxsFromReceipts(pending: TxHash[], aztecNode: AztecNode): Promise<ReceiptClassification>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3NpZnlfcGVuZGluZ190eHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy90YWdnaW5nL3NlbmRlcl9zeW5jL3V0aWxzL2NsYXNzaWZ5X3BlbmRpbmdfdHhzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ25FLE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2pFLE9BQU8sRUFBRSxNQUFNLEVBQVksTUFBTSxrQkFBa0IsQ0FBQztBQUVwRCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSx3REFBd0QsQ0FBQztBQUN4RixPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSx5Q0FBeUMsQ0FBQztBQUV4RSxrR0FBa0c7QUFDbEcsTUFBTSxNQUFNLGlCQUFpQixHQUFHO0lBQzlCLGlCQUFpQixFQUFFLE1BQU0sRUFBRSxDQUFDO0lBQzVCLDZCQUE2QixFQUFFLE1BQU0sRUFBRSxDQUFDO0lBQ3hDLGNBQWMsRUFBRSxNQUFNLEVBQUUsQ0FBQztDQUMxQixDQUFDO0FBRUYscUVBQXFFO0FBQ3JFLHdCQUFnQiwwQkFBMEIsQ0FDeEMsVUFBVSxFQUFFLFNBQVMsRUFBRSxFQUN2QixTQUFTLEVBQUUsR0FBRyxDQUFDLE1BQU0sRUFBRSxRQUFRLENBQUMsRUFDaEMsb0JBQW9CLEVBQUUsV0FBVyxHQUNoQyxpQkFBaUIsQ0FzQm5CO0FBRUQsK0VBQStFO0FBQy9FLE1BQU0sTUFBTSxxQkFBcUIsR0FBRztJQUNsQyxpQkFBaUIsRUFBRSxNQUFNLEVBQUUsQ0FBQztJQUM1QixlQUFlLEVBQUUsTUFBTSxFQUFFLENBQUM7SUFDMUIsNkJBQTZCLEVBQUUsTUFBTSxFQUFFLENBQUM7Q0FDekMsQ0FBQztBQUVGLDZGQUE2RjtBQUM3Rix3QkFBc0IsOEJBQThCLENBQ2xELE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFDakIsU0FBUyxFQUFFLFNBQVMsR0FDbkIsT0FBTyxDQUFDLHFCQUFxQixDQUFDLENBb0NoQyJ9

package/dest/tagging/sender_sync/utils/classify_pending_txs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify_pending_txs.d.ts","sourceRoot":"","sources":["../../../../src/tagging/sender_sync/utils/classify_pending_txs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,MAAM,EAAY,MAAM,kBAAkB,CAAC;AAEpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wDAAwD,CAAC;AACxF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yCAAyC,CAAC;AAExE,kGAAkG;AAClG,MAAM,MAAM,iBAAiB,GAAG;IAC9B,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,6BAA6B,EAAE,MAAM,EAAE,CAAC;IACxC,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AAEF,qEAAqE;AACrE,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,SAAS,EAAE,EACvB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,EAChC,oBAAoB,EAAE,WAAW,GAChC,iBAAiB,CAsBnB;AAED,+EAA+E;AAC/E,MAAM,MAAM,qBAAqB,GAAG;IAClC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,6BAA6B,EAAE,MAAM,EAAE,CAAC;CACzC,CAAC;AAEF,6FAA6F;AAC7F,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,MAAM,EAAE,EACjB,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC,qBAAqB,CAAC,CAoChC"}