@aztec/simulator 0.59.0 → 0.61.0

package/src/public/enqueued_call_side_effect_trace.ts

@@ -1,5 +1,6 @@
 import { UnencryptedL2Log } from '@aztec/circuit-types';
 import {
+  AvmContractBytecodeHints,
   AvmContractInstanceHint,
   AvmExecutionHints,
   AvmExternalCallHint,
@@ -7,7 +8,7 @@ import {
   AztecAddress,
   CallContext,
   type CombinedConstantData,
-  type ContractInstanceWithAddress,
+  type ContractClassIdPreimage,
   ContractStorageRead,
   ContractStorageUpdateRequest,
   EthAddress,
@@ -44,6 +45,7 @@ import {
   ScopedNoteHash,
   type ScopedNullifier,
   ScopedReadRequest,
+  SerializableContractInstance,
   TreeLeafReadRequest,
   VMCircuitPublicInputs,
 } from '@aztec/circuits.js';
@@ -58,8 +60,6 @@ import { type AvmExecutionEnvironment } from '../avm/avm_execution_environment.j
 import { SideEffectLimitReachedError } from './side_effect_errors.js';
 import { type PublicSideEffectTraceInterface } from './side_effect_trace_interface.js';
 
-export type TracedContractInstance = { exists: boolean } & ContractInstanceWithAddress;
-
 /**
  * A struct containing just the side effects as regular arrays
  * as opposed to "Tuple" arrays used by circuit public inputs.
@@ -157,7 +157,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     this.sideEffectCounter++;
   }
 
-  public tracePublicStorageRead(storageAddress: Fr, slot: Fr, value: Fr, _exists: boolean, _cached: boolean) {
+  public tracePublicStorageRead(contractAddress: Fr, slot: Fr, value: Fr, _exists: boolean, _cached: boolean) {
     // NOTE: exists and cached are unused for now but may be used for optimizations or kernel hints later
     if (
       this.contractStorageReads.length + this.previousValidationRequestArrayLengths.publicDataReads >=
@@ -167,7 +167,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     }
 
     this.contractStorageReads.push(
-      new ContractStorageRead(slot, value, this.sideEffectCounter, AztecAddress.fromField(storageAddress)),
+      new ContractStorageRead(slot, value, this.sideEffectCounter, AztecAddress.fromField(contractAddress)),
     );
     this.avmCircuitHints.storageValues.items.push(
       new AvmKeyValueHint(/*key=*/ new Fr(this.sideEffectCounter), /*value=*/ value),
@@ -176,7 +176,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     this.incrementSideEffectCounter();
   }
 
