@aztec/pxe 0.0.1-commit.9ef841308 → 0.0.1-commit.a5db02d

package/src/tagging/constants.ts

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

package/src/tagging/get_all_logs_by_tags.ts

@@ -1,49 +1,54 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { BlockHash } from '@aztec/stdlib/block';
-import { MAX_LOGS_PER_TAG, MAX_RPC_LEN } from '@aztec/stdlib/interfaces/api-limit';
+import { MAX_RPC_LEN } from '@aztec/stdlib/interfaces/api-limit';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { SiloedTag, Tag, TxScopedL2Log } from '@aztec/stdlib/logs';
+import {
+  type LogIncludeOptions,
+  type LogResult,
+  type SiloedTag,
+  type Tag,
+  queryAllPrivateLogsByTags,
+  queryAllPublicLogsByTags,
+} from '@aztec/stdlib/logs';
+
+/** Optional block-range, effects opt-in, and pagination cap shared by both wrappers. */
+export type GetAllLogsByTagsOptions = {
+  /** Lower block bound, inclusive. */
+  fromBlock?: BlockNumber;
+  /** Upper block bound, exclusive. */
+  toBlock?: BlockNumber;
+  /**
+   * When set, each log also carries `noteHashes` and all `nullifiers` of its tx. Defaults to off — sender
+   * sync only needs `txHash`. The recipient-sync/log-service paths flip this on to build `PendingTaggedLog`
+   * / `LogRetrievalResponse` from note data.
+   */
+  includeEffects?: boolean;
+  /**
+   * Maximum number of logs returned per tag per round-trip. Capped at `MAX_LOGS_PER_TAG` on the node
+   * (rejected if higher). Defaults to `MAX_LOGS_PER_TAG`. Mainly useful for tests that need to force
+   * pagination at a small page size.
+   */
+  limitPerTag?: number;
+};
 
 /**
- * Generic pagination helper that fetches all pages of results.
- * @param numTags - The number of tags being queried (determines result array size).
- * @param fetchPage - Function that fetches a single page of results given a page number.
- * @returns An array of arrays, one per tag, containing all results across all pages.
+ * Splits tags into chunks of MAX_RPC_LEN, paginates each chunk via the stdlib per-tag cursor helper,
+ * then stitches the results back into a single array preserving the original tag order.
  */
