@aztec/pxe 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/src/storage/private_event_store/private_event_store.ts

@@ -0,0 +1,213 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+import type { EventSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { L2BlockHash } from '@aztec/stdlib/block';
+import { type InTx, TxHash } from '@aztec/stdlib/tx';
+
+import type { PackedPrivateEvent } from '../../pxe.js';
+
+export type PrivateEventStoreFilter = {
+  contractAddress: AztecAddress;
+  fromBlock: number;
+  toBlock: number;
+  scopes: AztecAddress[];
+  txHash?: TxHash;
+};
+
+type PrivateEventEntry = {
+  msgContent: Buffer;
+  eventCommitmentIndex: number;
+  l2BlockNumber: number;
+  l2BlockHash: Buffer;
+  txHash: Buffer;
+  /** The lookup key for #eventsByContractScopeSelector, used for cleanup during rollback */
+  lookupKey: string;
+};
+
+type PrivateEventMetadata = InTx & {
+  contractAddress: AztecAddress;
+  scope: AztecAddress;
+};
+
+/**
+ * Stores decrypted private event logs.
+ */
+export class PrivateEventStore {
+  #store: AztecAsyncKVStore;
+  /** Map storing the actual private event log entries, keyed by eventCommitmentIndex */
+  #eventLogs: AztecAsyncMap<number, PrivateEventEntry>;
+  /** Map from contractAddress_scope_eventSelector to eventCommitmentIndex[] for efficient lookup */
+  #eventsByContractScopeSelector: AztecAsyncMap<string, number[]>;
+  /** Map from block number to eventCommitmentIndex[] for rollback support */
+  #eventsByBlockNumber: AztecAsyncMap<number, number[]>;
+  /** Map from eventCommitmentIndex to boolean indicating if log has been seen. */
+  #seenLogs: AztecAsyncMap<number, boolean>;
+
+  logger = createLogger('private_event_store');
+
+  constructor(store: AztecAsyncKVStore) {
+    this.#store = store;
+    this.#eventLogs = this.#store.openMap('private_event_logs');
+    this.#eventsByContractScopeSelector = this.#store.openMap('events_by_contract_scope_selector');
+    this.#seenLogs = this.#store.openMap('seen_logs');
+    this.#eventsByBlockNumber = this.#store.openMap('events_by_block_number');
+  }
+
+  #keyFor(contractAddress: AztecAddress, scope: AztecAddress, eventSelector: EventSelector): string {
+    return `${contractAddress.toString()}_${scope.toString()}_${eventSelector.toString()}`;
+  }
+
+  /**
+   * Store a private event log.
+   * @param eventSelector - The event selector of the event.
+   * @param msgContent - The content of the event.
+   * @param eventCommitmentIndex - The index of the event commitment in the nullifier tree.
+   * @param metadata
+   *  contractAddress - The address of the contract that emitted the event.
+   *  scope - The address to which the event is scoped.
+   *  txHash - The transaction hash of the event log.
+   *  blockNumber - The block number in which the event was emitted.
+   */
+  storePrivateEventLog(
+    eventSelector: EventSelector,
+    msgContent: Fr[],
+    eventCommitmentIndex: number,
+    metadata: PrivateEventMetadata,
+  ): Promise<void> {
+    const { contractAddress, scope, txHash, l2BlockNumber, l2BlockHash } = metadata;
+
+    return this.#store.transactionAsync(async () => {
+      const key = this.#keyFor(contractAddress, scope, eventSelector);
+
+      // Check if this exact log has already been stored using eventCommitmentIndex as unique identifier
+      const hasBeenSeen = await this.#seenLogs.getAsync(eventCommitmentIndex);
+      if (hasBeenSeen) {
+        this.logger.verbose('Ignoring duplicate event log', { txHash: txHash.toString(), eventCommitmentIndex });
+        return;
+      }
+
+      this.logger.verbose('storing private event log', { contractAddress, scope, msgContent, l2BlockNumber });
+
+      await this.#eventLogs.set(eventCommitmentIndex, {
+        msgContent: serializeToBuffer(msgContent),
+        l2BlockNumber,
+        l2BlockHash: l2BlockHash.toBuffer(),
+        eventCommitmentIndex,
+        txHash: txHash.toBuffer(),
+        lookupKey: key,
+      });
+
+      const existingIndices = (await this.#eventsByContractScopeSelector.getAsync(key)) || [];
+      await this.#eventsByContractScopeSelector.set(key, [...existingIndices, eventCommitmentIndex]);
+
+      const existingBlockIndices = (await this.#eventsByBlockNumber.getAsync(l2BlockNumber)) || [];
+      await this.#eventsByBlockNumber.set(l2BlockNumber, [...existingBlockIndices, eventCommitmentIndex]);
+
+      // Mark this log as seen using eventCommitmentIndex
+      await this.#seenLogs.set(eventCommitmentIndex, true);
+    });
+  }
+
+  /**
+   * Returns the private events given search parameters.
+   * @param eventSelector - The event selector to filter by.
+   * @param filter - Filtering criteria:
+   *  contractAddress: The address of the contract to get events from.
+   *  fromBlock: The block number to search from (inclusive).
+   *  toBlock: The block number to search upto (exclusive).
+   *  scope: - The addresses that decrypted the logs.
+   * @returns - The event log contents, augmented with metadata about
+   *  the transaction and block it the event was included in .
+   */
+  public async getPrivateEvents(
+    eventSelector: EventSelector,
+    filter: PrivateEventStoreFilter,
+  ): Promise<PackedPrivateEvent[]> {
+    const events: Array<{ eventCommitmentIndex: number; event: PackedPrivateEvent }> = [];
+
+    for (const scope of filter.scopes) {
+      const key = this.#keyFor(filter.contractAddress, scope, eventSelector);
+      const eventCommitmentIndices = (await this.#eventsByContractScopeSelector.getAsync(key)) || [];
+
+      for (const eventCommitmentIndex of eventCommitmentIndices) {
+        const entry = await this.#eventLogs.getAsync(eventCommitmentIndex);
+        if (!entry || entry.l2BlockNumber < filter.fromBlock || entry.l2BlockNumber >= filter.toBlock) {
+          continue;
+        }
+
+        // Convert buffer back to Fr array
+        const reader = BufferReader.asReader(entry.msgContent);
+        const numFields = entry.msgContent.length / Fr.SIZE_IN_BYTES;
+        const msgContent = reader.readArray(numFields, Fr);
+        const txHash = TxHash.fromBuffer(entry.txHash);
+        const l2BlockHash = L2BlockHash.fromBuffer(entry.l2BlockHash);
+
+        if (filter.txHash && !txHash.equals(filter.txHash)) {
+          continue;
+        }
+
+        events.push({
+          eventCommitmentIndex: entry.eventCommitmentIndex,
+          event: {
+            packedEvent: msgContent,
+            l2BlockNumber: BlockNumber(entry.l2BlockNumber),
+            txHash,
+            l2BlockHash,
+            eventSelector,
+          },
+        });
+      }
+    }
+
+    // Sort by eventCommitmentIndex only
+    events.sort((a, b) => a.eventCommitmentIndex - b.eventCommitmentIndex);
+    return events.map(ev => ev.event);
+  }
+
+  /**
+   * Rolls back private events that were stored after a given `blockNumber` and up to `synchedBlockNumber` (the block
+   * number up to which PXE managed to sync before the reorg happened).
+   */
+  public async rollbackEventsAfterBlock(blockNumber: number, synchedBlockNumber: number): Promise<void> {
+    await this.#store.transactionAsync(async () => {
+      let removedCount = 0;
+
+      for (let block = blockNumber + 1; block <= synchedBlockNumber; block++) {
+        const indices = await this.#eventsByBlockNumber.getAsync(block);
+        if (indices) {
+          await this.#eventsByBlockNumber.delete(block);
+
+          for (const eventCommitmentIndex of indices) {
+            const entry = await this.#eventLogs.getAsync(eventCommitmentIndex);
+            if (!entry) {
+              throw new Error(`Event log not found for eventCommitmentIndex ${eventCommitmentIndex}`);
+            }
+
+            await this.#eventLogs.delete(eventCommitmentIndex);
+            await this.#seenLogs.delete(eventCommitmentIndex);
+
+            // Update #eventsByContractScopeSelector using the stored lookupKey
+            const existingIndices = await this.#eventsByContractScopeSelector.getAsync(entry.lookupKey);
+            if (!existingIndices || existingIndices.length === 0) {
+              throw new Error(`No indices found in #eventsByContractScopeSelector for key ${entry.lookupKey}`);
+            }
+            const filteredIndices = existingIndices.filter(idx => idx !== eventCommitmentIndex);
+            if (filteredIndices.length === 0) {
+              await this.#eventsByContractScopeSelector.delete(entry.lookupKey);
+            } else {
+              await this.#eventsByContractScopeSelector.set(entry.lookupKey, filteredIndices);
+            }
+
+            removedCount++;
+          }
+        }
+      }
+
+      this.logger.verbose(`Rolled back ${removedCount} private events after block ${blockNumber}`);
+    });
+  }
+}

