@aztec/pxe 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/dest/tagging/recipient_sync/sync_tagged_private_logs.js

@@ -1,16 +1,16 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
 import { isDefined } from '@aztec/foundation/types';
-import { SiloedTag } from '@aztec/stdlib/logs';
-import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
-import { getAllPrivateLogsByTags } from '../get_all_logs_by_tags.js';
+import { AppTaggingSecretKind, SiloedTag } from '@aztec/stdlib/logs';
+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
- * into shared RPC calls.
+ * into shared RPC calls. Handles both constrained and unconstrained secrets, which differ in their scan strategy
+ * but share the same batching infrastructure.
  *
- * # Explanation of how the algorithm works
+ * # Unconstrained secrets
  *
- * For each secret we sync logs that correspond to the tagging index range
+ * 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
@@ -47,24 +47,40 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
  * 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`.
  *
- * ## Batching across secrets
+ * # Constrained secrets
  *
- * Instead of running one RPC call per secret, we merge tags from all pending secrets 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.
+ * 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 async function syncTaggedPrivateLogs(secrets, aztecNode, taggingStore, anchorBlockHeader, finalizedBlockNumber, jobId) {
     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) {
@@ -74,7 +90,7 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
             allLogs.push(...logsFoundWithSecret.map(({ log })=>log));
             // Persist new indexes. If the finalized index moved forward, the window advances
             // and we need another round for this secret.
-            return await updateIndexesAndAdvanceWindow(pendingSecret, logsFoundWithSecret, taggingStore, currentTimestamp, finalizedBlockNumber, jobId);
+            return pendingSecret.kind === AppTaggingSecretKind.CONSTRAINED ? await processConstrainedResults(pendingSecret, logsFoundWithSecret, taggingStore, currentTimestamp, finalizedBlockNumber, jobId) : await processUnconstrainedResults(pendingSecret, logsFoundWithSecret, taggingStore, currentTimestamp, finalizedBlockNumber, jobId);
         }));
         pending = nextRound.filter(isDefined);
     }
@@ -82,23 +98,37 @@ 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 [currentHighestAgedIndex, currentHighestFinalizedIndex] = await Promise.all([
-            taggingStore.getHighestAgedIndex(secret, jobId),
-            taggingStore.getHighestFinalizedIndex(secret, jobId)
-        ]);
-        const start = currentHighestAgedIndex === undefined ? 0 : currentHighestAgedIndex + 1;
-        const end = (currentHighestFinalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
+        const currentHighestFinalizedIndex = await taggingStore.getHighestFinalizedIndex(secret, jobId);
+        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
+            // window cap.
+            const start = currentHighestFinalizedIndex === undefined ? 0 : currentHighestFinalizedIndex + 1;
+            return {
+                kind: AppTaggingSecretKind.CONSTRAINED,
+                secret,
+                start,
+                end: Math.min(boundEnd, start + INITIAL_CONSTRAINED_PROBE_LEN),
+                boundEnd,
+                probeLen: INITIAL_CONSTRAINED_PROBE_LEN
+            };
+        }
+        // Unconstrained secrets can have gaps, so they scan the whole window starting past the highest aged index.
+        const highestAgedIndex = await taggingStore.getHighestAgedIndex(secret, jobId);
+        const start = highestAgedIndex === undefined ? 0 : highestAgedIndex + 1;
         return {
+            kind: AppTaggingSecretKind.UNCONSTRAINED,
             secret,
             start,
-            end
+            end: boundEnd
         };
     }));
 }
 /**
  * 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
@@ -109,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 = [];
@@ -136,9 +164,50 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
     return logsPerSecret;
 }
 /**
- * Processes a single secret's fetched logs: updates stored indexes and returns a new PendingSecret
+ * Processes fetched logs for a constrained secret: persists the finalized index and advances the probe. See the
+ * "# Constrained secrets" section above for why the scan stops at the first missing index. Only `highestFinalizedIndex`
+ * is tracked (no aged index).
+ */ async function processConstrainedResults(pending, logsWithIndexes, taggingStore, currentTimestamp, finalizedBlockNumber, jobId) {
+    // Find where the contiguous run of indexes ends; all logs in the batch fall within this prefix.
+    const indexesWithLogs = new Set(logsWithIndexes.map((l)=>l.taggingIndex));
+    let firstMissingIndex = pending.start;
+    while(firstMissingIndex < pending.end && indexesWithLogs.has(firstMissingIndex)){
+        firstMissingIndex++;
+    }
+    // Persist the highest finalized index found. The nullifier for a constrained-delivery log is emitted in the same
+    // transaction, guaranteeing the log cannot disappear once included, so we persist even when a gap stops the scan.
+    // This lets the next sync round skip already-finalized indexes.
+    const { highestFinalizedIndex } = findHighestIndexes(logsWithIndexes, currentTimestamp, finalizedBlockNumber);
+    if (highestFinalizedIndex !== undefined) {
+        await taggingStore.updateHighestFinalizedIndex(pending.secret, highestFinalizedIndex, jobId);
+    }
+    // Advancing the probe is decoupled from persisting the finalized index: keep scanning as long as the probe was
+    // entirely hits (no gap) and there is room before the protocol bound, even if none of those hits is finalized yet.
+    // 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, 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
+    // once the probe saturates the window.
+    const nextProbeLen = Math.min(pending.probeLen * 2, UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN);
+    if (probeFullyConsumed && pending.end < boundEnd) {
+        return {
+            kind: AppTaggingSecretKind.CONSTRAINED,
+            secret: pending.secret,
+            start: pending.end,
+            end: Math.min(boundEnd, pending.end + nextProbeLen),
+            boundEnd,
+            probeLen: nextProbeLen
+        };
+    }
+    return undefined;
+}
+/**
+ * Processes a single unconstrained secret's fetched logs: updates stored indexes and returns a new PendingSecret
  * if the window needs to advance, or undefined if this secret is done.
- */ async function updateIndexesAndAdvanceWindow(pending, logsWithIndexes, taggingStore, currentTimestamp, finalizedBlockNumber, jobId) {
+ */ async function processUnconstrainedResults(pending, logsWithIndexes, taggingStore, currentTimestamp, finalizedBlockNumber, jobId) {
     const { highestAgedIndex, highestFinalizedIndex } = findHighestIndexes(logsWithIndexes, currentTimestamp, finalizedBlockNumber);
     // Store updates in data provider and update local variables
     if (highestAgedIndex !== undefined) {
@@ -155,9 +224,11 @@ 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 = unfinalizedTaggingIndexesWindowEnd(highestFinalizedIndex);
     return {
+        kind: AppTaggingSecretKind.UNCONSTRAINED,
         secret: pending.secret,
         start: pending.end,
-        end: highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1
+        end
     };
 }

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,44 +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.
-        // `storePendingIndexes` 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 indexedTxEffects = await Promise.all(txHashesWithExecutionReverted.map((txHash)=>aztecNode.getTxEffect(txHash)));
-            for (const indexedTxEffect of indexedTxEffects){
-                if (indexedTxEffect === undefined) {
-                    throw new Error('TxEffect not found for execution-reverted tx. This is either a bug or a reorg has occurred.');
-                }
-                await taggingStore.finalizePendingIndexesOfAPartiallyRevertedTx(indexedTxEffect.data, 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);
@@ -79,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"}

package/dest/tagging/sender_sync/utils/classify_pending_txs.js

@@ -0,0 +1,61 @@
+import { TxHash, TxStatus } from '@aztec/stdlib/tx';
+/** Groups a window's pending txs by what its logs say about them. */ export function classifyPendingTxsFromLogs(pendingTxs, txsInLogs, finalizedBlockNumber) {
+    const txHashesFinalized = [];
+    const txHashesWithExecutionReverted = [];
+    const txHashesAbsent = [];
+    for (const pendingTx of pendingTxs){
+        const txHash = TxHash.fromString(pendingTx.txHash);
+        const txInLogs = txsInLogs.get(pendingTx.txHash);
+        if (!txInLogs) {
+            txHashesAbsent.push(txHash);
+        } else if (txInLogs.blockNumber > finalizedBlockNumber) {
+        // A tx in the logs is mined in the log's block, so it is finalized exactly when that block is at or below the
+        // finalized tip. This one is not, so it belongs to no group until the tip catches up.
+        } else if (txInLogs.taggingIndexes.includes(pendingTx.highestIndex)) {
+            txHashesFinalized.push(txHash);
+        } else {
+            // A partially reverted tx: the revert dropped the logs carrying its higher indexes.
+            txHashesWithExecutionReverted.push(txHash);
+        }
+    }
+    return {
+        txHashesFinalized,
+        txHashesWithExecutionReverted,
+        txHashesAbsent
+    };
+}
+/** Groups pending txs by what their receipts say, for the txs the logs could not resolve. */ export async function classifyPendingTxsFromReceipts(pending, aztecNode) {
+    const receipts = await Promise.all(pending.map((pendingTxHash)=>aztecNode.getTxReceipt(pendingTxHash)));
+    const txHashesFinalized = [];
+    const txHashesDropped = [];
+    const txHashesWithExecutionReverted = [];
+    for(let i = 0; i < receipts.length; i++){
+        const receipt = receipts[i];
+        const txHash = pending[i];
+        if (receipt.status === TxStatus.FINALIZED) {
+            // Tx has been included in a block and the corresponding block is finalized
+            if (receipt.hasExecutionSucceeded()) {
+                // No part of execution reverted - we just finalize all the indexes.
+                txHashesFinalized.push(txHash);
+            } else if (receipt.hasExecutionReverted()) {
+                // Tx was mined but execution reverted (app logic, teardown, or both). Some logs from the non-revertible
+                // phase may still be onchain. We check which tags made it onchain and finalize those; drop the rest.
+                txHashesWithExecutionReverted.push(txHash);
+            } else {
+                // Defensive check - this branch should never be triggered
+                throw new Error('Both hasExecutionSucceeded and hasExecutionReverted on the receipt returned false. This should never happen and it implies a bug. Please open an issue.');
+            }
+        } else if (receipt.isDropped()) {
+            // Tx was dropped from the mempool --> we drop the corresponding pending indexes.
+            txHashesDropped.push(txHash);
+        } else {
+        // Tx is still pending, not yet finalized, or was mined successfully but not yet finalized --> we don't do
+        // anything.
+        }
+    }
+    return {
+        txHashesFinalized,
+        txHashesDropped,
+        txHashesWithExecutionReverted
+    };
+}

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

@@ -1,9 +1,12 @@
-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';
 /**
- * Loads tagging indexes from the Aztec node and stores them in the tagging data provider.
+ * Loads tagging indexes from the Aztec node and stores them in the tagging data provider. Returns the txs the
+ * window's logs carried, keyed by tx hash string, with the block each was mined in and the window indexes it used,
+ * so the caller can classify their finalization status without further node queries.
  * @remarks This function is one of two places by which a pending index can get to the tagging data provider. The other
  * place is when a tx is being sent from this PXE.
  * @param extendedSecret - The app tagging secret whose indexes are being synced.
@@ -11,9 +14,16 @@ import type { SenderTaggingStore } from '../../../storage/tagging_store/sender_t
  * @param end - The ending index (exclusive) of the window to process.
  * @param aztecNode - The Aztec node instance to query for logs.
  * @param taggingStore - The data provider to store pending indexes.
- * @param anchorBlockHash - Hash of a block to use as reference block when querying node.
+ * @param anchor - Block the log query is anchored to.
  * @param jobId - Job identifier, used to keep writes in-memory until they can be persisted in a data integrity
  * preserving way.
  */
-export declare function loadAndStoreNewTaggingIndexes(extendedSecret: AppTaggingSecret, start: number, end: number, aztecNode: AztecNode, taggingStore: SenderTaggingStore, anchorBlockHash: BlockHash, jobId: string): Promise<void>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvbG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNyRCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEVBQUUsS0FBSyxnQkFBZ0IsRUFBYSxNQUFNLG9CQUFvQixDQUFDO0FBR3RFLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFHakc7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsd0JBQXNCLDZCQUE2QixDQUNqRCxjQUFjLEVBQUUsZ0JBQWdCLEVBQ2hDLEtBQUssRUFBRSxNQUFNLEVBQ2IsR0FBRyxFQUFFLE1BQU0sRUFDWCxTQUFTLEVBQUUsU0FBUyxFQUNwQixZQUFZLEVBQUUsa0JBQWtCLEVBQ2hDLGVBQWUsRUFBRSxTQUFTLEVBQzFCLEtBQUssRUFBRSxNQUFNLGlCQWdCZCJ9
+export declare function loadAndStoreNewTaggingIndexes(extendedSecret: AppTaggingSecret, start: number, end: number, aztecNode: AztecNode, taggingStore: SenderTaggingStore, anchor: LogQueryAnchor, jobId: string): Promise<Map<string, TxInLogs>>;
+/** A tx that a sync window's logs carried. */
+export type TxInLogs = {
+    /** The block the tx was mined in, which decides whether it is finalized. */
+    blockNumber: BlockNumber;
+    /** The window's tagging indexes whose siloed tags this tx's logs carried. */
+    taggingIndexes: number[];
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvbG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNuRSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEVBQUUsS0FBSyxnQkFBZ0IsRUFBNkIsTUFBTSxvQkFBb0IsQ0FBQztBQUd0RixPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHdEQUF3RCxDQUFDO0FBQ2pHLE9BQU8sRUFBRSxLQUFLLGNBQWMsRUFBMkIsTUFBTSwrQkFBK0IsQ0FBQztBQUU3Rjs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUNILHdCQUFzQiw2QkFBNkIsQ0FDakQsY0FBYyxFQUFFLGdCQUFnQixFQUNoQyxLQUFLLEVBQUUsTUFBTSxFQUNiLEdBQUcsRUFBRSxNQUFNLEVBQ1gsU0FBUyxFQUFFLFNBQVMsRUFDcEIsWUFBWSxFQUFFLGtCQUFrQixFQUNoQyxNQUFNLEVBQUUsY0FBYyxFQUN0QixLQUFLLEVBQUUsTUFBTSxHQUNaLE9BQU8sQ0FBQyxHQUFHLENBQUMsTUFBTSxFQUFFLFFBQVEsQ0FBQyxDQUFDLENBNkJoQztBQUVELDhDQUE4QztBQUM5QyxNQUFNLE1BQU0sUUFBUSxHQUFHO0lBQ3JCLDRFQUE0RTtJQUM1RSxXQUFXLEVBQUUsV0FBVyxDQUFDO0lBQ3pCLDZFQUE2RTtJQUM3RSxjQUFjLEVBQUUsTUFBTSxFQUFFLENBQUM7Q0FDMUIsQ0FBQyJ9

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

@@ -1 +1 @@
-{"version":3,"file":"load_and_store_new_tagging_indexes.d.ts","sourceRoot":"","sources":["../../../../src/tagging/sender_sync/utils/load_and_store_new_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,EAAE,KAAK,gBAAgB,EAAa,MAAM,oBAAoB,CAAC;AAGtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wDAAwD,CAAC;AAGjG;;;;;;;;;;;;GAYG;AACH,wBAAsB,6BAA6B,CACjD,cAAc,EAAE,gBAAgB,EAChC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,kBAAkB,EAChC,eAAe,EAAE,SAAS,EAC1B,KAAK,EAAE,MAAM,iBAgBd"}
+{"version":3,"file":"load_and_store_new_tagging_indexes.d.ts","sourceRoot":"","sources":["../../../../src/tagging/sender_sync/utils/load_and_store_new_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,EAAE,KAAK,gBAAgB,EAA6B,MAAM,oBAAoB,CAAC;AAGtF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wDAAwD,CAAC;AACjG,OAAO,EAAE,KAAK,cAAc,EAA2B,MAAM,+BAA+B,CAAC;AAE7F;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,6BAA6B,CACjD,cAAc,EAAE,gBAAgB,EAChC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,kBAAkB,EAChC,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CA6BhC;AAED,8CAA8C;AAC9C,MAAM,MAAM,QAAQ,GAAG;IACrB,4EAA4E;IAC5E,WAAW,EAAE,WAAW,CAAC;IACzB,6EAA6E;IAC7E,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC"}

package/dest/tagging/sender_sync/utils/load_and_store_new_tagging_indexes.js

@@ -2,7 +2,9 @@ import { SiloedTag } from '@aztec/stdlib/logs';
 import { TxHash } from '@aztec/stdlib/tx';
 import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
 /**
- * Loads tagging indexes from the Aztec node and stores them in the tagging data provider.
+ * Loads tagging indexes from the Aztec node and stores them in the tagging data provider. Returns the txs the
+ * window's logs carried, keyed by tx hash string, with the block each was mined in and the window indexes it used,
+ * so the caller can classify their finalization status without further node queries.
  * @remarks This function is one of two places by which a pending index can get to the tagging data provider. The other
  * place is when a tx is being sent from this PXE.
  * @param extendedSecret - The app tagging secret whose indexes are being synced.
@@ -10,10 +12,10 @@ import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
  * @param end - The ending index (exclusive) of the window to process.
  * @param aztecNode - The Aztec node instance to query for logs.
  * @param taggingStore - The data provider to store pending indexes.
- * @param anchorBlockHash - Hash of a block to use as reference block when querying node.
+ * @param anchor - Block the log query is anchored to.
  * @param jobId - Job identifier, used to keep writes in-memory until they can be persisted in a data integrity
  * preserving way.
- */ export async function loadAndStoreNewTaggingIndexes(extendedSecret, start, end, aztecNode, taggingStore, anchorBlockHash, jobId) {
+ */ export async function loadAndStoreNewTaggingIndexes(extendedSecret, start, end, aztecNode, taggingStore, anchor, jobId) {
     // We compute the tags for the current window of indexes
     const siloedTagsForWindow = await Promise.all(Array.from({
         length: end - start
@@ -21,52 +23,51 @@ import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
             extendedSecret,
             index: start + i
         })));
-    const txsForTags = await getTxsContainingTags(siloedTagsForWindow, aztecNode, anchorBlockHash);
-    const txIndexesMap = getTxIndexesMap(txsForTags, start, siloedTagsForWindow.length);
-    // Now we iterate over the map, construct the tagging index ranges and store them in the db.
-    for (const [txHashStr, indexes] of txIndexesMap.entries()){
+    const allLogs = await getAllPrivateLogsByTags(aztecNode, siloedTagsForWindow, anchor);
+    if (allLogs.length !== siloedTagsForWindow.length) {
+        throw new Error(`Number of log arrays does not match number of tags. ${allLogs.length} !== ${siloedTagsForWindow.length}`);
+    }
+    const txsInLogs = getTxsInLogs(allLogs, start);
+    // Now we iterate over the map, construct the tagging index ranges and store them in the db. A tx already tracked
+    // in the store is merged rather than range-checked: if this PXE sent the tx and it partially reverted, the chain
+    // only shows the surviving sub-range of the prove-time entry (the finalized receipt step of the sync owns
+    // resolving that difference), and a tx from another PXE may straddle a sync window boundary, in which case the
+    // entry is widened so the next index choice covers the full onchain range.
+    for (const [txHashStr, { taggingIndexes }] of txsInLogs.entries()){
         const txHash = TxHash.fromString(txHashStr);
         const ranges = [
             {
                 extendedSecret,
-                lowestIndex: Math.min(...indexes),
-                highestIndex: Math.max(...indexes)
+                lowestIndex: Math.min(...taggingIndexes),
+                highestIndex: Math.max(...taggingIndexes)
             }
         ];
-        await taggingStore.storePendingIndexes(ranges, txHash, jobId);
+        await taggingStore.mergePendingIndexes(ranges, txHash, jobId);
     }
+    return txsInLogs;
 }
-// Returns txs that used the given tags. A tag might have been used in multiple txs and for this reason we return
-// an array for each tag.
-async function getTxsContainingTags(tags, aztecNode, anchorBlockHash) {
-    // We use the utility function below to retrieve all logs for the tags across all pages, so we don't need to handle
-    // pagination here. Sender sync only needs `txHash` from each log, so we leave `includeEffects` off.
-    const allLogs = await getAllPrivateLogsByTags(aztecNode, tags, anchorBlockHash);
-    return allLogs.map((logs)=>logs.map((log)=>log.txHash));
-}
-// Returns a map of txHash to all indexes for that txHash.
-function getTxIndexesMap(txHashesForTags, start, count) {
-    if (txHashesForTags.length !== count) {
-        throw new Error(`Number of tx hashes arrays does not match number of tags. ${txHashesForTags.length} !== ${count}`);
-    }
-    const indexesMap = new Map();
+// Returns a map of txHash to the block it was mined in and all window indexes used by it.
+function getTxsInLogs(logsForTags, start) {
+    const txsInLogs = new Map();
     // Iterate over indexes
-    for(let i = 0; i < txHashesForTags.length; i++){
+    for(let i = 0; i < logsForTags.length; i++){
         const taggingIndex = start + i;
-        const txHashesForTag = txHashesForTags[i];
-        // iterate over tx hashes that used that index (tag)
-        for (const txHash of txHashesForTag){
-            const key = txHash.toString();
-            const existing = indexesMap.get(key);
+        // iterate over logs that used that index (tag)
+        for (const log of logsForTags[i]){
+            const key = log.txHash.toString();
+            const existing = txsInLogs.get(key);
             // Add the index to the tx's indexes
             if (existing) {
-                existing.push(taggingIndex);
+                existing.taggingIndexes.push(taggingIndex);
             } else {
-                indexesMap.set(key, [
-                    taggingIndex
-                ]);
+                txsInLogs.set(key, {
+                    blockNumber: log.blockNumber,
+                    taggingIndexes: [
+                        taggingIndex
+                    ]
+                });
             }
         }
     }
-    return indexesMap;
+    return txsInLogs;
 }