@aztec/pxe 0.40.1 → 0.42.0

package/src/kernel_prover/private_inputs_builders/build_private_kernel_reset_hints.ts

@@ -0,0 +1,250 @@
+import {
+  type Fr,
+  KeyValidationHint,
+  MAX_KEY_VALIDATION_REQUESTS_PER_TX,
+  MAX_NEW_NOTE_HASHES_PER_TX,
+  MAX_NEW_NULLIFIERS_PER_TX,
+  MAX_NOTE_ENCRYPTED_LOGS_PER_TX,
+  MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
+  MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+  MembershipWitness,
+  NULLIFIER_TREE_HEIGHT,
+  PRIVATE_RESET_VARIANTS,
+  type PrivateKernelData,
+  PrivateKernelResetCircuitPrivateInputs,
+  type PrivateKernelResetCircuitPrivateInputsVariants,
+  PrivateKernelResetHints,
+  type ReadRequest,
+  type ScopedKeyValidationRequestAndGenerator,
+  ScopedNoteHash,
+  ScopedNullifier,
+  ScopedReadRequest,
+  buildNoteHashReadRequestHints,
+  buildNullifierReadRequestHints,
+  buildTransientDataHints,
+  getNonEmptyItems,
+} from '@aztec/circuits.js';
+import { makeTuple } from '@aztec/foundation/array';
+import { type Tuple } from '@aztec/foundation/serialize';
+import type { ExecutionResult } from '@aztec/simulator';
+
+import { type ProvingDataOracle } from '../proving_data_oracle.js';
+import { buildPrivateKernelResetOutputs } from './build_private_kernel_reset_outputs.js';
+
+function getNullifierReadRequestHints<PENDING extends number, SETTLED extends number>(
+  nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
+  nullifiers: Tuple<ScopedNullifier, typeof MAX_NEW_NULLIFIERS_PER_TX>,
+  oracle: ProvingDataOracle,
+  sizePending: PENDING,
+  sizeSettled: SETTLED,
+  futureNullifiers: ScopedNullifier[],
+) {
+  const getNullifierMembershipWitness = async (nullifier: Fr) => {
+    const res = await oracle.getNullifierMembershipWitness(nullifier);
+    if (!res) {
+      throw new Error(`Cannot find the leaf for nullifier ${nullifier.toBigInt()}.`);
+    }
+
+    const { index, siblingPath, leafPreimage } = res;
+    return {
+      membershipWitness: new MembershipWitness(
+        NULLIFIER_TREE_HEIGHT,
+        index,
+        siblingPath.toTuple<typeof NULLIFIER_TREE_HEIGHT>(),
+      ),
+      leafPreimage,
+    };
+  };
+
+  return buildNullifierReadRequestHints(
+    { getNullifierMembershipWitness },
+    nullifierReadRequests,
+    nullifiers,
+    sizePending,
+    sizeSettled,
+    futureNullifiers,
+  );
+}
+
+async function getMasterSecretKeysAndAppKeyGenerators(
+  keyValidationRequests: Tuple<ScopedKeyValidationRequestAndGenerator, typeof MAX_KEY_VALIDATION_REQUESTS_PER_TX>,
+  oracle: ProvingDataOracle,
+) {
+  const keysHints = makeTuple(MAX_KEY_VALIDATION_REQUESTS_PER_TX, KeyValidationHint.empty);
+
+  let keyIndex = 0;
+  for (let i = 0; i < keyValidationRequests.length; ++i) {
+    const request = keyValidationRequests[i].request;
+    if (request.isEmpty()) {
+      break;
+    }
+    const secretKeys = await oracle.getMasterSecretKey(request.request.pkM);
+    keysHints[keyIndex] = new KeyValidationHint(secretKeys, i);
+    keyIndex++;
+  }
+  return {
+    keysCount: keyIndex,
+    keysHints,
+  };
+}
+
+export async function buildPrivateKernelResetInputs(
+  executionStack: ExecutionResult[],
+  previousKernelData: PrivateKernelData,
+  noteHashLeafIndexMap: Map<bigint, bigint>,
+  noteHashNullifierCounterMap: Map<number, number>,
+  oracle: ProvingDataOracle,
+) {
+  const publicInputs = previousKernelData.publicInputs;
+  // Use max sizes, they will be trimmed down later.
+
+  const futureNoteHashes = collectNested(executionStack, executionResult => {
+    const nonEmptyNoteHashes = getNonEmptyItems(executionResult.callStackItem.publicInputs.newNoteHashes);
+    return nonEmptyNoteHashes.map(
+      noteHash =>
+        new ScopedNoteHash(
+          noteHash,
+          noteHashNullifierCounterMap.get(noteHash.counter) ?? 0,
+          executionResult.callStackItem.publicInputs.callContext.storageContractAddress,
+        ),
+    );
+  });
+
+  const {
+    numPendingReadHints: noteHashPendingReadHints,
+    numSettledReadHints: noteHashSettledReadHints,
+    hints: noteHashReadRequestHints,
+  } = await buildNoteHashReadRequestHints(
+    oracle,
+    publicInputs.validationRequests.noteHashReadRequests,
+    publicInputs.end.newNoteHashes,
+    noteHashLeafIndexMap,
+    MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
+    MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
+    futureNoteHashes,
+  );
+
+  const futureNullifiers = collectNested(executionStack, executionResult => {
+    const nonEmptyNullifiers = getNonEmptyItems(executionResult.callStackItem.publicInputs.newNullifiers);
+    return nonEmptyNullifiers.map(
+      nullifier =>
+        new ScopedNullifier(nullifier, executionResult.callStackItem.publicInputs.callContext.storageContractAddress),
+    );
+  });
+
+  const {
+    numPendingReadHints: nullifierPendingReadHints,
+    numSettledReadHints: nullifierSettledReadHints,
+    hints: nullifierReadRequestHints,
+  } = await getNullifierReadRequestHints(
+    publicInputs.validationRequests.nullifierReadRequests,
+    publicInputs.end.newNullifiers,
+    oracle,
+    MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+    MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+    futureNullifiers,
+  );
+
+  const { keysCount, keysHints } = await getMasterSecretKeysAndAppKeyGenerators(
+    publicInputs.validationRequests.scopedKeyValidationRequestsAndGenerators,
+    oracle,
+  );
+
+  const futureNoteHashReads = collectNestedReadRequests(
+    executionStack,
+    executionResult => executionResult.callStackItem.publicInputs.noteHashReadRequests,
+  );
+  const futureNullifierReads = collectNestedReadRequests(
+    executionStack,
+    executionResult => executionResult.callStackItem.publicInputs.nullifierReadRequests,
+  );
+
+  const [
+    transientNullifierIndexesForNoteHashes,
+    transientNoteHashIndexesForNullifiers,
+    transientNoteHashIndexesForLogs,
+  ] = buildTransientDataHints(
+    publicInputs.end.newNoteHashes,
+    publicInputs.end.newNullifiers,
+    publicInputs.end.noteEncryptedLogsHashes,
+    futureNoteHashReads,
+    futureNullifierReads,
+    MAX_NEW_NOTE_HASHES_PER_TX,
+    MAX_NEW_NULLIFIERS_PER_TX,
+    MAX_NOTE_ENCRYPTED_LOGS_PER_TX,
+  );
+
+  const expectedOutputs = buildPrivateKernelResetOutputs(
+    previousKernelData.publicInputs.end.newNoteHashes,
+    previousKernelData.publicInputs.end.newNullifiers,
+    previousKernelData.publicInputs.end.noteEncryptedLogsHashes,
+    transientNullifierIndexesForNoteHashes,
+    transientNoteHashIndexesForNullifiers,
+  );
+
+  let privateInputs;
+
+  for (const [sizeTag, hintSizes] of Object.entries(PRIVATE_RESET_VARIANTS)) {
+    if (
+      hintSizes.NOTE_HASH_PENDING_AMOUNT >= noteHashPendingReadHints &&
+      hintSizes.NOTE_HASH_SETTLED_AMOUNT >= noteHashSettledReadHints &&
+      hintSizes.NULLIFIER_PENDING_AMOUNT >= nullifierPendingReadHints &&
+      hintSizes.NULLIFIER_SETTLED_AMOUNT >= nullifierSettledReadHints &&
+      hintSizes.NULLIFIER_KEYS >= keysCount
+    ) {
+      privateInputs = new PrivateKernelResetCircuitPrivateInputs(
+        previousKernelData,
+        expectedOutputs,
+        new PrivateKernelResetHints(
+          transientNullifierIndexesForNoteHashes,
+          transientNoteHashIndexesForNullifiers,
+          transientNoteHashIndexesForLogs,
+          noteHashReadRequestHints,
+          nullifierReadRequestHints,
+          keysHints,
+        ).trimToSizes(
+          hintSizes.NOTE_HASH_PENDING_AMOUNT,
+          hintSizes.NOTE_HASH_SETTLED_AMOUNT,
+          hintSizes.NULLIFIER_PENDING_AMOUNT,
+          hintSizes.NULLIFIER_SETTLED_AMOUNT,
+          hintSizes.NULLIFIER_KEYS,
+        ),
+        sizeTag,
+      );
+      break;
+    }
+  }
+
+  if (!privateInputs) {
+    throw new Error('No private inputs found for the given hint sizes.');
+  }
+
+  return privateInputs as PrivateKernelResetCircuitPrivateInputsVariants;
+}
+
+function collectNested<T>(
+  executionStack: ExecutionResult[],
+  extractExecutionItems: (execution: ExecutionResult) => T[],
+): T[] {
+  const thisExecutionReads = executionStack.flatMap(extractExecutionItems);
+
+  return thisExecutionReads.concat(
+    executionStack.flatMap(({ nestedExecutions }) => collectNested(nestedExecutions, extractExecutionItems)),
+  );
+}
+
+function collectNestedReadRequests(
+  executionStack: ExecutionResult[],
+  extractReadRequests: (execution: ExecutionResult) => ReadRequest[],
+): ScopedReadRequest[] {
+  return collectNested(executionStack, executionResult => {
+    const nonEmptyReadRequests = getNonEmptyItems(extractReadRequests(executionResult));
+    return nonEmptyReadRequests.map(
+      readRequest =>
+        new ScopedReadRequest(
+          readRequest,
+          executionResult.callStackItem.publicInputs.callContext.storageContractAddress,
+        ),
+    );
+  });
+}

