@aztec/pxe 0.56.0 → 0.57.0

package/src/kernel_prover/test/test_circuit_prover.ts

@@ -3,19 +3,17 @@ import {
   type PrivateKernelProver,
   type PrivateKernelSimulateOutput,
 } from '@aztec/circuit-types';
-import type { CircuitName, CircuitSimulationStats } from '@aztec/circuit-types/stats';
+import type { CircuitSimulationStats } from '@aztec/circuit-types/stats';
 import {
   ClientIvcProof,
-  type PrivateCircuitPublicInputs,
   type PrivateKernelCircuitPublicInputs,
   type PrivateKernelInitCircuitPrivateInputs,
   type PrivateKernelInnerCircuitPrivateInputs,
-  type PrivateKernelResetCircuitPrivateInputsVariants,
+  type PrivateKernelResetCircuitPrivateInputs,
   type PrivateKernelTailCircuitPrivateInputs,
   type PrivateKernelTailCircuitPublicInputs,
   VerificationKeyAsFields,
 } from '@aztec/circuits.js';
-import { siloNoteHash } from '@aztec/circuits.js/hash';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
 import {
@@ -26,6 +24,8 @@ import {
   executeReset,
   executeTail,
   executeTailForPublic,
+  getPrivateKernelResetArtifactName,
+  maxPrivateKernelResetDimensions,
 } from '@aztec/noir-protocol-circuits-types';
 
 import { type WitnessMap } from '@noir-lang/types';
@@ -40,12 +40,6 @@ export class TestPrivateKernelProver implements PrivateKernelProver {
     return Promise.resolve(ClientIvcProof.empty());
   }
 
-  public getSiloedCommitments(publicInputs: PrivateCircuitPublicInputs) {
-    const contractAddress = publicInputs.callContext.storageContractAddress;
-
-    return Promise.resolve(publicInputs.noteHashes.map(commitment => siloNoteHash(contractAddress, commitment.value)));
-  }
-
   public async simulateProofInit(
     privateInputs: PrivateKernelInitCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
@@ -75,19 +69,20 @@ export class TestPrivateKernelProver implements PrivateKernelProver {
   }
 
   public async simulateProofReset(
-    privateInputs: PrivateKernelResetCircuitPrivateInputsVariants,
+    privateInputs: PrivateKernelResetCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
-    const [duration, result] = await elapsed(() => executeReset(privateInputs));
+    const variantPrivateInputs = privateInputs.trimToSizes();
+    const [duration, result] = await elapsed(() => executeReset(variantPrivateInputs, privateInputs.dimensions));
     this.log.debug(`Simulated private kernel reset`, {
       eventName: 'circuit-simulation',
-      circuitName: ('private-kernel-reset-' + privateInputs.sizeTag) as CircuitName,
+      circuitName: 'private-kernel-reset',
       duration,
-      inputSize: privateInputs.toBuffer().length,
+      inputSize: variantPrivateInputs.toBuffer().length,
       outputSize: result.toBuffer().length,
     } satisfies CircuitSimulationStats);
     return this.makeEmptyKernelSimulateOutput<PrivateKernelCircuitPublicInputs>(
       result,
-      'PrivateKernelResetFullArtifact',
+      getPrivateKernelResetArtifactName(maxPrivateKernelResetDimensions),
     );
   }
 
@@ -129,6 +124,7 @@ export class TestPrivateKernelProver implements PrivateKernelProver {
       publicInputs,
       verificationKey: ProtocolCircuitVks[circuitType].keyAsFields,
       outputWitness: new Map(),
+      bytecode: Buffer.from([]),
     };
     return kernelProofOutput;
   }

package/src/note_processor/note_processor.ts

@@ -1,4 +1,4 @@
-import { type AztecNode, L1NotePayload, type L2Block, TaggedLog } from '@aztec/circuit-types';
+import { type AztecNode, L1NotePayload, type L2Block } from '@aztec/circuit-types';
 import { type NoteProcessorStats } from '@aztec/circuit-types/stats';
 import { type AztecAddress, INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX, type PublicKey } from '@aztec/circuits.js';
 import { type Fr } from '@aztec/foundation/fields';
@@ -12,7 +12,7 @@ import { type IncomingNoteDao } from '../database/incoming_note_dao.js';
 import { type PxeDatabase } from '../database/index.js';
 import { type OutgoingNoteDao } from '../database/outgoing_note_dao.js';
 import { getAcirSimulator } from '../simulator/index.js';
-import { produceNoteDaos } from './produce_note_dao.js';
+import { produceNoteDaos } from './utils/produce_note_daos.js';
 
 /**
  * Contains all the decrypted data in this array so that we can later batch insert it all into the database.
@@ -142,35 +142,33 @@ export class NoteProcessor {
         for (const functionLogs of txFunctionLogs) {
           for (const log of functionLogs.logs) {
             this.stats.seen++;
-            const incomingTaggedNote = TaggedLog.decryptAsIncoming(log.data, ivskM)!;
-            const outgoingTaggedNote = TaggedLog.decryptAsOutgoing(log.data, ovskM)!;
-
-            if (incomingTaggedNote || outgoingTaggedNote) {
-              if (
-                incomingTaggedNote &&
-                outgoingTaggedNote &&
-                !incomingTaggedNote.payload.equals(outgoingTaggedNote.payload)
-              ) {
+            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(
-                    incomingTaggedNote.payload,
-                  )}, Outgoing: ${JSON.stringify(outgoingTaggedNote.payload)}`,
+                    incomingNotePayload,
+                  )}, Outgoing: ${JSON.stringify(outgoingNotePayload)}`,
                 );
               }
 
-              const payload = incomingTaggedNote?.payload || outgoingTaggedNote?.payload;
+              const payload = incomingNotePayload || outgoingNotePayload;
 
-              const txHash = block.body.txEffects[indexOfTxInABlock].txHash;
+              const txEffect = block.body.txEffects[indexOfTxInABlock];
               const { incomingNote, outgoingNote, incomingDeferredNote, outgoingDeferredNote } = await produceNoteDaos(
                 this.simulator,
-                incomingTaggedNote ? this.ivpkM : undefined,
-                outgoingTaggedNote ? this.ovpkM : undefined,
-                payload,
-                txHash,
+                this.db,
+                incomingNotePayload ? this.ivpkM : undefined,
+                outgoingNotePayload ? this.ovpkM : undefined,
+                payload!,
+                txEffect.txHash,
                 noteHashes,
                 dataStartIndexForTx,
                 excludedIndices,
                 this.log,
+                txEffect.unencryptedLogs,
               );
 
               if (incomingNote) {
@@ -300,8 +298,17 @@ export class NoteProcessor {
     const outgoingNotes: OutgoingNoteDao[] = [];
 
     for (const deferredNote of deferredNoteDaos) {
-      const { publicKey, note, contractAddress, storageSlot, noteTypeId, txHash, noteHashes, dataStartIndexForTx } =
-        deferredNote;
+      const {
+        publicKey,
+        note,
+        contractAddress,
+        storageSlot,
+        noteTypeId,
+        txHash,
+        noteHashes,
+        dataStartIndexForTx,
+        unencryptedLogs,
+      } = deferredNote;
       const payload = new L1NotePayload(note, contractAddress, storageSlot, noteTypeId);
 
       const isIncoming = publicKey.equals(this.ivpkM);
@@ -314,6 +321,7 @@ export class NoteProcessor {
 
       const { incomingNote, outgoingNote } = await produceNoteDaos(
         this.simulator,
+        this.db,
         isIncoming ? this.ivpkM : undefined,
         isOutgoing ? this.ovpkM : undefined,
         payload,
@@ -322,6 +330,7 @@ export class NoteProcessor {
         dataStartIndexForTx,
         excludedIndices,
         this.log,
+        unencryptedLogs,
       );
 
       if (isIncoming) {

package/src/note_processor/utils/add_nullable_field_to_payload.ts

@@ -0,0 +1,67 @@
+import { L1NotePayload, Note } from '@aztec/circuit-types';
+import { type Fr } from '@aztec/foundation/fields';
+import { ContractNotFoundError } from '@aztec/simulator';
+
+import { type PxeDatabase } from '../../database/pxe_database.js';
+
+/**
+ * Inserts publicly delivered nullable fields into the note payload.
+ * @param db - PXE database used to fetch contract instance and artifact.
+ * @param payload - Note payload to which nullable fields should be added.
+ * @param nullableFields - List of nullable fields to be added to the note payload.
+ * @returns Note payload with nullable fields added.
+ */
+export async function addNullableFieldsToPayload(
+  db: PxeDatabase,
+  payload: L1NotePayload,
+  nullableFields: Fr[],
+): Promise<L1NotePayload> {
+  const instance = await db.getContractInstance(payload.contractAddress);
+  if (!instance) {
+    throw new ContractNotFoundError(
+      `Could not find instance for ${payload.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(payload.noteTypeId))?.fields;
+
+  if (!noteFields) {
+    throw new Error(`Could not find note fields for note type ${payload.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 nullable fields into the note based on its indices defined in the ABI.
+  const modifiedNoteItems = [...payload.note.items];
+  let indexInNullable = 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 nullable fields at the end
+        modifiedNoteItems.push(...nullableFields.slice(indexInNullable));
+      } else {
+        const noteFieldLength = noteFields[i + 1].index - noteField.index;
+        const nullableFieldsToInsert = nullableFields.slice(indexInNullable, indexInNullable + noteFieldLength);
+        indexInNullable += noteFieldLength;
+        // Now we insert the nullable fields at the note field index
+        modifiedNoteItems.splice(noteField.index, 0, ...nullableFieldsToInsert);
+      }
+    }
+  }
+
+  return new L1NotePayload(
+    new Note(modifiedNoteItems),
+    payload.contractAddress,
+    payload.storageSlot,
+    payload.noteTypeId,
+  );
+}

package/src/note_processor/utils/brute_force_note_info.ts

@@ -0,0 +1,82 @@
+import { type L1NotePayload, type TxHash } from '@aztec/circuit-types';
+import { computeNoteHashNonce, siloNullifier } from '@aztec/circuits.js/hash';
+import { Fr } from '@aztec/foundation/fields';
+import { type AcirSimulator } from '@aztec/simulator';
+
+export interface NoteInfo {
+  noteHashIndex: number;
+  nonce: Fr;
+  noteHash: Fr;
+  siloedNullifier: Fr;
+  txHash: TxHash;
+}
+
+/**
+ * Finds nonce, index, inner hash and siloed nullifier for a given note.
+ * @dev Finds the index in the note hash tree by computing the note hash with different nonce and see which hash for
+ * the current tx matches this value.
+ * @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 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.
+ * @returns Nonce, index, inner hash and siloed nullifier for a given note.
+ * @throws If cannot find the nonce for the note.
+ */
+export async function bruteForceNoteInfo(
+  simulator: AcirSimulator,
+  siloedNoteHashes: Fr[],
+  txHash: TxHash,
+  { contractAddress, storageSlot, noteTypeId, note }: L1NotePayload,
+  excludedIndices: Set<number>,
+  computeNullifier: boolean,
+): Promise<NoteInfo> {
+  let noteHashIndex = 0;
+  let nonce: Fr | undefined;
+  let noteHash: Fr | undefined;
+  let siloedNoteHash: Fr | undefined;
+  let innerNullifier: Fr | undefined;
+  const firstNullifier = Fr.fromBuffer(txHash.toBuffer());
+
+  for (; noteHashIndex < siloedNoteHashes.length; ++noteHashIndex) {
+    if (excludedIndices.has(noteHashIndex)) {
+      continue;
+    }
+
+    const siloedNoteHashFromTxEffect = siloedNoteHashes[noteHashIndex];
+    if (siloedNoteHashFromTxEffect.equals(Fr.ZERO)) {
+      break;
+    }
+
+    const expectedNonce = computeNoteHashNonce(firstNullifier, noteHashIndex);
+    ({ noteHash, siloedNoteHash, innerNullifier } = await simulator.computeNoteHashAndOptionallyANullifier(
+      contractAddress,
+      expectedNonce,
+      storageSlot,
+      noteTypeId,
+      computeNullifier,
+      note,
+    ));
+
+    if (siloedNoteHashFromTxEffect.equals(siloedNoteHash)) {
+      nonce = expectedNonce;
+      break;
+    }
+  }
+
+  if (!nonce) {
+    // NB: this used to warn the user that a decrypted log didn't match any notes.
+    // This was previously fine as we didn't chop transient note logs, but now we do (#1641 complete).
+    throw new Error('Cannot find a matching note hash for the note.');
+  }
+
+  return {
+    noteHashIndex,
+    nonce,
+    noteHash: noteHash!,
+    siloedNullifier: siloNullifier(contractAddress, innerNullifier!),
+    txHash,
+  };
+}

package/src/note_processor/utils/index.ts

@@ -0,0 +1,2 @@
+export { produceNoteDaos } from './produce_note_daos.js';
+export { NoteInfo } from './brute_force_note_info.js';

package/src/note_processor/utils/produce_note_daos.ts

@@ -0,0 +1,114 @@
+import { type L1NotePayload, type PublicKey, type TxHash, type UnencryptedTxL2Logs } from '@aztec/circuit-types';
+import { type Fr } from '@aztec/foundation/fields';
+import { type Logger } from '@aztec/foundation/log';
+import { type AcirSimulator } from '@aztec/simulator';
+
+import { type DeferredNoteDao } from '../../database/deferred_note_dao.js';
+import { IncomingNoteDao } from '../../database/incoming_note_dao.js';
+import { OutgoingNoteDao } from '../../database/outgoing_note_dao.js';
+import { type PxeDatabase } from '../../database/pxe_database.js';
+import { produceNoteDaosForKey } from './produce_note_daos_for_key.js';
+
+/**
+ * Decodes a note from a transaction that we know was intended for us.
+ * Throws if we do not yet have the contract corresponding to the note in our database.
+ * Accepts a set of excluded indices, which are indices that have been assigned a note in the same tx.
+ * Inserts the index of the note into the excludedIndices set if the note is successfully decoded.
+ *
+ * @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 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.
+ * @param noteHashes - New note hashes in this transaction, one of which belongs to this note.
+ * @param dataStartIndexForTx - The next available leaf index for the note hash tree for this transaction.
+ * @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 logger - An instance of Logger.
+ * @param unencryptedLogs - Unencrypted logs for the transaction (used to complete partial notes).
+ * @returns An object containing the incoming, outgoing, and deferred notes.
+ */
+export async function produceNoteDaos(
+  simulator: AcirSimulator,
+  db: PxeDatabase,
+  ivpkM: PublicKey | undefined,
+  ovpkM: PublicKey | undefined,
+  payload: L1NotePayload,
+  txHash: TxHash,
+  noteHashes: Fr[],
+  dataStartIndexForTx: number,
+  excludedIndices: Set<number>,
+  logger: Logger,
+  unencryptedLogs: UnencryptedTxL2Logs,
+): Promise<{
+  incomingNote: IncomingNoteDao | undefined;
+  outgoingNote: OutgoingNoteDao | undefined;
+  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.');
+  }
+
+  let incomingNote: IncomingNoteDao | undefined;
+  let outgoingNote: OutgoingNoteDao | undefined;
+  let incomingDeferredNote: DeferredNoteDao | undefined;
+  let outgoingDeferredNote: DeferredNoteDao | undefined;
+
+  if (ivpkM) {
+    [incomingNote, incomingDeferredNote] = await produceNoteDaosForKey(
+      simulator,
+      db,
+      ivpkM,
+      payload,
+      txHash,
+      noteHashes,
+      dataStartIndexForTx,
+      excludedIndices,
+      logger,
+      unencryptedLogs,
+      IncomingNoteDao.fromPayloadAndNoteInfo,
+    );
+  }
+
+  if (ovpkM) {
+    if (incomingNote) {
+      // 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.nonce,
+        incomingNote.noteHash,
+        incomingNote.index,
+        ovpkM,
+      );
+    } else {
+      [outgoingNote, outgoingDeferredNote] = await produceNoteDaosForKey(
+        simulator,
+        db,
+        ovpkM,
+        payload,
+        txHash,
+        noteHashes,
+        dataStartIndexForTx,
+        excludedIndices,
+        logger,
+        unencryptedLogs,
+        OutgoingNoteDao.fromPayloadAndNoteInfo,
+      );
+    }
+  }
+
+  return {
+    incomingNote,
+    outgoingNote,
+    incomingDeferredNote,
+    outgoingDeferredNote,
+  };
+}