-async function getAllPages<T>(numTags: number, fetchPage: (page: number) => Promise<T[][]>): Promise<T[][]> {
-  const allResultsPerTag: T[][] = Array.from({ length: numTags }, () => []);
-  let page = 0;
-  let hasMore = true;
-
-  while (hasMore) {
-    const resultsPage = await fetchPage(page);
-    hasMore = false;
-
-    for (let i = 0; i < resultsPage.length; i++) {
-      allResultsPerTag[i].push(...resultsPage[i]);
-      if (resultsPage[i].length === MAX_LOGS_PER_TAG) {
-        hasMore = true;
-      }
-    }
-    page++;
+async function getAllPagesInBatches<T extends Tag | SiloedTag, Opts extends LogIncludeOptions>(
+  tags: T[],
+  fetchAllPagesForBatch: (batch: T[]) => Promise<LogResult<Opts>[][]>,
+): Promise<LogResult<Opts>[][]> {
+  if (tags.length === 0) {
+    return [];
   }
 
-  return allResultsPerTag;
-}
-
-/**
- * Splits tags into chunks of MAX_RPC_LEN, fetches logs for each chunk using getAllPages, then stitches the results
- * back into a single array preserving the original tag order.
- */
-async function getAllPagesInBatches<Tag, T>(
-  tags: Tag[],
-  fetchAllPagesForBatch: (batch: Tag[]) => Promise<T[][]>,
-): Promise<T[][]> {
   if (tags.length <= MAX_RPC_LEN) {
     return fetchAllPagesForBatch(tags);
   }
 
-  const batches: Tag[][] = [];
+  const batches: T[][] = [];
   for (let i = 0; i < tags.length; i += MAX_RPC_LEN) {
     batches.push(tags.slice(i, i + MAX_RPC_LEN));
   }
@@ -52,41 +57,64 @@ async function getAllPagesInBatches<Tag, T>(
 }
 
 /**
- * Fetches all private logs for the given tags, automatically paginating through all pages.
+ * Fetches all private logs for the given tags, automatically paginating per-tag via `afterLog` cursors.
+ *
  * @param aztecNode - The Aztec node to query.
  * @param tags - The siloed tags to search for.
- * @param anchorBlockHash - reference block for the Aztec node query, throws if block is not found there (typically
- * because of reorgs).
+ * @param anchorBlockHash - Reference block for the Aztec node query, throws if block is not found there (typically
+ *   because of reorgs).
+ * @param options - Optional `fromBlock`/`toBlock` range and `includeEffects` opt-in.
  * @returns An array of log arrays, one per tag, containing all logs across all pages.
  */
-export function getAllPrivateLogsByTags(
+export function getAllPrivateLogsByTags<Opts extends GetAllLogsByTagsOptions = GetAllLogsByTagsOptions>(
   aztecNode: AztecNode,
   tags: SiloedTag[],
   anchorBlockHash: BlockHash,
-): Promise<TxScopedL2Log[][]> {
-  return getAllPagesInBatches(tags, batch =>
-    getAllPages(batch.length, page => aztecNode.getPrivateLogsByTags(batch, page, anchorBlockHash)),
+  options: Opts = {} as Opts,
+): Promise<LogResult<Opts>[][]> {
+  return getAllPagesInBatches<SiloedTag, Opts>(
+    tags,
+    batch =>
+      queryAllPrivateLogsByTags(aztecNode, {
+        tags: batch,
+        referenceBlock: anchorBlockHash,
+        fromBlock: options.fromBlock,
+        toBlock: options.toBlock,
+        includeEffects: options.includeEffects ?? false,
+        limitPerTag: options.limitPerTag,
+      }) as Promise<LogResult<Opts>[][]>,
   );
 }
 
 /**
- * Fetches all public logs for the given tags from a contract, automatically paginating through all pages.
+ * Fetches all public logs for the given tags from a contract, automatically paginating per-tag via `afterLog` cursors.
+ *
  * @param aztecNode - The Aztec node to query.
  * @param contractAddress - The contract address to search logs for.
  * @param tags - The tags to search for.
- * @param anchorBlockHash - reference block for the Aztec node query, throws if block is not found there (typically
- * because of reorgs).
+ * @param anchorBlockHash - Reference block for the Aztec node query, throws if block is not found there (typically
+ *   because of reorgs).
+ * @param options - Optional `fromBlock`/`toBlock` range and `includeEffects` opt-in.
  * @returns An array of log arrays, one per tag, containing all logs across all pages.
  */
-export function getAllPublicLogsByTagsFromContract(
+export function getAllPublicLogsByTagsFromContract<Opts extends GetAllLogsByTagsOptions = GetAllLogsByTagsOptions>(
   aztecNode: AztecNode,
   contractAddress: AztecAddress,
   tags: Tag[],
   anchorBlockHash: BlockHash,
-): Promise<TxScopedL2Log[][]> {
-  return getAllPagesInBatches(tags, batch =>
-    getAllPages(batch.length, page =>
-      aztecNode.getPublicLogsByTagsFromContract(contractAddress, batch, page, anchorBlockHash),
-    ),
+  options: Opts = {} as Opts,
+): Promise<LogResult<Opts>[][]> {
+  return getAllPagesInBatches<Tag, Opts>(
+    tags,
+    batch =>
+      queryAllPublicLogsByTags(aztecNode, {
+        contractAddress,
+        tags: batch,
+        referenceBlock: anchorBlockHash,
+        fromBlock: options.fromBlock,
+        toBlock: options.toBlock,
+        includeEffects: options.includeEffects ?? false,
+        limitPerTag: options.limitPerTag,
+      }) as Promise<LogResult<Opts>[][]>,
   );
 }

package/src/tagging/index.ts

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

package/src/tagging/persist_sender_tagging_index_ranges.ts

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

package/src/tagging/recipient_sync/sync_tagged_private_logs.ts

@@ -0,0 +1,301 @@
+import { 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 { 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.
+ * - 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`.
+ *
+ * # 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 anchorBlockNumber = anchorBlockHeader.getBlockNumber();
+  const anchorBlockHash = await anchorBlockHeader.hash();
+  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, anchorBlockNumber, anchorBlockHash);
+
+    const nextRound = await Promise.all(
+      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.
+        const processForKind =
+          pendingSecret.secret.kind === AppTaggingSecretKind.CONSTRAINED
+            ? processConstrainedResults
+            : processUnconstrainedResults;
+
+        return await processForKind(
+          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 Promise.all(
+    secrets.map(async secret => {
+      const currentHighestFinalizedIndex = await taggingStore.getHighestFinalizedIndex(secret, jobId);
+
+      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 };
+    }),
+  );
+}
+
+/**
+ * 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,
+  anchorBlockNumber: BlockNumber,
+  anchorBlockHash: BlockHash,
+): 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 Promise.all(
+    pending.map(({ secret }, i) =>
+      Promise.all(indexesPerSecret[i].map(index => SiloedTag.compute({ extendedSecret: secret, 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),
+  });
+
+  // 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. 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`
+ * is tracked (no aged index).
+ */
+async function processConstrainedResults(
+  pending: PendingSecret,
+  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.
+  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.
+  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,
+      };
+    }
+  }
+
+  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: PendingSecret,
+  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.
+  return {
+    secret: pending.secret,
+    start: pending.end,
+    end: highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1,
+  };
+}
+
+type PendingSecret = {
+  secret: AppTaggingSecret;
+  start: number;
+  end: number;
+};
+
+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 } {