@aztec/pxe 0.63.1 → 0.64.0

package/src/note_decryption_utils/produce_note_daos_for_key.ts

@@ -13,6 +13,8 @@ export async function produceNoteDaosForKey<T>(
   pkM: PublicKey,
   payload: L1NotePayload,
   txHash: TxHash,
+  l2BlockNumber: number,
+  l2BlockHash: string,
   noteHashes: Fr[],
   dataStartIndexForTx: number,
   excludedIndices: Set<number>,
@@ -21,6 +23,8 @@ export async function produceNoteDaosForKey<T>(
     note: Note,
     payload: L1NotePayload,
     noteInfo: NoteInfo,
+    l2BlockNumber: number,
+    l2BlockHash: string,
     dataStartIndexForTx: number,
     pkM: PublicKey,
   ) => T,
@@ -44,7 +48,7 @@ export async function produceNoteDaosForKey<T>(
     );
     excludedIndices?.add(noteInfo.noteHashIndex);
 
-    noteDao = daoConstructor(note, payload, noteInfo, dataStartIndexForTx, pkM);
+    noteDao = daoConstructor(note, payload, noteInfo, l2BlockNumber, l2BlockHash, dataStartIndexForTx, pkM);
   } catch (e) {
     logger.error(`Could not process note because of "${e}". Discarding note...`);
   }

package/src/pxe_service/create_pxe_service.ts

@@ -3,6 +3,7 @@ import { type AztecNode, type PrivateKernelProver } from '@aztec/circuit-types';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { KeyStore } from '@aztec/key-store';
+import { L2TipsStore } from '@aztec/kv-store/stores';
 import { createStore } from '@aztec/kv-store/utils';
 
 import { type PXEServiceConfig } from '../config/index.js';
@@ -39,12 +40,14 @@ export async function createPXEService(
   const keyStore = new KeyStore(
     await createStore('pxe_key_store', configWithContracts, createDebugLogger('aztec:pxe:keystore:lmdb')),
   );
-  const db = new KVPxeDatabase(
-    await createStore('pxe_data', configWithContracts, createDebugLogger('aztec:pxe:data:lmdb')),
-  );
+
+  const store = await createStore('pxe_data', configWithContracts, createDebugLogger('aztec:pxe:data:lmdb'));
+
+  const db = new KVPxeDatabase(store);
+  const tips = new L2TipsStore(store, 'pxe');
 
   const prover = proofCreator ?? (await createProver(config, logSuffix));
-  const server = new PXEService(keyStore, aztecNode, db, prover, config, logSuffix);
+  const server = new PXEService(keyStore, aztecNode, db, tips, prover, config, logSuffix);
   await server.start();
   return server;
 }

package/src/pxe_service/pxe_service.ts

