@aztec/simulator 0.60.0 → 0.62.0

package/src/public/enqueued_call_simulator.ts

@@ -1,17 +1,16 @@
 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,
@@ -52,6 +51,7 @@ import {
   RevertCode,
   TreeLeafReadRequest,
   VMCircuitPublicInputs,
+  VerificationKeyData,
   makeEmptyProof,
   makeEmptyRecursiveProof,
 } from '@aztec/circuits.js';
@@ -59,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 */
@@ -186,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;
@@ -215,7 +204,7 @@ 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.
@@ -226,7 +215,7 @@ export class EnqueuedCallSimulator {
         // 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(),
@@ -237,7 +226,7 @@ export class EnqueuedCallSimulator {
     }
 
     return {
-      provingRequests,
+      avmProvingRequest: avmProvingRequest!,
       kernelOutput,
       newUnencryptedLogs: topResult.allUnencryptedLogs,
       returnValues: accumulatePublicReturnValues(topResult),
@@ -257,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) };
@@ -283,9 +272,24 @@ export class EnqueuedCallSimulator {
       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),
@@ -293,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),

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;
@@ -270,7 +266,7 @@ export class EnqueuedCallsProcessor {
         throw enqueuedCallResult.revertReason;
       }
 
-      provingRequests.push(...enqueuedCallResult.provingRequests);
+      avmProvingRequest = enqueuedCallResult.avmProvingRequest;
       returnValues.push(enqueuedCallResult.returnValues);
       gasUsed = gasUsed.add(enqueuedCallResult.gasUsed);
       revertReason ??= enqueuedCallResult.revertReason;