package/src/kernel_prover/private_inputs_builders/build_private_kernel_reset_outputs.ts

@@ -0,0 +1,45 @@
+import {
+  MAX_NEW_NOTE_HASHES_PER_TX,
+  MAX_NEW_NULLIFIERS_PER_TX,
+  MAX_NOTE_ENCRYPTED_LOGS_PER_TX,
+  NoteLogHash,
+  PrivateKernelResetOutputs,
+  ScopedNoteHash,
+  ScopedNullifier,
+} from '@aztec/circuits.js';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { type Tuple } from '@aztec/foundation/serialize';
+
+export function buildPrivateKernelResetOutputs(
+  prevNoteHashes: Tuple<ScopedNoteHash, typeof MAX_NEW_NOTE_HASHES_PER_TX>,
+  prevNullifiers: Tuple<ScopedNullifier, typeof MAX_NEW_NULLIFIERS_PER_TX>,
+  prevLogs: Tuple<NoteLogHash, typeof MAX_NOTE_ENCRYPTED_LOGS_PER_TX>,
+  transientNullifierIndexesForNoteHashes: Tuple<number, typeof MAX_NEW_NOTE_HASHES_PER_TX>,
+  transientNoteHashIndexesForNullifiers: Tuple<number, typeof MAX_NEW_NULLIFIERS_PER_TX>,
+) {
+  // Propagate note hashes that are not going to be squashed in the transient arrays.
+  // A value isn't going to be squashed if the symmetrical index in the corresponding array is the length of the array.
+  const noteHashes = padArrayEnd(
+    prevNoteHashes.filter((_, index) => transientNullifierIndexesForNoteHashes[index] === MAX_NEW_NULLIFIERS_PER_TX),
+    ScopedNoteHash.empty(),
+    MAX_NEW_NOTE_HASHES_PER_TX,
+  );
+
+  const nullifiers = padArrayEnd(
+    prevNullifiers.filter((_, index) => transientNoteHashIndexesForNullifiers[index] === MAX_NEW_NOTE_HASHES_PER_TX),
+    ScopedNullifier.empty(),
+    MAX_NEW_NULLIFIERS_PER_TX,
+  );
+
+  const nullifiedNotes = prevNoteHashes
+    .filter((_, index) => transientNullifierIndexesForNoteHashes[index] < MAX_NEW_NULLIFIERS_PER_TX)
+    .map(n => n.counter);
+
+  const logs = padArrayEnd(
+    prevLogs.filter(l => !l.isEmpty() && !nullifiedNotes.includes(l.noteHashCounter)),
+    NoteLogHash.empty(),
+    MAX_NOTE_ENCRYPTED_LOGS_PER_TX,
+  );
+
+  return new PrivateKernelResetOutputs(noteHashes, nullifiers, logs);
+}

