@aztec/pxe 0.0.1-commit.dbf9cec → 0.0.1-commit.e0f15ab9b

package/src/storage/tagging_store/sender_tagging_store.ts

@@ -1,10 +1,13 @@
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import type { ExtendedDirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
-import { TxHash } from '@aztec/stdlib/tx';
+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
@@ -15,20 +18,19 @@ export class SenderTaggingStore implements StagedStore {
 
   #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.
+  // 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.
   //
-  // TODO(#17615): This assumes no logs are used in the non-revertible phase.
+  // 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 => { pending index, txHash }[]
-  #pendingIndexes: AztecAsyncMap<string, { index: number; txHash: string }[]>;
+  // directional app tagging secret => { lowestIndex, highestIndex, txHash }[]
+  #pendingIndexes: AztecAsyncMap<string, PendingIndexesEntry[]>;
 
-  // jobId => directional app tagging secret => { pending index, txHash }[]
-  #pendingIndexesForJob: Map<string, Map<string, { index: number; txHash: string }[]>>;
+  // 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
@@ -50,7 +52,7 @@ export class SenderTaggingStore implements StagedStore {
     this.#lastFinalizedIndexesForJob = new Map();
   }
 
-  #getPendingIndexesForJob(jobId: string): Map<string, { index: number; txHash: string }[]> {
+  #getPendingIndexesForJob(jobId: string): Map<string, PendingIndexesEntry[]> {
     let pendingIndexesForJob = this.#pendingIndexesForJob.get(jobId);
     if (!pendingIndexesForJob) {
       pendingIndexesForJob = new Map();
@@ -68,7 +70,7 @@ export class SenderTaggingStore implements StagedStore {
     return jobStagedLastFinalizedIndexes;
   }
 
-  async #readPendingIndexes(jobId: string, secret: string): Promise<{ index: number; txHash: string }[]> {
+  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);
@@ -76,7 +78,7 @@ export class SenderTaggingStore implements StagedStore {
     return staged !== undefined ? staged : (dbValue ?? []);
   }
 
-  #writePendingIndexes(jobId: string, secret: string, pendingIndexes: { index: number; txHash: string }[]) {
+  #writePendingIndexes(jobId: string, secret: string, pendingIndexes: PendingIndexesEntry[]) {
     this.#getPendingIndexesForJob(jobId).set(secret, pendingIndexes);
   }
 
@@ -126,57 +128,37 @@ export class SenderTaggingStore implements StagedStore {
   }
 
   /**
-   * 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.
+   * 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 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.
+   * @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(preTags: PreTag[], txHash: TxHash, jobId: string): Promise<void> {
-    if (preTags.length === 0) {
+  storePendingIndexes(ranges: TaggingIndexRange[], txHash: TxHash, jobId: string): Promise<void> {
+    if (ranges.length === 0) {
       return Promise.resolve();
     }
 
-    // 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.extendedSecret.toString()));
-    if (secretsSet.size !== preTags.length) {
-      return Promise.reject(new Error(`Duplicate secrets found when storing pending indexes`));
-    }
-
     const txHashStr = txHash.toString();
 
     return this.#store.transactionAsync(async () => {
       // Prefetch all data, start reads during iteration to keep IndexedDB transaction alive
-      const preTagReadPromises = preTags.map(({ extendedSecret, index }) => {
-        const secretStr = extendedSecret.toString();
-        return {
-          extendedSecret,
-          secretStr,
-          index,
-          pending: this.#readPendingIndexes(jobId, secretStr),
-          finalized: this.#readLastFinalizedIndex(jobId, secretStr),
-        };
-      });
+      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 preTagData = await Promise.all(
-        preTagReadPromises.map(async item => ({
+      const rangeData = await Promise.all(
+        rangeReadPromises.map(async item => ({
           ...item,
           pendingData: await item.pending,
           finalizedIndex: await item.finalized,
@@ -184,48 +166,51 @@ export class SenderTaggingStore implements StagedStore {
       );
 
       // Process in memory and validate
-      for (const { secretStr, index, pendingData, finalizedIndex } of preTagData) {
-        // First we check that for any secret the highest used index in tx is not further than window length from
-        // the highest finalized index.
-        if (index > (finalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN) {
+      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 ${index} is further than window length from the highest finalized index ${finalizedIndex ?? 0}.
+            `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 new pending index is lower than or equal to the last finalized index
-        if (finalizedIndex !== undefined && index <= finalizedIndex) {
+        // 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 ${index} for secret ${secretStr}: ` +
-              `it is lower than or equal to the last finalized index ${finalizedIndex}`,
+            `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 this secret + txHash combination already exists
-        const existingForSecretAndTx = pendingData.find(entry => entry.txHash === txHashStr);
+        // Check if an entry with the same txHash already exists
+        const existingEntry = pendingData.find(entry => entry.txHash === txHashStr);
 
-        if (existingForSecretAndTx) {
-          // If it exists with a different index, throw an error
-          if (existingForSecretAndTx.index !== index) {
+        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(
-              `Cannot store index ${index} for secret ${secretStr} and txHash ${txHashStr}: ` +
-                `a different index ${existingForSecretAndTx.index} already exists for this secret-txHash pair`,
+              `Conflicting range for secret ${secretStr} and txHash ${txHashStr}: ` +
+                `existing [${existingEntry.lowestIndex}, ${existingEntry.highestIndex}] vs ` +
+                `new [${range.lowestIndex}, ${range.highestIndex}]`,
             );
           }
-          // If it exists with the same index, ignore the update (no-op)
+          // Exact duplicate — skip
         } else {
-          // If it doesn't exist, add it
-          this.#writePendingIndexes(jobId, secretStr, [...pendingData, { index, txHash: txHashStr }]);
+          this.#writePendingIndexes(jobId, secretStr, [
+            ...pendingData,
+            { lowestIndex: range.lowestIndex, highestIndex: range.highestIndex, txHash: txHashStr },
+          ]);
         }
       }
     });
   }
 
   /**
-   * Returns the transaction hashes of all pending transactions that contain indexes within a specified range
-   * for a given directional app tagging secret.
+   * 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).
@@ -241,7 +226,7 @@ export class SenderTaggingStore implements StagedStore {
     return this.#store.transactionAsync(async () => {
       const existing = await this.#readPendingIndexes(jobId, secret.toString());
       const txHashes = existing
-        .filter(entry => entry.index >= startIndex && entry.index < endIndex)
+        .filter(entry => entry.highestIndex >= startIndex && entry.highestIndex < endIndex)
         .map(entry => entry.txHash);
       return Array.from(new Set(txHashes)).map(TxHash.fromString);
     });
@@ -269,16 +254,15 @@ export class SenderTaggingStore implements StagedStore {
       const pendingPromise = this.#readPendingIndexes(jobId, secretStr);
       const finalizedPromise = this.#readLastFinalizedIndex(jobId, secretStr);
 
-      const [pendingTxScopedIndexes, lastFinalized] = await Promise.all([pendingPromise, finalizedPromise]);
-      const pendingIndexes = pendingTxScopedIndexes.map(entry => entry.index);
+      const [pendingEntries, lastFinalized] = await Promise.all([pendingPromise, finalizedPromise]);
 
-      if (pendingTxScopedIndexes.length === 0) {
+      if (pendingEntries.length === 0) {
         return lastFinalized;
       }
 
-      // 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);
+      // 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));
     });
   }
 
@@ -294,7 +278,7 @@ export class SenderTaggingStore implements StagedStore {
 
     return this.#store.transactionAsync(async () => {
       // Prefetch all data, start reads during iteration to keep IndexedDB transaction alive
-      const secretReadPromises: Map<string, Promise<{ index: number; txHash: string }[]>> = new Map();
+      const secretReadPromises: Map<string, Promise<PendingIndexesEntry[]>> = new Map();
 
       for await (const secret of this.#pendingIndexes.keysAsync()) {
         secretReadPromises.set(secret, this.#readPendingIndexes(jobId, secret));
@@ -330,22 +314,15 @@ export class SenderTaggingStore implements StagedStore {
     });
   }
 
-  /**
-   * Updates pending indexes corresponding to the given transaction hashes to be finalized and prunes any lower pending
-   * indexes.
-   */
-  finalizePendingIndexes(txHashes: TxHash[], jobId: string): Promise<void> {
-    if (txHashes.length === 0) {
-      return Promise.resolve();
-    }
-
-    const txHashStrings = new Set(txHashes.map(tx => tx.toString()));
-
+  /** 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<{ index: number; txHash: string }[]>; finalized: Promise<number | undefined> }
+        { pending: Promise<PendingIndexesEntry[]>; finalized: Promise<number | undefined> }
       > = new Map();
 
       for await (const secret of this.#pendingIndexes.keysAsync()) {
@@ -375,55 +352,125 @@ export class SenderTaggingStore implements StagedStore {
         })),
       );
 
-      // Process all txHashes for each secret in memory
-      for (const { secret, pendingData, lastFinalized } of dataResults) {
-        if (!pendingData || pendingData.length === 0) {
+      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;
         }
 
-        let currentPending = pendingData;
-        let currentFinalized = lastFinalized;
+        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}`);
+        }
 
-        // Process all txHashes for this secret
-        for (const txHashStr of txHashStrings) {
-          const matchingIndexes = currentPending.filter(item => item.txHash === txHashStr).map(item => item.index);
-          if (matchingIndexes.length === 0) {
-            continue;
-          }
+        const newFinalized = matchingEntries[0].highestIndex;
 
-          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}`);
-          }
+        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}`,
+          );
+        }
 
-          const newFinalized = matchingIndexes[0];
+        currentFinalized = newFinalized;
 
-          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}`,
-            );
-          }
+        // 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!);
+      }
 
-          currentFinalized = newFinalized;
+      // Write final state if changed
+      if (currentFinalized !== lastFinalized) {
+        this.#writeLastFinalizedIndex(jobId, secret, currentFinalized!);
+      }
+      if (currentPending !== pendingData) {
+        this.#writePendingIndexes(jobId, secret, currentPending);
+      }
+    }
+  }
 
-          // 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.index > currentFinalized!);
-        }
+  /**
+   * 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();
 
-        // Write final state if changed
-        if (currentFinalized !== lastFinalized) {
-          this.#writeLastFinalizedIndex(jobId, secret, currentFinalized!);
-        }
-        if (currentPending !== pendingData) {
-          this.#writePendingIndexes(jobId, secret, currentPending);
+    // 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/index.ts

@@ -16,4 +16,4 @@ export { getAllPrivateLogsByTags, getAllPublicLogsByTagsFromContract } from './g
 
 // Re-export tagging-related types from stdlib
 export { ExtendedDirectionalAppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';
-export { type PreTag } from '@aztec/stdlib/logs';
+export { type PreTag, type TaggingIndexRange } from '@aztec/stdlib/logs';

package/src/tagging/sender_sync/sync_sender_tagging_indexes.ts

@@ -62,11 +62,29 @@ export async function syncSenderTaggingIndexes(
       break;
     }
 
-    const { txHashesToFinalize, txHashesToDrop } = await getStatusChangeOfPending(pendingTxHashes, aztecNode);
+    const { txHashesToFinalize, txHashesToDrop, txHashesWithExecutionReverted } = await getStatusChangeOfPending(
+      pendingTxHashes,
+      aztecNode,
+    );
 
     await taggingStore.dropPendingIndexes(txHashesToDrop, jobId);
     await taggingStore.finalizePendingIndexes(txHashesToFinalize, jobId);
 
+    if (txHashesWithExecutionReverted.length > 0) {
+      const indexedTxEffects = await Promise.all(
+        txHashesWithExecutionReverted.map(txHash => aztecNode.getTxEffect(txHash)),
+      );
+      for (const indexedTxEffect of indexedTxEffects) {
+        if (indexedTxEffect === undefined) {
+          throw new Error(
+            'TxEffect not found for execution-reverted tx. This is either a bug or a reorg has occurred.',
+          );
+        }
+
+        await taggingStore.finalizePendingIndexesOfAPartiallyRevertedTx(indexedTxEffect.data, jobId);
+      }
+    }
+
     // We check if the finalized index has been updated.
     newFinalizedIndex = await taggingStore.getLastFinalizedIndex(secret, jobId);
     if (previousFinalizedIndex !== newFinalizedIndex) {

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

@@ -2,35 +2,50 @@ import type { AztecNode } from '@aztec/stdlib/interfaces/server';
 import { TxHash, TxStatus } from '@aztec/stdlib/tx';
 
 /**
- * Based on receipts obtained from `aztecNode` returns which pending transactions changed their status to finalized or
- * dropped.
+ * Based on receipts obtained from `aztecNode` returns which pending transactions changed their status to finalized,
+ * dropped, or execution-reverted (but mined).
  */
 export async function getStatusChangeOfPending(
   pending: TxHash[],
   aztecNode: AztecNode,
-): Promise<{ txHashesToFinalize: TxHash[]; txHashesToDrop: TxHash[] }> {
+): Promise<{
+  txHashesToFinalize: TxHash[];
+  txHashesToDrop: TxHash[];
+  txHashesWithExecutionReverted: TxHash[];
+}> {
   // Get receipts for all pending tx hashes.
   const receipts = await Promise.all(pending.map(pendingTxHash => aztecNode.getTxReceipt(pendingTxHash)));
 
   const txHashesToFinalize: TxHash[] = [];
   const txHashesToDrop: TxHash[] = [];
+  const txHashesWithExecutionReverted: TxHash[] = [];
 
   for (let i = 0; i < receipts.length; i++) {
     const receipt = receipts[i];
     const txHash = pending[i];
 
-    if (receipt.status === TxStatus.FINALIZED && receipt.hasExecutionSucceeded()) {
-      // 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()) {
-      // Tx was dropped or reverted --> we drop the corresponding pending indexes.
-      // TODO(#17615): Don't drop pending indexes corresponding to non-revertible phases.
+    if (receipt.status === TxStatus.FINALIZED) {
+      // Tx has been included in a block and the corresponding block is finalized
+      if (receipt.hasExecutionSucceeded()) {
+        // No part of execution reverted - we just finalize all the indexes.
+        txHashesToFinalize.push(txHash);
+      } else if (receipt.hasExecutionReverted()) {
+        // Tx was mined but execution reverted (app logic, teardown, or both). Some logs from the non-revertible
+        // phase may still be onchain. We check which tags made it onchain and finalize those; drop the rest.
+        txHashesWithExecutionReverted.push(txHash);
+      } else {
+        // Defensive check - this branch should never be triggered
+        throw new Error(
+          'Both hasExecutionSucceeded and hasExecutionReverted on the receipt returned false. This should never happen and it implies a bug. Please open an issue.',
+        );
+      }
+    } else if (receipt.isDropped()) {
+      // Tx was dropped from the mempool --> we drop the corresponding pending indexes.
       txHashesToDrop.push(txHash);
     } else {
       // Tx is still pending, not yet finalized, or was mined successfully but not yet finalized --> we don't do anything.
     }
   }
 
-  return { txHashesToFinalize, txHashesToDrop };
+  return { txHashesToFinalize, txHashesToDrop, txHashesWithExecutionReverted };
 }

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

@@ -16,6 +16,7 @@ import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
  * @param end - The ending index (exclusive) of the window to process.
  * @param aztecNode - The Aztec node instance to query for logs.
  * @param taggingStore - The data provider to store pending indexes.
+ * @param anchorBlockHash - Hash of a block to use as reference block when querying node.
  * @param jobId - Job identifier, used to keep writes in-memory until they can be persisted in a data integrity
  * preserving way.
  */
@@ -34,12 +35,13 @@ export async function loadAndStoreNewTaggingIndexes(
   );
 
   const txsForTags = await getTxsContainingTags(siloedTagsForWindow, aztecNode, anchorBlockHash);
-  const highestIndexMap = getTxHighestIndexMap(txsForTags, start, siloedTagsForWindow.length);
+  const txIndexesMap = getTxIndexesMap(txsForTags, start, siloedTagsForWindow.length);
 
-  // Now we iterate over the map, reconstruct the preTags and tx hash and store them in the db.
-  for (const [txHashStr, highestIndex] of highestIndexMap.entries()) {
+  // Now we iterate over the map, construct the tagging index ranges and store them in the db.
+  for (const [txHashStr, indexes] of txIndexesMap.entries()) {
     const txHash = TxHash.fromString(txHashStr);
-    await taggingStore.storePendingIndexes([{ extendedSecret, index: highestIndex }], txHash, jobId);
+    const ranges = [{ extendedSecret, lowestIndex: Math.min(...indexes), highestIndex: Math.max(...indexes) }];
+    await taggingStore.storePendingIndexes(ranges, txHash, jobId);
   }
 }
 
@@ -56,20 +58,28 @@ async function getTxsContainingTags(
   return allLogs.map(logs => logs.map(log => log.txHash));
 }
 
-// Returns a map of txHash to the highest index for that txHash.
-function getTxHighestIndexMap(txHashesForTags: TxHash[][], start: number, count: number): Map<string, number> {
+// Returns a map of txHash to all indexes for that txHash.
+function getTxIndexesMap(txHashesForTags: TxHash[][], start: number, count: number): Map<string, number[]> {
   if (txHashesForTags.length !== count) {
     throw new Error(`Number of tx hashes arrays does not match number of tags. ${txHashesForTags.length} !== ${count}`);
   }
 
-  const highestIndexMap = new Map<string, number>();
+  const indexesMap = new Map<string, number[]>();
+  // Iterate over indexes
   for (let i = 0; i < txHashesForTags.length; i++) {
     const taggingIndex = start + i;
     const txHashesForTag = txHashesForTags[i];
+    // iterate over tx hashes that used that index (tag)
     for (const txHash of txHashesForTag) {
       const key = txHash.toString();
-      highestIndexMap.set(key, Math.max(highestIndexMap.get(key) ?? 0, taggingIndex));
+      const existing = indexesMap.get(key);
+      // Add the index to the tx's indexes
+      if (existing) {
+        existing.push(taggingIndex);
+      } else {
+        indexesMap.set(key, [taggingIndex]);
+      }
     }
   }
-  return highestIndexMap;
+  return indexesMap;
 }