@aztec/pxe 0.0.1-commit.d1f2d6c → 0.0.1-commit.d431d1c

package/src/storage/private_event_store/private_event_store.ts

@@ -1,16 +1,15 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
-import { Semaphore } from '@aztec/foundation/queue';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@aztec/kv-store';
 import type { EventSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { InTx, TxHash } from '@aztec/stdlib/tx';
+import { L2BlockHash } from '@aztec/stdlib/block';
+import { type InTx, TxHash } from '@aztec/stdlib/tx';
 
 import type { StagedStore } from '../../job_coordinator/job_coordinator.js';
 import type { PackedPrivateEvent } from '../../pxe.js';
-import { StoredPrivateEvent } from './stored_private_event.js';
 
 export type PrivateEventStoreFilter = {
   contractAddress: AztecAddress;
@@ -20,6 +19,20 @@ export type PrivateEventStoreFilter = {
   txHash?: TxHash;
 };
 
+type PrivateEventEntry = {
+  randomness: Fr; // Note that this value is currently not being returned on queries and is therefore temporarily unused
+  msgContent: Buffer;
+  l2BlockNumber: number;
+  l2BlockHash: Buffer;
+  txHash: Buffer;
+  /** The index of the tx within the block, used for ordering events */
+  txIndexInBlock: number;
+  /** The index of the event within the tx (based on nullifier position), used for ordering events */
+  eventIndexInTx: number;
+  /** The lookup key for #eventsByContractScopeSelector, used for cleanup during rollback */
+  lookupKey: string;
+};
+
 type PrivateEventMetadata = InTx & {
   contractAddress: AztecAddress;
   scope: AztecAddress;
@@ -36,29 +49,104 @@ export class PrivateEventStore implements StagedStore {
   readonly storeName: string = 'private_event';
 
   #store: AztecAsyncKVStore;
-  /** Actual private event log entries, keyed by siloedEventCommitment */
-  #events: AztecAsyncMap<string, Buffer>;
-  /** Multi-map from contractAddress_eventSelector to siloedEventCommitment for efficient lookup */
-  #eventsByContractAndEventSelector: AztecAsyncMultiMap<string, string>;
+  /** Map storing the actual private event log entries, keyed by siloedEventCommitment */
+  #eventLogs: AztecAsyncMap<string, PrivateEventEntry>;
+  /** Multi-map from contractAddress_scope_eventSelector to siloedEventCommitment for efficient lookup */
+  #eventsByContractScopeSelector: AztecAsyncMultiMap<string, string>;
   /** Multi-map from block number to siloedEventCommitment for rollback support */
   #eventsByBlockNumber: AztecAsyncMultiMap<number, string>;
+  /** Map from siloedEventCommitment to boolean indicating if log has been seen. */
+  #seenLogs: AztecAsyncMap<string, boolean>;
 
-  /** jobId => eventId (event siloed nullifier) => StoredPrivateEvent */
-  #eventsForJob: Map<string, Map<string, StoredPrivateEvent>>;
-
-  /** Per-job locks to prevent concurrent writes from affecting each other. */
-  #jobLocks: Map<string, Semaphore>;
+  /** jobId => eventId (event siloed nullifier)  => PrivateEventEntry */
+  #eventLogsInJobStage: Map<string, Map<string, PrivateEventEntry>>;
 
   logger = createLogger('private_event_store');
 
   constructor(store: AztecAsyncKVStore) {
     this.#store = store;
-    this.#events = this.#store.openMap('private_event_logs');
-    this.#eventsByContractAndEventSelector = this.#store.openMultiMap('events_by_contract_selector');
+    this.#eventLogs = this.#store.openMap('private_event_logs');
+    this.#eventsByContractScopeSelector = this.#store.openMultiMap('events_by_contract_scope_selector');
+    this.#seenLogs = this.#store.openMap('seen_logs');
     this.#eventsByBlockNumber = this.#store.openMultiMap('events_by_block_number');
 
-    this.#eventsForJob = new Map();
-    this.#jobLocks = new Map();
+    this.#eventLogsInJobStage = new Map();
+  }
+
+  #keyFor(contractAddress: AztecAddress, scope: AztecAddress, eventSelector: EventSelector): string {
+    return `${contractAddress.toString()}_${scope.toString()}_${eventSelector.toString()}`;
+  }
+
+  async commit(jobId: string): Promise<void> {
+    await Promise.all(
+      [...this.#getEventLogsInJobStage(jobId).entries()].map(async ([eventId, eventEntry]) => {
+        this.logger.verbose('storing private event log (KV store)', eventEntry);
+
+        await Promise.all([
+          this.#eventLogs.set(eventId, eventEntry),
+          this.#eventsByContractScopeSelector.set(eventEntry.lookupKey, eventId),
+          this.#eventsByBlockNumber.set(eventEntry.l2BlockNumber, eventId),
+          this.#seenLogs.set(eventId, true),
+        ]);
+      }),
+    );
+
+    return this.discardStaged(jobId);
+  }
+
+  discardStaged(jobId: string): Promise<void> {
+    this.#eventLogsInJobStage.delete(jobId);
+    return Promise.resolve();
+  }
+
+  #getEventLogsInJobStage(jobId: string): Map<string, PrivateEventEntry> {
+    let jobStage = this.#eventLogsInJobStage.get(jobId);
+    if (jobStage === undefined) {
+      jobStage = new Map();
+      this.#eventLogsInJobStage.set(jobId, jobStage);
+    }
+    return jobStage;
+  }
+
+  async #isSeenLog(jobId: string, eventId: string): Promise<boolean> {
+    const eventLogsInJobStage = this.#getEventLogsInJobStage(jobId).get(eventId);
+    return !!eventLogsInJobStage || !!(await this.#seenLogs.getAsync(eventId));
+  }
+
+  #addEventLogToStage(jobId: string, eventId: string, eventEntry: PrivateEventEntry) {
+    this.#getEventLogsInJobStage(jobId).set(eventId, eventEntry);
+  }
+
+  async #getEventSiloedNullifiers(
+    contractAddress: AztecAddress,
+    scope: AztecAddress,
+    eventSelector: EventSelector,
+    jobId?: string,
+  ): Promise<string[]> {
+    const key = this.#keyFor(contractAddress, scope, eventSelector);
+    const eventSiloedNullifiersInStorage: string[] = [];
+    for await (const eventId of this.#eventsByContractScopeSelector.getValuesAsync(key)) {
+      eventSiloedNullifiersInStorage.push(eventId);
+    }
+
+    if (!jobId) {
+      return eventSiloedNullifiersInStorage;
+    }
+
+    const eventSiloedNullifiersInJobStage = new Set(
+      [...this.#getEventLogsInJobStage(jobId).entries()]
+        .filter(([_, entry]) => entry.lookupKey === key)
+        .map(([idx, _]) => idx),
+    );
+    return [...new Set(eventSiloedNullifiersInStorage).union(eventSiloedNullifiersInJobStage)];
+  }
+
+  async #getEventLogBySiloedNullifier(eventId: string, jobId?: string): Promise<PrivateEventEntry | undefined> {
+    if (jobId) {
+      return this.#getEventLogsInJobStage(jobId).get(eventId) ?? (await this.#eventLogs.getAsync(eventId));
+    } else {
+      return await this.#eventLogs.getAsync(eventId);
+    }
   }
 
   /**
@@ -80,43 +168,39 @@ export class PrivateEventStore implements StagedStore {
     siloedEventCommitment: Fr,
     metadata: PrivateEventMetadata,
     jobId: string,
-  ) {
-    return this.#withJobLock(jobId, async () => {
-      const { contractAddress, scope, txHash, l2BlockNumber, l2BlockHash, txIndexInBlock, eventIndexInTx } = metadata;
+  ): Promise<void> {
+    const { contractAddress, scope, txHash, l2BlockNumber, l2BlockHash, txIndexInBlock, eventIndexInTx } = metadata;
+
+    return this.#store.transactionAsync(async () => {
+      const key = this.#keyFor(contractAddress, scope, eventSelector);
+
+      // The siloed event commitment is guaranteed to be unique as it's inserted into the nullifier tree. For this
+      // reason we use it as id.
       const eventId = siloedEventCommitment.toString();
 
+      const hasBeenSeen = await this.#isSeenLog(jobId, eventId);
+      if (hasBeenSeen) {
+        this.logger.verbose('Ignoring duplicate event log', { txHash: txHash.toString(), siloedEventCommitment });
+        return;
+      }
+
       this.logger.verbose('storing private event log (job stage)', {
-        eventId,
         contractAddress,
         scope,
         msgContent,
         l2BlockNumber,
       });
 
-      const existing = await this.#readEvent(eventId, jobId);
-
-      if (existing) {
-        // If we already stored this event, we still want to make sure to track it for the given scope
-        existing.addScope(scope.toString());
-        this.#writeEvent(eventId, existing, jobId);
-      } else {
-        this.#writeEvent(
-          eventId,
-          new StoredPrivateEvent(
-            randomness,
-            msgContent,
-            l2BlockNumber,
-            l2BlockHash,
-            txHash,
-            txIndexInBlock,
-            eventIndexInTx,
-            contractAddress,
-            eventSelector,
-            new Set([scope.toString()]),
-          ),
-          jobId,
-        );
-      }
+      this.#addEventLogToStage(jobId, eventId, {
+        randomness,
+        msgContent: serializeToBuffer(msgContent),
+        l2BlockNumber,
+        l2BlockHash: l2BlockHash.toBuffer(),
+        txHash: txHash.toBuffer(),
+        txIndexInBlock,
+        eventIndexInTx,
+        lookupKey: key,
+      });
     });
   }
 
@@ -131,78 +215,64 @@ export class PrivateEventStore implements StagedStore {
    * @returns - The event log contents, augmented with metadata about the transaction and block in which the event was
    * included.
    */