package/src/kernel_prover/private_inputs_builders/build_private_kernel_tail_hints.ts

@@ -1,119 +1,16 @@
 import {
-  type Fr,
-  GrumpkinScalar,
-  type MAX_ENCRYPTED_LOGS_PER_TX,
+  MAX_ENCRYPTED_LOGS_PER_TX,
   MAX_NEW_NOTE_HASHES_PER_TX,
   MAX_NEW_NULLIFIERS_PER_TX,
-  MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_TX,
-  type MAX_NULLIFIER_READ_REQUESTS_PER_TX,
-  type MAX_UNENCRYPTED_LOGS_PER_TX,
-  MembershipWitness,
-  NULLIFIER_TREE_HEIGHT,
+  MAX_NOTE_ENCRYPTED_LOGS_PER_TX,
+  MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
+  MAX_UNENCRYPTED_LOGS_PER_TX,
   type PrivateKernelCircuitPublicInputs,
   PrivateKernelTailHints,
-  type ScopedNullifier,
-  type ScopedNullifierKeyValidationRequest,
-  type ScopedReadRequest,
-  type SideEffect,
-  type SideEffectType,
-  buildNoteHashReadRequestHints,
-  buildNullifierReadRequestHints,
-  buildTransientDataHints,
   sortByCounterGetSortedHints,
 } from '@aztec/circuits.js';
