@aztec/pxe 0.67.1 → 0.68.0

package/src/simulator_oracle/index.ts

@@ -24,7 +24,7 @@ import {
   type L1_TO_L2_MSG_TREE_HEIGHT,
   PrivateLog,
   computeAddressSecret,
-  computeTaggingSecret,
+  computeTaggingSecretPoint,
 } from '@aztec/circuits.js';
 import { type FunctionArtifact, getFunctionArtifact } from '@aztec/foundation/abi';
 import { poseidon2Hash } from '@aztec/foundation/crypto';
@@ -38,6 +38,7 @@ import { type IncomingNoteDao } from '../database/incoming_note_dao.js';
 import { type PxeDatabase } from '../database/index.js';
 import { produceNoteDaos } from '../note_decryption_utils/produce_note_daos.js';
 import { getAcirSimulator } from '../simulator/index.js';
+import { WINDOW_HALF_SIZE, getIndexedTaggingSecretsForTheWindow, getInitialIndexesMap } from './tagging_utils.js';
 
 /**
  * A data oracle that provides information needed for simulating a transaction.
@@ -252,33 +253,33 @@ export class SimulatorOracle implements DBOracle {
    * finally the index specified tag. We will then query the node with this tag for each address in the address book.
    * @returns The full list of the users contact addresses.
    */
