@aztec/pxe 0.60.0 → 0.62.0

package/src/note_processor/note_processor.ts

@@ -1,6 +1,12 @@
 import { type AztecNode, L1NotePayload, type L2Block } from '@aztec/circuit-types';
 import { type NoteProcessorStats } from '@aztec/circuit-types/stats';
-import { type CompleteAddress, INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX, type PublicKey } from '@aztec/circuits.js';
+import {
+  type CompleteAddress,
+  INITIAL_L2_BLOCK_NUM,
+  MAX_NOTE_HASHES_PER_TX,
+  computeAddressSecret,
+  computePoint,
+} from '@aztec/circuits.js';
 import { type Fr } from '@aztec/foundation/fields';
 import { type Logger, createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
@@ -48,10 +54,6 @@ export class NoteProcessor {
 
   private constructor(
     public readonly account: CompleteAddress,
-    /** The public counterpart to the secret key to be used in the decryption of incoming note logs. */
-    private readonly ivpkM: PublicKey,
-    /** The public counterpart to the secret key to be used in the decryption of outgoing note logs. */
-    private readonly ovpkM: PublicKey,
     private keyStore: KeyStore,
     private db: PxeDatabase,
     private node: AztecNode,
@@ -60,7 +62,7 @@ export class NoteProcessor {
     private log: Logger,
   ) {}
 
-  public static async create(
+  public static create(
     account: CompleteAddress,
     keyStore: KeyStore,
     db: PxeDatabase,
@@ -69,10 +71,7 @@ export class NoteProcessor {
     simulator = getAcirSimulator(db, node, keyStore),
     log = createDebugLogger('aztec:note_processor'),
   ) {
-    const ivpkM = await keyStore.getMasterIncomingViewingPublicKey(account.address);
-    const ovpkM = await keyStore.getMasterOutgoingViewingPublicKey(account.address);
-
-    return new NoteProcessor(account, ivpkM, ovpkM, keyStore, db, node, startingBlock, simulator, log);
+    return new NoteProcessor(account, keyStore, db, node, startingBlock, simulator, log);
   }
 
   /**
@@ -95,7 +94,7 @@ export class NoteProcessor {
   }
 
   private getSyncedToBlock(): number {
-    return this.db.getSynchedBlockNumberForPublicKey(this.ivpkM) ?? this.startingBlock - 1;
+    return this.db.getSynchedBlockNumberForAccount(this.account.address) ?? this.startingBlock - 1;
   }
 
   /**
@@ -114,13 +113,17 @@ export class NoteProcessor {
     const deferredIncomingNotes: DeferredNoteDao[] = [];
     const deferredOutgoingNotes: DeferredNoteDao[] = [];
 
-    const ivskM = await this.keyStore.getMasterSecretKey(this.ivpkM);
-    const ovskM = await this.keyStore.getMasterSecretKey(this.ovpkM);
+    const ivskM = await this.keyStore.getMasterSecretKey(this.account.publicKeys.masterIncomingViewingPublicKey);
+    const addressSecret = computeAddressSecret(this.account.getPreaddress(), ivskM);
+
+    const ovskM = await this.keyStore.getMasterSecretKey(this.account.publicKeys.masterOutgoingViewingPublicKey);
 
     // Iterate over both blocks and encrypted logs.
     for (const block of blocks) {
       this.stats.blocks++;
-      const { txLogs } = block.body.noteEncryptedLogs;
+      const { txLogs: encryptedTxLogs } = block.body.noteEncryptedLogs;
+      const { txLogs: unencryptedTxLogs } = block.body.unencryptedLogs;
+
       const dataStartIndexForBlock =
         block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
         block.body.numberOfTxsIncludingPadded * MAX_NOTE_HASHES_PER_TX;
@@ -131,65 +134,77 @@ export class NoteProcessor {
       const outgoingNotes: OutgoingNoteDao[] = [];
 
       // Iterate over all the encrypted logs and try decrypting them. If successful, store the note.
-      for (let indexOfTxInABlock = 0; indexOfTxInABlock < txLogs.length; ++indexOfTxInABlock) {
+      for (let indexOfTxInABlock = 0; indexOfTxInABlock < encryptedTxLogs.length; ++indexOfTxInABlock) {
         this.stats.txs++;
         const dataStartIndexForTx = dataStartIndexForBlock + indexOfTxInABlock * MAX_NOTE_HASHES_PER_TX;
         const noteHashes = block.body.txEffects[indexOfTxInABlock].noteHashes;
         // Note: Each tx generates a `TxL2Logs` object and for this reason we can rely on its index corresponding
         //       to the index of a tx in a block.
-        const txFunctionLogs = txLogs[indexOfTxInABlock].functionLogs;
+        const encryptedTxFunctionLogs = encryptedTxLogs[indexOfTxInABlock].functionLogs;
+        const unencryptedTxFunctionLogs = unencryptedTxLogs[indexOfTxInABlock].functionLogs;
         const excludedIndices: Set<number> = new Set();
-        for (const functionLogs of txFunctionLogs) {
-          for (const log of functionLogs.logs) {
-            this.stats.seen++;
-            const incomingNotePayload = L1NotePayload.decryptAsIncoming(log, ivskM);
-            const outgoingNotePayload = L1NotePayload.decryptAsOutgoing(log, ovskM);
-
-            if (incomingNotePayload || outgoingNotePayload) {
-              if (incomingNotePayload && outgoingNotePayload && !incomingNotePayload.equals(outgoingNotePayload)) {
-                throw new Error(
-                  `Incoming and outgoing note payloads do not match. Incoming: ${JSON.stringify(
-                    incomingNotePayload,
-                  )}, Outgoing: ${JSON.stringify(outgoingNotePayload)}`,
-                );
-              }
 
-              const payload = incomingNotePayload || outgoingNotePayload;
-
-              const txEffect = block.body.txEffects[indexOfTxInABlock];
-              const { incomingNote, outgoingNote, incomingDeferredNote, outgoingDeferredNote } = await produceNoteDaos(
-                this.simulator,
-                this.db,
-                incomingNotePayload ? this.ivpkM : undefined,
-                outgoingNotePayload ? this.ovpkM : undefined,
-                payload!,
-                txEffect.txHash,
-                noteHashes,
-                dataStartIndexForTx,
-                excludedIndices,
-                this.log,
-                txEffect.unencryptedLogs,
+        // We iterate over both encrypted and unencrypted logs to decrypt the notes since partial notes are passed
+        // via the unencrypted logs stream.
+        for (const txFunctionLogs of [encryptedTxFunctionLogs, unencryptedTxFunctionLogs]) {
+          const isFromPublic = txFunctionLogs === unencryptedTxFunctionLogs;
+          for (const functionLogs of txFunctionLogs) {
+            for (const unprocessedLog of functionLogs.logs) {
+              this.stats.seen++;
+              const incomingNotePayload = L1NotePayload.decryptAsIncoming(
+                unprocessedLog.data,
+                addressSecret,
+                isFromPublic,
               );
-
-              if (incomingNote) {
-                incomingNotes.push(incomingNote);
-                this.stats.decryptedIncoming++;
-              }
-              if (outgoingNote) {
-                outgoingNotes.push(outgoingNote);
-                this.stats.decryptedOutgoing++;
-              }
-              if (incomingDeferredNote) {
-                deferredIncomingNotes.push(incomingDeferredNote);
-                this.stats.deferredIncoming++;
-              }
-              if (outgoingDeferredNote) {
-                deferredOutgoingNotes.push(outgoingDeferredNote);
-                this.stats.deferredOutgoing++;
-              }
-
-              if (incomingNote == undefined && outgoingNote == undefined && incomingDeferredNote == undefined) {
-                this.stats.failed++;
+              const outgoingNotePayload = L1NotePayload.decryptAsOutgoing(unprocessedLog.data, ovskM, isFromPublic);
+
+              if (incomingNotePayload || outgoingNotePayload) {
+                if (incomingNotePayload && outgoingNotePayload && !incomingNotePayload.equals(outgoingNotePayload)) {
+                  throw new Error(
+                    `Incoming and outgoing note payloads do not match. Incoming: ${JSON.stringify(
+                      incomingNotePayload,
+                    )}, Outgoing: ${JSON.stringify(outgoingNotePayload)}`,
+                  );
+                }
+
+                const payload = incomingNotePayload || outgoingNotePayload;
+
+                const txEffect = block.body.txEffects[indexOfTxInABlock];
+                const { incomingNote, outgoingNote, incomingDeferredNote, outgoingDeferredNote } =
+                  await produceNoteDaos(
+                    this.simulator,
+                    this.db,
+                    incomingNotePayload ? computePoint(this.account.address) : undefined,
+                    outgoingNotePayload ? this.account.publicKeys.masterOutgoingViewingPublicKey : undefined,
+                    payload!,
+                    txEffect.txHash,
+                    noteHashes,
+                    dataStartIndexForTx,
+                    excludedIndices,
+                    this.log,
+                    txEffect.unencryptedLogs,
+                  );
+
+                if (incomingNote) {
+                  incomingNotes.push(incomingNote);
+                  this.stats.decryptedIncoming++;
+                }
+                if (outgoingNote) {
+                  outgoingNotes.push(outgoingNote);
+                  this.stats.decryptedOutgoing++;
+                }
+                if (incomingDeferredNote) {
+                  deferredIncomingNotes.push(incomingDeferredNote);
+                  this.stats.deferredIncoming++;
+                }
+                if (outgoingDeferredNote) {
+                  deferredOutgoingNotes.push(outgoingDeferredNote);
+                  this.stats.deferredOutgoing++;
+                }
+
+                if (incomingNote == undefined && outgoingNote == undefined && incomingDeferredNote == undefined) {
+                  this.stats.failed++;
+                }
               }
             }
           }
@@ -207,7 +222,7 @@ export class NoteProcessor {
     await this.processDeferredNotes(deferredIncomingNotes, deferredOutgoingNotes);
 
     const syncedToBlock = blocks[blocks.length - 1].number;
-    await this.db.setSynchedBlockNumberForPublicKey(this.ivpkM, syncedToBlock);
+    await this.db.setSynchedBlockNumberForAccount(this.account.address, syncedToBlock);
 
     this.log.debug(`Synched block ${syncedToBlock}`);
   }
@@ -241,7 +256,7 @@ export class NoteProcessor {
     const nullifiers: Fr[] = blocksAndNotes.flatMap(b =>
       b.block.body.txEffects.flatMap(txEffect => txEffect.nullifiers),
     );
-    const removedNotes = await this.db.removeNullifiedNotes(nullifiers, this.ivpkM);
+    const removedNotes = await this.db.removeNullifiedNotes(nullifiers, computePoint(this.account.address));
     removedNotes.forEach(noteDao => {
       this.log.verbose(
         `Removed note for contract ${noteDao.contractAddress} at slot ${
@@ -265,15 +280,15 @@ export class NoteProcessor {
       await this.db.addDeferredNotes([...deferredIncomingNotes, ...deferredOutgoingNotes]);
       deferredIncomingNotes.forEach(noteDao => {
         this.log.verbose(
-          `Deferred incoming note for contract ${noteDao.contractAddress} at slot ${
-            noteDao.storageSlot
+          `Deferred incoming note for contract ${noteDao.payload.contractAddress} at slot ${
+            noteDao.payload.storageSlot
           } in tx ${noteDao.txHash.toString()}`,
         );
       });
       deferredOutgoingNotes.forEach(noteDao => {
         this.log.verbose(
-          `Deferred outgoing note for contract ${noteDao.contractAddress} at slot ${
-            noteDao.storageSlot
+          `Deferred outgoing note for contract ${noteDao.payload.contractAddress} at slot ${
+            noteDao.payload.storageSlot
           } in tx ${noteDao.txHash.toString()}`,
         );
       });
@@ -298,21 +313,10 @@ export class NoteProcessor {
     const outgoingNotes: OutgoingNoteDao[] = [];
 
     for (const deferredNote of deferredNoteDaos) {
-      const {
-        publicKey,
-        note,
-        contractAddress,
-        storageSlot,
-        noteTypeId,
-        txHash,
-        noteHashes,
-        dataStartIndexForTx,
-        unencryptedLogs,
-      } = deferredNote;
-      const payload = new L1NotePayload(note, contractAddress, storageSlot, noteTypeId);
+      const { publicKey, payload, txHash, noteHashes, dataStartIndexForTx, unencryptedLogs } = deferredNote;
 
-      const isIncoming = publicKey.equals(this.ivpkM);
-      const isOutgoing = publicKey.equals(this.ovpkM);
+      const isIncoming = publicKey.equals(computePoint(this.account.address));
+      const isOutgoing = publicKey.equals(this.account.publicKeys.masterOutgoingViewingPublicKey);
 
       if (!isIncoming && !isOutgoing) {
         // The note does not belong to this note processor
@@ -322,8 +326,8 @@ export class NoteProcessor {
       const { incomingNote, outgoingNote } = await produceNoteDaos(
         this.simulator,
         this.db,
-        isIncoming ? this.ivpkM : undefined,
-        isOutgoing ? this.ovpkM : undefined,
+        isIncoming ? computePoint(this.account.address) : undefined,
+        isOutgoing ? this.account.publicKeys.masterOutgoingViewingPublicKey : undefined,
         payload,
         txHash,
         noteHashes,

package/src/note_processor/utils/add_public_values_to_payload.ts

@@ -0,0 +1,63 @@
+import { type L1NotePayload, Note } from '@aztec/circuit-types';
+import { ContractNotFoundError } from '@aztec/simulator';
+
+import { type PxeDatabase } from '../../database/pxe_database.js';
+
+/**
+ * Merges privately and publicly delivered note values.
+ * @param db - PXE database used to fetch contract instance and artifact.
+ * @param payload - Payload corresponding to the note.
+ * @returns Note payload with public fields added.
+ */
+export async function getOrderedNoteItems(
+  db: PxeDatabase,
+  { contractAddress, noteTypeId, privateNoteValues, publicNoteValues }: L1NotePayload,
+): Promise<Note> {
+  if (publicNoteValues.length === 0) {
+    return new Note(privateNoteValues);
+  }
+
+  const instance = await db.getContractInstance(contractAddress);
+  if (!instance) {
+    throw new ContractNotFoundError(
+      `Could not find instance for ${contractAddress.toString()}. This should never happen here as the partial notes flow should be triggered only for non-deferred notes.`,
+    );
+  }
+
+  const artifact = await db.getContractArtifact(instance.contractClassId);
+  if (!artifact) {
+    throw new Error(
+      `Could not find artifact for contract class ${instance.contractClassId.toString()}. This should never happen here as the partial notes flow should be triggered only for non-deferred notes.`,
+    );
+  }
+
+  const noteFields = Object.values(artifact.notes).find(note => note.id.equals(noteTypeId))?.fields;
+
+  if (!noteFields) {
+    throw new Error(`Could not find note fields for note type ${noteTypeId.toString()}.`);
+  }
+
+  // We sort note fields by index so that we can iterate over them in order.
+  noteFields.sort((a, b) => a.index - b.index);
+
+  // Now we insert the public fields into the note based on its indices defined in the ABI.
+  const modifiedNoteItems = privateNoteValues;
+  let indexInPublicValues = 0;
+  for (let i = 0; i < noteFields.length; i++) {
+    const noteField = noteFields[i];
+    if (noteField.nullable) {
+      if (i == noteFields.length - 1) {
+        // We are processing the last field so we simply insert the rest of the public fields at the end
+        modifiedNoteItems.push(...publicNoteValues.slice(indexInPublicValues));
+      } else {
+        const noteFieldLength = noteFields[i + 1].index - noteField.index;
+        const publicValuesToInsert = publicNoteValues.slice(indexInPublicValues, indexInPublicValues + noteFieldLength);
+        indexInPublicValues += noteFieldLength;
+        // Now we insert the public fields at the note field index
+        modifiedNoteItems.splice(noteField.index, 0, ...publicValuesToInsert);
+      }
+    }
+  }
+
+  return new Note(modifiedNoteItems);
+}

package/src/note_processor/utils/brute_force_note_info.ts

@@ -1,5 +1,7 @@
-import { type L1NotePayload, type TxHash } from '@aztec/circuit-types';
+import { type Note, type TxHash } from '@aztec/circuit-types';
+import { type AztecAddress } from '@aztec/circuits.js';
 import { computeNoteHashNonce, siloNullifier } from '@aztec/circuits.js/hash';
+import { type NoteSelector } from '@aztec/foundation/abi';
 import { Fr } from '@aztec/foundation/fields';
 import { type AcirSimulator } from '@aztec/simulator';
 
@@ -18,7 +20,10 @@ export interface NoteInfo {
  * @remarks This method assists in identifying spent notes in the note hash tree.
  * @param siloedNoteHashes - Note hashes in the tx. One of them should correspond to the note we are looking for
  * @param txHash - Hash of a tx the note was emitted in.
- * @param l1NotePayload - The note payload.
+ * @param contractAddress - Address of the contract the note was emitted in.
+ * @param storageSlot - Storage slot of the note.
+ * @param noteTypeId - Type of the note.
+ * @param note - Note items.
  * @param excludedIndices - Indices that have been assigned a note in the same tx. Notes in a tx can have the same
  * l1NotePayload. We need to find a different index for each replicate.
  * @param computeNullifier - A flag indicating whether to compute the nullifier or just return 0.
@@ -29,7 +34,10 @@ export async function bruteForceNoteInfo(
   simulator: AcirSimulator,
   siloedNoteHashes: Fr[],
   txHash: TxHash,
-  { contractAddress, storageSlot, noteTypeId, note }: L1NotePayload,
+  contractAddress: AztecAddress,
+  storageSlot: Fr,
+  noteTypeId: NoteSelector,
+  note: Note,
   excludedIndices: Set<number>,
   computeNullifier: boolean,
 ): Promise<NoteInfo> {

package/src/note_processor/utils/produce_note_daos.ts

@@ -17,7 +17,7 @@ import { produceNoteDaosForKey } from './produce_note_daos_for_key.js';
  *
  * @param simulator - An instance of AcirSimulator.
  * @param db - An instance of PxeDatabase.
- * @param ivpkM - The public counterpart to the secret key to be used in the decryption of incoming note logs.
+ * @param addressPoint - The public counterpart to the address secret, which is used in the decryption of incoming note logs.
  * @param ovpkM - The public counterpart to the secret key to be used in the decryption of outgoing note logs.
  * @param payload - An instance of l1NotePayload.
  * @param txHash - The hash of the transaction that created the note. Equivalent to the first nullifier of the transaction.
@@ -31,7 +31,7 @@ import { produceNoteDaosForKey } from './produce_note_daos_for_key.js';
 export async function produceNoteDaos(
   simulator: AcirSimulator,
   db: PxeDatabase,
-  ivpkM: PublicKey | undefined,
+  addressPoint: PublicKey | undefined,
   ovpkM: PublicKey | undefined,
   payload: L1NotePayload,
   txHash: TxHash,
@@ -46,10 +46,8 @@ export async function produceNoteDaos(
   incomingDeferredNote: DeferredNoteDao | undefined;
   outgoingDeferredNote: DeferredNoteDao | undefined;
 }> {
-  // WARNING: This code is full of tech debt and will be refactored once we have final design of partial notes
-  // delivery.
-  if (!ivpkM && !ovpkM) {
-    throw new Error('Both ivpkM and ovpkM are undefined. Cannot create note.');
+  if (!addressPoint && !ovpkM) {
+    throw new Error('Both addressPoint and ovpkM are undefined. Cannot create note.');
   }
 
   let incomingNote: IncomingNoteDao | undefined;
@@ -57,11 +55,11 @@ export async function produceNoteDaos(
   let incomingDeferredNote: DeferredNoteDao | undefined;
   let outgoingDeferredNote: DeferredNoteDao | undefined;
 
-  if (ivpkM) {
+  if (addressPoint) {
     [incomingNote, incomingDeferredNote] = await produceNoteDaosForKey(
       simulator,
       db,
-      ivpkM,
+      addressPoint,
       payload,
       txHash,
       noteHashes,
@@ -78,11 +76,11 @@ export async function produceNoteDaos(
       // Incoming note is defined meaning that this PXE has both the incoming and outgoing keys. We can skip computing
       // note hash and note index since we already have them in the incoming note.
       outgoingNote = new OutgoingNoteDao(
-        payload.note,
-        payload.contractAddress,
-        payload.storageSlot,
-        payload.noteTypeId,
-        txHash,
+        incomingNote.note,
+        incomingNote.contractAddress,
+        incomingNote.storageSlot,
+        incomingNote.noteTypeId,
+        incomingNote.txHash,
         incomingNote.nonce,
         incomingNote.noteHash,
         incomingNote.index,

package/src/note_processor/utils/produce_note_daos_for_key.ts

@@ -1,11 +1,11 @@
-import { type L1NotePayload, type TxHash, UnencryptedTxL2Logs } from '@aztec/circuit-types';
-import { Fr, type PublicKey } from '@aztec/circuits.js';
+import { type L1NotePayload, type Note, type TxHash, type UnencryptedTxL2Logs } from '@aztec/circuit-types';
+import { type Fr, type PublicKey } from '@aztec/circuits.js';
 import { type Logger } from '@aztec/foundation/log';
 import { type AcirSimulator, ContractNotFoundError } from '@aztec/simulator';
 
 import { DeferredNoteDao } from '../../database/deferred_note_dao.js';
 import { type PxeDatabase } from '../../database/pxe_database.js';
-import { addNullableFieldsToPayload } from './add_nullable_field_to_payload.js';
+import { getOrderedNoteItems } from './add_public_values_to_payload.js';
 import { type NoteInfo, bruteForceNoteInfo } from './brute_force_note_info.js';
 
 export async function produceNoteDaosForKey<T>(
@@ -19,61 +19,40 @@ export async function produceNoteDaosForKey<T>(
   excludedIndices: Set<number>,
   logger: Logger,
   unencryptedLogs: UnencryptedTxL2Logs,
-  daoConstructor: (payload: L1NotePayload, noteInfo: NoteInfo, dataStartIndexForTx: number, pkM: PublicKey) => T,
+  daoConstructor: (
+    note: Note,
+    payload: L1NotePayload,
+    noteInfo: NoteInfo,
+    dataStartIndexForTx: number,
+    pkM: PublicKey,
+  ) => T,
 ): Promise<[T | undefined, DeferredNoteDao | undefined]> {
   let noteDao: T | undefined;
   let deferredNoteDao: DeferredNoteDao | undefined;
 
   try {
+    // We get the note by merging publicly and privately delivered note values.
+    const note = await getOrderedNoteItems(db, payload);
+
     const noteInfo = await bruteForceNoteInfo(
       simulator,
       noteHashes,
       txHash,
-      payload,
+      payload.contractAddress,
+      payload.storageSlot,
+      payload.noteTypeId,
+      note,
       excludedIndices,
       true, // For incoming we compute a nullifier (recipient of incoming is the party that nullifies).
     );
     excludedIndices?.add(noteInfo.noteHashIndex);
 
-    noteDao = daoConstructor(payload, noteInfo, dataStartIndexForTx, pkM);
+    noteDao = daoConstructor(note, payload, noteInfo, dataStartIndexForTx, pkM);
   } catch (e) {
     if (e instanceof ContractNotFoundError) {
       logger.warn(e.message);
 
-      deferredNoteDao = new DeferredNoteDao(
-        pkM,
-        payload.note,
-        payload.contractAddress,
-        payload.storageSlot,
-        payload.noteTypeId,
-        txHash,
-        noteHashes,
-        dataStartIndexForTx,
-        unencryptedLogs,
-      );
-    } else if (
-      (e as any).message.includes('failed to solve blackbox function: embedded_curve_add') ||
-      (e as any).message.includes('Could not find key prefix.')
-    ) {
-      // TODO(#8769): This branch is a temporary partial notes delivery solution that should be eventually replaced.
-      // Both error messages above occur only when we are dealing with a partial note and are thrown when calling
-      // `note.compute_note_hash()` or `note.compute_nullifier_without_context()`
-      // in `compute_note_hash_and_optionally_a_nullifier` function. It occurs with partial notes because in the
-      // partial flow we receive a note log of a note that is missing some fields here and then we try to compute
-      // the note hash with MSM while some of the fields are zeroed out (or get a nsk for zero npk_m_hash).
-      noteDao = await handlePartialNote(
-        simulator,
-        db,
-        pkM,
-        payload,
-        txHash,
-        noteHashes,
-        dataStartIndexForTx,
-        excludedIndices,
-        logger,
-        unencryptedLogs,
-        daoConstructor,
-      );
+      deferredNoteDao = new DeferredNoteDao(pkM, payload, txHash, noteHashes, dataStartIndexForTx, unencryptedLogs);
     } else {
       logger.error(`Could not process note because of "${e}". Discarding note...`);
     }
@@ -81,77 +60,3 @@ export async function produceNoteDaosForKey<T>(
 
   return [noteDao, deferredNoteDao];
 }
-
-async function handlePartialNote<T>(
-  simulator: AcirSimulator,
-  db: PxeDatabase,
-  pkM: PublicKey,
-  payload: L1NotePayload,
-  txHash: TxHash,
-  noteHashes: Fr[],
-  dataStartIndexForTx: number,
-  excludedIndices: Set<number>,
-  logger: Logger,
-  unencryptedLogs: UnencryptedTxL2Logs,
-  daoConstructor: (payload: L1NotePayload, noteInfo: NoteInfo, dataStartIndexForTx: number, pkM: PublicKey) => T,
-): Promise<T | undefined> {
-  let noteDao: T | undefined;
-
-  for (const functionLogs of unencryptedLogs.functionLogs) {
-    for (const log of functionLogs.logs) {
-      const { data } = log;
-      // It is the expectation that partial notes will have the corresponding unencrypted log be multiple
-      // of Fr.SIZE_IN_BYTES as the nullable fields should be simply concatenated.
-      if (data.length % Fr.SIZE_IN_BYTES === 0) {
-        const nullableFields = [];
-        for (let i = 0; i < data.length; i += Fr.SIZE_IN_BYTES) {
-          const chunk = data.subarray(i, i + Fr.SIZE_IN_BYTES);
-          nullableFields.push(Fr.fromBuffer(chunk));
-        }
-
-        // We insert the nullable fields into the note and then we try to produce the note dao again
-        const payloadWithNullableFields = await addNullableFieldsToPayload(db, payload, nullableFields);
-
-        let deferredNoteDao: DeferredNoteDao | undefined;
-        try {
-          [noteDao, deferredNoteDao] = await produceNoteDaosForKey(
-            simulator,
-            db,
-            pkM,
-            payloadWithNullableFields,
-            txHash,
-            noteHashes,
-            dataStartIndexForTx,
-            excludedIndices,
-            logger,
-            UnencryptedTxL2Logs.empty(), // We set unencrypted logs to empty to prevent infinite recursion.
-            daoConstructor,
-          );
-        } catch (e) {
-          // We ignore the key prefix error because that is expected to be triggered when an incorrect value
-          // is inserted at the position of `npk_m_hash`. This happens commonly because we are brute forcing
-          // the unencrypted logs.
-          if (!(e as any).message.includes('Could not find key prefix.')) {
-            throw e;
-          }
-        }
-
-        if (deferredNoteDao) {
-          // This should not happen as we should first get contract not found error before the blackbox func error.
-          throw new Error('Partial notes should never be deferred.');
-        }
-
-        if (noteDao) {
-          // We managed to complete the partial note so we terminate the search.
-          break;
-        }
-      }
-    }
-  }
-
-  if (!noteDao) {
-    logger.error(`Partial note note found. Discarding note...`);
-  }
-
-  return noteDao;
-}