-import { makeTuple } from '@aztec/foundation/array';
-import { type Tuple } from '@aztec/foundation/serialize';
-
-import { type ProvingDataOracle } from '../proving_data_oracle.js';
-
-/** @deprecated Use sortByCounterGetSortedHints instead */
-function sortSideEffects<T extends SideEffectType, K extends number>(
-  sideEffects: Tuple<T, K>,
-): [Tuple<T, K>, Tuple<number, K>] {
-  const sorted = sideEffects
-    .map((sideEffect, index) => ({ sideEffect, index }))
-    .sort((a, b) => {
-      // Empty ones go to the right
-      if (a.sideEffect.isEmpty()) {
-        return 1;
-      }
-      return Number(a.sideEffect.counter.toBigInt() - b.sideEffect.counter.toBigInt());
-    });
-
-  const originalToSorted = sorted.map(() => 0);
-  sorted.forEach(({ index }, i) => {
-    originalToSorted[index] = i;
-  });
-
-  return [sorted.map(({ sideEffect }) => sideEffect) as Tuple<T, K>, originalToSorted as Tuple<number, K>];
-}
-
-function getNullifierReadRequestHints(
-  nullifierReadRequests: Tuple<ScopedReadRequest, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
-  nullifiers: Tuple<ScopedNullifier, typeof MAX_NEW_NULLIFIERS_PER_TX>,
-  oracle: ProvingDataOracle,
-) {
-  const getNullifierMembershipWitness = async (nullifier: Fr) => {
-    const res = await oracle.getNullifierMembershipWitness(nullifier);
-    if (!res) {
-      throw new Error(`Cannot find the leaf for nullifier ${nullifier.toBigInt()}.`);
-    }
-
-    const { index, siblingPath, leafPreimage } = res;
-    return {
-      membershipWitness: new MembershipWitness(
-        NULLIFIER_TREE_HEIGHT,
-        index,
-        siblingPath.toTuple<typeof NULLIFIER_TREE_HEIGHT>(),
-      ),
-      leafPreimage,
-    };
-  };
-
-  return buildNullifierReadRequestHints({ getNullifierMembershipWitness }, nullifierReadRequests, nullifiers);
-}
-
-async function getMasterNullifierSecretKeys(
-  nullifierKeyValidationRequests: Tuple<
-    ScopedNullifierKeyValidationRequest,
-    typeof MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_TX
-  >,
-  oracle: ProvingDataOracle,
-) {
-  const keys = makeTuple(MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_TX, GrumpkinScalar.zero);
-  for (let i = 0; i < nullifierKeyValidationRequests.length; ++i) {
-    const request = nullifierKeyValidationRequests[i].request;
-    if (request.isEmpty()) {
-      break;
-    }
-    keys[i] = await oracle.getMasterNullifierSecretKey(request.masterNullifierPublicKey);
-  }
-  return keys;
-}
-
-export async function buildPrivateKernelTailHints(
-  publicInputs: PrivateKernelCircuitPublicInputs,
-  noteHashLeafIndexMap: Map<bigint, bigint>,
-  oracle: ProvingDataOracle,
-) {
-  const noteHashReadRequestHints = await buildNoteHashReadRequestHints(
-    oracle,
-    publicInputs.validationRequests.noteHashReadRequests,
-    publicInputs.end.newNoteHashes,
-    noteHashLeafIndexMap,
-  );
-
-  const nullifierReadRequestHints = await getNullifierReadRequestHints(
-    publicInputs.validationRequests.nullifierReadRequests,
-    publicInputs.end.newNullifiers,
-    oracle,
-  );
-
-  const masterNullifierSecretKeys = await getMasterNullifierSecretKeys(
-    publicInputs.validationRequests.nullifierKeyValidationRequests,
-    oracle,
-  );
 
+export function buildPrivateKernelTailHints(publicInputs: PrivateKernelCircuitPublicInputs): PrivateKernelTailHints {
   const [sortedNoteHashes, sortedNoteHashesIndexes] = sortByCounterGetSortedHints(
     publicInputs.end.newNoteHashes,
     MAX_NEW_NOTE_HASHES_PER_TX,
@@ -124,36 +21,42 @@ export async function buildPrivateKernelTailHints(
     MAX_NEW_NULLIFIERS_PER_TX,
   );
 
-  const [sortedEncryptedLogHashes, sortedEncryptedLogHashesIndexes] = sortSideEffects<
-    SideEffect,
-    typeof MAX_ENCRYPTED_LOGS_PER_TX
-  >(publicInputs.end.encryptedLogsHashes);
+  const [sortedNoteEncryptedLogHashes, sortedNoteEncryptedLogHashesIndexes] = sortByCounterGetSortedHints(
+    publicInputs.end.noteEncryptedLogsHashes,
+    MAX_NOTE_ENCRYPTED_LOGS_PER_TX,
+  );
 
-  const [sortedUnencryptedLogHashes, sortedUnencryptedLogHashesIndexes] = sortSideEffects<
-    SideEffect,
-    typeof MAX_UNENCRYPTED_LOGS_PER_TX
-  >(publicInputs.end.unencryptedLogsHashes);
+  const [sortedEncryptedLogHashes, sortedEncryptedLogHashesIndexes] = sortByCounterGetSortedHints(
+    publicInputs.end.encryptedLogsHashes,
+    MAX_ENCRYPTED_LOGS_PER_TX,
+  );
 
-  const [transientNullifierIndexesForNoteHashes, transientNoteHashIndexesForNullifiers] = buildTransientDataHints(
-    sortedNoteHashes,
-    sortedNullifiers,
-    MAX_NEW_NOTE_HASHES_PER_TX,
-    MAX_NEW_NULLIFIERS_PER_TX,
+  const [sortedUnencryptedLogHashes, sortedUnencryptedLogHashesIndexes] = sortByCounterGetSortedHints(
+    publicInputs.end.unencryptedLogsHashes,
+    MAX_UNENCRYPTED_LOGS_PER_TX,
+  );
+
+  const [sortedCallRequests, sortedCallRequestsIndexes] = sortByCounterGetSortedHints(
+    publicInputs.end.publicCallStack,
+    MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
+    {
+      ascending: false,
+      hintIndexesBy: 'sorted',
+    },
   );
 
   return new PrivateKernelTailHints(
-    transientNullifierIndexesForNoteHashes,
-    transientNoteHashIndexesForNullifiers,
-    noteHashReadRequestHints,
-    nullifierReadRequestHints,
-    masterNullifierSecretKeys,
     sortedNoteHashes,
     sortedNoteHashesIndexes,
     sortedNullifiers,
     sortedNullifiersIndexes,
+    sortedNoteEncryptedLogHashes,
+    sortedNoteEncryptedLogHashesIndexes,
     sortedEncryptedLogHashes,
     sortedEncryptedLogHashesIndexes,
     sortedUnencryptedLogHashes,
     sortedUnencryptedLogHashesIndexes,
+    sortedCallRequests,
+    sortedCallRequestsIndexes,
   );
 }

package/src/kernel_prover/private_inputs_builders/index.ts

@@ -1,3 +1,5 @@
+export { buildPrivateKernelInitHints } from './build_private_kernel_init_hints.js';
 export { buildPrivateKernelInnerHints } from './build_private_kernel_inner_hints.js';
 export { buildPrivateKernelTailHints } from './build_private_kernel_tail_hints.js';
-export { buildPrivateKernelTailOutputs } from './build_private_kernel_tail_outputs.js';
+export { buildPrivateKernelResetInputs } from './build_private_kernel_reset_hints.js';
+export { buildPrivateKernelResetOutputs } from './build_private_kernel_reset_outputs.js';

package/src/kernel_prover/proving_data_oracle.ts

@@ -70,10 +70,13 @@ export interface ProvingDataOracle {
   getNoteHashTreeRoot(): Promise<Fr>;
 
   /**
-   * Get the master secret key of the nullifier public key.
-   *
-   * @param nullifierPublicKey - The nullifier public key.
-   * @returns the master nullifier secret key.
+   * Retrieves the sk_m corresponding to the pk_m.
+   * @throws If the provided public key is not associated with any of the registered accounts.
+   * @param pkM - The master public key to get secret key for.
+   * @returns A Promise that resolves to sk_m.
+   * @dev Used when feeding the sk_m to the kernel circuit for keys verification.
    */
-  getMasterNullifierSecretKey(nullifierPublicKey: Point): Promise<GrumpkinPrivateKey>;
+  getMasterSecretKey(masterPublicKey: Point): Promise<GrumpkinPrivateKey>;
+
+  getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
 }

package/src/kernel_prover/test/test_circuit_prover.ts

@@ -1,11 +1,12 @@
 import { type AppCircuitProofOutput, type KernelProofOutput, type ProofCreator } from '@aztec/circuit-types';
-import { type CircuitSimulationStats } from '@aztec/circuit-types/stats';
+import type { CircuitName, CircuitSimulationStats } from '@aztec/circuit-types/stats';
 import {
   NESTED_RECURSIVE_PROOF_LENGTH,
   type PrivateCircuitPublicInputs,
   type PrivateKernelCircuitPublicInputs,
   type PrivateKernelInitCircuitPrivateInputs,
   type PrivateKernelInnerCircuitPrivateInputs,
+  type PrivateKernelResetCircuitPrivateInputsVariants,
   type PrivateKernelTailCircuitPrivateInputs,
   type PrivateKernelTailCircuitPublicInputs,
   RECURSIVE_PROOF_LENGTH,
@@ -15,7 +16,13 @@ import {
 import { siloNoteHash } from '@aztec/circuits.js/hash';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
-import { executeInit, executeInner, executeTail, executeTailForPublic } from '@aztec/noir-protocol-circuits-types';
+import {
+  executeInit,
+  executeInner,
+  executeReset,
+  executeTail,
+  executeTailForPublic,
+} from '@aztec/noir-protocol-circuits-types';
 
 /**
  * Test Proof Creator executes circuit simulations and provides fake proofs.
@@ -59,6 +66,20 @@ export class TestProofCreator implements ProofCreator {
     return this.makeEmptyKernelProofOutput<PrivateKernelCircuitPublicInputs>(result);
   }
 
+  public async createProofReset(
+    privateInputs: PrivateKernelResetCircuitPrivateInputsVariants,
+  ): Promise<KernelProofOutput<PrivateKernelCircuitPublicInputs>> {
+    const [duration, result] = await elapsed(() => executeReset(privateInputs));
+    this.log.debug(`Simulated private kernel reset`, {
+      eventName: 'circuit-simulation',
+      circuitName: ('private-kernel-reset-' + privateInputs.sizeTag) as CircuitName,
+      duration,
+      inputSize: privateInputs.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    } satisfies CircuitSimulationStats);
+    return this.makeEmptyKernelProofOutput<PrivateKernelCircuitPublicInputs>(result);
+  }
+
   public async createProofTail(
     privateInputs: PrivateKernelTailCircuitPrivateInputs,
   ): Promise<KernelProofOutput<PrivateKernelTailCircuitPublicInputs>> {
@@ -68,7 +89,7 @@ export class TestProofCreator implements ProofCreator {
     );
     this.log.debug(`Simulated private kernel ordering`, {
       eventName: 'circuit-simulation',
-      circuitName: 'private-kernel-ordering',
+      circuitName: 'private-kernel-tail',
       duration,
       inputSize: privateInputs.toBuffer().length,
       outputSize: result.toBuffer().length,

package/src/note_processor/note_processor.ts

@@ -1,7 +1,6 @@
 import {
   type AztecNode,
-  type EncryptedL2BlockL2Logs,
-  type KeyStore,
+  type EncryptedNoteL2BlockL2Logs,
   L1NotePayload,
   type L2Block,
   TaggedNote,
@@ -11,6 +10,7 @@ import { INITIAL_L2_BLOCK_NUM, MAX_NEW_NOTE_HASHES_PER_TX, type PublicKey } from
 import { type Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
+import { type KeyStore } from '@aztec/key-store';
 import { ContractNotFoundError } from '@aztec/simulator';
 
 import { DeferredNoteDao } from '../database/deferred_note_dao.js';
@@ -88,7 +88,7 @@ export class NoteProcessor {
    * @param encryptedL2BlockLogs - Encrypted logs associated with the L2 blocks.
    * @returns A promise that resolves once the processing is completed.
    */
-  public async process(l2Blocks: L2Block[], encryptedL2BlockLogs: EncryptedL2BlockL2Logs[]): Promise<void> {
+  public async process(l2Blocks: L2Block[], encryptedL2BlockLogs: EncryptedNoteL2BlockL2Logs[]): Promise<void> {
     if (l2Blocks.length !== encryptedL2BlockLogs.length) {
       throw new Error(
         `Number of blocks and EncryptedLogs is not equal. Received ${l2Blocks.length} blocks, ${encryptedL2BlockLogs.length} encrypted logs.`,
@@ -130,7 +130,8 @@ export class NoteProcessor {
         for (const functionLogs of txFunctionLogs) {
           for (const log of functionLogs.logs) {
             this.stats.seen++;
-            const taggedNote = TaggedNote.fromEncryptedBuffer(log.data, secretKey);
+            // @todo Issue(#6410) We should also try decrypting as outgoing if this fails.
+            const taggedNote = TaggedNote.decryptAsIncoming(log.data, secretKey);
             if (taggedNote?.notePayload) {
               const { notePayload: payload } = taggedNote;
               // We have successfully decrypted the data.

package/src/note_processor/produce_note_dao.ts

@@ -107,25 +107,9 @@ async function findNoteIndexAndNullifier(
   }
 
   if (!nonce) {
-    let errorString;
-    if (siloedNoteHash == undefined) {
-      errorString = 'Cannot find a matching commitment for the note.';
-    } else {
-      errorString = `We decrypted a log, but couldn't find a corresponding note in the tree.
-This might be because the note was nullified in the same tx which created it.
-In that case, everything is fine. To check whether this is the case, look back through
-the logs for a notification
-'important: chopped commitment for siloed inner hash note
-${siloedNoteHash.toString()}'.
-If you can see that notification. Everything's fine.
-If that's not the case, and you can't find such a notification, something has gone wrong.
-There could be a problem with the way you've defined a custom note, or with the way you're
-serializing / deserializing / hashing / encrypting / decrypting that note.
-Please see the following github issue to track an improvement that we're working on:
-https://github.com/AztecProtocol/aztec-packages/issues/1641`;
-    }
-
-    throw new Error(errorString);
+    // 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 commitment for the note.');
   }
 
   return {

package/src/pxe_http/pxe_http_server.ts

@@ -1,7 +1,7 @@
 import {
   AuthWitness,
   CompleteAddress,
-  EncryptedL2BlockL2Logs,
+  EncryptedNoteL2BlockL2Logs,
   ExtendedNote,
   ExtendedUnencryptedL2Log,
   L2Block,
@@ -50,7 +50,7 @@ export function createPXERpcServer(pxeService: PXE): JsonRpcServer {
       TxEffect,
       LogId,
     },
-    { SimulatedTx, Tx, TxReceipt, EncryptedL2BlockL2Logs, UnencryptedL2BlockL2Logs, NullifierMembershipWitness },
+    { SimulatedTx, Tx, TxReceipt, EncryptedNoteL2BlockL2Logs, UnencryptedL2BlockL2Logs, NullifierMembershipWitness },
     ['start', 'stop'],
   );
 }