@@ -286,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) {
@@ -301,8 +296,8 @@ export class EnqueuedCallsProcessor {
     }
 
     return {
+      avmProvingRequest: avmProvingRequest!,
       publicKernelOutput,
-      provingRequests,
       durationMs: phaseTimer.ms(),
       gasUsed,
       returnValues: revertReason ? [] : returnValues,
@@ -349,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.
@@ -358,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);

package/src/public/public_db_sources.ts

@@ -203,24 +203,19 @@ export class WorldStateDB extends ContractsDataSourcePublicDB implements PublicS
     messageHash: Fr,
     secret: Fr,
   ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>> {
-    let nullifierIndex: bigint | undefined;
-    let messageIndex: bigint | undefined;
-    let startIndex = 0n;
-
-    // We iterate over messages until we find one whose nullifier is not in the nullifier tree --> we need to check
-    // for nullifiers because messages can have duplicates.
     const timer = new Timer();
-    do {
-      messageIndex = (await this.db.findLeafIndexAfter(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, messageHash, startIndex))!;
-      if (messageIndex === undefined) {
-        throw new Error(`No non-nullified L1 to L2 message found for message hash ${messageHash.toString()}`);
-      }
 
-      const messageNullifier = computeL1ToL2MessageNullifier(contractAddress, messageHash, secret, messageIndex);
-      nullifierIndex = await this.getNullifierIndex(messageNullifier);
+    const messageIndex = await this.db.findLeafIndex(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, messageHash);
+    if (messageIndex === undefined) {
+      throw new Error(`No L1 to L2 message found for message hash ${messageHash.toString()}`);
+    }
+
+    const messageNullifier = computeL1ToL2MessageNullifier(contractAddress, messageHash, secret);
+    const nullifierIndex = await this.getNullifierIndex(messageNullifier);
 
-      startIndex = messageIndex + 1n;
-    } while (nullifierIndex !== undefined);
+    if (nullifierIndex !== undefined) {
+      throw new Error(`No non-nullified L1 to L2 message found for message hash ${messageHash.toString()}`);
+    }
 
     const siblingPath = await this.db.getSiblingPath<typeof L1_TO_L2_MSG_TREE_HEIGHT>(
       MerkleTreeId.L1_TO_L2_MESSAGE_TREE,

package/src/public/public_kernel.ts

@@ -1,4 +1,3 @@
-import { type CircuitSimulationStats } from '@aztec/circuit-types/stats';
 import {
   type KernelCircuitPublicInputs,
   type PublicKernelCircuitPrivateInputs,
@@ -10,7 +9,9 @@ import {
 import { createDebugLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
 import {
-  SimulatedServerCircuitArtifacts,
+  SimulatedPublicKernelInnerArtifact,
+  SimulatedPublicKernelMergeArtifact,
+  SimulatedPublicKernelTailArtifact,
   convertSimulatedPublicInnerInputsToWitnessMap,
   convertSimulatedPublicInnerOutputFromWitnessMap,
   convertSimulatedPublicMergeInputsToWitnessMap,
@@ -19,7 +20,6 @@ import {
   convertSimulatedPublicTailOutputFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types';
 
-import { WASMSimulator } from '../providers/acvm_wasm.js';
 import { type SimulationProvider } from '../providers/simulation_provider.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
 
@@ -29,9 +29,6 @@ import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simul
 export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimulator {
   private log = createDebugLogger('aztec:public-kernel-simulator');
 
-  // Some circuits are so small it is faster to use WASM
-  private wasmSimulator: WASMSimulator = new WASMSimulator();
-
   constructor(private simulator: SimulationProvider) {}
 
   /**
@@ -42,7 +39,7 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
   public async publicKernelCircuitInner(input: PublicKernelInnerCircuitPrivateInputs): Promise<VMCircuitPublicInputs> {
     const inputWitness = convertSimulatedPublicInnerInputsToWitnessMap(input);
     const [duration, witness] = await elapsed(() =>
-      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedServerCircuitArtifacts.PublicKernelInnerArtifact),
+      this.simulator.simulateCircuit(inputWitness, SimulatedPublicKernelInnerArtifact),
     );
     const result = convertSimulatedPublicInnerOutputFromWitnessMap(witness);
     this.log.debug(`Simulated public kernel inner circuit`, {
@@ -51,7 +48,7 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
       duration,
       inputSize: input.toBuffer().length,
       outputSize: result.toBuffer().length,
-    } satisfies CircuitSimulationStats);
+    });
     return result;
   }
 
@@ -65,7 +62,7 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
   ): Promise<PublicKernelCircuitPublicInputs> {
     const inputWitness = convertSimulatedPublicMergeInputsToWitnessMap(input);
     const [duration, witness] = await elapsed(() =>
-      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedServerCircuitArtifacts.PublicKernelMergeArtifact),
+      this.simulator.simulateCircuit(inputWitness, SimulatedPublicKernelMergeArtifact),
     );
     const result = convertSimulatedPublicMergeOutputFromWitnessMap(witness);
     this.log.debug(`Simulated public kernel merge circuit`, {
@@ -74,7 +71,7 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
       duration,
       inputSize: input.toBuffer().length,
       outputSize: result.toBuffer().length,
-    } satisfies CircuitSimulationStats);
+    });
     return result;
   }
 
@@ -88,7 +85,7 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
   ): Promise<KernelCircuitPublicInputs> {
     const inputWitness = convertSimulatedPublicTailInputsToWitnessMap(input);
     const [duration, witness] = await elapsed(() =>
-      this.wasmSimulator.simulateCircuit(inputWitness, SimulatedServerCircuitArtifacts.PublicKernelTailArtifact),
+      this.simulator.simulateCircuit(inputWitness, SimulatedPublicKernelTailArtifact),
     );
     const result = convertSimulatedPublicTailOutputFromWitnessMap(witness);
     this.log.debug(`Simulated public kernel tail circuit`, {
@@ -97,7 +94,7 @@ export class RealPublicKernelCircuitSimulator implements PublicKernelCircuitSimu
       duration,
       inputSize: input.toBuffer().length,
       outputSize: result.toBuffer().length,
-    } satisfies CircuitSimulationStats);
+    });
     return result;
   }
 }

package/src/public/public_kernel_tail_simulator.ts

@@ -1,4 +1,3 @@
-import { ProvingRequestType, type PublicKernelTailRequest } from '@aztec/circuit-types';
 import {
   type KernelCircuitPublicInputs,
   MAX_NULLIFIERS_PER_TX,
@@ -7,10 +6,11 @@ import {
   type PublicKernelCircuitPublicInputs,
   PublicKernelData,
   PublicKernelTailCircuitPrivateInputs,
+  VerificationKeyData,
   makeEmptyRecursiveProof,
   mergeAccumulatedData,
 } from '@aztec/circuits.js';
-import { ProtocolCircuitVks, getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types';
+import { getVKSiblingPath } from '@aztec/noir-protocol-circuits-types';
 import { type MerkleTreeReadOperations } from '@aztec/world-state';
 
 import { HintsBuilder } from './hints_builder.js';
@@ -28,19 +28,10 @@ export class PublicKernelTailSimulator {
     return new PublicKernelTailSimulator(db, publicKernelSimulator, hintsBuilder);
   }
 
-  async simulate(
-    previousOutput: PublicKernelCircuitPublicInputs,
-  ): Promise<{ output: KernelCircuitPublicInputs; provingRequest: PublicKernelTailRequest }> {
+  async simulate(previousOutput: PublicKernelCircuitPublicInputs): Promise<KernelCircuitPublicInputs> {
     const inputs = await this.buildPrivateInputs(previousOutput);
 
-    const output = await this.publicKernelSimulator.publicKernelCircuitTail(inputs);
-
-    const provingRequest: PublicKernelTailRequest = {
-      type: ProvingRequestType.PUBLIC_KERNEL_TAIL,
-      inputs,
-    };
-
-    return { output, provingRequest };
+    return await this.publicKernelSimulator.publicKernelCircuitTail(inputs);
   }
 
   private async buildPrivateInputs(previousOutput: PublicKernelCircuitPublicInputs) {
@@ -98,8 +89,8 @@ export class PublicKernelTailSimulator {
 
   private getPreviousKernelData(previousOutput: PublicKernelCircuitPublicInputs): PublicKernelData {
     const proof = makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH);
-    const vk = 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);
   }

package/src/public/public_processor.ts

@@ -152,7 +152,7 @@ export class PublicProcessor {
       }
       try {
         const [processedTx, returnValues] = !tx.hasPublicCalls()
-          ? [makeProcessedTx(tx, tx.data.toKernelCircuitPublicInputs(), [])]
+          ? [makeProcessedTx(tx, tx.data.toKernelCircuitPublicInputs())]
           : await this.processTxWithPublicCalls(tx);
         this.log.debug(`Processed tx`, {
           txHash: processedTx.hash,
@@ -253,7 +253,7 @@ export class PublicProcessor {
   private async processTxWithPublicCalls(tx: Tx): Promise<[ProcessedTx, NestedProcessReturnValues[]]> {
     const timer = new Timer();
 
-    const { tailKernelOutput, returnValues, revertReason, provingRequests, gasUsed, processedPhases } =
+    const { avmProvingRequest, tailKernelOutput, returnValues, revertReason, gasUsed, processedPhases } =
       await this.enqueuedCallsProcessor.process(tx);
 
     if (!tailKernelOutput) {
@@ -279,7 +279,7 @@ export class PublicProcessor {
     const phaseCount = processedPhases.length;
     this.metrics.recordTx(phaseCount, timer.ms());
 
-    const processedTx = makeProcessedTx(tx, tailKernelOutput, provingRequests, revertReason, gasUsed);
+    const processedTx = makeProcessedTx(tx, tailKernelOutput, { avmProvingRequest, revertReason, gasUsed });
     return [processedTx, returnValues];
   }
 }