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

package/src/tagging/recipient_sync/sync_tagged_private_logs.ts

@@ -0,0 +1,356 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import { allToCompletion } from '@aztec/foundation/promise';
+import { isDefined } from '@aztec/foundation/types';
+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 {
+  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';
+
+/**
+ * Fetches and syncs tagged private logs for multiple sender-recipient pairs, batching tag queries across all secrets
+ * into shared RPC calls. Handles both constrained and unconstrained secrets, which differ in their scan strategy
+ * but share the same batching infrastructure.
+ *
+ * # Unconstrained secrets
+ *
+ * For each unconstrained secret we sync logs that correspond to the tagging index range
+ * (highestAgedIndex, highestFinalizedIndex + WINDOW_LEN]
+ *
+ * highestAgedIndex is the highest index that was used in a tx that is included in a block at least
+ *                  `MAX_TX_LIFETIME` seconds ago.
+ * highestFinalizedIndex is the highest index that was used in a tx that is included in a finalized block.
+ *
+ * "(" denotes an open end of the range - the index is not included in the range.
+ * "]" denotes a closed end of the range - the index is included in the range.
+ *
+ * ## Explanation of highestAgedIndex
+ *
+ * highestAgedIndex is chosen such that for all tagging indexes `i <= highestAgedIndex` we know that no new logs can
+ * ever appear.
+ *
+ * This relies on the "maximum inclusion timestamp" rule enforced by the kernel and rollup circuits:
+ * - a transaction's maximum inclusion timestamp is at most `MAX_TX_LIFETIME` seconds after
+ *   the timestamp of its anchor block; and
+ * - a rollup only includes transactions whose inclusion timestamp is >= the L2 block's timestamp.
+ *
+ * Suppose some device used index `I` in a transaction anchored to block `B_N` at time `N`, and that block is now at
+ * least `MAX_TX_LIFETIME` seconds in the past. Then there is no possibility of any *other* device
+ * trying to use an index <= `I` while anchoring to a *newer* block than `B_N` because if we were anchoring to
+ * a newer block than `B_N` then we would already have seen the log with index `I` and hence the device would have
+ * chosen a larger index.
+ *    If that *other* device would anchor to a block older than `B_N` then that tx could never be included in a block
+ * because it would already have been expired.
+ *
+ * Therefore, once we see that index `I` has been used in a block that is at least `MAX_TX_LIFETIME`
+ * seconds old, we can safely stop syncing logs for all indexes <= `I` and set highestAgedIndex = `I`.
+ *
+ * ## Explanation of the upper bound `highestFinalizedIndex + WINDOW_LEN`
+ *
+ * When a sender chooses a tagging index, they will select an index that is at most `WINDOW_LEN` greater than
+ * the highest finalized index. If that index was already used, they will throw an error. For this reason we
+ * don't have to look further than `highestFinalizedIndex + WINDOW_LEN`.
+ *
+ * # Constrained secrets
+ *
+ * Constrained delivery enforces a contiguous index sequence (each send proves the predecessor's nullifier,
+ * chaining back to the handshake), so there is only one sender and indexes are sequential. This means:
+ * - The lower bound is `highestFinalizedIndex + 1`. The `highestAgedIndex` mechanism is unnecessary because
+ *   the nullifier chain prevents out-of-order index usage: no device can fill in a lower index after a higher
+ *   one is already on-chain.
+ * - Because the sequence is gapless, the scan stops at the first missing index: that gap proves the sequence has
+ *   ended and no further logs exist. We exploit this with a doubling first-miss probe (see
+ *   `INITIAL_CONSTRAINED_PROBE_LEN` in ../constants.ts), so a
+ *   steady-state sync with no new logs costs two tags instead of the whole window. The probe length is in-memory
+ *   state scoped to one sync call, so every sync restarts at the initial probe.
+ * - The upper bound is the same as unconstrained: `highestFinalizedIndex + WINDOW_LEN`. Advancing the probe is
+ *   decoupled from persisting the finalized index, so unfinalized logs at the top of the run are still fetched
+ *   while only the finalized prefix is persisted.
+ *
+ * # Batching across secrets
+ *
+ * Instead of running one RPC call per secret, we merge tags from all pending secrets (both constrained and
+ * unconstrained) into a single flat array, make one batched `getAllPrivateLogsByTags` call (which internally
+ * chunks at MAX_RPC_LEN), then split results back per secret using tracked offsets. Only secrets whose window
+ * advanced are kept for the next iteration.
+ */
+export async function syncTaggedPrivateLogs(
+  secrets: AppTaggingSecret[],
+  aztecNode: AztecNode,
+  taggingStore: RecipientTaggingStore,
+  anchorBlockHeader: BlockHeader,
+  finalizedBlockNumber: BlockNumber,
+  jobId: string,
+): Promise<LogResult[]> {
+  if (secrets.length === 0) {
+    return [];
+  }
+
+  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: LogResult[] = [];
+
+  while (pending.length > 0) {
+    // Compute tags for all pending secrets and fetch logs in batched RPC calls
+    const logsPerSecret = await fetchLogsForSecrets(pending, aztecNode, anchor);
+
+    const nextRound = await allToCompletion(
+      pending.map(async (pendingSecret, i) => {
+        const logsFoundWithSecret = logsPerSecret[i];
+        if (logsFoundWithSecret.length === 0) {
+          // No logs found, no need to update indexes or advance window.
+          return undefined;
+        }
+
+        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 pendingSecret.kind === AppTaggingSecretKind.CONSTRAINED
+          ? await processConstrainedResults(
+              pendingSecret,
+              logsFoundWithSecret,
+              taggingStore,
+              currentTimestamp,
+              finalizedBlockNumber,
+              jobId,
+            )
+          : await processUnconstrainedResults(
+              pendingSecret,
+              logsFoundWithSecret,
+              taggingStore,
+              currentTimestamp,
+              finalizedBlockNumber,
+              jobId,
+            );
+      }),
+    );
+
+    pending = nextRound.filter(isDefined);
+  }
+
+  return allLogs;
+}
+
+/** Reads stored indexes for each secret and computes the initial index range to query. */
+function getIndexRangesForSecrets(
+  secrets: AppTaggingSecret[],
+  taggingStore: RecipientTaggingStore,
+  jobId: string,
+): Promise<PendingSecret[]> {
+  return allToCompletion(
+    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,
+        };
+      }
+
+      // 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 };
+    }),
+  );
+}
+
+/**
+ * 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: PendingSecret[],
+  aztecNode: AztecNode,
+  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));
+
+  // Compute siloed tags for all indexes
+  const tagsPerSecret = await allToCompletion(
+    pending.map(({ secret }, i) =>
+      allToCompletion(indexesPerSecret[i].map(index => SiloedTag.compute({ extendedSecret: secret, index }))),
+    ),
+  );
+
+  const allTags = tagsPerSecret.flat();
+
+  // 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[][] = [];
+  let offset = 0;
+  for (const indexes of indexesPerSecret) {
+    const logsForSecret: LogWithIndex[] = [];
+    for (let i = 0; i < indexes.length; i++) {
+      for (const log of allResults[offset + i]) {
+        logsForSecret.push({ log, taggingIndex: indexes[i] });
+      }
+    }
+    logsPerSecret.push(logsForSecret);
+    offset += indexes.length;
+  }
+
+  return logsPerSecret;
+}
+
+/**
+ * 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: PendingConstrained,
+  logsWithIndexes: LogWithIndex[],
+  taggingStore: RecipientTaggingStore,
+  currentTimestamp: bigint,
+  finalizedBlockNumber: BlockNumber,
+  jobId: string,
+): Promise<PendingSecret | undefined> {
+  // 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 processUnconstrainedResults(
+  pending: PendingUnconstrained,
+  logsWithIndexes: LogWithIndex[],
+  taggingStore: RecipientTaggingStore,
+  currentTimestamp: bigint,
+  finalizedBlockNumber: BlockNumber,
+  jobId: string,
+): Promise<PendingSecret | undefined> {
+  const { highestAgedIndex, highestFinalizedIndex } = findHighestIndexes(
+    logsWithIndexes,
+    currentTimestamp,
+    finalizedBlockNumber,
+  );
+
+  // Store updates in data provider and update local variables
+  if (highestAgedIndex !== undefined) {
+    await taggingStore.updateHighestAgedIndex(pending.secret, highestAgedIndex, jobId);
+  }
+
+  if (highestFinalizedIndex === undefined) {
+    // We have not found a new highest finalized index, so there is no need to move the window forward.
+    return undefined;
+  }
+
+  if (highestAgedIndex !== undefined && highestAgedIndex > highestFinalizedIndex) {
+    // This is just a sanity check as this should never happen.
+    throw new Error(
+      `Highest aged index (${highestAgedIndex}) must not exceed highest finalized index (${highestFinalizedIndex})`,
+    );
+  }
+
+  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,
+  };
+}
+
+/** 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 (highest finalized index + WINDOW_LEN + 1, 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/recipient_sync/utils/find_highest_indexes.ts

@@ -1,11 +1,11 @@
 import { MAX_TX_LIFETIME } from '@aztec/constants';
-import type { TxScopedL2Log } from '@aztec/stdlib/logs';
+import type { LogResult } from '@aztec/stdlib/logs';
 
 /**
  * Finds the highest aged and the highest finalized tagging indexes.
  */
 export function findHighestIndexes(
-  privateLogsWithIndexes: Array<{ log: TxScopedL2Log; taggingIndex: number }>,
+  privateLogsWithIndexes: Array<{ log: LogResult; taggingIndex: number }>,
   currentTimestamp: bigint,
   finalizedBlockNumber: number,
 ): { highestAgedIndex: number | undefined; highestFinalizedIndex: number | undefined } {

package/src/tagging/reconcile_tagging_index_ranges.ts

@@ -0,0 +1,102 @@
+import { type AppTaggingSecret, SiloedTag, type TaggingIndexRange } from '@aztec/stdlib/logs';
+
+/**
+ * Reconciles tagging index ranges recorded by the PXE during private execution against the set of siloed tags whose
+ * private logs survived to the final kernel output.
+ *
+ * Each input range is the contiguous `[lowestIndex, highestIndex]` set of indexes that the tagging index cache
+ * reserved for a given tagging secret while a tx was being executed. The kernel may then squash some of those logs
+ * (e.g. when a note is created and nullified within the same tx, taking its log with it), so the actual on-chain
+ * footprint can be a strict subset of what was reserved.
+ *
+ * For each input range, this function shrinks `[lowestIndex, highestIndex]` so that both bounds correspond to indexes
+ * that actually survived, trimming any dropped indices at the front or the back. It is possible that some interior
+ * indexes were also dropped, leaving gaps between the lowest and highest indices, but we ignore those and accept the
+ * resulting inefficiency rather than complicate the tagging model with one in which transactions may use interleaved
+ * indices.
+ *
+ * Trimming tailing indices (e.g. `highestIndex`) is highly useful as it lets us reuse those indices in future
+ * transactions. Trimming indices at the front (e.g. `lowestIndex`) is not as impactful since we will not ever use a
+ * tagging index if a larger one exists (same as with gaps), but it does help in both making the consistency check
+ * between database and transaction effects cheaper (as there's fewer logs to test) and making the database more
+ * accurately reflect reality.
+ *
+ * Ranges with no surviving indexes are dropped from the output entirely.
+ *
+ * Example scenario:
+ *   - used indexes 3 to 7, kerel squashed indexes 3, 5, and 7:
+ *      - range: [3, 7]
+ *      - survived: set(3, 5, 7)
+ *      - output: [4, 6]  (trimmed from both ends, gap at 5 is tolerated)
+ *
+ * @param ranges - The tagging index ranges as recorded during private execution (pre-squash).
+ * @param survivingTags - The set of siloed tag values (as strings) of private logs that survived kernel squashing.
+ * @returns The reconciled ranges, with bounds tightened to surviving indexes and fully-squashed ranges removed.
+ */
+export async function reconcileTaggingIndexRangesAgainstSurvivingTags(
+  ranges: TaggingIndexRange[],
+  survivingTags: Set<string>,
+): Promise<TaggingIndexRange[]> {
+  const reconciled: TaggingIndexRange[] = [];
+
+  for (const range of ranges) {
+    const newLowestIndex = await findFirstSurvivingIndex(
+      range.extendedSecret,
+      range.lowestIndex,
+      range.highestIndex,
+      survivingTags,
+    );
+    if (newLowestIndex === undefined) {
+      // No index in this range corresponds to a surviving log: the entire range was squashed.
+      continue;
+    }
+
+    // newLowestIndex is itself a survivor, so the backward scan is guaranteed to find at least that index.
+    const newHighestIndex = await findLastSurvivingIndex(
+      range.extendedSecret,
+      newLowestIndex,
+      range.highestIndex,
+      survivingTags,
+    );
+
+    reconciled.push({
+      extendedSecret: range.extendedSecret,
+      lowestIndex: newLowestIndex,
+      highestIndex: newHighestIndex!,
+    });
+  }
+
+  return reconciled;
+}
+
+/** Scans `[start, end]` ascending and returns the first index whose siloed tag is in `survivingTags`. */
+async function findFirstSurvivingIndex(
+  secret: AppTaggingSecret,
+  start: number,
+  end: number,
+  survivingTags: Set<string>,
+): Promise<number | undefined> {
+  for (let index = start; index <= end; index++) {
+    const tag = await SiloedTag.compute({ extendedSecret: secret, index });
+    if (survivingTags.has(tag.value.toString())) {
+      return index;
+    }
+  }
+  return undefined;
+}
+
+/** Scans `[start, end]` descending and returns the first index whose siloed tag is in `survivingTags`. */
+async function findLastSurvivingIndex(
+  secret: AppTaggingSecret,
+  start: number,
+  end: number,
+  survivingTags: Set<string>,
+): Promise<number | undefined> {
+  for (let index = end; index >= start; index--) {
+    const tag = await SiloedTag.compute({ extendedSecret: secret, index });
+    if (survivingTags.has(tag.value.toString())) {
+      return index;
+    }
+  }
+  return undefined;
+}

package/src/tagging/sender_sync/sync_sender_tagging_indexes.ts

@@ -1,17 +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 { ExtendedDirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+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 { getStatusChangeOfPending } 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 secret that's unique for (sender, recipient, app) tuple while the direction of
- * sender -> recipient matters.
+ * @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).
@@ -19,10 +21,11 @@ import { loadAndStoreNewTaggingIndexes } from './utils/load_and_store_new_taggin
  * updates its status accordingly.
  */
 export async function syncSenderTaggingIndexes(
-  secret: ExtendedDirectionalAppTaggingSecret,
+  secret: AppTaggingSecret,
   aztecNode: AztecNode,
   taggingStore: SenderTaggingStore,
-  anchorBlockHash: BlockHash,
+  finalizedBlockNumber: BlockNumber,
+  anchor: LogQueryAnchor,
   jobId: string,
 ): Promise<void> {
   // # Explanation of how syncing works
@@ -40,32 +43,40 @@ 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) {
-    // Load and store indexes for the current window. These indexes may already exist in the database if txs using
-    // them were previously sent from this PXE. Any duplicates are handled by the tagging data provider.
-    await loadAndStoreNewTaggingIndexes(secret, start, end, aztecNode, taggingStore, anchorBlockHash, jobId);
+    const txsInLogs = await loadAndStoreNewTaggingIndexes(secret, start, end, aztecNode, taggingStore, anchor, jobId);
 
-    // Retrieve all indexes within the current window from storage and update their status accordingly.
-    const pendingTxHashes = await taggingStore.getTxHashesOfPendingIndexes(secret, start, end, jobId);
-    if (pendingTxHashes.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;
     }
 
-    const { txHashesToFinalize, txHashesToDrop } = await getStatusChangeOfPending(pendingTxHashes, aztecNode);
+    const { txHashesFinalizedFromLogs, txHashesFinalizedFromReceipts, txHashesDropped, receiptsWithExecutionReverted } =
+      await resolvePendingTxs(pendingTxs, txsInLogs, finalizedBlockNumber, aztecNode);
 
-    await taggingStore.dropPendingIndexes(txHashesToDrop, jobId);
-    await taggingStore.finalizePendingIndexes(txHashesToFinalize, jobId);
+    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);
@@ -82,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,92 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import { allToCompletion } from '@aztec/foundation/promise';
+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 allToCompletion(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 };
+}