@@ -6,6 +6,7 @@ import {
   type ExtendedNote,
   type FunctionCall,
   type GetUnencryptedLogsResponse,
+  type InBlock,
   type IncomingNotesFilter,
   L1EventPayload,
   type L2Block,
@@ -22,7 +23,6 @@ import {
   type SiblingPath,
   SimulationError,
   type Tx,
-  type TxEffect,
   type TxExecutionRequest,
   type TxHash,
   TxProvingResult,
@@ -43,7 +43,6 @@ import {
   computeAddressSecret,
   computeContractAddressFromInstance,
   computeContractClassId,
-  computePoint,
   getContractClassFromArtifact,
 } from '@aztec/circuits.js';
 import { computeNoteHashNonce, siloNullifier } from '@aztec/circuits.js/hash';
@@ -58,6 +57,7 @@ import { Fr, type Point } from '@aztec/foundation/fields';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
 import { type KeyStore } from '@aztec/key-store';
+import { type L2TipsStore } from '@aztec/kv-store/stores';
 import {
   ProtocolContractAddress,
   getCanonicalProtocolContract,
@@ -93,12 +93,13 @@ export class PXEService implements PXE {
     private keyStore: KeyStore,
     private node: AztecNode,
     private db: PxeDatabase,
+    tipsStore: L2TipsStore,
     private proofCreator: PrivateKernelProver,
-    private config: PXEServiceConfig,
+    config: PXEServiceConfig,
     logSuffix?: string,
   ) {
     this.log = createDebugLogger(logSuffix ? `aztec:pxe_service_${logSuffix}` : `aztec:pxe_service`);
-    this.synchronizer = new Synchronizer(node, db, this.jobQueue, logSuffix);
+    this.synchronizer = new Synchronizer(node, db, tipsStore, config, logSuffix);
     this.contractDataOracle = new ContractDataOracle(db);
     this.simulator = getAcirSimulator(db, node, keyStore, this.contractDataOracle);
     this.packageVersion = getPackageInfo().version;
@@ -112,8 +113,7 @@ export class PXEService implements PXE {
    * @returns A promise that resolves when the server has started successfully.
    */
   public async start() {
-    const { l2BlockPollingIntervalMS } = this.config;
-    await this.synchronizer.start(1, l2BlockPollingIntervalMS);
+    await this.synchronizer.start();
     await this.#registerProtocolContracts();
     const info = await this.getNodeInfo();
     this.log.info(`Started PXE connected to chain ${info.l1ChainId} version ${info.protocolVersion}`);
@@ -242,21 +242,24 @@ export class PXEService implements PXE {
 
     if (artifact) {
       // If the user provides an artifact, validate it against the expected class id and register it
-      const contractClassId = computeContractClassId(getContractClassFromArtifact(artifact));
+      const contractClass = getContractClassFromArtifact(artifact);
+      const contractClassId = computeContractClassId(contractClass);
       if (!contractClassId.equals(instance.contractClassId)) {
         throw new Error(
           `Artifact does not match expected class id (computed ${contractClassId} but instance refers to ${instance.contractClassId})`,
         );
       }
-      if (
-        // Computed address from the instance does not match address inside instance
-        !computeContractAddressFromInstance(instance).equals(instance.address)
-      ) {
+      if (!computeContractAddressFromInstance(instance).equals(instance.address)) {
         throw new Error('Added a contract in which the address does not match the contract instance.');
       }
 
       await this.db.addContractArtifact(contractClassId, artifact);
+
+      // TODO: PXE may not want to broadcast the artifact to the network
       await this.node.addContractArtifact(instance.address, artifact);
+
+      // TODO(#10007): Node should get public contract class from the registration event, not from PXE registration
+      await this.node.addContractClass({ ...contractClass, privateFunctions: [], unconstrainedFunctions: [] });
     } else {
       // Otherwise, make sure there is an artifact already registered for that class id
       artifact = await this.db.getContractArtifact(instance.contractClassId);
@@ -289,7 +292,7 @@ export class PXEService implements PXE {
       let owner = filter.owner;
       if (owner === undefined) {
         const completeAddresses = (await this.db.getCompleteAddresses()).find(completeAddress =>
-          computePoint(completeAddress.address).equals(dao.addressPoint),
+          completeAddress.address.toAddressPoint().equals(dao.addressPoint),
         );
         if (completeAddresses === undefined) {
           throw new Error(`Cannot find complete address for addressPoint ${dao.addressPoint.toString()}`);
@@ -350,7 +353,7 @@ export class PXEService implements PXE {
       throw new Error(`Unknown account: ${note.owner.toString()}`);
     }
 
-    const nonces = await this.#getNoteNonces(note);
+    const { data: nonces, l2BlockNumber, l2BlockHash } = await this.#getNoteNonces(note);
     if (nonces.length === 0) {
       throw new Error(`Cannot find the note in tx: ${note.txHash}.`);
     }
@@ -385,11 +388,13 @@ export class PXEService implements PXE {
           note.storageSlot,
           note.noteTypeId,
           note.txHash,
+          l2BlockNumber,
+          l2BlockHash,
           nonce,
           noteHash,
           siloedNullifier,
           index,
-          computePoint(owner.address),
+          owner.address.toAddressPoint(),
         ),
         scope,
       );
@@ -397,7 +402,7 @@ export class PXEService implements PXE {
   }
 
   public async addNullifiedNote(note: ExtendedNote) {
-    const nonces = await this.#getNoteNonces(note);
+    const { data: nonces, l2BlockHash, l2BlockNumber } = await this.#getNoteNonces(note);
     if (nonces.length === 0) {
       throw new Error(`Cannot find the note in tx: ${note.txHash}.`);
     }
@@ -428,11 +433,13 @@ export class PXEService implements PXE {
           note.storageSlot,
           note.noteTypeId,
           note.txHash,
+          l2BlockNumber,
+          l2BlockHash,
           nonce,
           noteHash,
           Fr.ZERO, // We are not able to derive
           index,
-          computePoint(note.owner),
+          note.owner.toAddressPoint(),
         ),
       );
     }
@@ -444,15 +451,15 @@ export class PXEService implements PXE {
    * @returns The nonces of the note.
    * @remarks More than a single nonce may be returned since there might be more than one nonce for a given note.
    */
-  async #getNoteNonces(note: ExtendedNote): Promise<Fr[]> {
+  async #getNoteNonces(note: ExtendedNote): Promise<InBlock<Fr[]>> {
     const tx = await this.node.getTxEffect(note.txHash);
     if (!tx) {
       throw new Error(`Unknown tx: ${note.txHash}`);
     }
 
     const nonces: Fr[] = [];
-    const firstNullifier = tx.nullifiers[0];
-    const hashes = tx.noteHashes;
+    const firstNullifier = tx.data.nullifiers[0];
+    const hashes = tx.data.noteHashes;
     for (let i = 0; i < hashes.length; ++i) {
       const hash = hashes[i];
       if (hash.equals(Fr.ZERO)) {
@@ -473,7 +480,7 @@ export class PXEService implements PXE {
       }
     }
 
-    return nonces;
+    return { l2BlockHash: tx.l2BlockHash, l2BlockNumber: tx.l2BlockNumber, data: nonces };
   }
 
   public async getBlock(blockNumber: number): Promise<L2Block | undefined> {
@@ -496,10 +503,19 @@ export class PXEService implements PXE {
     txRequest: TxExecutionRequest,
     privateExecutionResult: PrivateExecutionResult,
   ): Promise<TxProvingResult> {
-    return this.jobQueue.put(async () => {
-      const { publicInputs, clientIvcProof } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult);
-      return new TxProvingResult(privateExecutionResult, publicInputs, clientIvcProof!);
-    });
+    return this.jobQueue
+      .put(async () => {
+        const { publicInputs, clientIvcProof } = await this.#prove(
+          txRequest,
+          this.proofCreator,
+          privateExecutionResult,
+        );
+        return new TxProvingResult(privateExecutionResult, publicInputs, clientIvcProof!);
+      })
+      .catch(err => {
+        this.log.error(err);
+        throw err;
+      });
   }
 
   // TODO(#7456) Prevent msgSender being defined here for the first call
@@ -511,47 +527,52 @@ export class PXEService implements PXE {
     profile: boolean = false,
     scopes?: AztecAddress[],
   ): Promise<TxSimulationResult> {
-    return await this.jobQueue.put(async () => {
-      const privateExecutionResult = await this.#executePrivate(txRequest, msgSender, scopes);
-
-      let publicInputs: PrivateKernelTailCircuitPublicInputs;
-      let profileResult;
-      if (profile) {
-        ({ publicInputs, profileResult } = await this.#profileKernelProver(
-          txRequest,
-          this.proofCreator,
-          privateExecutionResult,
-        ));
-      } else {
-        publicInputs = await this.#simulateKernels(txRequest, privateExecutionResult);
-      }
+    return await this.jobQueue
+      .put(async () => {
+        const privateExecutionResult = await this.#executePrivate(txRequest, msgSender, scopes);
+
+        let publicInputs: PrivateKernelTailCircuitPublicInputs;
+        let profileResult;
+        if (profile) {
+          ({ publicInputs, profileResult } = await this.#profileKernelProver(
+            txRequest,
+            this.proofCreator,
+            privateExecutionResult,
+          ));
+        } else {
+          publicInputs = await this.#simulateKernels(txRequest, privateExecutionResult);
+        }
 
-      const privateSimulationResult = new PrivateSimulationResult(privateExecutionResult, publicInputs);
-      const simulatedTx = privateSimulationResult.toSimulatedTx();
-      let publicOutput: PublicSimulationOutput | undefined;
-      if (simulatePublic) {
-        publicOutput = await this.#simulatePublicCalls(simulatedTx);
-      }
+        const privateSimulationResult = new PrivateSimulationResult(privateExecutionResult, publicInputs);
+        const simulatedTx = privateSimulationResult.toSimulatedTx();
+        let publicOutput: PublicSimulationOutput | undefined;
+        if (simulatePublic) {
+          publicOutput = await this.#simulatePublicCalls(simulatedTx);
+        }
 
-      if (!skipTxValidation) {
-        if (!(await this.node.isValidTx(simulatedTx, true))) {
-          throw new Error('The simulated transaction is unable to be added to state and is invalid.');
+        if (!skipTxValidation) {
+          if (!(await this.node.isValidTx(simulatedTx, true))) {
+            throw new Error('The simulated transaction is unable to be added to state and is invalid.');
+          }
         }
-      }
 
-      // We log only if the msgSender is undefined, as simulating with a different msgSender
-      // is unlikely to be a real transaction, and likely to be only used to read data.
-      // Meaning that it will not necessarily have produced a nullifier (and thus have no TxHash)
-      // If we log, the `getTxHash` function will throw.
-      if (!msgSender) {
-        this.log.info(`Executed local simulation for ${simulatedTx.getTxHash()}`);
-      }
-      return TxSimulationResult.fromPrivateSimulationResultAndPublicOutput(
-        privateSimulationResult,
-        publicOutput,
-        profileResult,
-      );
-    });
+        // We log only if the msgSender is undefined, as simulating with a different msgSender
+        // is unlikely to be a real transaction, and likely to be only used to read data.
+        // Meaning that it will not necessarily have produced a nullifier (and thus have no TxHash)
+        // If we log, the `getTxHash` function will throw.
+        if (!msgSender) {
+          this.log.info(`Executed local simulation for ${simulatedTx.getTxHash()}`);
+        }
+        return TxSimulationResult.fromPrivateSimulationResultAndPublicOutput(
+          privateSimulationResult,
+          publicOutput,
+          profileResult,
+        );
+      })
+      .catch(err => {
+        this.log.error(err);
+        throw err;
+      });
   }
 
   public async sendTx(tx: Tx): Promise<TxHash> {
@@ -560,7 +581,10 @@ export class PXEService implements PXE {
       throw new Error(`A settled tx with equal hash ${txHash.toString()} exists.`);
     }
     this.log.info(`Sending transaction ${txHash}`);
-    await this.node.sendTx(tx);
+    await this.node.sendTx(tx).catch(err => {
+      this.log.error(err);
+      throw err;
+    });
     this.log.info(`Sent transaction ${txHash}`);
     return txHash;
   }
@@ -573,21 +597,26 @@ export class PXEService implements PXE {
     scopes?: AztecAddress[],
   ): Promise<AbiDecoded> {
     // all simulations must be serialized w.r.t. the synchronizer
-    return await this.jobQueue.put(async () => {
-      // TODO - Should check if `from` has the permission to call the view function.
-      const functionCall = await this.#getFunctionCall(functionName, args, to);
-      const executionResult = await this.#simulateUnconstrained(functionCall, scopes);
-
-      // TODO - Return typed result based on the function artifact.
-      return executionResult;
-    });
+    return await this.jobQueue
+      .put(async () => {
+        // TODO - Should check if `from` has the permission to call the view function.
+        const functionCall = await this.#getFunctionCall(functionName, args, to);
+        const executionResult = await this.#simulateUnconstrained(functionCall, scopes);
+
+        // TODO - Return typed result based on the function artifact.
+        return executionResult;
+      })
+      .catch(err => {
+        this.log.error(err);
+        throw err;
+      });
   }
 
   public getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
     return this.node.getTxReceipt(txHash);
   }
 
-  public getTxEffect(txHash: TxHash): Promise<TxEffect | undefined> {
+  public getTxEffect(txHash: TxHash) {
     return this.node.getTxEffect(txHash);
   }
 
@@ -773,7 +802,11 @@ export class PXEService implements PXE {
       return result;
     } catch (err) {
       if (err instanceof SimulationError) {
-        await enrichPublicSimulationError(err, this.contractDataOracle, this.db, this.log);
+        try {
+          await enrichPublicSimulationError(err, this.contractDataOracle, this.db, this.log);
+        } catch (enrichErr) {
+          this.log.error(`Failed to enrich public simulation error: ${enrichErr}`);
+        }
       }
       throw err;
     }
@@ -944,4 +977,8 @@ export class PXEService implements PXE {
 
     return decodedEvents;
   }
+
+  async resetNoteSyncData() {
+    return await this.db.resetNoteSyncData();
+  }
 }

package/src/simulator_oracle/index.ts

@@ -1,5 +1,6 @@
 import {
   type AztecNode,
+  type InBlock,
   L1NotePayload,
   type L2Block,
   type L2BlockNumber,
@@ -22,7 +23,6 @@ import {
   type KeyValidationRequest,
   type L1_TO_L2_MSG_TREE_HEIGHT,
   computeAddressSecret,
-  computePoint,
   computeTaggingSecret,
 } from '@aztec/circuits.js';
 import { type FunctionArtifact, getFunctionArtifact } from '@aztec/foundation/abi';
@@ -268,8 +268,11 @@ export class SimulatorOracle implements DBOracle {
     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]);
+
     return new IndexedTaggingSecret(secret, index);
   }
 
@@ -289,7 +292,9 @@ export class SimulatorOracle implements DBOracle {
     this.log.verbose(
       `Incrementing secret ${secret} as sender ${sender} for recipient: ${recipient} at contract: ${contractName}(${contractAddress})`,
     );
-    await this.db.incrementTaggingSecretsIndexesAsSender([secret]);
+
+    const [index] = await this.db.getTaggingSecretsIndexesAsSender([secret]);
+    await this.db.setTaggingSecretsIndexesAsSender([new IndexedTaggingSecret(secret, index + 1)]);
   }
 
   async #calculateTaggingSecret(contractAddress: AztecAddress, sender: AztecAddress, recipient: AztecAddress) {
@@ -329,6 +334,70 @@ export class SimulatorOracle implements DBOracle {
     return appTaggingSecrets.map((secret, i) => new IndexedTaggingSecret(secret, indexes[i]));
   }
 
+  /**
+   * Updates the local index of the shared tagging secret of a sender / recipient pair
+   * if a log with a larger index is found from the node.
+   * @param contractAddress - The address of the contract that the logs are tagged for
+   * @param sender - The address of the sender, we must know the sender's ivsk_m.
+   * @param recipient - The address of the recipient.
+   */
+  public async syncTaggedLogsAsSender(
+    contractAddress: AztecAddress,
+    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.
+
+    do {
+      const currentTags = [...new Array(INDEX_OFFSET)].map((_, i) => {
+        const indexedAppTaggingSecret = new IndexedTaggingSecret(appTaggingSecret, currentIndex + i);
+        return indexedAppTaggingSecret.computeTag(recipient);
+      });
+      previousEmptyBack = currentEmptyBack;
+
+      const possibleLogs = await this.aztecNode.getLogsByTags(currentTags);
+
+      const indexOfFirstLog = possibleLogs.findIndex(possibleLog => possibleLog.length !== 0);
+      currentEmptyFront = indexOfFirstLog === -1 ? INDEX_OFFSET : indexOfFirstLog;
+
+      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);
+
+    // We unwind the entire current window and the amount of consecutive empty slots from the previous window
+    const newIndex = currentIndex - (INDEX_OFFSET + previousEmptyBack);
+
+    await this.db.setTaggingSecretsIndexesAsSender([new IndexedTaggingSecret(appTaggingSecret, newIndex)]);
+
+    const contractName = await this.contractDataOracle.getDebugContractName(contractAddress);
+    this.log.debug(
+      `Syncing logs for sender ${sender}, secret ${appTaggingSecret}:${currentIndex} at contract: ${contractName}(${contractAddress})`,
+    );
+  }
+
   /**
    * Synchronizes the logs tagged with scoped addresses and all the senders in the addressbook.
    * Returns the unsynched logs and updates the indexes of the secrets used to tag them until there are no more logs to sync.
@@ -441,7 +510,12 @@ export class SimulatorOracle implements DBOracle {
 
       result.set(
         recipient.toString(),
-        logs.filter(log => log.blockNumber <= maxBlockNumber),
+        // 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)),
+        ),
       );
     }
     return result;
@@ -469,7 +543,7 @@ export class SimulatorOracle implements DBOracle {
     const incomingNotes: IncomingNoteDao[] = [];
     const outgoingNotes: OutgoingNoteDao[] = [];
 
-    const txEffectsCache = new Map<string, TxEffect | undefined>();
+    const txEffectsCache = new Map<string, InBlock<TxEffect> | undefined>();
 
     for (const scopedLog of scopedLogs) {
       const incomingNotePayload = L1NotePayload.decryptAsIncoming(
@@ -510,11 +584,13 @@ export class SimulatorOracle implements DBOracle {
           // mocking ESM exports, we have to pollute the method even more by providing a simulator parameter so tests can inject a fake one.
           simulator ?? getAcirSimulator(this.db, this.aztecNode, this.keyStore, this.contractDataOracle),
           this.db,
-          incomingNotePayload ? computePoint(recipient) : undefined,
+          incomingNotePayload ? recipient.toAddressPoint() : undefined,
           outgoingNotePayload ? recipientCompleteAddress.publicKeys.masterOutgoingViewingPublicKey : undefined,
           payload!,
-          txEffect.txHash,
-          txEffect.noteHashes,
+          txEffect.data.txHash,
+          txEffect.l2BlockNumber,
+          txEffect.l2BlockHash,
+          txEffect.data.noteHashes,
           scopedLog.dataStartIndexForTx,
           excludedIndices.get(scopedLog.txHash.toString())!,
           this.log,
@@ -557,17 +633,19 @@ export class SimulatorOracle implements DBOracle {
     }
     const nullifiedNotes: IncomingNoteDao[] = [];
     const currentNotesForRecipient = await this.db.getIncomingNotes({ owner: recipient });
-    const nullifierIndexes = await this.aztecNode.findLeavesIndexes(
-      'latest',
-      MerkleTreeId.NULLIFIER_TREE,
-      currentNotesForRecipient.map(note => note.siloedNullifier),
-    );
-
-    const foundNullifiers = currentNotesForRecipient
-      .filter((_, i) => nullifierIndexes[i] !== undefined)
-      .map(note => note.siloedNullifier);
+    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, computePoint(recipient));
+    await this.db.removeNullifiedNotes(foundNullifiers, recipient.toAddressPoint());
     nullifiedNotes.forEach(noteDao => {
       this.log.verbose(
         `Removed note for contract ${noteDao.contractAddress} at slot ${