@aztec/pxe 0.55.1 → 0.57.0

package/src/kernel_prover/kernel_prover.ts

@@ -1,4 +1,13 @@
-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 {
   Fr,
   PrivateCallData,
@@ -15,29 +24,18 @@ import {
 import { createDebugLogger } from '@aztec/foundation/log';
 import { assertLength } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
-import {
-  ClientCircuitArtifacts,
-  PrivateResetTagToArtifactName,
-  getVKTreeRoot,
-} from '@aztec/noir-protocol-circuits-types';
-import {
-  type ExecutionResult,
-  collectEnqueuedPublicFunctionCalls,
-  collectNoteHashLeafIndexMap,
-  collectNoteHashNullifierCounterMap,
-  collectPublicTeardownFunctionCall,
-  getFinalMinRevertibleSideEffectCounter,
-} from '@aztec/simulator';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types';
 
 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(),
   outputWitness: new Map(),
+  bytecode: Buffer.from([]),
 };
 /**
  * The KernelProver class is responsible for generating kernel proofs.
@@ -63,7 +61,7 @@ export class KernelProver {
    */
   async prove(
     txRequest: TxRequest,
-    executionResult: ExecutionResult,
+    executionResult: PrivateExecutionResult,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
     const executionStack = [executionResult];
     let firstIteration = true;
@@ -81,22 +79,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());
 
@@ -117,7 +122,7 @@ export class KernelProver {
         const proofInput = new PrivateKernelInitCircuitPrivateInputs(txRequest, getVKTreeRoot(), 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 +135,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 +179,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,34 +188,7 @@ 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(

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,
+  };
+}