@aztec/pxe 0.56.0 → 0.58.0

package/src/kernel_prover/kernel_prover.ts

@@ -1,6 +1,17 @@
-import { type PrivateKernelProver, type PrivateKernelSimulateOutput } from '@aztec/circuit-types';
 import {
+  type PrivateExecutionResult,
+  type PrivateKernelProver,
+  type PrivateKernelSimulateOutput,
+  collectEnqueuedPublicFunctionCalls,
+  collectNoteHashLeafIndexMap,
+  collectNoteHashNullifierCounterMap,
+  collectPublicTeardownFunctionCall,
+  getFinalMinRevertibleSideEffectCounter,
+} from '@aztec/circuit-types';
+import {
+  CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS,
   Fr,
+  PROTOCOL_CONTRACT_TREE_HEIGHT,
   PrivateCallData,
   PrivateKernelCircuitPublicInputs,
   PrivateKernelData,
@@ -12,32 +23,27 @@ import {
   VK_TREE_HEIGHT,
   VerificationKeyAsFields,
 } from '@aztec/circuits.js';
+import { makeTuple } from '@aztec/foundation/array';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { assertLength } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types';
 import {
-  ClientCircuitArtifacts,
-  PrivateResetTagToArtifactName,
-  getVKTreeRoot,
-} from '@aztec/noir-protocol-circuits-types';
-import {
-  type ExecutionResult,
-  collectEnqueuedPublicFunctionCalls,
-  collectNoteHashLeafIndexMap,
-  collectNoteHashNullifierCounterMap,
-  collectPublicTeardownFunctionCall,
-  getFinalMinRevertibleSideEffectCounter,
-} from '@aztec/simulator';
+  getProtocolContractSiblingPath,
+  isProtocolContract,
+  protocolContractTreeRoot,
+} from '@aztec/protocol-contracts';
 
 import { type WitnessMap } from '@noir-lang/types';
 