package/src/note_processor/utils/produce_note_daos_for_key.ts

@@ -0,0 +1,157 @@
+import { type L1NotePayload, type TxHash, UnencryptedTxL2Logs } from '@aztec/circuit-types';
+import { 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 { type NoteInfo, bruteForceNoteInfo } from './brute_force_note_info.js';
+
+export async function produceNoteDaosForKey<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, DeferredNoteDao | undefined]> {
+  let noteDao: T | undefined;
+  let deferredNoteDao: DeferredNoteDao | undefined;
+
+  try {
+    const noteInfo = await bruteForceNoteInfo(
+      simulator,
+      noteHashes,
+      txHash,
+      payload,
+      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);
+  } 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,
+      );
+    } else {
+      logger.error(`Could not process note because of "${e}". Discarding note...`);
+    }
+  }
+
+  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;
+}

package/src/pxe_http/pxe_http_server.ts

@@ -1,6 +1,10 @@
 import {
   AuthWitness,
   CompleteAddress,
+  CountedNoteLog,
+  CountedPublicExecutionRequest,
+  EncryptedL2Log,
+  EncryptedL2NoteLog,
   EncryptedNoteL2BlockL2Logs,
   ExtendedNote,
   ExtendedUnencryptedL2Log,
@@ -9,17 +13,20 @@ import {
   Note,
   NullifierMembershipWitness,
   type PXE,
+  PrivateExecutionResult,
   SiblingPath,
-  SimulatedTx,
   Tx,
   TxEffect,
   TxExecutionRequest,
   TxHash,
+  TxProvingResult,
   TxReceipt,
+  TxSimulationResult,
   UnencryptedL2BlockL2Logs,
+  UnencryptedL2Log,
   UniqueNote,
 } from '@aztec/circuit-types';
-import { FunctionSelector } from '@aztec/circuits.js';
+import { FunctionSelector, PrivateCallStackItem } from '@aztec/circuits.js';
 import { NoteSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Buffer32 } from '@aztec/foundation/buffer';
@@ -59,9 +66,17 @@ export function createPXERpcServer(pxeService: PXE): JsonRpcServer {
     },
     {
       EncryptedNoteL2BlockL2Logs,
+      EncryptedL2NoteLog,
+      EncryptedL2Log,
+      UnencryptedL2Log,
       NoteSelector,
       NullifierMembershipWitness,
-      SimulatedTx,
+      TxSimulationResult,
+      TxProvingResult,
+      PrivateExecutionResult,
+      PrivateCallStackItem,
+      CountedPublicExecutionRequest,
+      CountedNoteLog,
       Tx,
       TxReceipt,
       UnencryptedL2BlockL2Logs,