@aztec/pxe 0.0.1-commit.c7c42ec → 0.0.1-commit.f295ac2

package/src/storage/tagging_store/sender_tagging_store.ts

@@ -3,14 +3,17 @@ 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';
+import type { StagedStore } from '../../job_coordinator/job_coordinator.js';
+import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.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
+ * 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 {
+export class SenderTaggingStore implements StagedStore {
+  readonly storeName = 'sender_tagging';
+
   #store: AztecAsyncKVStore;
 
   // Stores the pending indexes for each directional app tagging secret. Pending here means that the tx that contained
@@ -21,18 +24,114 @@ export class SenderTaggingStore {
   // the smaller ones are irrelevant due to tx atomicity.
   //
   // TODO(#17615): This assumes no logs are used in the non-revertible phase.
+  //
+  // directional app tagging secret => { pending index, txHash }[]
   #pendingIndexes: AztecAsyncMap<string, { index: number; txHash: string }[]>;
 
+  // jobId => directional app tagging secret => { pending index, txHash }[]
+  #pendingIndexesForJob: Map<string, Map<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.
+  //
+  // 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, { index: number; txHash: string }[]> {
+    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<{ index: number; txHash: string }[]> {
+    const jobStagedPendingIndexes = this.#getPendingIndexesForJob(jobId);
+    const pendingIndexes = jobStagedPendingIndexes.get(secret);
+    // We return the staged version of this if it exists, if not, we read from the DB.
+    // If the DB also has nothing, we return an empty array [].
+    return pendingIndexes !== undefined ? pendingIndexes : ((await this.#pendingIndexes.getAsync(secret)) ?? []);
+  }
+
+  #writePendingIndexes(jobId: string, secret: string, pendingIndexes: { index: number; txHash: string }[]) {
+    this.#getPendingIndexesForJob(jobId).set(secret, pendingIndexes);
+  }
+
+  /**
+   * Returns a job view of all the secrets that have a corresponding list of pending indexes either in persistent
+   * storage or the current job.
+   */
+  async #readSecretsWithPendingIndexes(jobId: string): Promise<string[]> {
+    const storedSecrets = new Set(await toArray(this.#pendingIndexes.keysAsync()));
+    const stagedSecrets = this.#getPendingIndexesForJob(jobId).keys();
+    return [...storedSecrets.union(new Set(stagedSecrets))];
+  }
+
+  async #readLastFinalizedIndex(jobId: string, secret: string): Promise<number | undefined> {
+    return (
+      this.#getLastFinalizedIndexesForJob(jobId).get(secret) ?? (await this.#lastFinalizedIndexes.getAsync(secret))
+    );
+  }
+
+  #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();
   }
 
   /**
@@ -43,6 +142,7 @@ export class SenderTaggingStore {
    * @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.
+   * @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.
@@ -56,7 +156,7 @@ export class SenderTaggingStore {
    * 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) {
+  async storePendingIndexes(preTags: PreTag[], txHash: TxHash, jobId: string) {
     // 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()));
@@ -67,7 +167,7 @@ export class SenderTaggingStore {
     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;
+      const finalizedIndex = (await this.getLastFinalizedIndex(secret, jobId)) ?? 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}.
@@ -78,7 +178,7 @@ export class SenderTaggingStore {
 
       // 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);
+      const lastFinalizedIndex = await this.#readLastFinalizedIndex(jobId, secretStr);
       if (lastFinalizedIndex !== undefined && index <= lastFinalizedIndex) {
         throw new Error(
           `Cannot store pending index ${index} for secret ${secretStr}: ` +
@@ -88,7 +188,7 @@ export class SenderTaggingStore {
 
       // Check if this secret + txHash combination already exists
       const txHashStr = txHash.toString();
-      const existingForSecret = (await this.#pendingIndexes.getAsync(secretStr)) ?? [];
+      const existingForSecret = await this.#readPendingIndexes(jobId, secretStr);
       const existingForSecretAndTx = existingForSecret.find(entry => entry.txHash === txHashStr);
 
       if (existingForSecretAndTx) {
@@ -102,7 +202,7 @@ export class SenderTaggingStore {
         // 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 }]);
+        this.#writePendingIndexes(jobId, secretStr, [...existingForSecret, { index, txHash: txHashStr }]);
       }
     }
   }
@@ -120,8 +220,9 @@ export class SenderTaggingStore {
     secret: DirectionalAppTaggingSecret,
     startIndex: number,
     endIndex: number,
+    jobId: string,
   ): Promise<TxHash[]> {
-    const existing = (await this.#pendingIndexes.getAsync(secret.toString())) ?? [];
+    const existing = await this.#readPendingIndexes(jobId, secret.toString());
     const txHashes = existing
       .filter(entry => entry.index >= startIndex && entry.index < endIndex)
       .map(entry => entry.txHash);
@@ -133,8 +234,8 @@ export class SenderTaggingStore {
    * @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());
+  getLastFinalizedIndex(secret: DirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
+    return this.#readLastFinalizedIndex(jobId, secret.toString());
   }
 
   /**
@@ -143,13 +244,13 @@ export class SenderTaggingStore {
    * @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> {
+  async getLastUsedIndex(secret: DirectionalAppTaggingSecret, jobId: string): Promise<number | undefined> {
     const secretStr = secret.toString();
-    const pendingTxScopedIndexes = (await this.#pendingIndexes.getAsync(secretStr)) ?? [];
+    const pendingTxScopedIndexes = await this.#readPendingIndexes(jobId, secretStr);
     const pendingIndexes = pendingTxScopedIndexes.map(entry => entry.index);
 
     if (pendingTxScopedIndexes.length === 0) {
-      return this.#lastFinalizedIndexes.getAsync(secretStr);
+      return this.#readLastFinalizedIndex(jobId, secretStr);
     }
 
     // As the last used index we return the highest one from the pending indexes. Note that this value will be always
@@ -160,23 +261,23 @@ export class SenderTaggingStore {
   /**
    * Drops all pending indexes corresponding to the given transaction hashes.
    */
-  async dropPendingIndexes(txHashes: TxHash[]) {
+  async dropPendingIndexes(txHashes: TxHash[], jobId: string) {
     if (txHashes.length === 0) {
       return;
     }
 
-    const txHashStrs = new Set<string>(txHashes.map(txHash => txHash.toString()));
-    const allSecrets = await toArray(this.#pendingIndexes.keysAsync());
+    const txHashStrings = new Set<string>(txHashes.map(txHash => txHash.toString()));
+    const allSecrets = await this.#readSecretsWithPendingIndexes(jobId);
 
     for (const secret of allSecrets) {
-      const pendingData = await this.#pendingIndexes.getAsync(secret);
+      const pendingData = await this.#readPendingIndexes(jobId, secret);
       if (pendingData) {
-        const filtered = pendingData.filter(item => !txHashStrs.has(item.txHash));
+        const filtered = pendingData.filter(item => !txHashStrings.has(item.txHash));
         if (filtered.length === 0) {
-          await this.#pendingIndexes.delete(secret);
+          this.#writePendingIndexes(jobId, secret, []);
         } else if (filtered.length !== pendingData.length) {
           // Some items were filtered out, so update the pending data
-          await this.#pendingIndexes.set(secret, filtered);
+          this.#writePendingIndexes(jobId, secret, filtered);
         }
         // else: No items were filtered out (txHashes not found for this secret) --> no-op
       }
@@ -187,7 +288,7 @@ export class SenderTaggingStore {
    * Updates pending indexes corresponding to the given transaction hashes to be finalized and prunes any lower pending
    * indexes.
    */
-  async finalizePendingIndexes(txHashes: TxHash[]) {
+  async finalizePendingIndexes(txHashes: TxHash[], jobId: string) {
     if (txHashes.length === 0) {
       return;
     }
@@ -195,10 +296,10 @@ export class SenderTaggingStore {
     for (const txHash of txHashes) {
       const txHashStr = txHash.toString();
 
-      const allSecrets = await toArray(this.#pendingIndexes.keysAsync());
+      const allSecrets = await this.#readSecretsWithPendingIndexes(jobId);
 
       for (const secret of allSecrets) {
-        const pendingData = await this.#pendingIndexes.getAsync(secret);
+        const pendingData = await this.#readPendingIndexes(jobId, secret);
         if (!pendingData) {
           continue;
         }
@@ -214,7 +315,7 @@ export class SenderTaggingStore {
           throw new Error(`Multiple pending indexes found for tx hash ${txHashStr} and secret ${secret}`);
         }
 
-        let lastFinalized = await this.#lastFinalizedIndexes.getAsync(secret);
+        let lastFinalized = await this.#readLastFinalizedIndex(jobId, secret);
         const newFinalized = matchingIndexes[0];
 
         if (newFinalized < (lastFinalized ?? 0)) {
@@ -225,7 +326,7 @@ export class SenderTaggingStore {
           );
         }
 
-        await this.#lastFinalizedIndexes.set(secret, newFinalized);
+        this.#writeLastFinalizedIndex(jobId, secret, newFinalized);
         lastFinalized = newFinalized;
 
         // When we add pending indexes, we ensure they are higher than the last finalized index. However, because we
@@ -234,9 +335,9 @@ export class SenderTaggingStore {
         // outdated pending indexes.
         const remainingItemsOfHigherIndex = pendingData.filter(item => item.index > (lastFinalized ?? 0));
         if (remainingItemsOfHigherIndex.length === 0) {
-          await this.#pendingIndexes.delete(secret);
+          this.#writePendingIndexes(jobId, secret, []);
         } else {
-          await this.#pendingIndexes.set(secret, remainingItemsOfHigherIndex);
+          this.#writePendingIndexes(jobId, secret, remainingItemsOfHigherIndex);
         }
       }
     }

package/src/tagging/constants.ts

@@ -0,0 +1,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/index.ts

@@ -11,17 +11,7 @@
 
 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;
+export { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from './constants.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

@@ -4,7 +4,7 @@ import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type { DirectionalAppTaggingSecret, TxScopedL2Log } from '@aztec/stdlib/logs';
 
 import type { RecipientTaggingStore } from '../../storage/tagging_store/recipient_tagging_store.js';
-import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../index.js';
+import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
 import { findHighestIndexes } from './utils/find_highest_indexes.js';
 import { loadLogsForRange } from './utils/load_logs_for_range.js';
 
@@ -21,6 +21,7 @@ export async function loadPrivateLogsForSenderRecipientPair(
   aztecNode: AztecNode,
   taggingStore: RecipientTaggingStore,
   anchorBlockNumber: BlockNumber,
+  jobId: string,
 ): Promise<TxScopedL2Log[]> {
   // # Explanation of how the algorithm works
   // When we perform the sync we will look at logs that correspond to the tagging index range
@@ -68,13 +69,16 @@ export async function loadPrivateLogsForSenderRecipientPair(
       throw new Error('Node failed to return latest block header when syncing logs');
     }
 
-    [finalizedBlockNumber, currentTimestamp] = [l2Tips.finalized.number, latestBlockHeader.globalVariables.timestamp];
+    [finalizedBlockNumber, currentTimestamp] = [
+      l2Tips.finalized.block.number,
+      latestBlockHeader.globalVariables.timestamp,
+    ];
   }
 
   let start: number, end: number;
   {
-    const currentHighestAgedIndex = await taggingStore.getHighestAgedIndex(secret);
-    const currentHighestFinalizedIndex = await taggingStore.getHighestFinalizedIndex(secret);
+    const currentHighestAgedIndex = await taggingStore.getHighestAgedIndex(secret, jobId);
+    const currentHighestFinalizedIndex = await taggingStore.getHighestFinalizedIndex(secret, jobId);
 
     // We don't want to include the highest aged index so we start from `currentHighestAgedIndex + 1` (or 0 if not set)
     start = currentHighestAgedIndex === undefined ? 0 : currentHighestAgedIndex + 1;
@@ -104,7 +108,7 @@ export async function loadPrivateLogsForSenderRecipientPair(
 
     // Store updates in data provider and update local variables
     if (highestAgedIndex !== undefined) {
-      await taggingStore.updateHighestAgedIndex(secret, highestAgedIndex);
+      await taggingStore.updateHighestAgedIndex(secret, highestAgedIndex, jobId);
     }
 
     if (highestFinalizedIndex === undefined) {
@@ -117,7 +121,7 @@ export async function loadPrivateLogsForSenderRecipientPair(
       throw new Error('Highest aged index lower than highest finalized index invariant violated');
     }
 
-    await taggingStore.updateHighestFinalizedIndex(secret, highestFinalizedIndex);
+    await taggingStore.updateHighestFinalizedIndex(secret, highestFinalizedIndex, jobId);
 
     // For the next iteration we want to look only at indexes for which we have not attempted to load logs yet while
     // ensuring that we do not look further than WINDOW_LEN ahead of the highest finalized index.

package/src/tagging/sender_sync/sync_sender_tagging_indexes.ts

@@ -3,7 +3,7 @@ import type { AztecNode } from '@aztec/stdlib/interfaces/server';
 import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
 
 import type { SenderTaggingStore } from '../../storage/tagging_store/sender_tagging_store.js';
-import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../index.js';
+import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
 import { getStatusChangeOfPending } from './utils/get_status_change_of_pending.js';
 import { loadAndStoreNewTaggingIndexes } from './utils/load_and_store_new_tagging_indexes.js';
 
@@ -26,6 +26,7 @@ export async function syncSenderTaggingIndexes(
   app: AztecAddress,
   aztecNode: AztecNode,
   taggingStore: SenderTaggingStore,
+  jobId: string,
 ): Promise<void> {
   // # Explanation of how syncing works
   //
@@ -45,7 +46,7 @@ export async function syncSenderTaggingIndexes(
   // Each window advance requires two queries (logs + tx status). For example, syncing indexes 0–500 with a window of
   // 100 takes at least 10 round trips (5 windows × 2 queries).
 
-  const finalizedIndex = await taggingStore.getLastFinalizedIndex(secret);
+  const finalizedIndex = await taggingStore.getLastFinalizedIndex(secret, jobId);
 
   let start = finalizedIndex === undefined ? 0 : finalizedIndex + 1;
   let end = start + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN;
@@ -56,21 +57,21 @@ 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);
+    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);
+    const pendingTxHashes = await taggingStore.getTxHashesOfPendingIndexes(secret, start, end, jobId);
     if (pendingTxHashes.length === 0) {
       break;
     }
 
     const { txHashesToFinalize, txHashesToDrop } = await getStatusChangeOfPending(pendingTxHashes, aztecNode);
 
-    await taggingStore.dropPendingIndexes(txHashesToDrop);
-    await taggingStore.finalizePendingIndexes(txHashesToFinalize);
+    await taggingStore.dropPendingIndexes(txHashesToDrop, jobId);
+    await taggingStore.finalizePendingIndexes(txHashesToFinalize, jobId);
 
     // We check if the finalized index has been updated.
-    newFinalizedIndex = await taggingStore.getLastFinalizedIndex(secret);
+    newFinalizedIndex = await taggingStore.getLastFinalizedIndex(secret, jobId);
     if (previousFinalizedIndex !== newFinalizedIndex) {
       // A new finalized index was found, so we'll run the loop again. For example:
       // - Previous finalized index: 10

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

@@ -10,7 +10,7 @@ export async function getStatusChangeOfPending(
   aztecNode: AztecNode,
 ): Promise<{ txHashesToFinalize: TxHash[]; txHashesToDrop: TxHash[] }> {
   // Get receipts for all pending tx hashes and the finalized block number.
-  const [receipts, { finalized }] = await Promise.all([
+  const [receipts, tips] = await Promise.all([
     Promise.all(pending.map(pendingTxHash => aztecNode.getTxReceipt(pendingTxHash))),
     aztecNode.getL2Tips(),
   ]);
@@ -22,7 +22,11 @@ export async function getStatusChangeOfPending(
     const receipt = receipts[i];
     const txHash = pending[i];
 
-    if (receipt.status === TxStatus.SUCCESS && receipt.blockNumber && receipt.blockNumber <= finalized.number) {
+    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);

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

@@ -17,6 +17,8 @@ import type { SenderTaggingStore } from '../../../storage/tagging_store/sender_t
  * @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 jobId - Job identifier, used to keep writes in-memory until they can be persisted in a data integrity
+ * preserving way.
  */
 export async function loadAndStoreNewTaggingIndexes(
   secret: DirectionalAppTaggingSecret,
@@ -25,6 +27,7 @@ export async function loadAndStoreNewTaggingIndexes(
   end: number,
   aztecNode: AztecNode,
   taggingStore: SenderTaggingStore,
+  jobId: string,
 ) {
   // We compute the tags for the current window of indexes
   const preTagsForWindow: PreTag[] = Array(end - start)
@@ -40,7 +43,7 @@ export async function loadAndStoreNewTaggingIndexes(
   // 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()) {
     const txHash = TxHash.fromString(txHashStr);
-    await taggingStore.storePendingIndexes([{ secret, index: highestIndex }], txHash);
+    await taggingStore.storePendingIndexes([{ secret, index: highestIndex }], txHash, jobId);
   }
 }
 

package/src/tree_membership/tree_membership_service.ts

@@ -2,73 +2,67 @@ import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { SiblingPath } from '@aztec/foundation/trees';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { BlockParameter } from '@aztec/stdlib/block';
+import { L2BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
 import { getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
 import { MerkleTreeId, NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
 
-import type { AnchorBlockStore } from '../storage/anchor_block_store/anchor_block_store.js';
-
+// TODO: REmove this class as it no longer seems valuable. The only somewhat real functionality in this class is in
+// the `getMembershipWitness` method that is used by `utilityGetMembershipWitness` oracle by then in Aztec.nr we
+// have helper functions around that oracle for archive and note hash tree and the generic method itself is not used
+// anywhere else - make sense to just have simple specific handlers for the archive and note hash trees and drop this.
 export class TreeMembershipService {
-  constructor(
-    private readonly aztecNode: AztecNode,
-    private readonly anchorBlockStore: AnchorBlockStore,
-  ) {}
+  constructor(private readonly aztecNode: AztecNode) {}
 
   /**
    * Gets the index of a nullifier in the nullifier tree.
    * @returns - The index of the nullifier. Undefined if it does not exist in the tree.
    */
-  public getNullifierIndex(nullifier: Fr) {
-    return this.#findLeafIndex('latest', MerkleTreeId.NULLIFIER_TREE, nullifier);
+  public async getNullifierIndex(nullifier: Fr): Promise<bigint | undefined> {
+    const [leafIndex] = await this.aztecNode.findLeavesIndexes('latest', MerkleTreeId.NULLIFIER_TREE, [nullifier]);
+    return leafIndex?.data;
   }
 
   /**
    * Fetches the index and sibling path of a leaf at a given block from a given tree.
-   * @param blockNumber - The block number at which to get the membership witness.
+   * @param blockHash - The block hash at which to get the membership witness.
    * @param treeId - Id of the tree to get the sibling path from.
    * @param leafValue - The leaf value
    * @returns The index and sibling path concatenated [index, sibling_path]
    */
-  public async getMembershipWitness(blockNumber: BlockParameter, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[]> {
-    const witness = await this.#tryGetMembershipWitness(blockNumber, treeId, leafValue);
+  public async getMembershipWitness(blockHash: L2BlockHash, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[]> {
+    const witness = await this.#tryGetMembershipWitness(blockHash, treeId, leafValue);
     if (!witness) {
-      throw new Error(`Leaf value ${leafValue} not found in tree ${MerkleTreeId[treeId]} at block ${blockNumber}`);
+      throw new Error(
+        `Leaf value ${leafValue} not found in tree ${MerkleTreeId[treeId]} at block hash ${blockHash.toString()}`,
+      );
     }
     return witness;
   }
 
   /**
    * Returns a low nullifier membership witness for a given nullifier at a given block.
-   * @param blockNumber - The block number at which to get the index.
+   * @param blockHash - The block hash at which to get the index.
    * @param nullifier - Nullifier we try to find the low nullifier witness for.
    * @returns The low nullifier membership witness (if found).
    * @remarks Low nullifier witness can be used to perform a nullifier non-inclusion proof by leveraging the "linked
    * list structure" of leaves and proving that a lower nullifier is pointing to a bigger next value than the nullifier
    * we are trying to prove non-inclusion for.
    */
-  public async getLowNullifierMembershipWitness(
-    blockNumber: BlockParameter,
+  public getLowNullifierMembershipWitness(
+    blockHash: L2BlockHash,
     nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined> {
-    const anchorBlockNumber = (await this.anchorBlockStore.getBlockHeader()).getBlockNumber();
-    if (blockNumber !== 'latest' && blockNumber > anchorBlockNumber) {
-      throw new Error(`Block number ${blockNumber} is higher than current block ${anchorBlockNumber}`);
-    }
-    return this.aztecNode.getLowNullifierMembershipWitness(blockNumber, nullifier);
+    return this.aztecNode.getLowNullifierMembershipWitness(blockHash, nullifier);
   }
 
   /**
    * Returns a witness for a given slot of the public data tree at a given block.
-   * @param blockNumber - The block number at which to get the witness.
+   * @param blockHash - The block hash at which to get the witness.
    * @param leafSlot - The slot of the public data in the public data tree.
    */
-  public async getPublicDataWitness(blockNumber: BlockParameter, leafSlot: Fr): Promise<PublicDataWitness | undefined> {
-    const anchorBlockNumber = (await this.anchorBlockStore.getBlockHeader()).getBlockNumber();
-    if (blockNumber !== 'latest' && blockNumber > anchorBlockNumber) {
-      throw new Error(`Block number ${blockNumber} is higher than current block ${anchorBlockNumber}`);
-    }
-    return await this.aztecNode.getPublicDataWitness(blockNumber, leafSlot);
+  public getPublicDataWitness(blockHash: L2BlockHash, leafSlot: Fr): Promise<PublicDataWitness | undefined> {
+    return this.aztecNode.getPublicDataWitness(blockHash, leafSlot);
   }
 
   /**
@@ -86,27 +80,18 @@ export class TreeMembershipService {
     return getNonNullifiedL1ToL2MessageWitness(this.aztecNode, contractAddress, messageHash, secret);
   }
 
-  async #tryGetMembershipWitness(
-    blockNumber: BlockParameter,
-    treeId: MerkleTreeId,
-    value: Fr,
-  ): Promise<Fr[] | undefined> {
+  async #tryGetMembershipWitness(blockHash: L2BlockHash, treeId: MerkleTreeId, value: Fr): Promise<Fr[] | undefined> {
     switch (treeId) {
       case MerkleTreeId.NULLIFIER_TREE:
-        return (await this.aztecNode.getNullifierMembershipWitness(blockNumber, value))?.withoutPreimage().toFields();
+        return (await this.aztecNode.getNullifierMembershipWitness(blockHash, value))?.withoutPreimage().toFields();
       case MerkleTreeId.NOTE_HASH_TREE:
-        return (await this.aztecNode.getNoteHashMembershipWitness(blockNumber, value))?.toFields();
+        return (await this.aztecNode.getNoteHashMembershipWitness(blockHash, value))?.toFields();
       case MerkleTreeId.PUBLIC_DATA_TREE:
-        return (await this.aztecNode.getPublicDataWitness(blockNumber, value))?.withoutPreimage().toFields();
+        return (await this.aztecNode.getPublicDataWitness(blockHash, value))?.withoutPreimage().toFields();
       case MerkleTreeId.ARCHIVE:
-        return (await this.aztecNode.getArchiveMembershipWitness(blockNumber, value))?.toFields();
+        return (await this.aztecNode.getArchiveMembershipWitness(blockHash, value))?.toFields();
       default:
         throw new Error('Not implemented');
     }
   }
-
-  async #findLeafIndex(blockNumber: BlockParameter, treeId: MerkleTreeId, leafValue: Fr): Promise<bigint | undefined> {
-    const [leafIndex] = await this.aztecNode.findLeavesIndexes(blockNumber, treeId, [leafValue]);
-    return leafIndex?.data;
-  }
 }

package/dest/contract_function_simulator/proxied_node.d.ts

@@ -1,9 +0,0 @@
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { NodeStats } from '@aztec/stdlib/tx';
-export type ProxiedNode = AztecNode & {
-    getStats(): NodeStats;
-};
-export declare class ProxiedNodeFactory {
-    static create(node: AztecNode): ProxiedNode;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJveGllZF9ub2RlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJhY3RfZnVuY3Rpb25fc2ltdWxhdG9yL3Byb3hpZWRfbm9kZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUtsRCxNQUFNLE1BQU0sV0FBVyxHQUFHLFNBQVMsR0FBRztJQUFFLFFBQVEsSUFBSSxTQUFTLENBQUE7Q0FBRSxDQUFDO0FBRWhFLHFCQUFhLGtCQUFrQjtJQUM3QixNQUFNLENBQUMsTUFBTSxDQUFDLElBQUksRUFBRSxTQUFTLGVBcUI1QjtDQUNGIn0=

package/dest/contract_function_simulator/proxied_node.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"proxied_node.d.ts","sourceRoot":"","sources":["../../src/contract_function_simulator/proxied_node.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAKlD,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG;IAAE,QAAQ,IAAI,SAAS,CAAA;CAAE,CAAC;AAEhE,qBAAa,kBAAkB;IAC7B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,eAqB5B;CACF"}