package/src/storage/tagging_store/index.ts

@@ -0,0 +1,3 @@
+export { SenderTaggingStore } from './sender_tagging_store.js';
+export { SenderAddressBookStore } from './sender_address_book_store.js';
+export { RecipientTaggingStore } from './recipient_tagging_store.js';

package/src/storage/tagging_store/recipient_tagging_store.ts

@@ -0,0 +1,53 @@
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+
+/**
+ * Data provider of tagging data used when syncing the logs as a recipient. The sender counterpart of this class
+ * is called SenderTaggingStore. We have the providers separate for the sender and recipient because
+ * the algorithms are completely disjoint and there is not data reuse between the two.
+ *
+ * @dev Chain reorgs do not need to be handled here because both the finalized and aged indexes refer to finalized
+ * blocks, which by definition cannot be affected by reorgs.
+ *
+ * TODO(benesjan): Relocate to yarn-project/pxe/src/storage/tagging_store
+ */
+export class RecipientTaggingStore {
+  #store: AztecAsyncKVStore;
+
+  #highestAgedIndex: AztecAsyncMap<string, number>;
+  #highestFinalizedIndex: AztecAsyncMap<string, number>;
+
+  constructor(store: AztecAsyncKVStore) {
+    this.#store = store;
+
+    this.#highestAgedIndex = this.#store.openMap('highest_aged_index');
+    this.#highestFinalizedIndex = this.#store.openMap('highest_finalized_index');
+  }
+
+  getHighestAgedIndex(secret: DirectionalAppTaggingSecret): Promise<number | undefined> {
+    return this.#highestAgedIndex.getAsync(secret.toString());
+  }
+
+  async updateHighestAgedIndex(secret: DirectionalAppTaggingSecret, index: number): Promise<void> {
+    const currentIndex = await this.#highestAgedIndex.getAsync(secret.toString());
+    if (currentIndex !== undefined && index <= currentIndex) {
+      // Log sync should never set a lower highest aged index.
+      throw new Error(`New highest aged index (${index}) must be higher than the current one (${currentIndex})`);
+    }
+    await this.#highestAgedIndex.set(secret.toString(), index);
+  }
+
+  getHighestFinalizedIndex(secret: DirectionalAppTaggingSecret): Promise<number | undefined> {
+    return this.#highestFinalizedIndex.getAsync(secret.toString());
+  }
+
+  async updateHighestFinalizedIndex(secret: DirectionalAppTaggingSecret, index: number): Promise<void> {
+    const currentIndex = await this.#highestFinalizedIndex.getAsync(secret.toString());
+    if (currentIndex !== undefined && index < currentIndex) {
+      // Log sync should never set a lower highest finalized index but it can happen that it would try to set the same
+      // one because we are loading logs from highest aged index + 1 and not from the highest finalized index.
+      throw new Error(`New highest finalized index (${index}) must be higher than the current one (${currentIndex})`);
+    }
+    await this.#highestFinalizedIndex.set(secret.toString(), index);
+  }
+}

