@aztec/pxe 0.0.1-commit.b655e406 → 0.0.1-commit.b6e433891

package/src/storage/tagging_store/sender_tagging_store.ts

@@ -0,0 +1,476 @@
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+import { ExtendedDirectionalAppTaggingSecret, SiloedTag, type TaggingIndexRange } from '@aztec/stdlib/logs';
+import { TxEffect, TxHash } from '@aztec/stdlib/tx';
+
+import type { StagedStore } from '../../job_coordinator/job_coordinator.js';
+import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.js';
+
+/** Internal representation of a pending index range entry. */
+type PendingIndexesEntry = { lowestIndex: number; highestIndex: number; txHash: string };
+
+/**
+ * Data provider of tagging data used when syncing the sender tagging indexes. The recipient counterpart of this class
+ * is called RecipientTaggingStore. We have the data stores separate for sender and recipient because
+ * the algorithms are completely disjoint and there is not data reuse between the two.
+ */
+export class SenderTaggingStore implements StagedStore {
+  readonly storeName = 'sender_tagging';
+
+  #store: AztecAsyncKVStore;
+
+  // Stores the pending index ranges for each directional app tagging secret. Pending here means that the tx that
+  // contained the private logs with tags corresponding to these indexes has not been finalized yet.
+  //
+  // We store the full range (lowestIndex, highestIndex) for each secret-tx pair because transactions can partially
+  // revert, in which case only some logs (from the non-revertible phase) survive onchain. By storing the range,
+  // we can expand it and check each individual siloed tag against the TxEffect to determine which indexes made it
+  // onchain.
+  //
+  // directional app tagging secret => { lowestIndex, highestIndex, txHash }[]
+  #pendingIndexes: AztecAsyncMap<string, PendingIndexesEntry[]>;
+
+  // jobId => directional app tagging secret => { lowestIndex, highestIndex, txHash }[]
+  #pendingIndexesForJob: Map<string, Map<string, PendingIndexesEntry[]>>;
+
+  // Stores the last (highest) finalized index for each directional app tagging secret. We care only about the last
+  // index because unlike the pending indexes, it will never happen that a finalized index would be removed and hence
+  // we don't need to store the history.
+  //
+  // directional app tagging secret => highest finalized index
+  #lastFinalizedIndexes: AztecAsyncMap<string, number>;
+
+  // jobId => directional app tagging secret => highest finalized index
+  #lastFinalizedIndexesForJob: Map<string, Map<string, number>>;
+
+  constructor(store: AztecAsyncKVStore) {
+    this.#store = store;
+
+    this.#pendingIndexes = this.#store.openMap('pending_indexes');
+    this.#lastFinalizedIndexes = this.#store.openMap('last_finalized_indexes');
+
+    this.#pendingIndexesForJob = new Map();
+    this.#lastFinalizedIndexesForJob = new Map();
+  }
+
+  #getPendingIndexesForJob(jobId: string): Map<string, PendingIndexesEntry[]> {
+    let pendingIndexesForJob = this.#pendingIndexesForJob.get(jobId);
+    if (!pendingIndexesForJob) {
+      pendingIndexesForJob = new Map();
+      this.#pendingIndexesForJob.set(jobId, pendingIndexesForJob);
+    }
+    return pendingIndexesForJob;
+  }
+
+  #getLastFinalizedIndexesForJob(jobId: string): Map<string, number> {
+    let jobStagedLastFinalizedIndexes = this.#lastFinalizedIndexesForJob.get(jobId);
+    if (!jobStagedLastFinalizedIndexes) {
+      jobStagedLastFinalizedIndexes = new Map();
+      this.#lastFinalizedIndexesForJob.set(jobId, jobStagedLastFinalizedIndexes);
+    }
+    return jobStagedLastFinalizedIndexes;
+  }
+
+  async #readPendingIndexes(jobId: string, secret: string): Promise<PendingIndexesEntry[]> {
+    // Always issue DB read to keep IndexedDB transaction alive (they auto-commit when a new micro-task starts and there
+    // are no pending read requests). The staged value still takes precedence if it exists.
+    const dbValue = await this.#pendingIndexes.getAsync(secret);
+    const staged = this.#getPendingIndexesForJob(jobId).get(secret);
+    return staged !== undefined ? staged : (dbValue ?? []);
+  }
+
+  #writePendingIndexes(jobId: string, secret: string, pendingIndexes: PendingIndexesEntry[]) {
+    this.#getPendingIndexesForJob(jobId).set(secret, pendingIndexes);
+  }
+
+  async #readLastFinalizedIndex(jobId: string, secret: string): Promise<number | undefined> {
+    // Always issue DB read to keep IndexedDB transaction alive (they auto-commit when a new micro-task starts and there
+    // are no pending read requests). The staged value still takes precedence if it exists.
+    const dbValue = await this.#lastFinalizedIndexes.getAsync(secret);
+    const staged = this.#getLastFinalizedIndexesForJob(jobId).get(secret);
+    return staged ?? dbValue;
+  }
+
+  #writeLastFinalizedIndex(jobId: string, secret: string, lastFinalizedIndex: number) {
+    this.#getLastFinalizedIndexesForJob(jobId).set(secret, lastFinalizedIndex);
+  }
+
+  /**
+   * Writes all job-specific in-memory data to persistent storage.
+   *
+   * @remark This method must run in a DB transaction context. It's designed to be called from JobCoordinator#commitJob.
+   */
+  async commit(jobId: string): Promise<void> {
+    const pendingIndexesForJob = this.#pendingIndexesForJob.get(jobId);
+    if (pendingIndexesForJob) {
+      for (const [secret, pendingIndexes] of pendingIndexesForJob.entries()) {
+        if (pendingIndexes.length === 0) {
+          await this.#pendingIndexes.delete(secret);
+        } else {
+          await this.#pendingIndexes.set(secret, pendingIndexes);
+        }
+      }
+    }
+
+    const lastFinalizedIndexesForJob = this.#lastFinalizedIndexesForJob.get(jobId);
+    if (lastFinalizedIndexesForJob) {
+      for (const [secret, lastFinalizedIndex] of lastFinalizedIndexesForJob.entries()) {
+        await this.#lastFinalizedIndexes.set(secret, lastFinalizedIndex);
+      }
+    }
+
+    return this.discardStaged(jobId);
+  }
+
+  discardStaged(jobId: string): Promise<void> {
+    this.#pendingIndexesForJob.delete(jobId);
+    this.#lastFinalizedIndexesForJob.delete(jobId);
+    return Promise.resolve();
+  }
+
+  /**
+   * Stores pending index ranges.
+   * @remarks If the same (secret, txHash) pair already exists in the db with an equal range, it's a no-op. This is
+   * expected to happen because whenever we start sync we start from the last finalized index and we can have pending
+   * ranges already stored from previous syncs. If the ranges differ, it throws an error as that indicates a bug.
+   * @param ranges - The tagging index ranges containing the directional app tagging secrets and the index ranges that are
+   * to be stored in the db.
+   * @param txHash - The tx in which the tagging indexes were used in private logs.
+   * @param jobId - job context for staged writes to this store. See `JobCoordinator` for more details.
+   * @throws If the highestIndex is further than window length from the highest finalized index for the same secret.
+   * @throws If the lowestIndex is lower than or equal to the last finalized index for the same secret.
+   * @throws If a different range already exists for the same (secret, txHash) pair.
+   */
+  storePendingIndexes(ranges: TaggingIndexRange[], txHash: TxHash, jobId: string): Promise<void> {
+    if (ranges.length === 0) {
+      return Promise.resolve();
+    }
+
+    const txHashStr = txHash.toString();
+
+    return this.#store.transactionAsync(async () => {
+      // Prefetch all data, start reads during iteration to keep IndexedDB transaction alive
+      const rangeReadPromises = ranges.map(range => ({
+        range,
+        secretStr: range.extendedSecret.toString(),
+        pending: this.#readPendingIndexes(jobId, range.extendedSecret.toString()),
+        finalized: this.#readLastFinalizedIndex(jobId, range.extendedSecret.toString()),
+      }));
+
+      // Await all reads together
+      const rangeData = await Promise.all(
+        rangeReadPromises.map(async item => ({
+          ...item,
+          pendingData: await item.pending,
+          finalizedIndex: await item.finalized,
+        })),
+      );
+
+      // Process in memory and validate
+      for (const { range, secretStr, pendingData, finalizedIndex } of rangeData) {
+        // Check that the highest index is not further than window length from the highest finalized index.
+        if (range.highestIndex > (finalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN) {
+          throw new Error(
+            `Highest used index ${range.highestIndex} is further than window length from the highest finalized index ${finalizedIndex ?? 0}.
+            Tagging window length ${UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN} is configured too low. Contact the Aztec team
+            to increase it!`,
+          );
+        }
+
+        // Throw if the lowest index is lower than or equal to the last finalized index
+        if (finalizedIndex !== undefined && range.lowestIndex <= finalizedIndex) {
+          throw new Error(
+            `Cannot store pending index range [${range.lowestIndex}, ${range.highestIndex}] for secret ${secretStr}: ` +
+              `lowestIndex is lower than or equal to the last finalized index ${finalizedIndex}`,
+          );
+        }
+
+        // Check if an entry with the same txHash already exists
+        const existingEntry = pendingData.find(entry => entry.txHash === txHashStr);
+
+        if (existingEntry) {
+          // Assert that the ranges are equal — different ranges for the same (secret, txHash) indicates a bug
+          if (existingEntry.lowestIndex !== range.lowestIndex || existingEntry.highestIndex !== range.highestIndex) {
+            throw new Error(
+              `Conflicting range for secret ${secretStr} and txHash ${txHashStr}: ` +
+                `existing [${existingEntry.lowestIndex}, ${existingEntry.highestIndex}] vs ` +
+                `new [${range.lowestIndex}, ${range.highestIndex}]`,
+            );
+          }
+          // Exact duplicate — skip
+        } else {
+          this.#writePendingIndexes(jobId, secretStr, [
+            ...pendingData,
+            { lowestIndex: range.lowestIndex, highestIndex: range.highestIndex, txHash: txHashStr },
+          ]);
+        }
+      }
+    });
+  }
+
+  /**
+   * Returns the transaction hashes of all pending transactions that contain highest indexes within a specified range
+   * for a given directional app tagging secret. We check based on the highest indexes only as that is the relevant
+   * information for the caller of this function.
+   * @param secret - The directional app tagging secret to query pending indexes for.
+   * @param startIndex - The lower bound of the index range (inclusive).
+   * @param endIndex - The upper bound of the index range (exclusive).
+   * @returns An array of unique transaction hashes for pending transactions that contain indexes in the range
+   * [startIndex, endIndex). Returns an empty array if no pending indexes exist in the range.
+   */
+  getTxHashesOfPendingIndexes(
+    secret: ExtendedDirectionalAppTaggingSecret,
+    startIndex: number,
+    endIndex: number,
+    jobId: string,
+  ): Promise<TxHash[]> {
+    return this.#store.transactionAsync(async () => {
+      const existing = await this.#readPendingIndexes(jobId, secret.toString());
+      const txHashes = existing
+        .filter(entry => entry.highestIndex >= startIndex && entry.highestIndex < endIndex)
+        .map(entry => entry.txHash);
+      return Array.from(new Set(txHashes)).map(TxHash.fromString);
+    });
+  }
+
+  /**
+   * Returns the last (highest) finalized index for a given secret.
+   * @param secret - The secret to get the last finalized index for.
+   * @returns The last (highest) finalized index for the given secret.
+   */
+  getLastFinalizedIndex(secret: ExtendedDirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
+    return this.#store.transactionAsync(() => this.#readLastFinalizedIndex(jobId, secret.toString()));
+  }
+
+  /**
+   * Returns the last used index for a given directional app tagging secret, considering both finalized and pending
+   * indexes.
+   * @param secret - The directional app tagging secret to query the last used index for.
+   * @returns The last used index.
+   */
+  getLastUsedIndex(secret: ExtendedDirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
+    const secretStr = secret.toString();
+
+    return this.#store.transactionAsync(async () => {
+      const pendingPromise = this.#readPendingIndexes(jobId, secretStr);
+      const finalizedPromise = this.#readLastFinalizedIndex(jobId, secretStr);
+
+      const [pendingEntries, lastFinalized] = await Promise.all([pendingPromise, finalizedPromise]);
+
+      if (pendingEntries.length === 0) {
+        return lastFinalized;
+      }
+
+      // As the last used index we return the highest one from the pending index ranges. Note that this value will be
+      // always higher than the last finalized index because we prune lower pending indexes when a tx is finalized.
+      return Math.max(...pendingEntries.map(entry => entry.highestIndex));
+    });
+  }
+
+  /**
+   * Drops all pending indexes corresponding to the given transaction hashes.
+   */
+  dropPendingIndexes(txHashes: TxHash[], jobId: string): Promise<void> {
+    if (txHashes.length === 0) {
+      return Promise.resolve();
+    }
+
+    const txHashStrings = new Set<string>(txHashes.map(txHash => txHash.toString()));
+
+    return this.#store.transactionAsync(async () => {
+      // Prefetch all data, start reads during iteration to keep IndexedDB transaction alive
+      const secretReadPromises: Map<string, Promise<PendingIndexesEntry[]>> = new Map();
+
+      for await (const secret of this.#pendingIndexes.keysAsync()) {
+        secretReadPromises.set(secret, this.#readPendingIndexes(jobId, secret));
+      }
+
+      // Add staged-only secrets (sync, no DB)
+      for (const secret of this.#getPendingIndexesForJob(jobId).keys()) {
+        if (!secretReadPromises.has(secret)) {
+          secretReadPromises.set(secret, Promise.resolve(this.#getPendingIndexesForJob(jobId).get(secret) ?? []));
+        }
+      }
+
+      // Await all reads together
+      const secrets = [...secretReadPromises.keys()];
+      const pendingDataResults = await Promise.all(secretReadPromises.values());
+
+      // Process in memory
+      for (let i = 0; i < secrets.length; i++) {
+        const secret = secrets[i];
+        const pendingData = pendingDataResults[i];
+
+        if (pendingData && pendingData.length > 0) {
+          const filtered = pendingData.filter(item => !txHashStrings.has(item.txHash));
+          if (filtered.length === 0) {
+            this.#writePendingIndexes(jobId, secret, []);
+          } else if (filtered.length !== pendingData.length) {
+            // Some items were filtered out, so update the pending data
+            this.#writePendingIndexes(jobId, secret, filtered);
+          }
+          // else: No items were filtered out (txHashes not found for this secret) --> no-op
+        }
+      }
+    });
+  }
+
+  /** Prefetches all pending and finalized index data for every secret (from both DB and staged writes). */
+  #getSecretsWithPendingData(
+    jobId: string,
+  ): Promise<{ secret: string; pendingData: PendingIndexesEntry[]; lastFinalized: number | undefined }[]> {
+    return this.#store.transactionAsync(async () => {
+      // Prefetch all data, start reads during iteration to keep IndexedDB transaction alive
+      const secretDataPromises: Map<
+        string,
+        { pending: Promise<PendingIndexesEntry[]>; finalized: Promise<number | undefined> }
+      > = new Map();
+
+      for await (const secret of this.#pendingIndexes.keysAsync()) {
+        secretDataPromises.set(secret, {
+          pending: this.#readPendingIndexes(jobId, secret),
+          finalized: this.#readLastFinalizedIndex(jobId, secret),
+        });
+      }
+
+      // Add staged-only secrets (sync, no DB)
+      for (const secret of this.#getPendingIndexesForJob(jobId).keys()) {
+        if (!secretDataPromises.has(secret)) {
+          secretDataPromises.set(secret, {
+            pending: Promise.resolve(this.#getPendingIndexesForJob(jobId).get(secret) ?? []),
+            finalized: Promise.resolve(this.#getLastFinalizedIndexesForJob(jobId).get(secret)),
+          });
+        }
+      }
+
+      // Await all reads together
+      const secrets = [...secretDataPromises.keys()];
+      const dataResults = await Promise.all(
+        secrets.map(async secret => ({
+          secret,
+          pendingData: await secretDataPromises.get(secret)!.pending,
+          lastFinalized: await secretDataPromises.get(secret)!.finalized,
+        })),
+      );
+
+      return dataResults.filter(r => r.pendingData.length > 0);
+    });
+  }
+
+  /**
+   * Updates pending indexes corresponding to the given transaction hashes to be finalized and prunes any lower pending
+   * indexes.
+   */
+  async finalizePendingIndexes(txHashes: TxHash[], jobId: string): Promise<void> {
+    if (txHashes.length === 0) {
+      return;
+    }
+
+    const txHashStrings = new Set(txHashes.map(tx => tx.toString()));
+    const secretsWithData = await this.#getSecretsWithPendingData(jobId);
+
+    for (const { secret, pendingData, lastFinalized } of secretsWithData) {
+      let currentPending = pendingData;
+      let currentFinalized = lastFinalized;
+
+      // Process all txHashes for this secret
+      for (const txHashStr of txHashStrings) {
+        const matchingEntries = currentPending.filter(item => item.txHash === txHashStr);
+        if (matchingEntries.length === 0) {
+          // This is expected as a higher index might have already been finalized which would lead to pruning of
+          // pending entries.
+          continue;
+        }
+
+        if (matchingEntries.length > 1) {
+          // We should always just store the highest pending index for a given tx hash and secret because the lower
+          // values are irrelevant.
+          throw new Error(`Multiple pending entries found for tx hash ${txHashStr} and secret ${secret}`);
+        }
+
+        const newFinalized = matchingEntries[0].highestIndex;
+
+        if (newFinalized < (currentFinalized ?? 0)) {
+          // This should never happen because when last finalized index was finalized we should have pruned the lower
+          // pending indexes.
+          throw new Error(
+            `New finalized index ${newFinalized} is smaller than the current last finalized index ${currentFinalized}`,
+          );
+        }
+
+        currentFinalized = newFinalized;
+
+        // When we add pending indexes, we ensure they are higher than the last finalized index. However, because we
+        // cannot control the order in which transactions are finalized, there may be pending indexes that are now
+        // obsolete because they are lower than the most recently finalized index. For this reason, we prune these
+        // outdated pending indexes.
+        currentPending = currentPending.filter(item => item.highestIndex > currentFinalized!);
+      }
+
+      // Write final state if changed
+      if (currentFinalized !== lastFinalized) {
+        this.#writeLastFinalizedIndex(jobId, secret, currentFinalized!);
+      }
+      if (currentPending !== pendingData) {
+        this.#writePendingIndexes(jobId, secret, currentPending);
+      }
+    }
+  }
+
+  /**
+   * Handles finalization of pending indexes for a transaction whose execution was partially reverted.
+   * Recomputes the siloed tags for each pending index of the given tx and checks which ones appear in the
+   * TxEffect's private logs (i.e., which ones made it onchain). Those that survived are finalized; those that
+   * didn't are dropped.
+   * @param txEffect - The tx effect of the partially reverted transaction.
+   * @param jobId - job context for staged writes to this store. See `JobCoordinator` for more details.
+   */
+  async finalizePendingIndexesOfAPartiallyRevertedTx(txEffect: TxEffect, jobId: string): Promise<void> {
+    const txHashStr = txEffect.txHash.toString();
+
+    // Build a set of all siloed tag values that made it onchain (first field of each private log).
+    const onChainTags = new Set<string>(txEffect.privateLogs.map(log => log.fields[0].toString()));
+
+    const secretsWithData = await this.#getSecretsWithPendingData(jobId);
+
+    for (const { secret, pendingData, lastFinalized } of secretsWithData) {
+      const matchingEntries = pendingData.filter(item => item.txHash === txHashStr);
+      if (matchingEntries.length === 0) {
+        // This is expected as a higher index might have already been finalized which would lead to pruning of
+        // pending entries.
+        continue;
+      }
+
+      if (matchingEntries.length > 1) {
+        // We should always just store the highest pending index for a given tx hash and secret because the lower
+        // values are irrelevant.
+        throw new Error(`Multiple pending entries found for tx hash ${txHashStr} and secret ${secret}`);
+      }
+
+      const pendingEntry = matchingEntries[0];
+
+      // Expand each matching entry's range and recompute siloed tags for each index.
+      const extendedSecret = ExtendedDirectionalAppTaggingSecret.fromString(secret);
+      let highestSurvivingIndex: number | undefined;
+
+      for (let index = pendingEntry.lowestIndex; index <= pendingEntry.highestIndex; index++) {
+        const siloedTag = await SiloedTag.compute({ extendedSecret, index });
+        if (onChainTags.has(siloedTag.value.toString())) {
+          highestSurvivingIndex = highestSurvivingIndex !== undefined ? Math.max(highestSurvivingIndex, index) : index;
+        }
+      }
+
+      // Remove all entries for this txHash from pending (both surviving and non-surviving).
+      let currentPending = pendingData.filter(item => item.txHash !== txHashStr);
+
+      if (highestSurvivingIndex !== undefined) {
+        const newFinalized = Math.max(lastFinalized ?? 0, highestSurvivingIndex);
+        this.#writeLastFinalizedIndex(jobId, secret, newFinalized);
+
+        // Prune pending indexes that are now <= the finalized index.
+        currentPending = currentPending.filter(item => item.highestIndex > newFinalized);
+      }
+
+      this.#writePendingIndexes(jobId, secret, currentPending);
+    }
+  }
+}