-  public tracePublicStorageWrite(storageAddress: Fr, slot: Fr, value: Fr) {
+  public tracePublicStorageWrite(contractAddress: Fr, slot: Fr, value: Fr) {
     if (
       this.contractStorageUpdateRequests.length + this.previousAccumulatedDataArrayLengths.publicDataUpdateRequests >=
       MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX
@@ -185,15 +185,15 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     }
 
     this.contractStorageUpdateRequests.push(
-      new ContractStorageUpdateRequest(slot, value, this.sideEffectCounter, storageAddress),
+      new ContractStorageUpdateRequest(slot, value, this.sideEffectCounter, contractAddress),
     );
     this.log.debug(`SSTORE cnt: ${this.sideEffectCounter} val: ${value} slot: ${slot}`);
     this.incrementSideEffectCounter();
   }
 
   // TODO(8287): _exists can be removed once we have the vm properly handling the equality check
-  public traceNoteHashCheck(_storageAddress: Fr, noteHash: Fr, leafIndex: Fr, exists: boolean) {
-    // NOTE: storageAddress is unused because noteHash is an already-siloed leaf
+  public traceNoteHashCheck(_contractAddress: Fr, noteHash: Fr, leafIndex: Fr, exists: boolean) {
+    // NOTE: contractAddress is unused because noteHash is an already-siloed leaf
     if (
       this.noteHashReadRequests.length + this.previousValidationRequestArrayLengths.noteHashReadRequests >=
       MAX_NOTE_HASH_READ_REQUESTS_PER_TX
@@ -208,22 +208,22 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     // NOTE: counter does not increment for note hash checks (because it doesn't rely on pending note hashes)
   }
 
-  public traceNewNoteHash(storageAddress: Fr, noteHash: Fr) {
+  public traceNewNoteHash(contractAddress: Fr, noteHash: Fr) {
     if (this.noteHashes.length + this.previousAccumulatedDataArrayLengths.noteHashes >= MAX_NOTE_HASHES_PER_TX) {
       throw new SideEffectLimitReachedError('note hash', MAX_NOTE_HASHES_PER_TX);
     }
 
-    this.noteHashes.push(new NoteHash(noteHash, this.sideEffectCounter).scope(AztecAddress.fromField(storageAddress)));
+    this.noteHashes.push(new NoteHash(noteHash, this.sideEffectCounter).scope(AztecAddress.fromField(contractAddress)));
     this.log.debug(`NEW_NOTE_HASH cnt: ${this.sideEffectCounter}`);
     this.incrementSideEffectCounter();
   }
 
-  public traceNullifierCheck(storageAddress: Fr, nullifier: Fr, _leafIndex: Fr, exists: boolean, _isPending: boolean) {
+  public traceNullifierCheck(contractAddress: Fr, nullifier: Fr, _leafIndex: Fr, exists: boolean, _isPending: boolean) {
     // NOTE: isPending and leafIndex are unused for now but may be used for optimizations or kernel hints later
     this.enforceLimitOnNullifierChecks();
 
     const readRequest = new ReadRequest(nullifier, this.sideEffectCounter).scope(
-      AztecAddress.fromField(storageAddress),
+      AztecAddress.fromField(contractAddress),
     );
     if (exists) {
       this.nullifierReadRequests.push(readRequest);
@@ -237,14 +237,14 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     this.incrementSideEffectCounter();
   }
 
-  public traceNewNullifier(storageAddress: Fr, nullifier: Fr) {
+  public traceNewNullifier(contractAddress: Fr, nullifier: Fr) {
     if (this.nullifiers.length + this.previousAccumulatedDataArrayLengths.nullifiers >= MAX_NULLIFIERS_PER_TX) {
       throw new SideEffectLimitReachedError('nullifier', MAX_NULLIFIERS_PER_TX);
     }
 
     this.nullifiers.push(
       new Nullifier(nullifier, this.sideEffectCounter, /*noteHash=*/ Fr.ZERO).scope(
-        AztecAddress.fromField(storageAddress),
+        AztecAddress.fromField(contractAddress),
       ),
     );
     this.log.debug(`NEW_NULLIFIER cnt: ${this.sideEffectCounter}`);
@@ -307,14 +307,17 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     this.incrementSideEffectCounter();
   }
 
-  public traceGetContractInstance(instance: TracedContractInstance) {
+  public traceGetContractInstance(
+    contractAddress: Fr,
+    exists: boolean,
+    instance: SerializableContractInstance = SerializableContractInstance.default(),
+  ) {
     this.enforceLimitOnNullifierChecks('(contract address nullifier from GETCONTRACTINSTANCE)');
-    // TODO(dbanks12): should emit a nullifier read request
 
     this.avmCircuitHints.contractInstances.items.push(
       new AvmContractInstanceHint(
-        instance.address,
-        new Fr(instance.exists ? 1 : 0),
+        contractAddress,
+        exists,
         instance.salt,
         instance.deployer,
         instance.contractClassId,
@@ -326,6 +329,40 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     this.incrementSideEffectCounter();
   }
 
+  // This tracing function gets called everytime we start simulation/execution.
+  // This happens both when starting a new top-level trace and the start of every nested trace
+  // We use this to collect the AvmContractBytecodeHints
+  public traceGetBytecode(
+    contractAddress: Fr,
+    exists: boolean,
+    bytecode: Buffer = Buffer.alloc(0),
+    contractInstance: SerializableContractInstance = SerializableContractInstance.default(),
+    contractClass: ContractClassIdPreimage = {
+      artifactHash: Fr.zero(),
+      privateFunctionsRoot: Fr.zero(),
+      publicBytecodeCommitment: Fr.zero(),
+    },
+  ) {
+    const instance = new AvmContractInstanceHint(
+      contractAddress,
+      exists,
+      contractInstance.salt,
+      contractInstance.deployer,
+      contractInstance.contractClassId,
+      contractInstance.initializationHash,
+      contractInstance.publicKeys,
+    );
+    // We need to deduplicate the contract instances based on addresses
+    this.avmCircuitHints.contractBytecodeHints.items.push(
+      new AvmContractBytecodeHints(bytecode, instance, contractClass),
+    );
+    this.log.debug(
+      `Bytecode retrieval for contract execution traced: exists=${exists}, instance=${JSON.stringify(
+        contractInstance,
+      )}`,
+    );
+  }
+
   /**
    * Trace a nested call.
    * Accept some results from a finished nested call's trace into this one.
@@ -334,7 +371,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     /** The trace of the nested call. */
     nestedCallTrace: this,
     /** The execution environment of the nested call. */
-    _nestedEnvironment: AvmExecutionEnvironment,
+    nestedEnvironment: AvmExecutionEnvironment,
     /** How much gas was available for this public execution. */
     startGasLeft: Gas,
     /** How much gas was left after this public execution. */
@@ -368,6 +405,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
         avmCallResults.output,
         gasUsed,
         endSideEffectCounter,
+        nestedEnvironment.address,
       ),
     );
   }
@@ -538,15 +576,9 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
 function createPublicCallRequest(avmEnvironment: AvmExecutionEnvironment): PublicCallRequest {
   const callContext = CallContext.from({
     msgSender: avmEnvironment.sender,
-    storageContractAddress: avmEnvironment.storageAddress,
+    contractAddress: avmEnvironment.address,
     functionSelector: avmEnvironment.functionSelector,
-    isDelegateCall: avmEnvironment.isDelegateCall,
     isStaticCall: avmEnvironment.isStaticCall,
   });
-  return new PublicCallRequest(
-    avmEnvironment.address,
-    callContext,
-    computeVarArgsHash(avmEnvironment.calldata),
-    /*counter=*/ 0,
-  );
+  return new PublicCallRequest(callContext, computeVarArgsHash(avmEnvironment.calldata), /*counter=*/ 0);
 }

package/src/public/enqueued_call_simulator.ts

@@ -1,22 +1,20 @@
 import {
-  AVM_REQUEST,
   type AvmProvingRequest,
   MerkleTreeId,
   NestedProcessReturnValues,
   ProvingRequestType,
   type PublicExecutionRequest,
   PublicKernelPhase,
-  type PublicProvingRequest,
   type SimulationError,
   type Tx,
   UnencryptedFunctionL2Logs,
 } from '@aztec/circuit-types';
 import {
+  AvmCircuitInputs,
   AztecAddress,
   ContractStorageRead,
   ContractStorageUpdateRequest,
   Fr,
-  FunctionData,
   Gas,
   type GlobalVariables,
   type Header,
@@ -42,7 +40,6 @@ import {
   PublicAccumulatedDataArrayLengths,
   PublicCallData,
   type PublicCallRequest,
-  PublicCallStackItem,
   PublicCircuitPublicInputs,
   PublicInnerCallRequest,
   type PublicKernelCircuitPublicInputs,
@@ -54,6 +51,7 @@ import {
   RevertCode,
   TreeLeafReadRequest,
   VMCircuitPublicInputs,
+  VerificationKeyData,
   makeEmptyProof,
   makeEmptyRecursiveProof,
 } from '@aztec/circuits.js';
@@ -61,33 +59,22 @@ import { computeVarArgsHash } from '@aztec/circuits.js/hash';
 import { makeTuple } from '@aztec/foundation/array';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
-import { ProtocolCircuitVks } from '@aztec/noir-protocol-circuits-types';
 import { type MerkleTreeReadOperations } from '@aztec/world-state';
 
 import { type PublicExecutionResult, accumulatePublicReturnValues, collectExecutionResults } from './execution.js';
 import { type PublicExecutor } from './executor.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
 
-function makeAvmProvingRequest(
-  inputs: PublicKernelInnerCircuitPrivateInputs,
-  result: PublicExecutionResult,
-): AvmProvingRequest {
+function makeAvmProvingRequest(inputs: PublicCircuitPublicInputs, result: PublicExecutionResult): AvmProvingRequest {
   return {
-    type: AVM_REQUEST,
-    functionName: result.functionName,
-    calldata: result.calldata,
-    bytecode: result.bytecode!,
-    avmHints: result.avmCircuitHints,
-    kernelRequest: {
-      type: ProvingRequestType.PUBLIC_KERNEL_INNER,
-      inputs,
-    },
+    type: ProvingRequestType.PUBLIC_VM,
+    inputs: new AvmCircuitInputs(result.functionName, result.calldata, inputs, result.avmCircuitHints),
   };
 }
 
 export type EnqueuedCallResult = {
   /** Inputs to be used for proving */
-  provingRequests: PublicProvingRequest[];
+  avmProvingRequest: AvmProvingRequest;
   /** The public kernel output at the end of the enqueued call */
   kernelOutput: VMCircuitPublicInputs;
   /** Unencrypted logs generated during the execution of this enqueued call */
@@ -157,7 +144,7 @@ export class EnqueuedCallSimulator {
     );
 
     const callStack = makeTuple(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, PublicInnerCallRequest.empty);
-    callStack[0].item.contractAddress = callRequest.contractAddress;
+    callStack[0].item.contractAddress = callRequest.callContext.contractAddress;
     callStack[0].item.callContext = callRequest.callContext;
     callStack[0].item.argsHash = callRequest.argsHash;
 
@@ -188,7 +175,7 @@ export class EnqueuedCallSimulator {
   ): Promise<EnqueuedCallResult> {
     const executionResults = collectExecutionResults(topResult);
 
-    const provingRequests: AvmProvingRequest[] = [];
+    let avmProvingRequest: AvmProvingRequest;
     let gasUsed = Gas.empty();
     let revertReason;
     let kernelOutput = startVMCircuitOutput;
@@ -197,22 +184,19 @@ export class EnqueuedCallSimulator {
       // Accumulate gas used in this enqueued call.
       gasUsed = gasUsed.add(Gas.from(result.startGasLeft).sub(Gas.from(result.endGasLeft)));
 
+      const { contractAddress, functionSelector } = result.executionRequest.callContext;
+
       // Sanity check for a current upstream assumption.
       // Consumers of the result seem to expect "reverted <=> revertReason !== undefined".
-      const functionSelector = result.executionRequest.callContext.functionSelector.toString();
       if (result.reverted && !result.revertReason) {
         throw new Error(
-          `Simulation of ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
-            result.functionName
-          }) reverted with no reason.`,
+          `Simulation of ${contractAddress}:${functionSelector}(${result.functionName}) reverted with no reason.`,
         );
       }
 
       // Simulate the public kernel circuit.
       this.log.debug(
-        `Running public kernel inner circuit for ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
-          result.functionName
-        })`,
+        `Running public kernel inner circuit for ${contractAddress}:${functionSelector}(${result.functionName})`,
       );
 
       const callData = await this.getPublicCallData(result);
@@ -220,20 +204,18 @@ export class EnqueuedCallSimulator {
       kernelOutput = output;
 
       // Capture the inputs for later proving in the AVM and kernel.
-      provingRequests.push(makeAvmProvingRequest(inputs, result));
+      avmProvingRequest = makeAvmProvingRequest(inputs.publicCall.publicInputs, result);
 
       // Safely return the revert reason and the kernel output (which has had its revertible side effects dropped)
       // TODO(@leila) we shouldn't drop everything when it reverts. The tail kernel needs the data to prove that it's reverted for the correct reason.
       if (result.reverted) {
         this.log.debug(
-          `Reverting on ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
-            result.functionName
-          }) with reason: ${result.revertReason}`,
+          `Reverting on ${contractAddress}:${functionSelector}(${result.functionName}) with reason: ${result.revertReason}`,
         );
         // TODO(@spalladino): Check gasUsed is correct. The AVM should take care of setting gasLeft to zero upon a revert.
 
         return {
-          provingRequests,
+          avmProvingRequest,
           kernelOutput,
           newUnencryptedLogs: UnencryptedFunctionL2Logs.empty(),
           returnValues: NestedProcessReturnValues.empty(),
@@ -244,7 +226,7 @@ export class EnqueuedCallSimulator {
     }
 
     return {
-      provingRequests,
+      avmProvingRequest: avmProvingRequest!,
       kernelOutput,
       newUnencryptedLogs: topResult.allUnencryptedLogs,
       returnValues: accumulatePublicReturnValues(topResult),
@@ -264,7 +246,7 @@ export class EnqueuedCallSimulator {
   ): Promise<{ inputs: PublicKernelInnerCircuitPrivateInputs; output: VMCircuitPublicInputs }> {
     // The proof is not used in simulation
     const proof = makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH);
-    const vk = ProtocolCircuitVks.PublicKernelInnerArtifact;
+    const vk = VerificationKeyData.makeFakeHonk();
     const previousKernel = new PublicKernelInnerData(previousOutput, proof, vk);
     const inputs = new PublicKernelInnerCircuitPrivateInputs(previousKernel, callData);
     return { inputs, output: await this.publicKernelSimulator.publicKernelCircuitInner(inputs) };
@@ -278,21 +260,36 @@ export class EnqueuedCallSimulator {
    */
   private async getPublicCallData(result: PublicExecutionResult) {
     const bytecodeHash = await this.getBytecodeHash(result);
-    const callStackItem = await this.getPublicCallStackItem(result);
-    return new PublicCallData(callStackItem, makeEmptyProof(), bytecodeHash);
+    const publicInputs = await this.getPublicCircuitPublicInputs(result);
+    return new PublicCallData(publicInputs, makeEmptyProof(), bytecodeHash);
   }
 
-  private async getPublicCallStackItem(result: PublicExecutionResult) {
+  private async getPublicCircuitPublicInputs(result: PublicExecutionResult) {
     const publicDataTreeInfo = await this.db.getTreeInfo(MerkleTreeId.PUBLIC_DATA_TREE);
     this.historicalHeader.state.partial.publicDataTree.root = Fr.fromBuffer(publicDataTreeInfo.root);
 
-    const publicCircuitPublicInputs = PublicCircuitPublicInputs.from({
+    return PublicCircuitPublicInputs.from({
       callContext: result.executionRequest.callContext,
       proverAddress: AztecAddress.ZERO,
       argsHash: computeVarArgsHash(result.executionRequest.args),
-      noteHashes: padArrayEnd(result.noteHashes, NoteHash.empty(), MAX_NOTE_HASHES_PER_CALL),
-      nullifiers: padArrayEnd(result.nullifiers, Nullifier.empty(), MAX_NULLIFIERS_PER_CALL),
-      l2ToL1Msgs: padArrayEnd(result.l2ToL1Messages, L2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_CALL),
+      noteHashes: padArrayEnd(
+        result.noteHashes,
+        NoteHash.empty(),
+        MAX_NOTE_HASHES_PER_CALL,
+        `Too many note hashes. Got ${result.noteHashes.length} with max being ${MAX_NOTE_HASHES_PER_CALL}`,
+      ),
+      nullifiers: padArrayEnd(
+        result.nullifiers,
+        Nullifier.empty(),
+        MAX_NULLIFIERS_PER_CALL,
+        `Too many nullifiers. Got ${result.nullifiers.length} with max being ${MAX_NULLIFIERS_PER_CALL}`,
+      ),
+      l2ToL1Msgs: padArrayEnd(
+        result.l2ToL1Messages,
+        L2ToL1Message.empty(),
+        MAX_L2_TO_L1_MSGS_PER_CALL,
+        `Too many L2 to L1 messages. Got ${result.l2ToL1Messages.length} with max being ${MAX_L2_TO_L1_MSGS_PER_CALL}`,
+      ),
       startSideEffectCounter: result.startSideEffectCounter,
       endSideEffectCounter: result.endSideEffectCounter,
       returnsHash: computeVarArgsHash(result.returnValues),
@@ -300,38 +297,50 @@ export class EnqueuedCallSimulator {
         result.noteHashReadRequests,
         TreeLeafReadRequest.empty(),
         MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
+        `Too many note hash read requests. Got ${result.noteHashReadRequests.length} with max being ${MAX_NOTE_HASH_READ_REQUESTS_PER_CALL}`,
       ),
       nullifierReadRequests: padArrayEnd(
         result.nullifierReadRequests,
         ReadRequest.empty(),
         MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
+        `Too many nullifier read requests. Got ${result.nullifierReadRequests.length} with max being ${MAX_NULLIFIER_READ_REQUESTS_PER_CALL}`,
       ),
       nullifierNonExistentReadRequests: padArrayEnd(
         result.nullifierNonExistentReadRequests,
         ReadRequest.empty(),
         MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL,
+        `Too many nullifier non-existent read requests. Got ${result.nullifierNonExistentReadRequests.length} with max being ${MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL}`,
       ),
       l1ToL2MsgReadRequests: padArrayEnd(
         result.l1ToL2MsgReadRequests,
         TreeLeafReadRequest.empty(),
         MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_CALL,
+        `Too many L1 to L2 message read requests. Got ${result.l1ToL2MsgReadRequests.length} with max being ${MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_CALL}`,
       ),
       contractStorageReads: padArrayEnd(
         result.contractStorageReads,
         ContractStorageRead.empty(),
         MAX_PUBLIC_DATA_READS_PER_CALL,
+        `Too many public data reads. Got ${result.contractStorageReads.length} with max being ${MAX_PUBLIC_DATA_READS_PER_CALL}`,
       ),
       contractStorageUpdateRequests: padArrayEnd(
         result.contractStorageUpdateRequests,
         ContractStorageUpdateRequest.empty(),
         MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
+        `Too many public data update requests. Got ${result.contractStorageUpdateRequests.length} with max being ${MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL}`,
       ),
       publicCallRequests: padArrayEnd(
         result.publicCallRequests,
         PublicInnerCallRequest.empty(),
         MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
+        `Too many public call requests. Got ${result.publicCallRequests.length} with max being ${MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL}`,
+      ),
+      unencryptedLogsHashes: padArrayEnd(
+        result.unencryptedLogsHashes,
+        LogHash.empty(),
+        MAX_UNENCRYPTED_LOGS_PER_CALL,
+        `Too many unencrypted logs. Got ${result.unencryptedLogsHashes.length} with max being ${MAX_UNENCRYPTED_LOGS_PER_CALL}`,
       ),
-      unencryptedLogsHashes: padArrayEnd(result.unencryptedLogsHashes, LogHash.empty(), MAX_UNENCRYPTED_LOGS_PER_CALL),
       historicalHeader: this.historicalHeader,
       globalVariables: this.globalVariables,
       startGasLeft: Gas.from(result.startGasLeft),
@@ -340,12 +349,6 @@ export class EnqueuedCallSimulator {
       // TODO(@just-mitch): need better mapping from simulator to revert code.
       revertCode: result.reverted ? RevertCode.APP_LOGIC_REVERTED : RevertCode.OK,
     });
-
-    return new PublicCallStackItem(
-      result.executionRequest.contractAddress,
-      new FunctionData(result.executionRequest.callContext.functionSelector, false),
-      publicCircuitPublicInputs,
-    );
   }
 
   private getBytecodeHash(_result: PublicExecutionResult) {

package/src/public/enqueued_calls_processor.ts

@@ -1,12 +1,10 @@
 import {
+  type AvmProvingRequest,
   type MerkleTreeReadOperations,
   type NestedProcessReturnValues,
   type ProcessedTx,
-  ProvingRequestType,
   type PublicExecutionRequest,
-  type PublicKernelMergeRequest,
   PublicKernelPhase,
-  type PublicProvingRequest,
   type SimulationError,
   type Tx,
 } from '@aztec/circuit-types';
@@ -23,12 +21,13 @@ import {
   type PublicKernelCircuitPublicInputs,
   PublicKernelData,
   type VMCircuitPublicInputs,
+  VerificationKeyData,
   makeEmptyProof,
   makeEmptyRecursiveProof,
 } from '@aztec/circuits.js';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
-import { ProtocolCircuitVks, TubeVk, getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types';
+import { getVKSiblingPath } from '@aztec/noir-protocol-circuits-types';
 
 import { inspect } from 'util';
 
@@ -45,10 +44,9 @@ const PhaseIsRevertible: Record<PublicKernelPhase, boolean> = {
 };
 
 type PublicPhaseResult = {
+  avmProvingRequest: AvmProvingRequest;
   /** The output of the public kernel circuit simulation for this phase */
   publicKernelOutput: PublicKernelCircuitPublicInputs;
-  /** The collection of public proving requests */
-  provingRequests: PublicProvingRequest[];
   /** Return values of simulating complete callstack */
   returnValues: NestedProcessReturnValues[];
   /** Gas used during the execution this phase */
@@ -66,8 +64,7 @@ export type ProcessedPhase = {
 };
 
 export type TxPublicCallsResult = {
-  /** The collection of public proving requests */
-  provingRequests: PublicProvingRequest[];
+  avmProvingRequest: AvmProvingRequest;
   /** The output of the public kernel tail circuit simulation for this tx */
   tailKernelOutput: KernelCircuitPublicInputs;
   /** Return values of simulating complete callstack */
@@ -158,8 +155,8 @@ export class EnqueuedCallsProcessor {
       PublicKernelPhase.TEARDOWN,
     ];
     const processedPhases: ProcessedPhase[] = [];
-    const provingRequests: PublicProvingRequest[] = [];
     const gasUsed: ProcessedTx['gasUsed'] = {};
+    let avmProvingRequest: AvmProvingRequest;
     let publicKernelOutput = tx.data.toPublicKernelCircuitPublicInputs();
     let isFromPrivate = true;
     let returnValues: NestedProcessReturnValues[] = [];
@@ -184,7 +181,9 @@ export class EnqueuedCallsProcessor {
         publicKernelOutput = result.publicKernelOutput;
         isFromPrivate = false;
 
-        provingRequests.push(...result.provingRequests);
+        // Propagate only one avmProvingRequest of a function call for now, so that we know it's still provable.
+        // Eventually this will be the proof for the entire public call stack.
+        avmProvingRequest = result.avmProvingRequest;
         if (phase === PublicKernelPhase.APP_LOGIC) {
           returnValues = result.returnValues;
         }
@@ -201,19 +200,16 @@ export class EnqueuedCallsProcessor {
       }
     }
 
-    const { output: tailKernelOutput, provingRequest } = await this.publicKernelTailSimulator
-      .simulate(publicKernelOutput)
-      .catch(
-        // the abstract phase manager throws if simulation gives error in non-revertible phase
-        async err => {
-          await this.worldStateDB.rollbackToCommit();
-          throw err;
-        },
-      );
-    provingRequests.push(provingRequest);
+    const tailKernelOutput = await this.publicKernelTailSimulator.simulate(publicKernelOutput).catch(
+      // the abstract phase manager throws if simulation gives error in non-revertible phase
+      async err => {
+        await this.worldStateDB.rollbackToCommit();
+        throw err;
+      },
+    );
 
     return {
-      provingRequests: provingRequests,
+      avmProvingRequest: avmProvingRequest!,
       tailKernelOutput,
       returnValues,
       gasUsed,
@@ -233,8 +229,8 @@ export class EnqueuedCallsProcessor {
     this.log.debug(`Beginning processing in phase ${PublicKernelPhase[phase]} for tx ${tx.getTxHash()}`);
 
     const phaseTimer = new Timer();
-    const provingRequests: PublicProvingRequest[] = [];
     const returnValues: NestedProcessReturnValues[] = [];
+    let avmProvingRequest: AvmProvingRequest;
     let publicKernelOutput = previousPublicKernelOutput;
     let gasUsed = Gas.empty();
     let revertReason: SimulationError | undefined;
@@ -265,14 +261,12 @@ export class EnqueuedCallsProcessor {
 
       if (enqueuedCallResult.revertReason && !PhaseIsRevertible[phase]) {
         this.log.debug(
-          `Simulation error on ${executionRequest.contractAddress.toString()}:${
-            executionRequest.callContext.functionSelector
-          } with reason: ${enqueuedCallResult.revertReason}`,
+          `Simulation error on ${executionRequest.callContext.contractAddress}:${executionRequest.callContext.functionSelector} with reason: ${enqueuedCallResult.revertReason}`,
         );
         throw enqueuedCallResult.revertReason;
       }
 
-      provingRequests.push(...enqueuedCallResult.provingRequests);
+      avmProvingRequest = enqueuedCallResult.avmProvingRequest;
       returnValues.push(enqueuedCallResult.returnValues);
       gasUsed = gasUsed.add(enqueuedCallResult.gasUsed);
       revertReason ??= enqueuedCallResult.revertReason;
@@ -288,14 +282,13 @@ export class EnqueuedCallsProcessor {
         tx.unencryptedLogs.addFunctionLogs([enqueuedCallResult.newUnencryptedLogs]);
       }
 
-      const { output, provingRequest } = await this.runMergeKernelCircuit(
+      const output = await this.runMergeKernelCircuit(
         publicKernelOutput,
         enqueuedCallResult.kernelOutput,
         isFromPrivate,
       );
       publicKernelOutput = output;
       isFromPrivate = false;
-      provingRequests.push(provingRequest);
     }
 
     if (phase === PublicKernelPhase.SETUP) {
@@ -303,8 +296,8 @@ export class EnqueuedCallsProcessor {
     }
 
     return {
+      avmProvingRequest: avmProvingRequest!,
       publicKernelOutput,
-      provingRequests,
       durationMs: phaseTimer.ms(),
       gasUsed,
       returnValues: revertReason ? [] : returnValues,
@@ -351,7 +344,7 @@ export class EnqueuedCallsProcessor {
     previousOutput: PublicKernelCircuitPublicInputs,
     enqueuedCallData: VMCircuitPublicInputs,
     isFromPrivate: boolean,
-  ): Promise<{ output: PublicKernelCircuitPublicInputs; provingRequest: PublicKernelMergeRequest }> {
+  ): Promise<PublicKernelCircuitPublicInputs> {
     const previousKernel = this.getPreviousKernelData(previousOutput, isFromPrivate);
 
     // The proof is not used in simulation.
@@ -360,25 +353,18 @@ export class EnqueuedCallsProcessor {
 
     const inputs = new PublicKernelCircuitPrivateInputs(previousKernel, callData);
 
-    const output = await this.publicKernelSimulator.publicKernelCircuitMerge(inputs);
-
-    const provingRequest: PublicKernelMergeRequest = {
-      type: ProvingRequestType.PUBLIC_KERNEL_MERGE,
-      inputs,
-    };
-
-    return { output, provingRequest };
+    return await this.publicKernelSimulator.publicKernelCircuitMerge(inputs);
   }
 
   private getPreviousKernelData(
     previousOutput: PublicKernelCircuitPublicInputs,
-    isFromPrivate: boolean,
+    _isFromPrivate: boolean,
   ): PublicKernelData {
     // The proof is not used in simulation.
     const proof = makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH);
 
-    const vk = isFromPrivate ? TubeVk : ProtocolCircuitVks.PublicKernelMergeArtifact;
-    const vkIndex = getVKIndex(vk);
+    const vk = VerificationKeyData.makeFakeHonk();
+    const vkIndex = 0;
     const siblingPath = getVKSiblingPath(vkIndex);
 
     return new PublicKernelData(previousOutput, proof, vk, vkIndex, siblingPath);