@aztec/pxe 0.0.1-commit.3100065 → 0.0.1-commit.330febf

package/src/tagging/recipient_sync/sync_tagged_private_logs.ts

@@ -1,14 +1,17 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
 import { isDefined } from '@aztec/foundation/types';
-import type { BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type { AppTaggingSecret, LogResult } from '@aztec/stdlib/logs';
 import { AppTaggingSecretKind, SiloedTag } from '@aztec/stdlib/logs';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 
 import type { RecipientTaggingStore } from '../../storage/tagging_store/recipient_tagging_store.js';
-import { 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 { type LogQueryAnchor, getAllPrivateLogsByTags, logQueryAnchorOf } from '../get_all_logs_by_tags.js';
 import { findHighestIndexes } from './utils/find_highest_indexes.js';
 
 /**
@@ -62,9 +65,14 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
  * - 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.
- * - The scan stops at the first gap in the index sequence. If all indexes in the batch have logs, the window
- *   advances. If a gap is found, the sequence has ended and no further logs exist.
- * - The upper bound is the same as unconstrained: `highestFinalizedIndex + WINDOW_LEN`.
+ * - 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
  *
@@ -85,8 +93,7 @@ export async function syncTaggedPrivateLogs(
     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
@@ -95,7 +102,7 @@ export async function syncTaggedPrivateLogs(
 
   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) => {
@@ -109,19 +116,23 @@ export async function syncTaggedPrivateLogs(
 
         // Persist new indexes. If the finalized index moved forward, the window advances
         // and we need another round for this secret.
-        const processForKind =
-          pendingSecret.secret.kind === AppTaggingSecretKind.CONSTRAINED
-            ? processConstrainedResults
-            : processUnconstrainedResults;
-
-        return await processForKind(
-          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,
+            );
       }),
     );
 
@@ -138,18 +149,29 @@ function getIndexRangesForSecrets(
   jobId: string,
 ): Promise<PendingSecret[]> {
   return Promise.all(
-    secrets.map(async secret => {
+    secrets.map(async (secret): Promise<PendingSecret> => {
       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,
+        };
+      }
 
-      const highestIndexBeforeStart =
-        secret.kind === AppTaggingSecretKind.CONSTRAINED
-          ? currentHighestFinalizedIndex
-          : await taggingStore.getHighestAgedIndex(secret, jobId);
-      const start = highestIndexBeforeStart === undefined ? 0 : highestIndexBeforeStart + 1;
-
-      const end = (currentHighestFinalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
-
-      return { secret, start, end };
+      // 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: boundEnd };
     }),
   );
 }
@@ -161,8 +183,7 @@ function getIndexRangesForSecrets(
 async function fetchLogsForSecrets(
   pending: PendingSecret[],
   aztecNode: AztecNode,
-  anchorBlockNumber: BlockNumber,
-  anchorBlockHash: BlockHash,
+  anchor: LogQueryAnchor,
 ): Promise<LogWithIndex[][]> {
   // Determine the index range for each secret
   const indexesPerSecret = pending.map(({ start, end }) => Array.from({ length: end - start }, (_, i) => start + i));
@@ -176,14 +197,10 @@ async function fetchLogsForSecrets(
 
   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: LogWithIndex[][] = [];
@@ -203,41 +220,58 @@ async function fetchLogsForSecrets(
 }
 
 /**
- * Processes fetched logs for a constrained secret. Constrained delivery guarantees contiguous index sequences,
- * so we scan from the start of the queried range and stop at the first missing index. Only `highestFinalizedIndex`
+ * 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: PendingSecret,
+  pending: PendingConstrained,
   logsWithIndexes: LogWithIndex[],
   taggingStore: RecipientTaggingStore,
   currentTimestamp: bigint,
   finalizedBlockNumber: BlockNumber,
   jobId: string,
 ): Promise<PendingSecret | undefined> {
-  // Find where the contiguous run of indexes ends. Constrained delivery guarantees there are no logs after the
-  // first gap, so all logs in the batch are within this prefix.
+  // 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++;
   }
 
-  // Finalize any logs before the gap. The nullifier for a constrained-delivery log is emitted in the same
-  // transaction, guaranteeing the log cannot disappear once included, so we persist the highest finalized
-  // index even when a gap stops the scan. This lets the next sync round skip already-finalized indexes.
+  // 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);
+  }
 
-    if (firstMissingIndex >= pending.end) {
-      return {
-        secret: pending.secret,
-        start: pending.end,
-        end: highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1,
-      };
-    }
+  // 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;
@@ -248,7 +282,7 @@ async function processConstrainedResults(
  * if the window needs to advance, or undefined if this secret is done.
  */
 async function processUnconstrainedResults(
-  pending: PendingSecret,
+  pending: PendingUnconstrained,
   logsWithIndexes: LogWithIndex[],
   taggingStore: RecipientTaggingStore,
   currentTimestamp: bigint,
@@ -282,19 +316,39 @@ async function processUnconstrainedResults(
 
   // 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,
   };
 }
 
-type PendingSecret = {
+/** Working scan state common to both secret kinds: the half-open [start, end) tag-index range to query this round. */
+type PendingSecretBase = {
   secret: AppTaggingSecret;
   start: number;
   end: number;
 };
 
+/** Constrained scan state, carrying the doubling-probe bookkeeping that only the gapless constrained scan uses. */
+type PendingConstrained = PendingSecretBase & {
+  kind: typeof AppTaggingSecretKind.CONSTRAINED;
+  // Exclusive upper bound on the indexes this secret may probe this sync, from `unfinalizedTaggingIndexesWindowEnd`:
+  // the protocol bound on how far ahead of finalized a log can sit. `end` grows toward it each round.
+  boundEnd: number;
+  // Intended probe length for the round that produced `end`. The queried span can be smaller when boundEnd caps it.
+  probeLen: number;
+};
+
+/** Unconstrained scan state: a plain window with no probe bookkeeping, since the scan always covers the full window. */
+type PendingUnconstrained = PendingSecretBase & {
+  kind: typeof AppTaggingSecretKind.UNCONSTRAINED;
+};
+
+type PendingSecret = PendingConstrained | PendingUnconstrained;
+
 type LogWithIndex = {
   log: LogResult;
   taggingIndex: number;

package/src/tagging/sender_sync/sync_sender_tagging_indexes.ts

@@ -1,20 +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 { 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 type { LogQueryAnchor } from '../get_all_logs_by_tags.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).
@@ -25,7 +24,8 @@ export async function syncSenderTaggingIndexes(
   secret: AppTaggingSecret,
   aztecNode: AztecNode,
   taggingStore: SenderTaggingStore,
-  anchorBlockHash: BlockHash,
+  finalizedBlockNumber: BlockNumber,
+  anchor: LogQueryAnchor,
   jobId: string,
 ): Promise<void> {
   // # Explanation of how syncing works
@@ -43,68 +43,39 @@ export async function syncSenderTaggingIndexes(
   // 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);
+    const txsInLogs = await loadAndStoreNewTaggingIndexes(secret, start, end, aztecNode, taggingStore, anchor, 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) {
+    // 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);
+    const { txHashesFinalizedFromLogs, txHashesFinalizedFromReceipts, txHashesDropped, receiptsWithExecutionReverted } =
+      await resolvePendingTxs(pendingTxs, txsInLogs, finalizedBlockNumber, aztecNode);
 
-    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.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);
 
-        await taggingStore.finalizePendingIndexesOfAPartiallyRevertedTx(receipt.txEffect, jobId);
-      }
+    for (const receipt of receiptsWithExecutionReverted) {
+      await taggingStore.finalizePendingIndexesOfAPartiallyRevertedTx(receipt.txEffect, jobId);
     }
 
     // We check if the finalized index has been updated.
@@ -122,8 +93,7 @@ export async function syncSenderTaggingIndexes(
       //    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/src/tagging/sender_sync/utils/classify_pending_txs.ts

@@ -0,0 +1,91 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import { TxHash, TxStatus } 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 function classifyPendingTxsFromLogs(
+  pendingTxs: PendingTx[],
+  txsInLogs: Map<string, TxInLogs>,
+  finalizedBlockNumber: BlockNumber,
+): LogClassification {
+  const txHashesFinalized: TxHash[] = [];
+  const txHashesWithExecutionReverted: TxHash[] = [];
+  const txHashesAbsent: TxHash[] = [];
+
+  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 };
+}
+
+/** 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 async function classifyPendingTxsFromReceipts(
+  pending: TxHash[],
+  aztecNode: AztecNode,
+): Promise<ReceiptClassification> {
+  const receipts = await Promise.all(pending.map(pendingTxHash => aztecNode.getTxReceipt(pendingTxHash)));
+
+  const txHashesFinalized: TxHash[] = [];
+  const txHashesDropped: TxHash[] = [];
+  const txHashesWithExecutionReverted: TxHash[] = [];
+
+  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/src/tagging/sender_sync/utils/load_and_store_new_tagging_indexes.ts

@@ -1,13 +1,15 @@
-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, SiloedTag } from '@aztec/stdlib/logs';
+import { type AppTaggingSecret, type LogResult, SiloedTag } from '@aztec/stdlib/logs';
 import { TxHash } from '@aztec/stdlib/tx';
 
 import type { SenderTaggingStore } from '../../../storage/tagging_store/sender_tagging_store.js';
-import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
+import { type LogQueryAnchor, 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.
@@ -15,7 +17,7 @@ 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.
  */
@@ -25,60 +27,64 @@ export async function loadAndStoreNewTaggingIndexes(
   end: number,
   aztecNode: AztecNode,
   taggingStore: SenderTaggingStore,
-  anchorBlockHash: BlockHash,
+  anchor: LogQueryAnchor,
   jobId: string,
-) {
+): Promise<Map<string, TxInLogs>> {
   // We compute the tags for the current window of indexes
   const siloedTagsForWindow = await Promise.all(
     Array.from({ length: end - start }, (_, i) => SiloedTag.compute({ extendedSecret, index: start + i })),
   );
 
-  const txsForTags = await getTxsContainingTags(siloedTagsForWindow, aztecNode, anchorBlockHash);
-  const txIndexesMap = getTxIndexesMap(txsForTags, start, siloedTagsForWindow.length);
+  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.
-  for (const [txHashStr, indexes] of txIndexesMap.entries()) {
+  // 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) }];
-    await taggingStore.storePendingIndexes(ranges, txHash, jobId);
+    const ranges = [
+      { extendedSecret, lowestIndex: Math.min(...taggingIndexes), highestIndex: Math.max(...taggingIndexes) },
+    ];
+    await taggingStore.mergePendingIndexes(ranges, txHash, jobId);
   }
-}
 
-// 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: SiloedTag[],
-  aztecNode: AztecNode,
-  anchorBlockHash: BlockHash,
-): Promise<TxHash[][]> {
-  // 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));
+  return txsInLogs;
 }
 
-// Returns a map of txHash to all indexes for that txHash.
-function getTxIndexesMap(txHashesForTags: TxHash[][], start: number, count: number): Map<string, number[]> {
-  if (txHashesForTags.length !== count) {
-    throw new Error(`Number of tx hashes arrays does not match number of tags. ${txHashesForTags.length} !== ${count}`);
-  }
+/** 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[];
+};
 
-  const indexesMap = new Map<string, number[]>();
+// Returns a map of txHash to the block it was mined in and all window indexes used by it.
+function getTxsInLogs(logsForTags: LogResult[][], start: number): Map<string, TxInLogs> {
+  const txsInLogs = new Map<string, TxInLogs>();
   // 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;
 }