@aztec/pxe 0.41.0 → 0.43.0

package/src/database/pxe_database_test_suite.ts

@@ -1,4 +1,4 @@
-import { type NoteFilter, NoteStatus, randomTxHash } from '@aztec/circuit-types';
+import { type IncomingNotesFilter, NoteStatus, type OutgoingNotesFilter, randomTxHash } from '@aztec/circuit-types';
 import { AztecAddress, CompleteAddress, INITIAL_L2_BLOCK_NUM, PublicKeys } from '@aztec/circuits.js';
 import { makeHeader } from '@aztec/circuits.js/testing';
 import { randomInt } from '@aztec/foundation/crypto';
@@ -6,8 +6,10 @@ import { Fr, Point } from '@aztec/foundation/fields';
 import { BenchmarkingContractArtifact } from '@aztec/noir-contracts.js/Benchmarking';
 import { SerializableContractInstance } from '@aztec/types/contracts';
 
-import { type NoteDao } from './note_dao.js';
-import { randomNoteDao } from './note_dao.test.js';
+import { type IncomingNoteDao } from './incoming_note_dao.js';
+import { randomIncomingNoteDao } from './incoming_note_dao.test.js';
+import { type OutgoingNoteDao } from './outgoing_note_dao.js';
+import { randomOutgoingNoteDao } from './outgoing_note_dao.test.js';
 import { type PxeDatabase } from './pxe_database.js';
 
 /**
@@ -68,13 +70,13 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
     });
 
-    describe('notes', () => {
+    describe('incoming notes', () => {
       let owners: CompleteAddress[];
       let contractAddresses: AztecAddress[];
       let storageSlots: Fr[];
-      let notes: NoteDao[];
+      let notes: IncomingNoteDao[];
 
-      const filteringTests: [() => NoteFilter, () => NoteDao[]][] = [
+      const filteringTests: [() => IncomingNotesFilter, () => IncomingNoteDao[]][] = [
         [() => ({}), () => notes],
 
         [
@@ -94,7 +96,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
 
         [
           () => ({ owner: owners[0].address }),
-          () => notes.filter(note => note.publicKey.equals(owners[0].publicKeys.masterIncomingViewingPublicKey)),
+          () => notes.filter(note => note.ivpkM.equals(owners[0].publicKeys.masterIncomingViewingPublicKey)),
         ],
 
         [
@@ -107,46 +109,44 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
         [() => ({ contractAddress: contractAddresses[0], storageSlot: storageSlots[1] }), () => []],
       ];
 
-      beforeEach(() => {
+      beforeEach(async () => {
         owners = Array.from({ length: 2 }).map(() => CompleteAddress.random());
         contractAddresses = Array.from({ length: 2 }).map(() => AztecAddress.random());
         storageSlots = Array.from({ length: 2 }).map(() => Fr.random());
 
         notes = Array.from({ length: 10 }).map((_, i) =>
-          randomNoteDao({
+          randomIncomingNoteDao({
             contractAddress: contractAddresses[i % contractAddresses.length],
             storageSlot: storageSlots[i % storageSlots.length],
-            publicKey: owners[i % owners.length].publicKeys.masterIncomingViewingPublicKey,
+            ivpkM: owners[i % owners.length].publicKeys.masterIncomingViewingPublicKey,
             index: BigInt(i),
           }),
         );
-      });
 
-      beforeEach(async () => {
         for (const owner of owners) {
           await database.addCompleteAddress(owner);
         }
       });
 
       it.each(filteringTests)('stores notes in bulk and retrieves notes', async (getFilter, getExpected) => {
-        await database.addNotes(notes);
-        await expect(database.getNotes(getFilter())).resolves.toEqual(getExpected());
+        await database.addNotes(notes, []);
+        await expect(database.getIncomingNotes(getFilter())).resolves.toEqual(getExpected());
       });
 
       it.each(filteringTests)('stores notes one by one and retrieves notes', async (getFilter, getExpected) => {
         for (const note of notes) {
           await database.addNote(note);
         }
-        await expect(database.getNotes(getFilter())).resolves.toEqual(getExpected());
+        await expect(database.getIncomingNotes(getFilter())).resolves.toEqual(getExpected());
       });
 
       it.each(filteringTests)('retrieves nullified notes', async (getFilter, getExpected) => {
-        await database.addNotes(notes);
+        await database.addNotes(notes, []);
 
         // Nullify all notes and use the same filter as other test cases
         for (const owner of owners) {
           const notesToNullify = notes.filter(note =>
-            note.publicKey.equals(owner.publicKeys.masterIncomingViewingPublicKey),
+            note.ivpkM.equals(owner.publicKeys.masterIncomingViewingPublicKey),
           );
           const nullifiers = notesToNullify.map(note => note.siloedNullifier);
           await expect(
@@ -154,41 +154,41 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
           ).resolves.toEqual(notesToNullify);
         }
 
-        await expect(database.getNotes({ ...getFilter(), status: NoteStatus.ACTIVE_OR_NULLIFIED })).resolves.toEqual(
-          getExpected(),
-        );
+        await expect(
+          database.getIncomingNotes({ ...getFilter(), status: NoteStatus.ACTIVE_OR_NULLIFIED }),
+        ).resolves.toEqual(getExpected());
       });
 
       it('skips nullified notes by default or when requesting active', async () => {
-        await database.addNotes(notes);
+        await database.addNotes(notes, []);
 
         const notesToNullify = notes.filter(note =>
-          note.publicKey.equals(owners[0].publicKeys.masterIncomingViewingPublicKey),
+          note.ivpkM.equals(owners[0].publicKeys.masterIncomingViewingPublicKey),
         );
         const nullifiers = notesToNullify.map(note => note.siloedNullifier);
-        await expect(database.removeNullifiedNotes(nullifiers, notesToNullify[0].publicKey)).resolves.toEqual(
+        await expect(database.removeNullifiedNotes(nullifiers, notesToNullify[0].ivpkM)).resolves.toEqual(
           notesToNullify,
         );
 
-        const actualNotesWithDefault = await database.getNotes({});
-        const actualNotesWithActive = await database.getNotes({ status: NoteStatus.ACTIVE });
+        const actualNotesWithDefault = await database.getIncomingNotes({});
+        const actualNotesWithActive = await database.getIncomingNotes({ status: NoteStatus.ACTIVE });
 
         expect(actualNotesWithDefault).toEqual(actualNotesWithActive);
         expect(actualNotesWithActive).toEqual(notes.filter(note => !notesToNullify.includes(note)));
       });
 
       it('returns active and nullified notes when requesting either', async () => {
-        await database.addNotes(notes);
+        await database.addNotes(notes, []);
 
         const notesToNullify = notes.filter(note =>
-          note.publicKey.equals(owners[0].publicKeys.masterIncomingViewingPublicKey),
+          note.ivpkM.equals(owners[0].publicKeys.masterIncomingViewingPublicKey),
         );
         const nullifiers = notesToNullify.map(note => note.siloedNullifier);
-        await expect(database.removeNullifiedNotes(nullifiers, notesToNullify[0].publicKey)).resolves.toEqual(
+        await expect(database.removeNullifiedNotes(nullifiers, notesToNullify[0].ivpkM)).resolves.toEqual(
           notesToNullify,
         );
 
-        const result = await database.getNotes({
+        const result = await database.getIncomingNotes({
           status: NoteStatus.ACTIVE_OR_NULLIFIED,
         });
 
@@ -198,6 +198,70 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
     });
 
+    describe('outgoing notes', () => {
+      let owners: CompleteAddress[];
+      let contractAddresses: AztecAddress[];
+      let storageSlots: Fr[];
+      let notes: OutgoingNoteDao[];
+
+      const filteringTests: [() => OutgoingNotesFilter, () => OutgoingNoteDao[]][] = [
+        [() => ({}), () => notes],
+
+        [
+          () => ({ contractAddress: contractAddresses[0] }),
+          () => notes.filter(note => note.contractAddress.equals(contractAddresses[0])),
+        ],
+        [() => ({ contractAddress: AztecAddress.random() }), () => []],
+
+        [
+          () => ({ storageSlot: storageSlots[0] }),
+          () => notes.filter(note => note.storageSlot.equals(storageSlots[0])),
+        ],
+        [() => ({ storageSlot: Fr.random() }), () => []],
+
+        [() => ({ txHash: notes[0].txHash }), () => [notes[0]]],
+        [() => ({ txHash: randomTxHash() }), () => []],
+
+        [
+          () => ({ owner: owners[0].address }),
+          () => notes.filter(note => note.ovpkM.equals(owners[0].publicKeys.masterOutgoingViewingPublicKey)),
+        ],
+
+        [
+          () => ({ contractAddress: contractAddresses[0], storageSlot: storageSlots[0] }),
+          () =>
+            notes.filter(
+              note => note.contractAddress.equals(contractAddresses[0]) && note.storageSlot.equals(storageSlots[0]),
+            ),
+        ],
+        [() => ({ contractAddress: contractAddresses[0], storageSlot: storageSlots[1] }), () => []],
+      ];
+
+      beforeEach(async () => {
+        owners = Array.from({ length: 2 }).map(() => CompleteAddress.random());
+        contractAddresses = Array.from({ length: 2 }).map(() => AztecAddress.random());
+        storageSlots = Array.from({ length: 2 }).map(() => Fr.random());
+
+        notes = Array.from({ length: 10 }).map((_, i) =>
+          randomOutgoingNoteDao({
+            contractAddress: contractAddresses[i % contractAddresses.length],
+            storageSlot: storageSlots[i % storageSlots.length],
+            ovpkM: owners[i % owners.length].publicKeys.masterOutgoingViewingPublicKey,
+            index: BigInt(i),
+          }),
+        );
+
+        for (const owner of owners) {
+          await database.addCompleteAddress(owner);
+        }
+      });
+
+      it.each(filteringTests)('stores notes in bulk and retrieves notes', async (getFilter, getExpected) => {
+        await database.addNotes([], notes);
+        await expect(database.getOutgoingNotes(getFilter())).resolves.toEqual(getExpected());
+      });
+    });
+
     describe('block header', () => {
       it('stores and retrieves the block header', async () => {
         const header = makeHeader(randomInt(1000), INITIAL_L2_BLOCK_NUM);

package/src/kernel_oracle/index.ts

@@ -4,7 +4,6 @@ import {
   type Fr,
   type FunctionSelector,
   type GrumpkinPrivateKey,
-  type KeyGenerator,
   MembershipWitness,
   type NOTE_HASH_TREE_HEIGHT,
   type Point,
@@ -70,23 +69,11 @@ export class KernelOracle implements ProvingDataOracle {
     return header.state.partial.noteHashTree.root;
   }
 
-  public getMasterSecretKeyAndAppKeyGenerator(masterPublicKey: Point): Promise<[GrumpkinPrivateKey, KeyGenerator]> {
-    return this.keyStore.getMasterSecretKeyAndAppKeyGenerator(masterPublicKey);
+  public getMasterSecretKey(masterPublicKey: Point): Promise<GrumpkinPrivateKey> {
+    return this.keyStore.getMasterSecretKey(masterPublicKey);
   }
 
-  public async getFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined> {
-    try {
-      const contractInstance = await this.contractDataOracle.getContractInstance(contractAddress);
-
-      const [contractArtifact, functionArtifact] = await Promise.all([
-        this.contractDataOracle.getContractArtifact(contractInstance.contractClassId),
-        this.contractDataOracle.getFunctionArtifact(contractAddress, selector),
-      ]);
-
-      return `${contractArtifact.name}:${functionArtifact.name}`;
-    } catch (e) {
-      this.log.error(`Failed to get function name for contract ${contractAddress} and selector ${selector}: ${e}`);
-      return 'Unknown';
-    }
+  public getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string> {
+    return this.contractDataOracle.getDebugFunctionName(contractAddress, selector);
   }
 }

package/src/kernel_prover/kernel_prover.ts

@@ -2,6 +2,12 @@ import { type KernelProofOutput, type ProofCreator } from '@aztec/circuit-types'
 import {
   CallRequest,
   Fr,
+  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,
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
   NESTED_RECURSIVE_PROOF_LENGTH,
   PrivateCallData,
@@ -16,6 +22,7 @@ import {
   type TxRequest,
   VK_TREE_HEIGHT,
   VerificationKeyAsFields,
+  getNonEmptyItems,
   makeRecursiveProof,
 } from '@aztec/circuits.js';
 import { padArrayEnd } from '@aztec/foundation/collection';
@@ -70,6 +77,9 @@ export class KernelProver {
     const noteHashNullifierCounterMap = collectNullifiedNoteHashCounters(executionResult);
 
     while (executionStack.length) {
+      if (!firstIteration && this.needsReset(executionStack, output)) {
+        output = await this.runReset(executionStack, output, noteHashLeafIndexMap, noteHashNullifierCounterMap);
+      }
       const currentExecution = executionStack.pop()!;
       executionStack.push(...[...currentExecution.nestedExecutions].reverse());
 
@@ -78,7 +88,7 @@ export class KernelProver {
         ? CallRequest.empty()
         : currentExecution.publicTeardownFunctionCall.toCallRequest();
 
-      const functionName = await this.oracle.getFunctionName(
+      const functionName = await this.oracle.getDebugFunctionName(
         currentExecution.callStackItem.contractAddress,
         currentExecution.callStackItem.functionData.selector,
       );
@@ -126,21 +136,11 @@ export class KernelProver {
       firstIteration = false;
     }
 
-    let previousVkMembershipWitness = await this.oracle.getVkMembershipWitness(output.verificationKey);
-    let previousKernelData = new PrivateKernelData(
-      output.publicInputs,
-      output.proof,
-      output.verificationKey,
-      Number(previousVkMembershipWitness.leafIndex),
-      assertLength<Fr, typeof VK_TREE_HEIGHT>(previousVkMembershipWitness.siblingPath, VK_TREE_HEIGHT),
-    );
-
-    output = await this.proofCreator.createProofReset(
-      await buildPrivateKernelResetInputs(previousKernelData, noteHashLeafIndexMap, this.oracle),
-    );
-
-    previousVkMembershipWitness = await this.oracle.getVkMembershipWitness(output.verificationKey);
-    previousKernelData = new PrivateKernelData(
+    if (this.somethingToReset(output)) {
+      output = await this.runReset(executionStack, output, noteHashLeafIndexMap, noteHashNullifierCounterMap);
+    }
+    const previousVkMembershipWitness = await this.oracle.getVkMembershipWitness(output.verificationKey);
+    const previousKernelData = new PrivateKernelData(
       output.publicInputs,
       output.proof,
       output.verificationKey,
@@ -160,6 +160,66 @@ export class KernelProver {
     return await this.proofCreator.createProofTail(privateInputs);
   }
 
+  private needsReset(executionStack: ExecutionResult[], output: KernelProofOutput<PrivateKernelCircuitPublicInputs>) {
+    const nextIteration = executionStack[executionStack.length - 1];
+    return (
+      getNonEmptyItems(nextIteration.callStackItem.publicInputs.newNoteHashes).length +
+        getNonEmptyItems(output.publicInputs.end.newNoteHashes).length >
+        MAX_NEW_NOTE_HASHES_PER_TX ||
+      getNonEmptyItems(nextIteration.callStackItem.publicInputs.newNullifiers).length +
+        getNonEmptyItems(output.publicInputs.end.newNullifiers).length >
+        MAX_NEW_NULLIFIERS_PER_TX ||
+      getNonEmptyItems(nextIteration.callStackItem.publicInputs.noteEncryptedLogsHashes).length +
+        getNonEmptyItems(output.publicInputs.end.noteEncryptedLogsHashes).length >
+        MAX_NOTE_ENCRYPTED_LOGS_PER_TX ||
+      getNonEmptyItems(nextIteration.callStackItem.publicInputs.noteHashReadRequests).length +
+        getNonEmptyItems(output.publicInputs.validationRequests.noteHashReadRequests).length >
+        MAX_NOTE_HASH_READ_REQUESTS_PER_TX ||
+      getNonEmptyItems(nextIteration.callStackItem.publicInputs.nullifierReadRequests).length +
+        getNonEmptyItems(output.publicInputs.validationRequests.nullifierReadRequests).length >
+        MAX_NULLIFIER_READ_REQUESTS_PER_TX ||
+      getNonEmptyItems(nextIteration.callStackItem.publicInputs.keyValidationRequestsAndGenerators).length +
+        getNonEmptyItems(output.publicInputs.validationRequests.scopedKeyValidationRequestsAndGenerators).length >
+        MAX_KEY_VALIDATION_REQUESTS_PER_TX
+    );
+  }
+
+  private somethingToReset(output: KernelProofOutput<PrivateKernelCircuitPublicInputs>) {
+    return (
+      getNonEmptyItems(output.publicInputs.validationRequests.noteHashReadRequests).length > 0 ||
+      getNonEmptyItems(output.publicInputs.validationRequests.nullifierReadRequests).length > 0 ||
+      getNonEmptyItems(output.publicInputs.validationRequests.scopedKeyValidationRequestsAndGenerators).length > 0 ||
+      output.publicInputs.end.newNoteHashes.find(noteHash => noteHash.nullifierCounter !== 0) ||
+      output.publicInputs.end.newNullifiers.find(nullifier => !nullifier.nullifiedNoteHash.equals(Fr.zero()))
+    );
+  }
+
+  private async runReset(
+    executionStack: ExecutionResult[],
+    output: KernelProofOutput<PrivateKernelCircuitPublicInputs>,
+    noteHashLeafIndexMap: Map<bigint, bigint>,
+    noteHashNullifierCounterMap: Map<number, number>,
+  ): Promise<KernelProofOutput<PrivateKernelCircuitPublicInputs>> {
+    const previousVkMembershipWitness = await this.oracle.getVkMembershipWitness(output.verificationKey);
+    const previousKernelData = new PrivateKernelData(
+      output.publicInputs,
+      output.proof,
+      output.verificationKey,
+      Number(previousVkMembershipWitness.leafIndex),
+      assertLength<Fr, typeof VK_TREE_HEIGHT>(previousVkMembershipWitness.siblingPath, VK_TREE_HEIGHT),
+    );
+
+    return this.proofCreator.createProofReset(
+      await buildPrivateKernelResetInputs(
+        executionStack,
+        previousKernelData,
+        noteHashLeafIndexMap,
+        noteHashNullifierCounterMap,
+        this.oracle,
+      ),
+    );
+  }
+
   private async createPrivateCallData(
     { callStackItem }: ExecutionResult,
     publicCallRequests: CallRequest[],

package/src/kernel_prover/private_inputs_builders/build_private_kernel_reset_hints.ts

@@ -1,5 +1,5 @@
 import {
-  Fr,
+  type Fr,
   KeyValidationHint,
   MAX_KEY_VALIDATION_REQUESTS_PER_TX,
   MAX_NEW_NOTE_HASHES_PER_TX,
@@ -14,15 +14,19 @@ import {
   PrivateKernelResetCircuitPrivateInputs,
   type PrivateKernelResetCircuitPrivateInputsVariants,
   PrivateKernelResetHints,
-  type ScopedKeyValidationRequest,
-  type ScopedNullifier,
-  type ScopedReadRequest,
+  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';
@@ -33,6 +37,7 @@ function getNullifierReadRequestHints<PENDING extends number, SETTLED extends nu
   oracle: ProvingDataOracle,
   sizePending: PENDING,
   sizeSettled: SETTLED,
+  futureNullifiers: ScopedNullifier[],
 ) {
   const getNullifierMembershipWitness = async (nullifier: Fr) => {
     const res = await oracle.getNullifierMembershipWitness(nullifier);
@@ -57,11 +62,12 @@ function getNullifierReadRequestHints<PENDING extends number, SETTLED extends nu
     nullifiers,
     sizePending,
     sizeSettled,
+    futureNullifiers,
   );
 }
 
 async function getMasterSecretKeysAndAppKeyGenerators(
-  keyValidationRequests: Tuple<ScopedKeyValidationRequest, typeof MAX_KEY_VALIDATION_REQUESTS_PER_TX>,
+  keyValidationRequests: Tuple<ScopedKeyValidationRequestAndGenerator, typeof MAX_KEY_VALIDATION_REQUESTS_PER_TX>,
   oracle: ProvingDataOracle,
 ) {
   const keysHints = makeTuple(MAX_KEY_VALIDATION_REQUESTS_PER_TX, KeyValidationHint.empty);
@@ -72,8 +78,8 @@ async function getMasterSecretKeysAndAppKeyGenerators(
     if (request.isEmpty()) {
       break;
     }
-    const [secretKeys, appKeyGenerator] = await oracle.getMasterSecretKeyAndAppKeyGenerator(request.masterPublicKey);
-    keysHints[keyIndex] = new KeyValidationHint(secretKeys, new Fr(appKeyGenerator), i);
+    const secretKeys = await oracle.getMasterSecretKey(request.request.pkM);
+    keysHints[keyIndex] = new KeyValidationHint(secretKeys, i);
     keyIndex++;
   }
   return {
@@ -83,12 +89,27 @@ async function getMasterSecretKeysAndAppKeyGenerators(
 }
 
 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,
@@ -100,8 +121,17 @@ export async function buildPrivateKernelResetInputs(
     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,
@@ -112,13 +142,23 @@ export async function buildPrivateKernelResetInputs(
     oracle,
     MAX_NULLIFIER_READ_REQUESTS_PER_TX,
     MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+    futureNullifiers,
   );
 
   const { keysCount, keysHints } = await getMasterSecretKeysAndAppKeyGenerators(
-    publicInputs.validationRequests.keyValidationRequests,
+    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,
@@ -127,6 +167,8 @@ export async function buildPrivateKernelResetInputs(
     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,
@@ -136,6 +178,8 @@ export async function buildPrivateKernelResetInputs(
     previousKernelData.publicInputs.end.newNoteHashes,
     previousKernelData.publicInputs.end.newNullifiers,
     previousKernelData.publicInputs.end.noteEncryptedLogsHashes,
+    transientNullifierIndexesForNoteHashes,
+    transientNoteHashIndexesForNullifiers,
   );
 
   let privateInputs;
@@ -177,3 +221,30 @@ export async function buildPrivateKernelResetInputs(
 
   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

@@ -14,22 +14,26 @@ 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 linked to a nullifier.
-  // Note that note hashes can't link to the first nullifier (counter == 0).
+  // 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(n => !n.nullifierCounter),
+    prevNoteHashes.filter((_, index) => transientNullifierIndexesForNoteHashes[index] === MAX_NEW_NULLIFIERS_PER_TX),
     ScopedNoteHash.empty(),
     MAX_NEW_NOTE_HASHES_PER_TX,
   );
 
   const nullifiers = padArrayEnd(
-    prevNullifiers.filter(n => n.nullifiedNoteHash.isZero()),
+    prevNullifiers.filter((_, index) => transientNoteHashIndexesForNullifiers[index] === MAX_NEW_NOTE_HASHES_PER_TX),
     ScopedNullifier.empty(),
     MAX_NEW_NULLIFIERS_PER_TX,
   );
 
-  const nullifiedNotes = prevNoteHashes.filter(n => !n.isEmpty() && n.nullifierCounter).map(n => n.counter);
+  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)),

package/src/kernel_prover/private_inputs_builders/build_private_kernel_tail_hints.ts

@@ -3,13 +3,14 @@ import {
   MAX_NEW_NOTE_HASHES_PER_TX,
   MAX_NEW_NULLIFIERS_PER_TX,
   MAX_NOTE_ENCRYPTED_LOGS_PER_TX,
+  MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
   MAX_UNENCRYPTED_LOGS_PER_TX,
   type PrivateKernelCircuitPublicInputs,
   PrivateKernelTailHints,
   sortByCounterGetSortedHints,
 } from '@aztec/circuits.js';
 
-export function buildPrivateKernelTailHints(publicInputs: PrivateKernelCircuitPublicInputs) {
+export function buildPrivateKernelTailHints(publicInputs: PrivateKernelCircuitPublicInputs): PrivateKernelTailHints {
   const [sortedNoteHashes, sortedNoteHashesIndexes] = sortByCounterGetSortedHints(
     publicInputs.end.newNoteHashes,
     MAX_NEW_NOTE_HASHES_PER_TX,
@@ -35,6 +36,15 @@ export function buildPrivateKernelTailHints(publicInputs: PrivateKernelCircuitPu
     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(
     sortedNoteHashes,
     sortedNoteHashesIndexes,
@@ -46,5 +56,7 @@ export function buildPrivateKernelTailHints(publicInputs: PrivateKernelCircuitPu
     sortedEncryptedLogHashesIndexes,
     sortedUnencryptedLogHashes,
     sortedUnencryptedLogHashesIndexes,
+    sortedCallRequests,
+    sortedCallRequestsIndexes,
   );
 }

package/src/kernel_prover/proving_data_oracle.ts

@@ -4,7 +4,6 @@ import {
   type Fr,
   type FunctionSelector,
   type GrumpkinPrivateKey,
-  type KeyGenerator,
   type MembershipWitness,
   type NOTE_HASH_TREE_HEIGHT,
   type Point,
@@ -71,13 +70,13 @@ export interface ProvingDataOracle {
   getNoteHashTreeRoot(): Promise<Fr>;
 
   /**
-   * Retrieves the sk_m for the pk_m and a generator index of the key type.
+   * 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 masterPublicKey - The master public key to get secret key for.
-   * @returns A Promise that resolves to sk_m and the corresponding app key generator.
+   * @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.
    */
-  getMasterSecretKeyAndAppKeyGenerator(masterPublicKey: Point): Promise<[GrumpkinPrivateKey, KeyGenerator]>;
+  getMasterSecretKey(masterPublicKey: Point): Promise<GrumpkinPrivateKey>;
 
-  getFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
+  getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
 }