package/src/tagging/constants.ts

@@ -1,2 +1,10 @@
-// Half the size of the window we slide over the tagging indexes.
-export const WINDOW_HALF_SIZE = 10;
+// 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.
+//
+// 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;

package/src/tagging/get_all_logs_by_tags.ts

@@ -0,0 +1,92 @@
+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 type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { SiloedTag, Tag, TxScopedL2Log } from '@aztec/stdlib/logs';
+
+/**
+ * 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.
+ */
+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++;
+  }
+
+  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[][] = [];
+  for (let i = 0; i < tags.length; i += MAX_RPC_LEN) {
+    batches.push(tags.slice(i, i + MAX_RPC_LEN));
+  }
+  const batchResults = await Promise.all(batches.map(fetchAllPagesForBatch));
+  return batchResults.flat();
+}
+
+/**
+ * Fetches all private logs for the given tags, automatically paginating through all pages.
+ * @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).
+ * @returns An array of log arrays, one per tag, containing all logs across all pages.
+ */
+export function getAllPrivateLogsByTags(
+  aztecNode: AztecNode,
+  tags: SiloedTag[],
+  anchorBlockHash: BlockHash,
+): Promise<TxScopedL2Log[][]> {
+  return getAllPagesInBatches(tags, batch =>
+    getAllPages(batch.length, page => aztecNode.getPrivateLogsByTags(batch, page, anchorBlockHash)),
+  );
+}
+
+/**
+ * Fetches all public logs for the given tags from a contract, automatically paginating through all pages.
+ * @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).
+ * @returns An array of log arrays, one per tag, containing all logs across all pages.
+ */
+export function getAllPublicLogsByTagsFromContract(
+  aztecNode: AztecNode,
+  contractAddress: AztecAddress,
+  tags: Tag[],
+  anchorBlockHash: BlockHash,
+): Promise<TxScopedL2Log[][]> {
+  return getAllPagesInBatches(tags, batch =>
+    getAllPages(batch.length, page =>
+      aztecNode.getPublicLogsByTagsFromContract(contractAddress, batch, page, anchorBlockHash),
+    ),
+  );
+}

package/src/tagging/index.ts

@@ -1,6 +1,19 @@
-export * from './tag.js';
-export * from './constants.js';
-export * from './siloed_tag.js';
-export * from './utils.js';
-export { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
-export { type PreTag } from '@aztec/stdlib/logs';
+/**
+ * This directory contains the sender and recipient synchronization algorithms that use tagging.
+ *
+ * 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.
+ *
+ * @module tagging
+ */
+
+export { loadPrivateLogsForSenderRecipientPair } from './recipient_sync/load_private_logs_for_sender_recipient_pair.js';
+export { syncSenderTaggingIndexes } from './sender_sync/sync_sender_tagging_indexes.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 { type PreTag, type TaggingIndexRange } from '@aztec/stdlib/logs';