-  public getPrivateEvents(
+  public async getPrivateEvents(
     eventSelector: EventSelector,
     filter: PrivateEventStoreFilter,
   ): Promise<PackedPrivateEvent[]> {
-    return this.#store.transactionAsync(async () => {
-      const events: Array<{
-        l2BlockNumber: number;
-        txIndexInBlock: number;
-        eventIndexInTx: number;
-        event: PackedPrivateEvent;
-      }> = [];
+    const events: Array<{
+      l2BlockNumber: number;
+      txIndexInBlock: number;
+      eventIndexInTx: number;
+      event: PackedPrivateEvent;
+    }> = [];
 
-      const key = this.#keyFor(filter.contractAddress, eventSelector);
-      const targetScopes = new Set(filter.scopes.map(s => s.toString()));
-
-      const eventIds: string[] = await toArray(this.#eventsByContractAndEventSelector.getValuesAsync(key));
+    for (const scope of filter.scopes) {
+      const eventIds = await this.#getEventSiloedNullifiers(filter.contractAddress, scope, eventSelector);
 
       for (const eventId of eventIds) {
-        const eventBuffer = await this.#events.getAsync(eventId);
-
-        // Defensive, if it happens, there's a problem with how we're handling #eventsByContractAndEventSelector
-        if (!eventBuffer) {
-          this.logger.verbose(
-            `EventId ${eventId} does not exist in main index but it is referenced from contract event selector index`,
-          );
-          continue;
-        }
-
-        const storedPrivateEvent = StoredPrivateEvent.fromBuffer(eventBuffer);
+        const entry = await this.#getEventLogBySiloedNullifier(eventId);
 
-        // Filter by block range
-        if (storedPrivateEvent.l2BlockNumber < filter.fromBlock || storedPrivateEvent.l2BlockNumber >= filter.toBlock) {
+        if (!entry || entry.l2BlockNumber < filter.fromBlock || entry.l2BlockNumber >= filter.toBlock) {
           continue;
         }
 
-        // Filter by scopes
-        if (storedPrivateEvent.scopes.intersection(targetScopes).size === 0) {
-          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);
 
-        // Filter by txHash
-        if (filter.txHash && !storedPrivateEvent.txHash.equals(filter.txHash)) {
+        if (filter.txHash && !txHash.equals(filter.txHash)) {
           continue;
         }
 
         events.push({
-          l2BlockNumber: storedPrivateEvent.l2BlockNumber,
-          txIndexInBlock: storedPrivateEvent.txIndexInBlock,
-          eventIndexInTx: storedPrivateEvent.eventIndexInTx,
+          l2BlockNumber: entry.l2BlockNumber,
+          txIndexInBlock: entry.txIndexInBlock,
+          eventIndexInTx: entry.eventIndexInTx,
           event: {
-            packedEvent: storedPrivateEvent.msgContent,
-            l2BlockNumber: BlockNumber(storedPrivateEvent.l2BlockNumber),
-            txHash: storedPrivateEvent.txHash,
-            l2BlockHash: storedPrivateEvent.l2BlockHash,
+            packedEvent: msgContent,
+            l2BlockNumber: BlockNumber(entry.l2BlockNumber),
+            txHash,
+            l2BlockHash,
             eventSelector,
           },
         });
       }
+    }
 
-      // Sort by block number, then by tx index within block, then by event index within tx
-      events.sort((a, b) => {
-        if (a.l2BlockNumber !== b.l2BlockNumber) {
-          return a.l2BlockNumber - b.l2BlockNumber;
-        }
-        if (a.txIndexInBlock !== b.txIndexInBlock) {
-          return a.txIndexInBlock - b.txIndexInBlock;
-        }
-        return a.eventIndexInTx - b.eventIndexInTx;
-      });
-
-      return events.map(ev => ev.event);
+    // Sort by block number, then by tx index within block, then by event index within tx
+    events.sort((a, b) => {
+      if (a.l2BlockNumber !== b.l2BlockNumber) {
+        return a.l2BlockNumber - b.l2BlockNumber;
+      }
+      if (a.txIndexInBlock !== b.txIndexInBlock) {
+        return a.txIndexInBlock - b.txIndexInBlock;
+      }
+      return a.eventIndexInTx - b.eventIndexInTx;
     });
+    return events.map(ev => ev.event);
   }
 
   /**
@@ -226,23 +296,23 @@ export class PrivateEventStore implements StagedStore {
     let removedCount = 0;
 
     for (let block = blockNumber + 1; block <= synchedBlockNumber; block++) {
-      const eventIds: string[] = await toArray(this.#eventsByBlockNumber.getValuesAsync(block));
+      const eventIds: string[] = [];
+      for await (const eventId of this.#eventsByBlockNumber.getValuesAsync(block)) {
+        eventIds.push(eventId);
+      }
 
       if (eventIds.length > 0) {
         await this.#eventsByBlockNumber.delete(block);
 
         for (const eventId of eventIds) {
-          const buffer = await this.#events.getAsync(eventId);
-          if (!buffer) {
-            throw new Error(`Event not found for eventId ${eventId}`);
+          const entry = await this.#eventLogs.getAsync(eventId);
+          if (!entry) {
+            throw new Error(`Event log not found for eventId ${eventId}`);
           }
 
-          const entry = StoredPrivateEvent.fromBuffer(buffer);
-          await this.#events.delete(eventId);
-          await this.#eventsByContractAndEventSelector.deleteValue(
-            this.#keyFor(entry.contractAddress, entry.eventSelector),
-            eventId,
-          );
+          await this.#eventLogs.delete(eventId);
+          await this.#seenLogs.delete(eventId);
+          await this.#eventsByContractScopeSelector.deleteValue(entry.lookupKey, eventId);
 
           removedCount++;
         }
@@ -251,113 +321,4 @@ export class PrivateEventStore implements StagedStore {
 
     this.logger.verbose(`Rolled back ${removedCount} private events after block ${blockNumber}`);
   }
-
-  /**
-   * Commits in memory job data to persistent storage.
-   *
-   * Called by JobCoordinator when a job completes successfully.
-   *
-   * Note: JobCoordinator wraps all commits in a single transaction, so we don't need our own transactionAsync here
-   * (and using one would throw on IndexedDB as it does not support nested txs).
-   *
-   * @param jobId - The jobId identifying which staged data to commit
-   */
-  commit(jobId: string): Promise<void> {
-    return this.#withJobLock(jobId, async () => {
-      for (const [eventId, entry] of this.#getEventsForJob(jobId).entries()) {
-        const lookupKey = this.#keyFor(entry.contractAddress, entry.eventSelector);
-        this.logger.verbose('storing private event log', { eventId, lookupKey });
-
-        await Promise.all([
-          this.#events.set(eventId, entry.toBuffer()),
-          this.#eventsByContractAndEventSelector.set(lookupKey, eventId),
-          this.#eventsByBlockNumber.set(entry.l2BlockNumber, eventId),
-        ]);
-      }
-
-      this.#clearJobData(jobId);
-    });
-  }
-
-  /**
-   * Discards in memory job data without persisting it.
-   */
-  discardStaged(jobId: string): Promise<void> {
-    return this.#withJobLock(jobId, () => Promise.resolve(this.#clearJobData(jobId)));
-  }
-
-  /**
-   * Reads an event from in-memory job data first, falling back to persistent storage if not found.
-   *
-   * Returns undefined if the event does not exist in the store overall.
-   */
-  async #readEvent(eventId: string, jobId: string): Promise<StoredPrivateEvent | undefined> {
-    const eventForJob = this.#getEventsForJob(jobId).get(eventId);
-    if (eventForJob) {
-      return eventForJob;
-    }
-
-    const buffer = await this.#events.getAsync(eventId);
-    return buffer ? StoredPrivateEvent.fromBuffer(buffer) : undefined;
-  }
-
-  /**
-   * Writes an event to in-memory job data.
-   *
-   * Writes are only allowed in a job context. Events modified during a job will only be persisted when `commit` is
-   * called.
-   */
-  #writeEvent(eventId: string, entry: StoredPrivateEvent, jobId: string) {
-    this.#getEventsForJob(jobId).set(eventId, entry);
-  }
-
-  /**
-   * Get in-memory data only visible to @param jobId
-   */
-  #getEventsForJob(jobId: string): Map<string, StoredPrivateEvent> {
-    let eventsForJob = this.#eventsForJob.get(jobId);
-    if (eventsForJob === undefined) {
-      eventsForJob = new Map();
-      this.#eventsForJob.set(jobId, eventsForJob);
-    }
-    return eventsForJob;
-  }
-
-  /**
-   * Clear data structures supporting a specific job.
-   */
-  #clearJobData(jobId: string) {
-    this.#eventsForJob.delete(jobId);
-    this.#jobLocks.delete(jobId);
-  }
-
-  /**
-   * Ensures a function can only run once it acquires a unique per-job lock, and handles proper lock release after it
-   * runs.
-   *
-   * This primitive allows concurrent writes on this store without risking data corruption due to unsound write
-   * interleaving.
-   */
-  async #withJobLock<T>(jobId: string, fn: () => Promise<T>): Promise<T> {
-    let lock = this.#jobLocks.get(jobId);
-    if (!lock) {
-      lock = new Semaphore(1);
-      this.#jobLocks.set(jobId, lock);
-    }
-    await lock.acquire();
-    try {
-      return await fn();
-    } finally {
-      lock.release();
-    }
-  }
-
-  /**
-   * Returns a string key based on @param contractAddress and @param eventSelector.
-   *
-   * The returned key is meant to be used when interacting with index #eventsByContractAndEventSelector.
-   */
-  #keyFor(contractAddress: AztecAddress, eventSelector: EventSelector): string {
-    return `${contractAddress.toString()}_${eventSelector.toString()}`;
-  }
 }