-import { buildPrivateKernelResetInputs, needsFinalReset, needsReset } from './hints/index.js';
+import { PrivateKernelResetPrivateInputsBuilder } from './hints/build_private_kernel_reset_private_inputs.js';
 import { type ProvingDataOracle } from './proving_data_oracle.js';
 
 const NULL_PROVE_OUTPUT: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs> = {
   publicInputs: PrivateKernelCircuitPublicInputs.empty(),
-  verificationKey: VerificationKeyAsFields.makeEmpty(),
+  verificationKey: VerificationKeyAsFields.makeEmpty(CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS),
   outputWitness: new Map(),
+  bytecode: Buffer.from([]),
 };
 /**
  * The KernelProver class is responsible for generating kernel proofs.
@@ -63,7 +69,7 @@ export class KernelProver {
    */
   async prove(
     txRequest: TxRequest,
-    executionResult: ExecutionResult,
+    executionResult: PrivateExecutionResult,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
     const executionStack = [executionResult];
     let firstIteration = true;
@@ -81,22 +87,29 @@ export class KernelProver {
     const witnessStack: WitnessMap[] = [];
 
     while (executionStack.length) {
-      if (!firstIteration && needsReset(output.publicInputs, executionStack)) {
-        const resetInputs = await this.getPrivateKernelResetInputs(
-          executionStack,
+      if (!firstIteration) {
+        let resetBuilder = new PrivateKernelResetPrivateInputsBuilder(
           output,
-          noteHashLeafIndexMap,
+          executionStack,
           noteHashNullifierCounterMap,
           validationRequestsSplitCounter,
-          false,
         );
-        output = await this.proofCreator.simulateProofReset(resetInputs);
-        // TODO(#7368) consider refactoring this redundant bytecode pushing
-        acirs.push(
-          Buffer.from(ClientCircuitArtifacts[PrivateResetTagToArtifactName[resetInputs.sizeTag]].bytecode, 'base64'),
-        );
-        witnessStack.push(output.outputWitness);
+        while (resetBuilder.needsReset()) {
+          const privateInputs = await resetBuilder.build(this.oracle, noteHashLeafIndexMap);
+          output = await this.proofCreator.simulateProofReset(privateInputs);
+          // TODO(#7368) consider refactoring this redundant bytecode pushing
+          acirs.push(output.bytecode);
+          witnessStack.push(output.outputWitness);
+
+          resetBuilder = new PrivateKernelResetPrivateInputsBuilder(
+            output,
+            executionStack,
+            noteHashNullifierCounterMap,
+            validationRequestsSplitCounter,
+          );
+        }
       }
+
       const currentExecution = executionStack.pop()!;
       executionStack.push(...[...currentExecution.nestedExecutions].reverse());
 
@@ -114,10 +127,15 @@ export class KernelProver {
       const privateCallData = await this.createPrivateCallData(currentExecution, appVk.verificationKey);
 
       if (firstIteration) {
-        const proofInput = new PrivateKernelInitCircuitPrivateInputs(txRequest, getVKTreeRoot(), privateCallData);
+        const proofInput = new PrivateKernelInitCircuitPrivateInputs(
+          txRequest,
+          getVKTreeRoot(),
+          protocolContractTreeRoot,
+          privateCallData,
+        );
         pushTestData('private-kernel-inputs-init', proofInput);
         output = await this.proofCreator.simulateProofInit(proofInput);
-        acirs.push(Buffer.from(ClientCircuitArtifacts.PrivateKernelInitArtifact.bytecode, 'base64'));
+        acirs.push(output.bytecode);
         witnessStack.push(output.outputWitness);
       } else {
         const previousVkMembershipWitness = await this.oracle.getVkMembershipWitness(output.verificationKey);
@@ -130,28 +148,34 @@ export class KernelProver {
         const proofInput = new PrivateKernelInnerCircuitPrivateInputs(previousKernelData, privateCallData);
         pushTestData('private-kernel-inputs-inner', proofInput);
         output = await this.proofCreator.simulateProofInner(proofInput);
-        acirs.push(Buffer.from(ClientCircuitArtifacts.PrivateKernelInnerArtifact.bytecode, 'base64'));
+        acirs.push(output.bytecode);
         witnessStack.push(output.outputWitness);
       }
       firstIteration = false;
     }
 
-    if (needsFinalReset(output.publicInputs)) {
-      const resetInputs = await this.getPrivateKernelResetInputs(
-        executionStack,
+    // Reset.
+    let resetBuilder = new PrivateKernelResetPrivateInputsBuilder(
+      output,
+      [],
+      noteHashNullifierCounterMap,
+      validationRequestsSplitCounter,
+    );
+    while (resetBuilder.needsReset()) {
+      const privateInputs = await resetBuilder.build(this.oracle, noteHashLeafIndexMap);
+      output = await this.proofCreator.simulateProofReset(privateInputs);
+      acirs.push(output.bytecode);
+      witnessStack.push(output.outputWitness);
+
+      resetBuilder = new PrivateKernelResetPrivateInputsBuilder(
         output,
-        noteHashLeafIndexMap,
+        [],
         noteHashNullifierCounterMap,
         validationRequestsSplitCounter,
-        true,
-      );
-      output = await this.proofCreator.simulateProofReset(resetInputs);
-      // TODO(#7368) consider refactoring this redundant bytecode pushing
-      acirs.push(
-        Buffer.from(ClientCircuitArtifacts[PrivateResetTagToArtifactName[resetInputs.sizeTag]].bytecode, 'base64'),
       );
-      witnessStack.push(output.outputWitness);
     }
+
+    // Private tail.
     const previousVkMembershipWitness = await this.oracle.getVkMembershipWitness(output.verificationKey);
     const previousKernelData = new PrivateKernelData(
       output.publicInputs,
@@ -168,14 +192,7 @@ export class KernelProver {
 
     pushTestData('private-kernel-inputs-ordering', privateInputs);
     const tailOutput = await this.proofCreator.simulateProofTail(privateInputs);
-    acirs.push(
-      Buffer.from(
-        privateInputs.isForPublic()
-          ? ClientCircuitArtifacts.PrivateKernelTailToPublicArtifact.bytecode
-          : ClientCircuitArtifacts.PrivateKernelTailArtifact.bytecode,
-        'base64',
-      ),
-    );
+    acirs.push(tailOutput.bytecode);
     witnessStack.push(tailOutput.outputWitness);
 
     // TODO(#7368) how do we 'bincode' encode these inputs?
@@ -184,41 +201,14 @@ export class KernelProver {
     return tailOutput;
   }
 
-  private async getPrivateKernelResetInputs(
-    executionStack: ExecutionResult[],
-    output: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>,
-    noteHashLeafIndexMap: Map<bigint, bigint>,
-    noteHashNullifierCounterMap: Map<number, number>,
-    validationRequestsSplitCounter: number,
-    shouldSilo: boolean,
-  ) {
-    const previousVkMembershipWitness = await this.oracle.getVkMembershipWitness(output.verificationKey);
-    const previousKernelData = new PrivateKernelData(
-      output.publicInputs,
-      output.verificationKey,
-      Number(previousVkMembershipWitness.leafIndex),
-      assertLength<Fr, typeof VK_TREE_HEIGHT>(previousVkMembershipWitness.siblingPath, VK_TREE_HEIGHT),
-    );
-
-    return await buildPrivateKernelResetInputs(
-      executionStack,
-      previousKernelData,
-      noteHashLeafIndexMap,
-      noteHashNullifierCounterMap,
-      validationRequestsSplitCounter,
-      shouldSilo,
-      this.oracle,
-    );
-  }
-
-  private async createPrivateCallData({ callStackItem }: ExecutionResult, vk: VerificationKeyAsFields) {
+  private async createPrivateCallData({ callStackItem }: PrivateExecutionResult, vk: VerificationKeyAsFields) {
     const { contractAddress, functionData } = callStackItem;
 
     const functionLeafMembershipWitness = await this.oracle.getFunctionMembershipWitness(
       contractAddress,
       functionData.selector,
     );
-    const { contractClassId, publicKeysHash, saltedInitializationHash } = await this.oracle.getContractAddressPreimage(
+    const { contractClassId, publicKeys, saltedInitializationHash } = await this.oracle.getContractAddressPreimage(
       contractAddress,
     );
     const { artifactHash: contractClassArtifactHash, publicBytecodeCommitment: contractClassPublicBytecodeCommitment } =
@@ -228,14 +218,19 @@ export class KernelProver {
     // const acirHash = keccak256(Buffer.from(bytecode, 'hex'));
     const acirHash = Fr.fromBuffer(Buffer.alloc(32, 0));
 
+    const protocolContractSiblingPath = isProtocolContract(contractAddress)
+      ? getProtocolContractSiblingPath(contractAddress)
+      : makeTuple(PROTOCOL_CONTRACT_TREE_HEIGHT, Fr.zero);
+
     return PrivateCallData.from({
       callStackItem,
       vk,
-      publicKeysHash,
+      publicKeys,
       contractClassArtifactHash,
       contractClassPublicBytecodeCommitment,
       saltedInitializationHash,
       functionLeafMembershipWitness,
+      protocolContractSiblingPath,
       acirHash,
     });
   }

package/src/kernel_prover/proving_data_oracle.ts

@@ -7,6 +7,7 @@ import {
   type MembershipWitness,
   type NOTE_HASH_TREE_HEIGHT,
   type Point,
+  type PublicKeys,
   type VK_TREE_HEIGHT,
   type VerificationKeyAsFields,
 } from '@aztec/circuits.js';
@@ -20,7 +21,7 @@ export interface ProvingDataOracle {
   /** Retrieves the preimage of a contract address from the registered contract instances db. */
   getContractAddressPreimage(
     address: AztecAddress,
-  ): Promise<{ saltedInitializationHash: Fr; publicKeysHash: Fr; contractClassId: Fr }>;
+  ): Promise<{ saltedInitializationHash: Fr; publicKeys: PublicKeys; contractClassId: Fr }>;
 
   /** Retrieves the preimage of a contract class id from the contract classes db. */
   getContractClassIdPreimage(

package/src/kernel_prover/test/test_circuit_prover.ts

@@ -3,19 +3,18 @@ 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 {
+  CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS,
   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 +25,8 @@ import {
   executeReset,
   executeTail,
   executeTailForPublic,
+  getPrivateKernelResetArtifactName,
+  maxPrivateKernelResetDimensions,
 } from '@aztec/noir-protocol-circuits-types';
 
 import { type WitnessMap } from '@noir-lang/types';
@@ -40,12 +41,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 +70,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),
     );
   }
 
@@ -116,7 +112,7 @@ export class TestPrivateKernelProver implements PrivateKernelProver {
     _appCircuitName?: string | undefined,
   ): Promise<AppCircuitSimulateOutput> {
     const appCircuitProofOutput: AppCircuitSimulateOutput = {
-      verificationKey: VerificationKeyAsFields.makeEmpty(),
+      verificationKey: VerificationKeyAsFields.makeEmpty(CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS),
     };
     return Promise.resolve(appCircuitProofOutput);
   }
@@ -129,6 +125,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,6 +1,6 @@
-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 CompleteAddress, INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX, type PublicKey } 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';
@@ -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.
@@ -47,7 +47,7 @@ export class NoteProcessor {
   };
 
   private constructor(
-    public readonly account: AztecAddress,
+    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. */
@@ -61,7 +61,7 @@ export class NoteProcessor {
   ) {}
 
   public static async create(
-    account: AztecAddress,
+    account: CompleteAddress,
     keyStore: KeyStore,
     db: PxeDatabase,
     node: AztecNode,
@@ -69,8 +69,8 @@ export class NoteProcessor {
     simulator = getAcirSimulator(db, node, keyStore),
     log = createDebugLogger('aztec:note_processor'),
   ) {
-    const ivpkM = await keyStore.getMasterIncomingViewingPublicKey(account);
-    const ovpkM = await keyStore.getMasterOutgoingViewingPublicKey(account);
+    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);
   }
@@ -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) {
@@ -227,7 +225,7 @@ export class NoteProcessor {
     const incomingNotes = blocksAndNotes.flatMap(b => b.incomingNotes);
     const outgoingNotes = blocksAndNotes.flatMap(b => b.outgoingNotes);
     if (incomingNotes.length || outgoingNotes.length) {
-      await this.db.addNotes(incomingNotes, outgoingNotes, this.account);
+      await this.db.addNotes(incomingNotes, outgoingNotes, this.account.address);
       incomingNotes.forEach(noteDao => {
         this.log.verbose(
           `Added incoming note for contract ${noteDao.contractAddress} at slot ${
@@ -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';