@aztec/pxe 0.69.1 → 0.71.0

package/src/database/kv_pxe_database.ts

@@ -12,6 +12,7 @@ import { type ContractArtifact, FunctionSelector, FunctionType } from '@aztec/fo
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { Fr } from '@aztec/foundation/fields';
 import { toArray } from '@aztec/foundation/iterable';
+import { type LogFn, createDebugOnlyLogger } from '@aztec/foundation/log';
 import {
   type AztecAsyncArray,
   type AztecAsyncKVStore,
@@ -63,6 +64,11 @@ export class KVPxeDatabase implements PxeDatabase {
   #taggingSecretIndexesForSenders: AztecAsyncMap<string, number>;
   #taggingSecretIndexesForRecipients: AztecAsyncMap<string, number>;
 
+  // Arbitrary data stored by contracts. Key is computed as `${contractAddress}:${key}`
+  #contractStore: AztecAsyncMap<string, Buffer>;
+
+  debug: LogFn;
+
   protected constructor(private db: AztecAsyncKVStore) {
     this.#db = db;
 
@@ -100,6 +106,10 @@ export class KVPxeDatabase implements PxeDatabase {
 
     this.#taggingSecretIndexesForSenders = db.openMap('tagging_secret_indexes_for_senders');
     this.#taggingSecretIndexesForRecipients = db.openMap('tagging_secret_indexes_for_recipients');
+
+    this.#contractStore = db.openMap('contract_store');
+
+    this.debug = createDebugOnlyLogger('aztec:kv-pxe-database');
   }
 
   public static async create(db: AztecAsyncKVStore): Promise<KVPxeDatabase> {
@@ -611,4 +621,56 @@ export class KVPxeDatabase implements PxeDatabase {
       await Promise.all(senders.map(sender => this.#taggingSecretIndexesForSenders.delete(sender)));
     });
   }
+
+  async dbStore(contractAddress: AztecAddress, slot: Fr, values: Fr[]): Promise<void> {
+    await this.#contractStore.set(
+      dbSlotToKey(contractAddress, slot),
+      Buffer.concat(values.map(value => value.toBuffer())),
+    );
+  }
+
+  async dbLoad(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null> {
+    const dataBuffer = await this.#contractStore.getAsync(dbSlotToKey(contractAddress, slot));
+    if (!dataBuffer) {
+      this.debug(`Data not found for contract ${contractAddress.toString()} and slot ${slot.toString()}`);
+      return null;
+    }
+    const values: Fr[] = [];
+    for (let i = 0; i < dataBuffer.length; i += Fr.SIZE_IN_BYTES) {
+      values.push(Fr.fromBuffer(dataBuffer.subarray(i, i + Fr.SIZE_IN_BYTES)));
+    }
+    return values;
+  }
+
+  async dbDelete(contractAddress: AztecAddress, slot: Fr): Promise<void> {
+    await this.#contractStore.delete(dbSlotToKey(contractAddress, slot));
+  }
+
+  async dbCopy(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void> {
+    // In order to support overlaping source and destination regions we need to check the relative positions of source
+    // and destination. If destination is ahead of source, then by the time we overwrite source elements using forward
+    // indexes we'll have already read those. On the contrary, if source is ahead of destination we need to use backward
+    // indexes to avoid reading elements that've been overwritten.
+
+    const indexes = Array.from(Array(numEntries).keys());
+    if (srcSlot.lt(dstSlot)) {
+      indexes.reverse();
+    }
+
+    for (const i of indexes) {
+      const currentSrcSlot = dbSlotToKey(contractAddress, srcSlot.add(new Fr(i)));
+      const currentDstSlot = dbSlotToKey(contractAddress, dstSlot.add(new Fr(i)));
+
+      const toCopy = await this.#contractStore.getAsync(currentSrcSlot);
+      if (!toCopy) {
+        throw new Error(`Attempted to copy empty slot ${currentSrcSlot} for contract ${contractAddress.toString()}`);
+      }
+
+      await this.#contractStore.set(currentDstSlot, toCopy);
+    }
+  }
+}
+
+function dbSlotToKey(contractAddress: AztecAddress, slot: Fr): string {
+  return `${contractAddress.toString()}:${slot.toString()}`;
 }

package/src/database/note_dao.ts

@@ -1,11 +1,9 @@
-import { type L1NotePayload, Note, TxHash, randomTxHash } from '@aztec/circuit-types';
+import { Note, TxHash, randomTxHash } from '@aztec/circuit-types';
 import { AztecAddress, Fr, Point, type PublicKey } from '@aztec/circuits.js';
 import { NoteSelector } from '@aztec/foundation/abi';
 import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import { type NoteData } from '@aztec/simulator/acvm';
-
-import { type NoteInfo } from '../note_decryption_utils/index.js';
+import { type NoteData } from '@aztec/simulator/client';
 
 /**
  * A Note Data Access Object, representing a note that was comitted to the note hash tree, holding all of the
@@ -61,32 +59,6 @@ export class NoteDao implements NoteData {
     public noteTypeId: NoteSelector,
   ) {}
 
-  static fromPayloadAndNoteInfo(
-    note: Note,
-    payload: L1NotePayload,
-    noteInfo: NoteInfo,
-    l2BlockNumber: number,
-    l2BlockHash: string,
-    dataStartIndexForTx: number,
-    addressPoint: PublicKey,
-  ) {
-    const noteHashIndexInTheWholeTree = BigInt(dataStartIndexForTx + noteInfo.noteHashIndex);
-    return new NoteDao(
-      note,
-      payload.contractAddress,
-      payload.storageSlot,
-      noteInfo.nonce,
-      noteInfo.noteHash,
-      noteInfo.siloedNullifier,
-      noteInfo.txHash,
-      l2BlockNumber,
-      l2BlockHash,
-      noteHashIndexInTheWholeTree,
-      addressPoint,
-      payload.noteTypeId,
-    );
-  }
-
   toBuffer(): Buffer {
     return serializeToBuffer([
       this.note,

package/src/database/outgoing_note_dao.ts

@@ -1,11 +1,9 @@
-import { type L1NotePayload, Note, TxHash, randomTxHash } from '@aztec/circuit-types';
+import { Note, TxHash, randomTxHash } from '@aztec/circuit-types';
 import { AztecAddress, Fr, Point, type PublicKey } from '@aztec/circuits.js';
 import { NoteSelector } from '@aztec/foundation/abi';
 import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
-import { type NoteInfo } from '../note_decryption_utils/index.js';
-
 /**
  * A note with contextual data which was decrypted as outgoing.
  */
@@ -38,31 +36,6 @@ export class OutgoingNoteDao {
     public ovpkM: PublicKey,
   ) {}
 
-  static fromPayloadAndNoteInfo(
-    note: Note,
-    payload: L1NotePayload,
-    noteInfo: NoteInfo,
-    l2BlockNumber: number,
-    l2BlockHash: string,
-    dataStartIndexForTx: number,
-    ovpkM: PublicKey,
-  ) {
-    const noteHashIndexInTheWholeTree = BigInt(dataStartIndexForTx + noteInfo.noteHashIndex);
-    return new OutgoingNoteDao(
-      note,
-      payload.contractAddress,
-      payload.storageSlot,
-      payload.noteTypeId,
-      noteInfo.txHash,
-      l2BlockNumber,
-      l2BlockHash,
-      noteInfo.nonce,
-      noteInfo.noteHash,
-      noteHashIndexInTheWholeTree,
-      ovpkM,
-    );
-  }
-
   toBuffer(): Buffer {
     return serializeToBuffer([
       this.note,

package/src/database/pxe_database.ts

@@ -213,4 +213,41 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
    * is also required to deal with chain reorgs.
    */
   resetNoteSyncData(): Promise<void>;
+
+  /**
+   * Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `dbLoad`.
+   * If data was already stored at this slot, it is overwrriten.
+   * @param contractAddress - The contract address to scope the data under.
+   * @param slot - The slot in the database in which to store the value. Slots need not be contiguous.
+   * @param values - The data to store.
+   */
+  dbStore(contractAddress: AztecAddress, slot: Fr, values: Fr[]): Promise<void>;
+
+  /**
+   * Returns data previously stored via `dbStore` in the per-contract non-volatile database.
+   * @param contractAddress - The contract address under which the data is scoped.
+   * @param slot - The slot in the database to read.
+   * @returns The stored data or `null` if no data is stored under the slot.
+   */
+  dbLoad(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null>;
+
+  /**
+   * Deletes data in the per-contract non-volatile database. Does nothing if no data was present.
+   * @param contractAddress - The contract address under which the data is scoped.
+   * @param slot - The slot in the database to delete.
+   */
+  dbDelete(contractAddress: AztecAddress, slot: Fr): Promise<void>;
+
+  /**
+   * Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data
+   * structures by avoiding repeated calls to `dbLoad` and `dbStore`.
+   * Supports overlapping source and destination regions (which will result in the overlapped source values being
+   * overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)
+   *
+   * @param contractAddress - The contract address under which the data is scoped.
+   * @param srcSlot - The first slot to copy from.
+   * @param dstSlot - The first slot to copy to.
+   * @param numEntries - The number of entries to copy.
+   */
+  dbCopy(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void>;
 }

package/src/database/pxe_database_test_suite.ts

@@ -405,5 +405,165 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
         await expect(database.getContractInstance(address)).resolves.toEqual(instance);
       });
     });
+
+    describe('contract non-volatile database', () => {
+      let contract: AztecAddress;
+
+      beforeEach(() => {
+        // Setup mock contract address
+        contract = AztecAddress.random();
+      });
+
+      it('stores and loads a single value', async () => {
+        const slot = new Fr(1);
+        const values = [new Fr(42)];
+
+        await database.dbStore(contract, slot, values);
+        const result = await database.dbLoad(contract, slot);
+        expect(result).toEqual(values);
+      });
+
+      it('stores and loads multiple values', async () => {
+        const slot = new Fr(1);
+        const values = [new Fr(42), new Fr(43), new Fr(44)];
+
+        await database.dbStore(contract, slot, values);
+        const result = await database.dbLoad(contract, slot);
+        expect(result).toEqual(values);
+      });
+
+      it('overwrites existing values', async () => {
+        const slot = new Fr(1);
+        const initialValues = [new Fr(42)];
+        const newValues = [new Fr(100)];
+
+        await database.dbStore(contract, slot, initialValues);
+        await database.dbStore(contract, slot, newValues);
+
+        const result = await database.dbLoad(contract, slot);
+        expect(result).toEqual(newValues);
+      });
+
+      it('stores values for different contracts independently', async () => {
+        const anotherContract = AztecAddress.random();
+        const slot = new Fr(1);
+        const values1 = [new Fr(42)];
+        const values2 = [new Fr(100)];
+
+        await database.dbStore(contract, slot, values1);
+        await database.dbStore(anotherContract, slot, values2);
+
+        const result1 = await database.dbLoad(contract, slot);
+        const result2 = await database.dbLoad(anotherContract, slot);
+
+        expect(result1).toEqual(values1);
+        expect(result2).toEqual(values2);
+      });
+
+      it('returns null for non-existent slots', async () => {
+        const slot = Fr.random();
+        const result = await database.dbLoad(contract, slot);
+        expect(result).toBeNull();
+      });
+
+      it('deletes a slot', async () => {
+        const slot = new Fr(1);
+        const values = [new Fr(42)];
+
+        await database.dbStore(contract, slot, values);
+        await database.dbDelete(contract, slot);
+
+        expect(await database.dbLoad(contract, slot)).toBeNull();
+      });
+
+      it('deletes an empty slot', async () => {
+        const slot = new Fr(1);
+        await database.dbDelete(contract, slot);
+
+        expect(await database.dbLoad(contract, slot)).toBeNull();
+      });
+
+      it('copies a single value', async () => {
+        const slot = new Fr(1);
+        const values = [new Fr(42)];
+
+        await database.dbStore(contract, slot, values);
+
+        const dstSlot = new Fr(5);
+        await database.dbCopy(contract, slot, dstSlot, 1);
+
+        expect(await database.dbLoad(contract, dstSlot)).toEqual(values);
+      });
+
+      it('copies multiple non-overlapping values', async () => {
+        const src = new Fr(1);
+        const valuesArray = [[new Fr(42)], [new Fr(1337)], [new Fr(13)]];
+
+        await database.dbStore(contract, src, valuesArray[0]);
+        await database.dbStore(contract, src.add(new Fr(1)), valuesArray[1]);
+        await database.dbStore(contract, src.add(new Fr(2)), valuesArray[2]);
+
+        const dst = new Fr(5);
+        await database.dbCopy(contract, src, dst, 3);
+
+        expect(await database.dbLoad(contract, dst)).toEqual(valuesArray[0]);
+        expect(await database.dbLoad(contract, dst.add(new Fr(1)))).toEqual(valuesArray[1]);
+        expect(await database.dbLoad(contract, dst.add(new Fr(2)))).toEqual(valuesArray[2]);
+      });
+
+      it('copies overlapping values with src ahead', async () => {
+        const src = new Fr(1);
+        const valuesArray = [[new Fr(42)], [new Fr(1337)], [new Fr(13)]];
+
+        await database.dbStore(contract, src, valuesArray[0]);
+        await database.dbStore(contract, src.add(new Fr(1)), valuesArray[1]);
+        await database.dbStore(contract, src.add(new Fr(2)), valuesArray[2]);
+
+        const dst = new Fr(2);
+        await database.dbCopy(contract, src, dst, 3);
+
+        expect(await database.dbLoad(contract, dst)).toEqual(valuesArray[0]);
+        expect(await database.dbLoad(contract, dst.add(new Fr(1)))).toEqual(valuesArray[1]);
+        expect(await database.dbLoad(contract, dst.add(new Fr(2)))).toEqual(valuesArray[2]);
+
+        // Slots 2 and 3 (src[1] and src[2]) should have been overwritten since they are also dst[0] and dst[1]
+        expect(await database.dbLoad(contract, src)).toEqual(valuesArray[0]); // src[0] (unchanged)
+        expect(await database.dbLoad(contract, src.add(new Fr(1)))).toEqual(valuesArray[0]); // dst[0]
+        expect(await database.dbLoad(contract, src.add(new Fr(2)))).toEqual(valuesArray[1]); // dst[1]
+      });
+
+      it('copies overlapping values with dst ahead', async () => {
+        const src = new Fr(5);
+        const valuesArray = [[new Fr(42)], [new Fr(1337)], [new Fr(13)]];
+
+        await database.dbStore(contract, src, valuesArray[0]);
+        await database.dbStore(contract, src.add(new Fr(1)), valuesArray[1]);
+        await database.dbStore(contract, src.add(new Fr(2)), valuesArray[2]);
+
+        const dst = new Fr(4);
+        await database.dbCopy(contract, src, dst, 3);
+
+        expect(await database.dbLoad(contract, dst)).toEqual(valuesArray[0]);
+        expect(await database.dbLoad(contract, dst.add(new Fr(1)))).toEqual(valuesArray[1]);
+        expect(await database.dbLoad(contract, dst.add(new Fr(2)))).toEqual(valuesArray[2]);
+
+        // Slots 5 and 6 (src[0] and src[1]) should have been overwritten since they are also dst[1] and dst[2]
+        expect(await database.dbLoad(contract, src)).toEqual(valuesArray[1]); // dst[1]
+        expect(await database.dbLoad(contract, src.add(new Fr(1)))).toEqual(valuesArray[2]); // dst[2]
+        expect(await database.dbLoad(contract, src.add(new Fr(2)))).toEqual(valuesArray[2]); // src[2] (unchanged)
+      });
+
+      it('copying fails if any value is empty', async () => {
+        const src = new Fr(1);
+        const valuesArray = [[new Fr(42)], [new Fr(1337)], [new Fr(13)]];
+
+        await database.dbStore(contract, src, valuesArray[0]);
+        // We skip src[1]
+        await database.dbStore(contract, src.add(new Fr(2)), valuesArray[2]);
+
+        const dst = new Fr(5);
+        await expect(database.dbCopy(contract, src, dst, 3)).rejects.toThrow('Attempted to copy empty slot');
+      });
+    });
   });
 }

package/src/kernel_oracle/index.ts

@@ -15,7 +15,7 @@ import {
 import { createLogger } from '@aztec/foundation/log';
 import { type Tuple } from '@aztec/foundation/serialize';
 import { type KeyStore } from '@aztec/key-store';
-import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/client';
+import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vks';
 
 import { type ContractDataOracle } from '../contract_data_oracle/index.js';
 import { type ProvingDataOracle } from './../kernel_prover/proving_data_oracle.js';

package/src/kernel_prover/hints/build_private_kernel_reset_private_inputs.ts

@@ -1,4 +1,4 @@
-import { type PrivateExecutionResult, type PrivateKernelSimulateOutput, collectNested } from '@aztec/circuit-types';
+import { type PrivateCallExecutionResult, type PrivateKernelSimulateOutput, collectNested } from '@aztec/circuit-types';
 import {
   type Fr,
   KeyValidationHint,
@@ -42,8 +42,8 @@ import { privateKernelResetDimensionsConfig } from '@aztec/noir-protocol-circuit
 import { type ProvingDataOracle } from '../proving_data_oracle.js';
 
 function collectNestedReadRequests(
-  executionStack: PrivateExecutionResult[],
-  extractReadRequests: (execution: PrivateExecutionResult) => ReadRequest[],
+  executionStack: PrivateCallExecutionResult[],
+  extractReadRequests: (execution: PrivateCallExecutionResult) => ReadRequest[],
 ): ScopedReadRequest[] {
   return collectNested(executionStack, executionResult => {
     const nonEmptyReadRequests = getNonEmptyItems(extractReadRequests(executionResult));
@@ -101,7 +101,7 @@ export class PrivateKernelResetPrivateInputsBuilder {
 
   constructor(
     private previousKernelOutput: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>,
-    private executionStack: PrivateExecutionResult[],
+    private executionStack: PrivateCallExecutionResult[],
     private noteHashNullifierCounterMap: Map<number, number>,
     private validationRequestsSplitCounter: number,
   ) {

package/src/kernel_prover/index.ts

@@ -1,4 +1,2 @@
-export { TestPrivateKernelProver } from './test/test_circuit_prover.js';
-
 export * from './kernel_prover.js';
 export * from './proving_data_oracle.js';

package/src/kernel_prover/kernel_prover.ts

@@ -1,4 +1,5 @@
 import {
+  type PrivateCallExecutionResult,
   type PrivateExecutionResult,
   type PrivateKernelProver,
   type PrivateKernelSimulateOutput,
@@ -10,6 +11,7 @@ import {
 } from '@aztec/circuit-types';
 import {
   CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS,
+  ClientIvcProof,
   Fr,
   PROTOCOL_CONTRACT_TREE_HEIGHT,
   PrivateCallData,
@@ -32,7 +34,7 @@ import { createLogger } from '@aztec/foundation/log';
 import { assertLength } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
 import { Timer } from '@aztec/foundation/timer';
-import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/client';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vks';
 import {
   getProtocolContractSiblingPath,
   isProtocolContract,
@@ -89,6 +91,12 @@ const NULL_PROVE_OUTPUT: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicI
   bytecode: Buffer.from([]),
 };
 
+export type ProvingConfig = {
+  simulate: boolean;
+  profile: boolean;
+  dryRun: boolean;
+};
+
 /**
  * The KernelProver class is responsible for generating kernel proofs.
  * It takes a transaction request, its signature, and the simulation result as inputs, and outputs a proof
@@ -98,7 +106,11 @@ const NULL_PROVE_OUTPUT: PrivateKernelSimulateOutput<PrivateKernelCircuitPublicI
 export class KernelProver {
   private log = createLogger('pxe:kernel-prover');
 
-  constructor(private oracle: ProvingDataOracle, private proofCreator: PrivateKernelProver) {}
+  constructor(
+    private oracle: ProvingDataOracle,
+    private proofCreator: PrivateKernelProver,
+    private fakeProofs = false,
+  ) {}
 
   /**
    * Generate a proof for a given transaction request and execution result.
@@ -116,14 +128,19 @@ export class KernelProver {
   async prove(
     txRequest: TxRequest,
     executionResult: PrivateExecutionResult,
-    profile: boolean = false,
-    dryRun: boolean = false,
+    { simulate, profile, dryRun }: ProvingConfig = { simulate: false, profile: false, dryRun: false },
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
+    if (simulate && profile) {
+      throw new Error('Cannot simulate and profile at the same time');
+    }
+
+    simulate = simulate || this.fakeProofs;
+
     const timer = new Timer();
 
     const isPrivateOnlyTx = this.isPrivateOnly(executionResult);
 
-    const executionStack = [executionResult];
+    const executionStack = [executionResult.entrypoint];
     let firstIteration = true;
 
     let output = NULL_PROVE_OUTPUT;
@@ -156,7 +173,9 @@ export class KernelProver {
         );
         while (resetBuilder.needsReset()) {
           const privateInputs = await resetBuilder.build(this.oracle, noteHashLeafIndexMap);
-          output = await this.proofCreator.simulateProofReset(privateInputs);
+          output = simulate
+            ? await this.proofCreator.simulateReset(privateInputs)
+            : await this.proofCreator.generateResetOutput(privateInputs);
           // TODO(#7368) consider refactoring this redundant bytecode pushing
           acirs.push(output.bytecode);
           witnessStack.push(output.outputWitness);
@@ -199,11 +218,17 @@ export class KernelProver {
           protocolContractTreeRoot,
           privateCallData,
           isPrivateOnlyTx,
+          executionResult.firstNullifier,
+        );
+        this.log.debug(
+          `Calling private kernel init with isPrivateOnly ${isPrivateOnlyTx} and firstNullifierHint ${proofInput.firstNullifierHint}`,
         );
 
         pushTestData('private-kernel-inputs-init', proofInput);
 
-        output = await this.proofCreator.simulateProofInit(proofInput);
+        output = simulate
+          ? await this.proofCreator.simulateInit(proofInput)
+          : await this.proofCreator.generateInitOutput(proofInput);
 
         acirs.push(output.bytecode);
         witnessStack.push(output.outputWitness);
@@ -222,7 +247,9 @@ export class KernelProver {
 
         pushTestData('private-kernel-inputs-inner', proofInput);
 
-        output = await this.proofCreator.simulateProofInner(proofInput);
+        output = simulate
+          ? await this.proofCreator.simulateInner(proofInput)
+          : await this.proofCreator.generateInnerOutput(proofInput);
 
         acirs.push(output.bytecode);
         witnessStack.push(output.outputWitness);
@@ -242,7 +269,9 @@ export class KernelProver {
     );
     while (resetBuilder.needsReset()) {
       const privateInputs = await resetBuilder.build(this.oracle, noteHashLeafIndexMap);
-      output = await this.proofCreator.simulateProofReset(privateInputs);
+      output = simulate
+        ? await this.proofCreator.simulateReset(privateInputs)
+        : await this.proofCreator.generateResetOutput(privateInputs);
 
       acirs.push(output.bytecode);
       witnessStack.push(output.outputWitness);
@@ -275,7 +304,9 @@ export class KernelProver {
 
     pushTestData('private-kernel-inputs-ordering', privateInputs);
 
-    const tailOutput = await this.proofCreator.simulateProofTail(privateInputs);
+    const tailOutput = simulate
+      ? await this.proofCreator.simulateTail(privateInputs)
+      : await this.proofCreator.generateTailOutput(privateInputs);
     if (tailOutput.publicInputs.forPublic) {
       const privateLogs = privateInputs.previousKernel.publicInputs.end.privateLogs;
       const nonRevertiblePrivateLogs = tailOutput.publicInputs.forPublic.nonRevertibleAccumulatedData.privateLogs;
@@ -290,18 +321,22 @@ export class KernelProver {
       tailOutput.profileResult = { gateCounts };
     }
 
-    this.log.verbose(`Private kernel witness generation took ${timer.ms()}ms`);
+    if (!simulate) {
+      this.log.info(`Private kernel witness generation took ${timer.ms()}ms`);
+    }
 
     // TODO(#7368) how do we 'bincode' encode these inputs?
-    if (!dryRun) {
+    if (!dryRun && !simulate) {
       const ivcProof = await this.proofCreator.createClientIvcProof(acirs, witnessStack);
       tailOutput.clientIvcProof = ivcProof;
+    } else {
+      tailOutput.clientIvcProof = ClientIvcProof.empty();
     }
 
     return tailOutput;
   }
 
-  private async createPrivateCallData({ publicInputs, vk: vkAsBuffer }: PrivateExecutionResult) {
+  private async createPrivateCallData({ publicInputs, vk: vkAsBuffer }: PrivateCallExecutionResult) {
     const { contractAddress, functionSelector } = publicInputs.callContext;
 
     const vkAsFields = vkAsFieldsMegaHonk(vkAsBuffer);
@@ -339,12 +374,15 @@ export class KernelProver {
   }
 
   private isPrivateOnly(executionResult: PrivateExecutionResult): boolean {
-    const makesPublicCalls =
-      executionResult.enqueuedPublicFunctionCalls.some(enqueuedCall => !enqueuedCall.isEmpty()) ||
-      !executionResult.publicTeardownFunctionCall.isEmpty();
-    return (
-      !makesPublicCalls &&
-      executionResult.nestedExecutions.every(nestedExecution => this.isPrivateOnly(nestedExecution))
-    );
+    const isPrivateOnlyRecursive = (callResult: PrivateCallExecutionResult): boolean => {
+      const makesPublicCalls =
+        callResult.enqueuedPublicFunctionCalls.some(enqueuedCall => !enqueuedCall.isEmpty()) ||
+        !callResult.publicTeardownFunctionCall.isEmpty();
+      return (
+        !makesPublicCalls &&
+        callResult.nestedExecutions.every(nestedExecution => isPrivateOnlyRecursive(nestedExecution))
+      );
+    };
+    return isPrivateOnlyRecursive(executionResult.entrypoint);
   }
 }

package/src/note_decryption_utils/add_public_values_to_payload.ts

@@ -41,7 +41,7 @@ export async function getOrderedNoteItems(
   noteFields.sort((a, b) => a.index - b.index);
 
   // Now we insert the public fields into the note based on its indices defined in the ABI.
-  const modifiedNoteItems = privateNoteValues;
+  const modifiedNoteItems = [...privateNoteValues];
   let indexInPublicValues = 0;
   for (let i = 0; i < noteFields.length; i++) {
     const noteField = noteFields[i];

package/src/pxe_service/error_enriching.ts

@@ -4,7 +4,7 @@ import { FunctionSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 import { type Logger } from '@aztec/foundation/log';
-import { resolveAssertionMessageFromRevertData, resolveOpcodeLocations } from '@aztec/simulator/errors';
+import { resolveAssertionMessageFromRevertData, resolveOpcodeLocations } from '@aztec/simulator/client';
 
 import { type ContractDataOracle, type PxeDatabase } from '../index.js';