package/src/tagging/index.ts

@@ -12,7 +12,6 @@
 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 { DirectionalAppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';

package/src/tagging/recipient_sync/load_private_logs_for_sender_recipient_pair.ts

@@ -1,6 +1,5 @@
 import type { BlockNumber } from '@aztec/foundation/branded-types';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type { DirectionalAppTaggingSecret, TxScopedL2Log } from '@aztec/stdlib/logs';
 
@@ -22,7 +21,6 @@ export async function loadPrivateLogsForSenderRecipientPair(
   aztecNode: AztecNode,
   taggingStore: RecipientTaggingStore,
   anchorBlockNumber: BlockNumber,
-  anchorBlockHash: L2BlockHash,
   jobId: string,
 ): Promise<TxScopedL2Log[]> {
   // # Explanation of how the algorithm works
@@ -94,15 +92,7 @@ export async function loadPrivateLogsForSenderRecipientPair(
 
   while (true) {
     // Get private logs with their block timestamps and corresponding tagging indexes
-    const privateLogsWithIndexes = await loadLogsForRange(
-      secret,
-      app,
-      aztecNode,
-      start,
-      end,
-      anchorBlockNumber,
-      anchorBlockHash,
-    );
+    const privateLogsWithIndexes = await loadLogsForRange(secret, app, aztecNode, start, end, anchorBlockNumber);
 
     if (privateLogsWithIndexes.length === 0) {
       break;

package/src/tagging/recipient_sync/utils/load_logs_for_range.ts

@@ -1,12 +1,9 @@
 import type { BlockNumber } from '@aztec/foundation/branded-types';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type { DirectionalAppTaggingSecret, PreTag, TxScopedL2Log } from '@aztec/stdlib/logs';
 import { SiloedTag, Tag } from '@aztec/stdlib/logs';
 
-import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
-
 /**
  * Gets private logs with their corresponding block timestamps and tagging indexes for the given index range, `app` and
  * `secret`. At most load logs from blocks up to and including `anchorBlockNumber`. `start` is inclusive and `end` is
@@ -19,7 +16,6 @@ export async function loadLogsForRange(
   start: number,
   end: number,
   anchorBlockNumber: BlockNumber,
-  anchorBlockHash: L2BlockHash,
 ): Promise<Array<{ log: TxScopedL2Log; taggingIndex: number }>> {
   // Derive tags for the window
   const preTags: PreTag[] = Array(end - start)
@@ -29,9 +25,7 @@ export async function loadLogsForRange(
     Promise.all(tags.map(tag => SiloedTag.compute(tag, app))),
   );
 
-  // We use the utility function below to retrieve all logs for the tags across all pages, so we don't need to handle
-  // pagination here.
-  const logs = await getAllPrivateLogsByTags(aztecNode, siloedTags, anchorBlockHash);
+  const logs = await aztecNode.getPrivateLogsByTags(siloedTags);
 
   // Pair logs with their corresponding tagging indexes
   const logsWithIndexes: Array<{ log: TxScopedL2Log; taggingIndex: number }> = [];

package/src/tagging/sender_sync/sync_sender_tagging_indexes.ts

@@ -1,5 +1,4 @@
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
 import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
 
@@ -27,7 +26,6 @@ export async function syncSenderTaggingIndexes(
   app: AztecAddress,
   aztecNode: AztecNode,
   taggingStore: SenderTaggingStore,
-  anchorBlockHash: L2BlockHash,
   jobId: string,
 ): Promise<void> {
   // # Explanation of how syncing works
@@ -59,7 +57,7 @@ export async function syncSenderTaggingIndexes(
   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, app, start, end, aztecNode, taggingStore, anchorBlockHash, jobId);
+    await loadAndStoreNewTaggingIndexes(secret, app, start, end, aztecNode, taggingStore, jobId);
 
     // Retrieve all indexes within the current window from storage and update their status accordingly.
     const pendingTxHashes = await taggingStore.getTxHashesOfPendingIndexes(secret, start, end, jobId);

package/src/tagging/sender_sync/utils/get_status_change_of_pending.ts

@@ -9,8 +9,11 @@ export async function getStatusChangeOfPending(
   pending: TxHash[],
   aztecNode: AztecNode,
 ): Promise<{ txHashesToFinalize: TxHash[]; txHashesToDrop: TxHash[] }> {
-  // Get receipts for all pending tx hashes.
-  const receipts = await Promise.all(pending.map(pendingTxHash => aztecNode.getTxReceipt(pendingTxHash)));
+  // Get receipts for all pending tx hashes and the finalized block number.
+  const [receipts, tips] = await Promise.all([
+    Promise.all(pending.map(pendingTxHash => aztecNode.getTxReceipt(pendingTxHash))),
+    aztecNode.getL2Tips(),
+  ]);
 
   const txHashesToFinalize: TxHash[] = [];
   const txHashesToDrop: TxHash[] = [];
@@ -19,16 +22,25 @@ export async function getStatusChangeOfPending(
     const receipt = receipts[i];
     const txHash = pending[i];
 
-    if (receipt.status === TxStatus.FINALIZED && receipt.hasExecutionSucceeded()) {
+    if (
+      receipt.status === TxStatus.SUCCESS &&
+      receipt.blockNumber &&
+      receipt.blockNumber <= tips.finalized.block.number
+    ) {
       // Tx has been included in a block and the corresponding block is finalized --> we mark the indexes as
       // finalized.
       txHashesToFinalize.push(txHash);
-    } else if (receipt.isDropped() || receipt.hasExecutionReverted()) {
+    } else if (
+      receipt.status === TxStatus.DROPPED ||
+      receipt.status === TxStatus.APP_LOGIC_REVERTED ||
+      receipt.status === TxStatus.TEARDOWN_REVERTED ||
+      receipt.status === TxStatus.BOTH_REVERTED
+    ) {
       // Tx was dropped or reverted --> we drop the corresponding pending indexes.
       // TODO(#17615): Don't drop pending indexes corresponding to non-revertible phases.
       txHashesToDrop.push(txHash);
     } else {
-      // Tx is still pending, not yet finalized, or was mined successfully but not yet finalized --> we don't do anything.
+      // Tx is still pending or the corresponding block is not yet finalized --> we don't do anything.
     }
   }
 

package/src/tagging/sender_sync/utils/load_and_store_new_tagging_indexes.ts

@@ -1,12 +1,10 @@
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { L2BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
 import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
 import { SiloedTag, Tag } from '@aztec/stdlib/logs';
 import { TxHash } from '@aztec/stdlib/tx';
 
 import type { SenderTaggingStore } from '../../../storage/tagging_store/sender_tagging_store.js';
-import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
 
 /**
  * Loads tagging indexes from the Aztec node and stores them in the tagging data provider.
@@ -29,7 +27,6 @@ export async function loadAndStoreNewTaggingIndexes(
   end: number,
   aztecNode: AztecNode,
   taggingStore: SenderTaggingStore,
-  anchorBlockHash: L2BlockHash,
   jobId: string,
 ) {
   // We compute the tags for the current window of indexes
@@ -40,7 +37,7 @@ export async function loadAndStoreNewTaggingIndexes(
     preTagsForWindow.map(async preTag => SiloedTag.compute(await Tag.compute(preTag), app)),
   );
 
-  const txsForTags = await getTxsContainingTags(siloedTagsForWindow, aztecNode, anchorBlockHash);
+  const txsForTags = await getTxsContainingTags(siloedTagsForWindow, aztecNode);
   const highestIndexMap = getTxHighestIndexMap(txsForTags, preTagsForWindow);
 
   // Now we iterate over the map, reconstruct the preTags and tx hash and store them in the db.
@@ -52,14 +49,8 @@ export async function loadAndStoreNewTaggingIndexes(
 
 // Returns txs that used the given tags. A tag might have been used in multiple txs and for this reason we return
 // an array for each tag.
-async function getTxsContainingTags(
-  tags: SiloedTag[],
-  aztecNode: AztecNode,
-  anchorBlockHash: L2BlockHash,
-): Promise<TxHash[][]> {
-  // We use the utility function below to retrieve all logs for the tags across all pages, so we don't need to handle
-  // pagination here.
-  const allLogs = await getAllPrivateLogsByTags(aztecNode, tags, anchorBlockHash);
+async function getTxsContainingTags(tags: SiloedTag[], aztecNode: AztecNode): Promise<TxHash[][]> {
+  const allLogs = await aztecNode.getPrivateLogsByTags(tags);
   return allLogs.map(logs => logs.map(log => log.txHash));
 }