-  public getContacts(): Promise<AztecAddress[]> {
-    return this.db.getContactAddresses();
+  public getSenders(): Promise<AztecAddress[]> {
+    return this.db.getSenderAddresses();
   }
 
   /**
-   * Returns the tagging secret for a given sender and recipient pair. For this to work, the ivpsk_m of the sender must be known.
+   * Returns the tagging secret for a given sender and recipient pair. For this to work, the ivsk_m of the sender must be known.
    * Includes the next index to be used used for tagging with this secret.
    * @param contractAddress - The contract address to silo the secret for
    * @param sender - The address sending the note
    * @param recipient - The address receiving the note
-   * @returns A siloed tagging secret that can be used to tag notes.
+   * @returns An indexed tagging secret that can be used to tag notes.
    */
-  public async getAppTaggingSecretAsSender(
+  public async getIndexedTaggingSecretAsSender(
     contractAddress: AztecAddress,
     sender: AztecAddress,
     recipient: AztecAddress,
   ): Promise<IndexedTaggingSecret> {
     await this.syncTaggedLogsAsSender(contractAddress, sender, recipient);
 
-    const secret = await this.#calculateTaggingSecret(contractAddress, sender, recipient);
-    const [index] = await this.db.getTaggingSecretsIndexesAsSender([secret]);
+    const appTaggingSecret = await this.#calculateAppTaggingSecret(contractAddress, sender, recipient);
+    const [index] = await this.db.getTaggingSecretsIndexesAsSender([appTaggingSecret]);
 
-    return new IndexedTaggingSecret(secret, index);
+    return new IndexedTaggingSecret(appTaggingSecret, index);
   }
 
   /**
-   * Increments the tagging secret for a given sender and recipient pair. For this to work, the ivpsk_m of the sender must be known.
+   * Increments the tagging secret for a given sender and recipient pair. For this to work, the ivsk_m of the sender must be known.
    * @param contractAddress - The contract address to silo the secret for
    * @param sender - The address sending the note
    * @param recipient - The address receiving the note
@@ -288,7 +289,7 @@ export class SimulatorOracle implements DBOracle {
     sender: AztecAddress,
     recipient: AztecAddress,
   ): Promise<void> {
-    const secret = await this.#calculateTaggingSecret(contractAddress, sender, recipient);
+    const secret = await this.#calculateAppTaggingSecret(contractAddress, sender, recipient);
     const contractName = await this.contractDataOracle.getDebugContractName(contractAddress);
     this.log.debug(`Incrementing app tagging secret at ${contractName}(${contractAddress})`, {
       secret,
@@ -302,37 +303,38 @@ export class SimulatorOracle implements DBOracle {
     await this.db.setTaggingSecretsIndexesAsSender([new IndexedTaggingSecret(secret, index + 1)]);
   }
 
-  async #calculateTaggingSecret(contractAddress: AztecAddress, sender: AztecAddress, recipient: AztecAddress) {
+  async #calculateAppTaggingSecret(contractAddress: AztecAddress, sender: AztecAddress, recipient: AztecAddress) {
     const senderCompleteAddress = await this.getCompleteAddress(sender);
     const senderIvsk = await this.keyStore.getMasterIncomingViewingSecretKey(sender);
-    const sharedSecret = computeTaggingSecret(senderCompleteAddress, senderIvsk, recipient);
-    // Silo the secret to the app so it can't be used to track other app's notes
-    const siloedSecret = poseidon2Hash([sharedSecret.x, sharedSecret.y, contractAddress]);
-    return siloedSecret;
+    const secretPoint = computeTaggingSecretPoint(senderCompleteAddress, senderIvsk, recipient);
+    // Silo the secret so it can't be used to track other app's notes
+    const appSecret = poseidon2Hash([secretPoint.x, secretPoint.y, contractAddress]);
+    return appSecret;
   }
 
   /**
-   * Returns the siloed tagging secrets for a given recipient and all the senders in the address book
+   * Returns the indexed tagging secrets for a given recipient and all the senders in the address book
    * This method should be exposed as an oracle call to allow aztec.nr to perform the orchestration
    * of the syncTaggedLogs and processTaggedLogs methods. However, it is not possible to do so at the moment,
    * so we're keeping it private for now.
    * @param contractAddress - The contract address to silo the secret for
    * @param recipient - The address receiving the notes
-   * @returns A list of siloed tagging secrets
+   * @returns A list of indexed tagging secrets
    */
-  async #getAppTaggingSecretsForContacts(
+  async #getIndexedTaggingSecretsForSenders(
     contractAddress: AztecAddress,
     recipient: AztecAddress,
   ): Promise<IndexedTaggingSecret[]> {
     const recipientCompleteAddress = await this.getCompleteAddress(recipient);
     const recipientIvsk = await this.keyStore.getMasterIncomingViewingSecretKey(recipient);
 
-    // We implicitly add all PXE accounts as contacts, this helps us decrypt tags on notes that we send to ourselves (recipient = us, sender = us)
-    const contacts = [...(await this.db.getContactAddresses()), ...(await this.keyStore.getAccounts())].filter(
+    // We implicitly add all PXE accounts as senders, this helps us decrypt tags on notes that we send to ourselves
+    // (recipient = us, sender = us)
+    const senders = [...(await this.db.getSenderAddresses()), ...(await this.keyStore.getAccounts())].filter(
       (address, index, self) => index === self.findIndex(otherAddress => otherAddress.equals(address)),
     );
-    const appTaggingSecrets = contacts.map(contact => {
-      const sharedSecret = computeTaggingSecret(recipientCompleteAddress, recipientIvsk, contact);
+    const appTaggingSecrets = senders.map(contact => {
+      const sharedSecret = computeTaggingSecretPoint(recipientCompleteAddress, recipientIvsk, contact);
       return poseidon2Hash([sharedSecret.x, sharedSecret.y, contractAddress]);
     });
     const indexes = await this.db.getTaggingSecretsIndexesAsRecipient(appTaggingSecrets);
@@ -351,65 +353,63 @@ export class SimulatorOracle implements DBOracle {
     sender: AztecAddress,
     recipient: AztecAddress,
   ): Promise<void> {
-    const appTaggingSecret = await this.#calculateTaggingSecret(contractAddress, sender, recipient);
-    let [currentIndex] = await this.db.getTaggingSecretsIndexesAsSender([appTaggingSecret]);
-
-    const INDEX_OFFSET = 10;
-
-    let previousEmptyBack = 0;
-    let currentEmptyBack = 0;
-    let currentEmptyFront: number;
-
-    // The below code is trying to find the index of the start of the first window in which for all elements of window, we do not see logs.
-    // We take our window size, and fetch the node for these logs. We store both the amount of empty consecutive slots from the front and the back.
-    // We use our current empty consecutive slots from the front, as well as the previous consecutive empty slots from the back to see if we ever hit a time where there
-    // is a window in which we see the combination of them to be greater than the window's size. If true, we rewind current index to the start of said window and use it.
-    // Assuming two windows of 5:
-    // [0, 1, 0, 1, 0], [0, 0, 0, 0, 0]
-    // We can see that when processing the second window, the previous amount of empty slots from the back of the window (1), added with the empty elements from the front of the window (5)
-    // is greater than 5 (6) and therefore we have found a window to use.
-    // We simply need to take the number of elements (10) - the size of the window (5) - the number of consecutive empty elements from the back of the last window (1) = 4;
-    // This is the first index of our desired window.
-    // Note that if we ever see a situation like so:
-    // [0, 1, 0, 1, 0], [0, 0, 0, 0, 1]
-    // This also returns the correct index (4), but this is indicative of a problem / desync. i.e. we should never have a window that has a log that exists after the window.
-
+    const appTaggingSecret = await this.#calculateAppTaggingSecret(contractAddress, sender, recipient);
+    const [oldIndex] = await this.db.getTaggingSecretsIndexesAsSender([appTaggingSecret]);
+
+    // This algorithm works such that:
+    // 1. If we find minimum consecutive empty logs in a window of logs we set the index to the index of the last log
+    // we found and quit.
+    // 2. If we don't find minimum consecutive empty logs in a window of logs we slide the window to latest log index
+    // and repeat the process.
+    const MIN_CONSECUTIVE_EMPTY_LOGS = 10;
+    const WINDOW_SIZE = MIN_CONSECUTIVE_EMPTY_LOGS * 2;
+
+    let [numConsecutiveEmptyLogs, currentIndex] = [0, oldIndex];
     do {
-      const currentTags = [...new Array(INDEX_OFFSET)].map((_, i) => {
+      // We compute the tags for the current window of indexes
+      const currentTags = [...new Array(WINDOW_SIZE)].map((_, i) => {
         const indexedAppTaggingSecret = new IndexedTaggingSecret(appTaggingSecret, currentIndex + i);
         return indexedAppTaggingSecret.computeSiloedTag(recipient, contractAddress);
       });
-      previousEmptyBack = currentEmptyBack;
 
+      // We fetch the logs for the tags
       const possibleLogs = await this.aztecNode.getLogsByTags(currentTags);
 
-      const indexOfFirstLog = possibleLogs.findIndex(possibleLog => possibleLog.length !== 0);
-      currentEmptyFront = indexOfFirstLog === -1 ? INDEX_OFFSET : indexOfFirstLog;
-
+      // We find the index of the last log in the window that is not empty
       const indexOfLastLog = possibleLogs.findLastIndex(possibleLog => possibleLog.length !== 0);
-      currentEmptyBack = indexOfLastLog === -1 ? INDEX_OFFSET : INDEX_OFFSET - 1 - indexOfLastLog;
 
-      currentIndex += INDEX_OFFSET;
-    } while (currentEmptyFront + previousEmptyBack < INDEX_OFFSET);
+      if (indexOfLastLog === -1) {
+        // We haven't found any logs in the current window so we stop looking
+        break;
+      }
 
-    // We unwind the entire current window and the amount of consecutive empty slots from the previous window
-    const newIndex = currentIndex - (INDEX_OFFSET + previousEmptyBack);
+      // We move the current index to that of the last log we found
+      currentIndex += indexOfLastLog + 1;
 
-    await this.db.setTaggingSecretsIndexesAsSender([new IndexedTaggingSecret(appTaggingSecret, newIndex)]);
+      // We compute the number of consecutive empty logs we found and repeat the process if we haven't found enough.
+      numConsecutiveEmptyLogs = WINDOW_SIZE - indexOfLastLog - 1;
+    } while (numConsecutiveEmptyLogs < MIN_CONSECUTIVE_EMPTY_LOGS);
 
     const contractName = await this.contractDataOracle.getDebugContractName(contractAddress);
-    this.log.debug(`Syncing logs for sender ${sender} at contract ${contractName}(${contractAddress})`, {
-      sender,
-      secret: appTaggingSecret,
-      index: currentIndex,
-      contractName,
-      contractAddress,
-    });
+    if (currentIndex !== oldIndex) {
+      await this.db.setTaggingSecretsIndexesAsSender([new IndexedTaggingSecret(appTaggingSecret, currentIndex)]);
+
+      this.log.debug(`Syncing logs for sender ${sender} at contract ${contractName}(${contractAddress})`, {
+        sender,
+        secret: appTaggingSecret,
+        index: currentIndex,
+        contractName,
+        contractAddress,
+      });
+    } else {
+      this.log.debug(`No new logs found for sender ${sender} at contract ${contractName}(${contractAddress})`);
+    }
   }
 
   /**
    * Synchronizes the logs tagged with scoped addresses and all the senders in the address book.
-   * Returns the unsynched logs and updates the indexes of the secrets used to tag them until there are no more logs to sync.
+   * Returns the unsynched logs and updates the indexes of the secrets used to tag them until there are no more logs
+   * to sync.
    * @param contractAddress - The address of the contract that the logs are tagged for
    * @param recipient - The address of the recipient
    * @returns A list of encrypted logs tagged with the recipient's address
@@ -419,125 +419,137 @@ export class SimulatorOracle implements DBOracle {
     maxBlockNumber: number,
     scopes?: AztecAddress[],
   ): Promise<Map<string, TxScopedL2Log[]>> {
+    // Ideally this algorithm would be implemented in noir, exposing its building blocks as oracles.
+    // However it is impossible at the moment due to the language not supporting nested slices.
+    // This nesting is necessary because for a given set of tags we don't
+    // know how many logs we will get back. Furthermore, these logs are of undetermined
+    // length, since we don't really know the note they correspond to until we decrypt them.
+
     const recipients = scopes ? scopes : await this.keyStore.getAccounts();
-    const result = new Map<string, TxScopedL2Log[]>();
+    // A map of logs going from recipient address to logs. Note that the logs might have been processed before
+    // due to us having a sliding window that "looks back" for logs as well. (We look back as there is no guarantee
+    // that a logs will be received ordered by a given tax index and that the tags won't be reused).
+    const logsMap = new Map<string, TxScopedL2Log[]>();
     const contractName = await this.contractDataOracle.getDebugContractName(contractAddress);
     for (const recipient of recipients) {
-      const logs: TxScopedL2Log[] = [];
-      // Ideally this algorithm would be implemented in noir, exposing its building blocks as oracles.
-      // However it is impossible at the moment due to the language not supporting nested slices.
-      // This nesting is necessary because for a given set of tags we don't
-      // know how many logs we will get back. Furthermore, these logs are of undetermined
-      // length, since we don't really know the note they correspond to until we decrypt them.
-
-      // 1. Get all the secrets for the recipient and sender pairs (#9365)
-      const appTaggingSecrets = await this.#getAppTaggingSecretsForContacts(contractAddress, recipient);
-
-      // 1.1 Set up a sliding window with an offset. Chances are the sender might have messed up
-      // and inadvertently incremented their index without use getting any logs (for example, in case
-      // of a revert). If we stopped looking for logs the first time
-      // we receive 0 for a tag, we might never receive anything from that sender again.
-      // Also there's a possibility that we have advanced our index, but the sender has reused it, so
-      // we might have missed some logs. For these reasons, we have to look both back and ahead of the
-      // stored index
-      const INDEX_OFFSET = 10;
-      type SearchState = {
-        currentTagggingSecrets: IndexedTaggingSecret[];
-        maxIndexesToCheck: { [k: string]: number };
-        initialSecretIndexes: { [k: string]: number };
-        secretsToIncrement: { [k: string]: number };
-      };
-      const searchState = appTaggingSecrets.reduce<SearchState>(
-        (acc, appTaggingSecret) => ({
-          // Start looking for logs before the stored index
-          currentTagggingSecrets: acc.currentTagggingSecrets.concat([
-            new IndexedTaggingSecret(appTaggingSecret.secret, Math.max(0, appTaggingSecret.index - INDEX_OFFSET)),
-          ]),
-          // Keep looking for logs beyond the stored index
-          maxIndexesToCheck: {
-            ...acc.maxIndexesToCheck,
-            ...{ [appTaggingSecret.secret.toString()]: appTaggingSecret.index + INDEX_OFFSET },
-          },
-          // Keeps track of the secrets we have to increment in the database
-          secretsToIncrement: {},
-          // Store the initial set of indexes for the secrets
-          initialSecretIndexes: {
-            ...acc.initialSecretIndexes,
-            ...{ [appTaggingSecret.secret.toString()]: appTaggingSecret.index },
-          },
-        }),
-        { currentTagggingSecrets: [], maxIndexesToCheck: {}, secretsToIncrement: {}, initialSecretIndexes: {} },
-      );
+      const logsForRecipient: TxScopedL2Log[] = [];
+
+      // Get all the secrets for the recipient and sender pairs (#9365)
+      const secrets = await this.#getIndexedTaggingSecretsForSenders(contractAddress, recipient);
+
+      // We fetch logs for a window of indexes in a range:
+      //    <latest_log_index - WINDOW_HALF_SIZE, latest_log_index + WINDOW_HALF_SIZE>.
+      //
+      // We use this window approach because it could happen that a sender might have messed up and inadvertently
+      // incremented their index without us getting any logs (for example, in case of a revert). If we stopped looking
+      // for logs the first time we don't receive any logs for a tag, we might never receive anything from that sender again.
+      //    Also there's a possibility that we have advanced our index, but the sender has reused it, so we might have missed
+      // some logs. For these reasons, we have to look both back and ahead of the stored index.
+      let secretsAndWindows = secrets.map(secret => {
+        return {
+          appTaggingSecret: secret.appTaggingSecret,
+          leftMostIndex: Math.max(0, secret.index - WINDOW_HALF_SIZE),
+          rightMostIndex: secret.index + WINDOW_HALF_SIZE,
+        };
+      });
 
-      let { currentTagggingSecrets } = searchState;
-      const { maxIndexesToCheck, secretsToIncrement, initialSecretIndexes } = searchState;
+      // As we iterate we store the largest index we have seen for a given secret to later on store it in the db.
+      const newLargestIndexMapToStore: { [k: string]: number } = {};
 
-      while (currentTagggingSecrets.length > 0) {
-        // 2. Compute tags using the secrets, recipient and index. Obtain logs for each tag (#9380)
-        const currentTags = currentTagggingSecrets.map(taggingSecret =>
-          taggingSecret.computeSiloedTag(recipient, contractAddress),
+      // The initial/unmodified indexes of the secrets stored in a key-value map where key is the app tagging secret.
+      const initialIndexesMap = getInitialIndexesMap(secrets);
+
+      while (secretsAndWindows.length > 0) {
+        const secretsForTheWholeWindow = getIndexedTaggingSecretsForTheWindow(secretsAndWindows);
+        const tagsForTheWholeWindow = secretsForTheWholeWindow.map(secret =>
+          secret.computeSiloedTag(recipient, contractAddress),
         );
-        const logsByTags = await this.aztecNode.getLogsByTags(currentTags);
-        const newTaggingSecrets: IndexedTaggingSecret[] = [];
+
+        // We store the new largest indexes we find in the iteration in the following map to later on construct
+        // a new set of secrets and windows to fetch logs for.
+        const newLargestIndexMapForIteration: { [k: string]: number } = {};
+
+        // Fetch the logs for the tags and iterate over them
+        const logsByTags = await this.aztecNode.getLogsByTags(tagsForTheWholeWindow);
+
         logsByTags.forEach((logsByTag, logIndex) => {
-          const { secret: currentSecret, index: currentIndex } = currentTagggingSecrets[logIndex];
-          const currentSecretAsStr = currentSecret.toString();
-          this.log.debug(`Syncing logs for recipient ${recipient} at contract ${contractName}(${contractAddress})`, {
-            recipient,
-            secret: currentSecret,
-            index: currentIndex,
-            contractName,
-            contractAddress,
-          });
-          // 3.1. Append logs to the list and increment the index for the tags that have logs (#9380)
           if (logsByTag.length > 0) {
-            const newIndex = currentIndex + 1;
-            this.log.debug(
-              `Found ${logsByTag.length} logs as recipient ${recipient}. Incrementing index to ${newIndex} at contract ${contractName}(${contractAddress})`,
-              {
-                recipient,
-                secret: currentSecret,
-                newIndex,
-                contractName,
-                contractAddress,
-              },
-            );
-            logs.push(...logsByTag);
-
-            if (currentIndex >= initialSecretIndexes[currentSecretAsStr]) {
-              // 3.2. Increment the index for the tags that have logs, provided they're higher than the one
-              // we have stored in the db (#9380)
-              secretsToIncrement[currentSecretAsStr] = newIndex;
-              // 3.3. Slide the window forwards if we have found logs beyond the initial index
-              maxIndexesToCheck[currentSecretAsStr] = currentIndex + INDEX_OFFSET;
+            // The logs for the given tag exist so we store them for later processing
+            logsForRecipient.push(...logsByTag);
+
+            // We retrieve the indexed tagging secret corresponding to the log as I need that to evaluate whether
+            // a new largest index have been found.
+            const secretCorrespondingToLog = secretsForTheWholeWindow[logIndex];
+            const initialIndex = initialIndexesMap[secretCorrespondingToLog.appTaggingSecret.toString()];
+
+            this.log.debug(`Found ${logsByTag.length} logs as recipient ${recipient}`, {
+              recipient,
+              secret: secretCorrespondingToLog.appTaggingSecret,
+              contractName,
+              contractAddress,
+            });
+
+            if (
+              secretCorrespondingToLog.index >= initialIndex &&
+              (newLargestIndexMapForIteration[secretCorrespondingToLog.appTaggingSecret.toString()] === undefined ||
+                secretCorrespondingToLog.index >=
+                  newLargestIndexMapForIteration[secretCorrespondingToLog.appTaggingSecret.toString()])
+            ) {
+              // We have found a new largest index so we store it for later processing (storing it in the db + fetching
+              // the difference of the window sets of current and the next iteration)
+              newLargestIndexMapForIteration[secretCorrespondingToLog.appTaggingSecret.toString()] =
+                secretCorrespondingToLog.index + 1;
+
+              this.log.debug(
+                `Incrementing index to ${
+                  secretCorrespondingToLog.index + 1
+                } at contract ${contractName}(${contractAddress})`,
+              );
             }
           }
-          // 3.4 Keep increasing the index (inside the window) temporarily for the tags that have no logs
-          // There's a chance the sender missed some and we want to catch up
-          if (currentIndex < maxIndexesToCheck[currentSecretAsStr]) {
-            const newTaggingSecret = new IndexedTaggingSecret(currentSecret, currentIndex + 1);
-            newTaggingSecrets.push(newTaggingSecret);
-          }
         });
-        await this.db.setTaggingSecretsIndexesAsRecipient(
-          Object.keys(secretsToIncrement).map(
-            secret => new IndexedTaggingSecret(Fr.fromHexString(secret), secretsToIncrement[secret]),
-          ),
-        );
-        currentTagggingSecrets = newTaggingSecrets;
+
+        // Now based on the new largest indexes we found, we will construct a new secrets and windows set to fetch logs
+        // for. Note that it's very unlikely that a new log from the current window would appear between the iterations
+        // so we fetch the logs only for the difference of the window sets.
+        const newSecretsAndWindows = [];
+        for (const [appTaggingSecret, newIndex] of Object.entries(newLargestIndexMapForIteration)) {
+          const secret = secrets.find(secret => secret.appTaggingSecret.toString() === appTaggingSecret);
+          if (secret) {
+            newSecretsAndWindows.push({
+              appTaggingSecret: secret.appTaggingSecret,
+              // We set the left most index to the new index to avoid fetching the same logs again
+              leftMostIndex: newIndex,
+              rightMostIndex: newIndex + WINDOW_HALF_SIZE,
+            });
+
+            // We store the new largest index in the map to later store it in the db.
+            newLargestIndexMapToStore[appTaggingSecret] = newIndex;
+          } else {
+            throw new Error(
+              `Secret not found for appTaggingSecret ${appTaggingSecret}. This is a bug as it should never happen!`,
+            );
+          }
+        }
+
+        // Now we set the new secrets and windows and proceed to the next iteration.
+        secretsAndWindows = newSecretsAndWindows;
       }
 
-      result.set(
+      // We filter the logs by block number and store them in the map.
+      logsMap.set(
         recipient.toString(),
-        // Remove logs with a block number higher than the max block number
-        // Duplicates are likely to happen due to the sliding window, so we also filter them out
-        logs.filter(
-          (log, index, self) =>
-            log.blockNumber <= maxBlockNumber && index === self.findIndex(otherLog => otherLog.equals(log)),
+        logsForRecipient.filter(log => log.blockNumber <= maxBlockNumber),
+      );
+
+      // At this point we have processed all the logs for the recipient so we store the new largest indexes in the db.
+      await this.db.setTaggingSecretsIndexesAsRecipient(
+        Object.entries(newLargestIndexMapToStore).map(
+          ([appTaggingSecret, index]) => new IndexedTaggingSecret(Fr.fromHexString(appTaggingSecret), index),
         ),
       );
     }
-    return result;
+    return logsMap;
   }
 
   /**
@@ -628,27 +640,30 @@ export class SimulatorOracle implements DBOracle {
         });
       });
     }
-    const nullifiedNotes: IncomingNoteDao[] = [];
-    const currentNotesForRecipient = await this.db.getIncomingNotes({ owner: recipient });
-    const nullifiersToCheck = currentNotesForRecipient.map(note => note.siloedNullifier);
-    const currentBlockNumber = await this.getBlockNumber();
-    const nullifierIndexes = await this.aztecNode.findNullifiersIndexesWithBlock(currentBlockNumber, nullifiersToCheck);
-
-    const foundNullifiers = nullifiersToCheck
-      .map((nullifier, i) => {
-        if (nullifierIndexes[i] !== undefined) {
-          return { ...nullifierIndexes[i], ...{ data: nullifier } } as InBlock<Fr>;
-        }
-      })
-      .filter(nullifier => nullifier !== undefined) as InBlock<Fr>[];
-
-    await this.db.removeNullifiedNotes(foundNullifiers, recipient.toAddressPoint());
-    nullifiedNotes.forEach(noteDao => {
-      this.log.verbose(`Removed note for contract ${noteDao.contractAddress} at slot ${noteDao.storageSlot}`, {
-        contract: noteDao.contractAddress,
-        slot: noteDao.storageSlot,
-        nullifier: noteDao.siloedNullifier.toString(),
+  }
+
+  public async removeNullifiedNotes(contractAddress: AztecAddress) {
+    for (const recipient of await this.keyStore.getAccounts()) {
+      const currentNotesForRecipient = await this.db.getIncomingNotes({ contractAddress, owner: recipient });
+      const nullifiersToCheck = currentNotesForRecipient.map(note => note.siloedNullifier);
+      const nullifierIndexes = await this.aztecNode.findNullifiersIndexesWithBlock('latest', nullifiersToCheck);
+
+      const foundNullifiers = nullifiersToCheck
+        .map((nullifier, i) => {
+          if (nullifierIndexes[i] !== undefined) {
+            return { ...nullifierIndexes[i], ...{ data: nullifier } } as InBlock<Fr>;
+          }
+        })
+        .filter(nullifier => nullifier !== undefined) as InBlock<Fr>[];
+
+      const nullifiedNotes = await this.db.removeNullifiedNotes(foundNullifiers, recipient.toAddressPoint());
+      nullifiedNotes.forEach(noteDao => {
+        this.log.verbose(`Removed note for contract ${noteDao.contractAddress} at slot ${noteDao.storageSlot}`, {
+          contract: noteDao.contractAddress,
+          slot: noteDao.storageSlot,
+          nullifier: noteDao.siloedNullifier.toString(),
+        });
       });
-    });
+    }
   }
 }

package/src/simulator_oracle/tagging_utils.ts

@@ -0,0 +1,31 @@
+import { type Fr, IndexedTaggingSecret } from '@aztec/circuits.js';
+
+// Half the size of the window we slide over the tagging secret indexes.
+export const WINDOW_HALF_SIZE = 10;
+
+export function getIndexedTaggingSecretsForTheWindow(
+  secretsAndWindows: { appTaggingSecret: Fr; leftMostIndex: number; rightMostIndex: number }[],
+): IndexedTaggingSecret[] {
+  const secrets: IndexedTaggingSecret[] = [];
+  for (const secretAndWindow of secretsAndWindows) {
+    for (let i = secretAndWindow.leftMostIndex; i <= secretAndWindow.rightMostIndex; i++) {
+      secrets.push(new IndexedTaggingSecret(secretAndWindow.appTaggingSecret, i));
+    }
+  }
+  return secrets;
+}
+
+/**
+ * Creates a map from app tagging secret to initial index.
+ * @param indexedTaggingSecrets - The indexed tagging secrets to get the initial indexes from.
+ * @returns The map from app tagging secret to initial index.
+ */
+export function getInitialIndexesMap(indexedTaggingSecrets: IndexedTaggingSecret[]): { [k: string]: number } {
+  const initialIndexes: { [k: string]: number } = {};
+
+  for (const indexedTaggingSecret of indexedTaggingSecrets) {
+    initialIndexes[indexedTaggingSecret.appTaggingSecret.toString()] = indexedTaggingSecret.index;
+  }
+
+  return initialIndexes;
+}

package/src/utils/create_pxe_service.ts

@@ -1,4 +1,5 @@
 import { BBNativePrivateKernelProver } from '@aztec/bb-prover';
+import { BBWasmPrivateKernelProver } from '@aztec/bb-prover/wasm';
 import { type AztecNode, type PrivateKernelProver } from '@aztec/circuit-types';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { createLogger } from '@aztec/foundation/log';
@@ -59,9 +60,11 @@ function createProver(config: PXEServiceConfig, logSuffix?: string) {
 
   // (@PhilWindle) Temporary validation until WASM is implemented
   if (!config.bbBinaryPath || !config.bbWorkingDirectory) {
-    throw new Error(`Prover must be configured with binary path and working directory`);
+    return new BBWasmPrivateKernelProver(16);
+  } else {
+    const bbConfig = config as Required<Pick<PXEServiceConfig, 'bbBinaryPath' | 'bbWorkingDirectory'>> &
+      PXEServiceConfig;
+    const log = createLogger('pxe:bb-native-prover' + (logSuffix ? `:${logSuffix}` : ''));
+    return BBNativePrivateKernelProver.new({ bbSkipCleanup: false, ...bbConfig }, log);
   }
-  const bbConfig = config as Required<Pick<PXEServiceConfig, 'bbBinaryPath' | 'bbWorkingDirectory'>> & PXEServiceConfig;
-  const log = createLogger('pxe:bb-native-prover' + (logSuffix ? `:${logSuffix}` : ''));
-  return BBNativePrivateKernelProver.new({ bbSkipCleanup: false, ...bbConfig }, log);
 }