package/src/storage/tagging_store/sender_address_book_store.ts

@@ -0,0 +1,42 @@
+import { toArray } from '@aztec/foundation/iterable';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+/**
+ * Stores sender addresses. During recipient log synchronization, these senders are used, along with a given recipient,
+ * to derive directional app tagging secrets that are then used to sync the logs.
+ */
+export class SenderAddressBookStore {
+  #store: AztecAsyncKVStore;
+  #addressBook: AztecAsyncMap<string, true>;
+
+  constructor(store: AztecAsyncKVStore) {
+    this.#store = store;
+
+    this.#addressBook = this.#store.openMap('address_book');
+  }
+
+  async addSender(address: AztecAddress): Promise<boolean> {
+    if (await this.#addressBook.hasAsync(address.toString())) {
+      return false;
+    }
+
+    await this.#addressBook.set(address.toString(), true);
+
+    return true;
+  }
+
+  async getSenders(): Promise<AztecAddress[]> {
+    return (await toArray(this.#addressBook.keysAsync())).map(AztecAddress.fromString);
+  }
+
+  async removeSender(address: AztecAddress): Promise<boolean> {
+    if (!(await this.#addressBook.hasAsync(address.toString()))) {
+      return false;
+    }
+
+    await this.#addressBook.delete(address.toString());
+
+    return true;
+  }
+}

package/src/storage/tagging_store/sender_tagging_store.ts

@@ -0,0 +1,244 @@
+import { toArray } from '@aztec/foundation/iterable';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
+import { TxHash } from '@aztec/stdlib/tx';
+
+import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/index.js';
+
+/**
+ * Data provider of tagging data used when syncing the sender tagging indexes. The recipient counterpart of this class
+ * is called RecipientTaggingStore. We have the providers separate for the sender and recipient because
+ * the algorithms are completely disjoint and there is not data reuse between the two.
+ */
+export class SenderTaggingStore {
+  #store: AztecAsyncKVStore;
+
+  // Stores the pending indexes 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 don't store just the highest index because if their transaction is dropped we'd then need the information about
+  // the lower pending indexes. For each secret-tx pair however we only store the largest index used in that tx, since
+  // the smaller ones are irrelevant due to tx atomicity.
+  //
+  // TODO(#17615): This assumes no logs are used in the non-revertible phase.
+  #pendingIndexes: AztecAsyncMap<string, { index: number; txHash: string }[]>;
+
+  // 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.
+  #lastFinalizedIndexes: AztecAsyncMap<string, number>;
+
+  constructor(store: AztecAsyncKVStore) {
+    this.#store = store;
+
+    this.#pendingIndexes = this.#store.openMap('pending_indexes');
+    this.#lastFinalizedIndexes = this.#store.openMap('last_finalized_indexes');
+  }
+
+  /**
+   * Stores pending indexes.
+   * @remarks Ignores the index if the same preTag + txHash combination already exists in the db with the same index.
+   * This is expected to happen because whenever we start sync we start from the last finalized index and we can have
+   * pending indexes already stored from previous syncs.
+   * @param preTags - The pre-tags containing the directional app tagging secrets and the indexes that are to be
+   * stored in the db.
+   * @param txHash - The tx in which the pretags were used in private logs.
+   * @throws If any two pre-tags contain the same directional app tagging secret. This is enforced because we care
+   * only about the highest index for a given secret that was used in the tx. Hence this check is a good way to catch
+   * bugs.
+   * @throws If the newly stored pending index is further than window length from the highest finalized index for the
+   * same secret. This is enforced in order to give a guarantee to a recipient that he doesn't need to look further than
+   * window length ahead of the highest finalized index.
+   * @throws If a secret + txHash pair already exists in the db with a different index value. It should never happen
+   * that we would attempt to store a different index for a given secret-txHash pair because we always store just the
+   * highest index for a given secret-txHash pair. Hence this is a good way to catch bugs.
+   * @throws If the newly stored pending index is lower than or equal to the last finalized index for the same secret.
+   * This is enforced because this should never happen if the syncing is done correctly as we look for logs from higher
+   * indexes than finalized ones.
+   */
+  async storePendingIndexes(preTags: PreTag[], txHash: TxHash) {
+    // The secrets in pre-tags should be unique because we always store just the highest index per given secret-txHash
+    // pair. Below we check that this is the case.
+    const secretsSet = new Set(preTags.map(preTag => preTag.secret.toString()));
+    if (secretsSet.size !== preTags.length) {
+      throw new Error(`Duplicate secrets found when storing pending indexes`);
+    }
+
+    for (const { secret, index } of preTags) {
+      // First we check that for any secret the highest used index in tx is not further than window length from
+      // the highest finalized index.
+      const finalizedIndex = (await this.getLastFinalizedIndex(secret)) ?? 0;
+      if (index > finalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN) {
+        throw new Error(
+          `Highest used index ${index} is further than window length from the highest finalized index ${finalizedIndex}.
+          Tagging window length ${UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN} is configured too low. Contact the Aztec team
+          to increase it!`,
+        );
+      }
+
+      // Throw if the new pending index is lower than or equal to the last finalized index
+      const secretStr = secret.toString();
+      const lastFinalizedIndex = await this.#lastFinalizedIndexes.getAsync(secretStr);
+      if (lastFinalizedIndex !== undefined && index <= lastFinalizedIndex) {
+        throw new Error(
+          `Cannot store pending index ${index} for secret ${secretStr}: ` +
+            `it is lower than or equal to the last finalized index ${lastFinalizedIndex}`,
+        );
+      }
+
+      // Check if this secret + txHash combination already exists
+      const txHashStr = txHash.toString();
+      const existingForSecret = (await this.#pendingIndexes.getAsync(secretStr)) ?? [];
+      const existingForSecretAndTx = existingForSecret.find(entry => entry.txHash === txHashStr);
+
+      if (existingForSecretAndTx) {
+        // If it exists with a different index, throw an error
+        if (existingForSecretAndTx.index !== index) {
+          throw new Error(
+            `Cannot store index ${index} for secret ${secretStr} and txHash ${txHashStr}: ` +
+              `a different index ${existingForSecretAndTx.index} already exists for this secret-txHash pair`,
+          );
+        }
+        // If it exists with the same index, ignore the update (no-op)
+      } else {
+        // If it doesn't exist, add it
+        await this.#pendingIndexes.set(secretStr, [...existingForSecret, { index, txHash: txHashStr }]);
+      }
+    }
+  }
+
+  /**
+   * Returns the transaction hashes of all pending transactions that contain indexes within a specified range
+   * for a given directional app tagging secret.
+   * @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.
+   */
+  async getTxHashesOfPendingIndexes(
+    secret: DirectionalAppTaggingSecret,
+    startIndex: number,
+    endIndex: number,
+  ): Promise<TxHash[]> {
+    const existing = (await this.#pendingIndexes.getAsync(secret.toString())) ?? [];
+    const txHashes = existing
+      .filter(entry => entry.index >= startIndex && entry.index < 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: DirectionalAppTaggingSecret): Promise<number | undefined> {
+    return this.#lastFinalizedIndexes.getAsync(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.
+   */
+  async getLastUsedIndex(secret: DirectionalAppTaggingSecret): Promise<number | undefined> {
+    const secretStr = secret.toString();
+    const pendingTxScopedIndexes = (await this.#pendingIndexes.getAsync(secretStr)) ?? [];
+    const pendingIndexes = pendingTxScopedIndexes.map(entry => entry.index);
+
+    if (pendingTxScopedIndexes.length === 0) {
+      return this.#lastFinalizedIndexes.getAsync(secretStr);
+    }
+
+    // As the last used index we return the highest one from the pending indexes. 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(...pendingIndexes);
+  }
+
+  /**
+   * Drops all pending indexes corresponding to the given transaction hashes.
+   */
+  async dropPendingIndexes(txHashes: TxHash[]) {
+    if (txHashes.length === 0) {
+      return;
+    }
+
+    const txHashStrs = new Set<string>(txHashes.map(txHash => txHash.toString()));
+    const allSecrets = await toArray(this.#pendingIndexes.keysAsync());
+
+    for (const secret of allSecrets) {
+      const pendingData = await this.#pendingIndexes.getAsync(secret);
+      if (pendingData) {
+        const filtered = pendingData.filter(item => !txHashStrs.has(item.txHash));
+        if (filtered.length === 0) {
+          await this.#pendingIndexes.delete(secret);
+        } else if (filtered.length !== pendingData.length) {
+          // Some items were filtered out, so update the pending data
+          await this.#pendingIndexes.set(secret, filtered);
+        }
+        // else: No items were filtered out (txHashes not found for this secret) --> no-op
+      }
+    }
+  }
+
+  /**
+   * Updates pending indexes corresponding to the given transaction hashes to be finalized and prunes any lower pending
+   * indexes.
+   */
+  async finalizePendingIndexes(txHashes: TxHash[]) {
+    if (txHashes.length === 0) {
+      return;
+    }
+
+    for (const txHash of txHashes) {
+      const txHashStr = txHash.toString();
+
+      const allSecrets = await toArray(this.#pendingIndexes.keysAsync());
+
+      for (const secret of allSecrets) {
+        const pendingData = await this.#pendingIndexes.getAsync(secret);
+        if (!pendingData) {
+          continue;
+        }
+
+        const matchingIndexes = pendingData.filter(item => item.txHash === txHashStr).map(item => item.index);
+        if (matchingIndexes.length === 0) {
+          continue;
+        }
+
+        if (matchingIndexes.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 indexes found for tx hash ${txHashStr} and secret ${secret}`);
+        }
+
+        let lastFinalized = await this.#lastFinalizedIndexes.getAsync(secret);
+        const newFinalized = matchingIndexes[0];
+
+        if (newFinalized < (lastFinalized ?? 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 ${lastFinalized}`,
+          );
+        }
+
+        await this.#lastFinalizedIndexes.set(secret, newFinalized);
+        lastFinalized = 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.
+        const remainingItemsOfHigherIndex = pendingData.filter(item => item.index > (lastFinalized ?? 0));
+        if (remainingItemsOfHigherIndex.length === 0) {
+          await this.#pendingIndexes.delete(secret);
+        } else {
+          await this.#pendingIndexes.set(secret, remainingItemsOfHigherIndex);
+        }
+      }
+    }
+  }
+}

package/src/tagging/index.ts

@@ -0,0 +1,28 @@
+/**
+ * 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';
+
+// 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;
+
+// Re-export tagging-related types from stdlib
+export { DirectionalAppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';
+export { type PreTag } from '@aztec/stdlib/logs';