@aztec/bb-prover 0.55.1 → 0.57.0

package/src/prover/bb_private_kernel_prover.ts

@@ -8,11 +8,10 @@ import {
   AGGREGATION_OBJECT_LENGTH,
   ClientIvcProof,
   Fr,
-  type PrivateCircuitPublicInputs,
   type PrivateKernelCircuitPublicInputs,
   type PrivateKernelInitCircuitPrivateInputs,
   type PrivateKernelInnerCircuitPrivateInputs,
-  type PrivateKernelResetCircuitPrivateInputsVariants,
+  type PrivateKernelResetCircuitPrivateInputs,
   type PrivateKernelTailCircuitPrivateInputs,
   type PrivateKernelTailCircuitPublicInputs,
   Proof,
@@ -20,14 +19,13 @@ import {
   type VerificationKeyAsFields,
   type VerificationKeyData,
 } from '@aztec/circuits.js';
-import { siloNoteHash } from '@aztec/circuits.js/hash';
 import { runInDirectory } from '@aztec/foundation/fs';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import {
   ClientCircuitArtifacts,
+  ClientCircuitVks,
   type ClientProtocolArtifact,
-  PrivateResetTagToArtifactName,
   ProtocolCircuitVks,
   convertPrivateKernelInitInputsToWitnessMap,
   convertPrivateKernelInitOutputsFromWitnessMap,
@@ -39,6 +37,7 @@ import {
   convertPrivateKernelTailInputsToWitnessMap,
   convertPrivateKernelTailOutputsFromWitnessMap,
   convertPrivateKernelTailToPublicInputsToWitnessMap,
+  getPrivateKernelResetArtifactName,
 } from '@aztec/noir-protocol-circuits-types';
 import { WASMSimulator } from '@aztec/simulator';
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
@@ -130,12 +129,6 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
     return await this.runInDirectory(operation);
   }
 
-  public getSiloedCommitments(publicInputs: PrivateCircuitPublicInputs) {
-    const contractAddress = publicInputs.callContext.storageContractAddress;
-
-    return Promise.resolve(publicInputs.noteHashes.map(commitment => siloNoteHash(contractAddress, commitment.value)));
-  }
-
   public async simulateProofInit(
     inputs: PrivateKernelInitCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
@@ -159,13 +152,15 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
   }
 
   public async simulateProofReset(
-    inputs: PrivateKernelResetCircuitPrivateInputsVariants,
+    inputs: PrivateKernelResetCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>> {
+    const variantInputs = inputs.trimToSizes();
+    const artifactName = getPrivateKernelResetArtifactName(inputs.dimensions);
     return await this.simulate(
-      inputs,
-      PrivateResetTagToArtifactName[inputs.sizeTag],
-      convertPrivateKernelResetInputsToWitnessMap,
-      output => convertPrivateKernelResetOutputsFromWitnessMap(output, inputs.sizeTag),
+      variantInputs,
+      artifactName,
+      variantInputs => convertPrivateKernelResetInputsToWitnessMap(variantInputs, artifactName),
+      output => convertPrivateKernelResetOutputsFromWitnessMap(output, artifactName),
     );
   }
 
@@ -283,14 +278,14 @@ export class BBNativePrivateKernelProver implements PrivateKernelProver {
       outputSize: output.toBuffer().length,
     } satisfies CircuitWitnessGenerationStats);
 
-    // TODO(#7410) we dont need to generate vk's for these circuits, they are in the vk tree
-    const { verificationKey } = await this.runInDirectory(dir =>
-      this.computeVerificationKey(dir, Buffer.from(compiledCircuit.bytecode, 'base64'), circuitType),
-    );
+    const verificationKey = ClientCircuitVks[circuitType].keyAsFields;
+    const bytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+
     const kernelOutput: PrivateKernelSimulateOutput<O> = {
       publicInputs: output,
       verificationKey,
       outputWitness,
+      bytecode,
     };
     return kernelOutput;
   }

package/src/prover/bb_prover.ts

@@ -2,8 +2,6 @@
 import {
   type AvmProofAndVerificationKey,
   type PublicInputsAndRecursiveProof,
-  type PublicKernelNonTailRequest,
-  type PublicKernelTailRequest,
   type ServerCircuitProver,
   makePublicInputsAndRecursiveProof,
 } from '@aztec/circuit-types';
@@ -18,6 +16,7 @@ import {
   type BlockMergeRollupInputs,
   type BlockRootOrBlockMergePublicInputs,
   type BlockRootRollupInputs,
+  type EmptyBlockRootRollupInputs,
   EmptyNestedCircuitInputs,
   EmptyNestedData,
   Fr,
@@ -27,7 +26,10 @@ import {
   type PrivateKernelEmptyInputData,
   PrivateKernelEmptyInputs,
   Proof,
+  type PublicKernelCircuitPrivateInputs,
   type PublicKernelCircuitPublicInputs,
+  type PublicKernelInnerCircuitPrivateInputs,
+  type PublicKernelTailCircuitPrivateInputs,
   RECURSIVE_PROOF_LENGTH,
   RecursiveProof,
   RootParityInput,
@@ -36,6 +38,7 @@ import {
   type RootRollupPublicInputs,
   TUBE_PROOF_LENGTH,
   type TubeInputs,
+  type VMCircuitPublicInputs,
   type VerificationKeyAsFields,
   type VerificationKeyData,
   makeRecursiveProofFromBinary,
@@ -55,10 +58,16 @@ import {
   convertBlockMergeRollupOutputsFromWitnessMap,
   convertBlockRootRollupInputsToWitnessMap,
   convertBlockRootRollupOutputsFromWitnessMap,
+  convertEmptyBlockRootRollupInputsToWitnessMap,
+  convertEmptyBlockRootRollupOutputsFromWitnessMap,
   convertMergeRollupInputsToWitnessMap,
   convertMergeRollupOutputsFromWitnessMap,
   convertPrivateKernelEmptyInputsToWitnessMap,
   convertPrivateKernelEmptyOutputsFromWitnessMap,
+  convertPublicInnerInputsToWitnessMap,
+  convertPublicInnerOutputFromWitnessMap,
+  convertPublicMergeInputsToWitnessMap,
+  convertPublicMergeOutputFromWitnessMap,
   convertPublicTailInputsToWitnessMap,
   convertPublicTailOutputFromWitnessMap,
   convertRootParityInputsToWitnessMap,
@@ -94,7 +103,6 @@ import {
 import type { ACVMConfig, BBConfig } from '../config.js';
 import { type UltraHonkFlavor, getUltraHonkFlavorForCircuit } from '../honk.js';
 import { ProverInstrumentation } from '../instrumentation.js';
-import { PublicKernelArtifactMapping } from '../mappings/mappings.js';
 import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
 import { extractAvmVkData, extractVkData } from '../verification_key/verification_key_data.js';
 
@@ -206,47 +214,70 @@ export class BBNativeRollupProver implements ServerCircuitProver {
   }
 
   /**
-   * Requests that a public kernel circuit be executed and the proof generated
+   * Requests that a public kernel inner circuit be executed and the proof generated
    * @param kernelRequest - The object encapsulating the request for a proof
    * @returns The requested circuit's public inputs and proof
    */
-  @trackSpan('BBNativeRollupProver.getPublicKernelProof', kernelReq => ({
-    [Attributes.PROTOCOL_CIRCUIT_NAME]: mapProtocolArtifactNameToCircuitName(
-      PublicKernelArtifactMapping[kernelReq.type]!.artifact,
-    ),
-  }))
-  public async getPublicKernelProof(
-    kernelRequest: PublicKernelNonTailRequest,
+  @trackSpan('BBNativeRollupProver.getPublicKernelInnerProof', {
+    [Attributes.PROTOCOL_CIRCUIT_NAME]: 'public-kernel-inner',
+  })
+  public async getPublicKernelInnerProof(
+    inputs: PublicKernelInnerCircuitPrivateInputs,
+  ): Promise<PublicInputsAndRecursiveProof<VMCircuitPublicInputs>> {
+    const artifact = 'PublicKernelInnerArtifact';
+
+    const { circuitOutput, proof } = await this.createRecursiveProof(
+      inputs,
+      artifact,
+      NESTED_RECURSIVE_PROOF_LENGTH,
+      convertPublicInnerInputsToWitnessMap,
+      convertPublicInnerOutputFromWitnessMap,
+    );
+
+    const verificationKey = await this.getVerificationKeyDataForCircuit(artifact);
+
+    await this.verifyProof(artifact, proof.binaryProof);
+
+    return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+  }
+
+  /**
+   * Requests that a public kernel merge circuit be executed and the proof generated
+   * @param kernelRequest - The object encapsulating the request for a proof
+   * @returns The requested circuit's public inputs and proof
+   */
+  @trackSpan('BBNativeRollupProver.getPublicKernelMergeProof', {
+    [Attributes.PROTOCOL_CIRCUIT_NAME]: 'public-kernel-merge',
+  })
+  public async getPublicKernelMergeProof(
+    inputs: PublicKernelCircuitPrivateInputs,
   ): Promise<PublicInputsAndRecursiveProof<PublicKernelCircuitPublicInputs>> {
-    const kernelOps = PublicKernelArtifactMapping[kernelRequest.type];
-    if (kernelOps === undefined) {
-      throw new Error(`Unable to prove kernel type ${kernelRequest.type}`);
-    }
+    const artifact = 'PublicKernelMergeArtifact';
 
     // We may need to convert the recursive proof into fields format
-    kernelRequest.inputs.previousKernel.proof = await this.ensureValidProof(
-      kernelRequest.inputs.previousKernel.proof,
-      kernelOps.artifact,
-      kernelRequest.inputs.previousKernel.vk,
+    inputs.previousKernel.proof = await this.ensureValidProof(
+      inputs.previousKernel.proof,
+      artifact,
+      inputs.previousKernel.vk,
     );
 
     await this.verifyWithKey(
-      getUltraHonkFlavorForCircuit(kernelOps.artifact),
-      kernelRequest.inputs.previousKernel.vk,
-      kernelRequest.inputs.previousKernel.proof.binaryProof,
+      getUltraHonkFlavorForCircuit(artifact),
+      inputs.previousKernel.vk,
+      inputs.previousKernel.proof.binaryProof,
     );
 
     const { circuitOutput, proof } = await this.createRecursiveProof(
-      kernelRequest.inputs,
-      kernelOps.artifact,
+      inputs,
+      artifact,
       NESTED_RECURSIVE_PROOF_LENGTH,
-      kernelOps.convertInputs,
-      kernelOps.convertOutputs,
+      convertPublicMergeInputsToWitnessMap,
+      convertPublicMergeOutputFromWitnessMap,
     );
 
-    const verificationKey = await this.getVerificationKeyDataForCircuit(kernelOps.artifact);
+    const verificationKey = await this.getVerificationKeyDataForCircuit(artifact);
 
-    await this.verifyProof(kernelOps.artifact, proof.binaryProof);
+    await this.verifyProof(artifact, proof.binaryProof);
 
     return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
   }
@@ -257,10 +288,10 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    * @returns The requested circuit's public inputs and proof
    */
   public async getPublicTailProof(
-    kernelRequest: PublicKernelTailRequest,
+    inputs: PublicKernelTailCircuitPrivateInputs,
   ): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
     const { circuitOutput, proof } = await this.createRecursiveProof(
-      kernelRequest.inputs,
+      inputs,
       'PublicKernelTailArtifact',
       NESTED_RECURSIVE_PROOF_LENGTH,
       convertPublicTailInputsToWitnessMap,
@@ -337,22 +368,42 @@ export class BBNativeRollupProver implements ServerCircuitProver {
   public async getBlockRootRollupProof(
     input: BlockRootRollupInputs,
   ): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
-    // TODO(#7346): When batch rollups are integrated, we probably want the below to be this.createRecursiveProof
-    // since we will no longer be verifying it directly on L1
-    const { circuitOutput, proof } = await this.createProof(
+    const { circuitOutput, proof } = await this.createRecursiveProof(
       input,
       'BlockRootRollupArtifact',
+      NESTED_RECURSIVE_PROOF_LENGTH,
       convertBlockRootRollupInputsToWitnessMap,
       convertBlockRootRollupOutputsFromWitnessMap,
     );
 
-    const recursiveProof = makeRecursiveProofFromBinary(proof, NESTED_RECURSIVE_PROOF_LENGTH);
-
     const verificationKey = await this.getVerificationKeyDataForCircuit('BlockRootRollupArtifact');
 
-    await this.verifyProof('BlockRootRollupArtifact', proof);
+    await this.verifyProof('BlockRootRollupArtifact', proof.binaryProof);
 
-    return makePublicInputsAndRecursiveProof(circuitOutput, recursiveProof, verificationKey);
+    return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
+  }
+
+  /**
+   * Simulates the empty block root rollup circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  public async getEmptyBlockRootRollupProof(
+    input: EmptyBlockRootRollupInputs,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
+    const { circuitOutput, proof } = await this.createRecursiveProof(
+      input,
+      'EmptyBlockRootRollupArtifact',
+      RECURSIVE_PROOF_LENGTH,
+      convertEmptyBlockRootRollupInputsToWitnessMap,
+      convertEmptyBlockRootRollupOutputsFromWitnessMap,
+    );
+
+    const verificationKey = await this.getVerificationKeyDataForCircuit('EmptyBlockRootRollupArtifact');
+
+    await this.verifyProof('EmptyBlockRootRollupArtifact', proof.binaryProof);
+
+    return makePublicInputsAndRecursiveProof(circuitOutput, proof, verificationKey);
   }
 
   /**

package/src/stats.ts

@@ -1,8 +1,6 @@
 import type { CircuitName } from '@aztec/circuit-types/stats';
 import { type ClientProtocolArtifact, type ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types';
 
-export { mapPublicKernelToCircuitName } from '@aztec/circuit-types';
-
 export function mapProtocolArtifactNameToCircuitName(
   artifact: ServerProtocolArtifact | ClientProtocolArtifact,
 ): CircuitName {
@@ -17,16 +15,16 @@ export function mapProtocolArtifactNameToCircuitName(
       return 'merge-rollup';
     case 'BlockRootRollupArtifact':
       return 'block-root-rollup';
+    case 'EmptyBlockRootRollupArtifact':
+      return 'empty-block-root-rollup';
     case 'BlockMergeRollupArtifact':
       return 'block-merge-rollup';
     case 'RootRollupArtifact':
       return 'root-rollup';
-    case 'PublicKernelSetupArtifact':
-      return 'public-kernel-setup';
-    case 'PublicKernelAppLogicArtifact':
-      return 'public-kernel-app-logic';
-    case 'PublicKernelTeardownArtifact':
-      return 'public-kernel-teardown';
+    case 'PublicKernelInnerArtifact':
+      return 'public-kernel-inner';
+    case 'PublicKernelMergeArtifact':
+      return 'public-kernel-merge';
     case 'PublicKernelTailArtifact':
       return 'public-kernel-tail';
     case 'PrivateKernelInitArtifact':
@@ -37,24 +35,14 @@ export function mapProtocolArtifactNameToCircuitName(
       return 'private-kernel-tail';
     case 'PrivateKernelTailToPublicArtifact':
       return 'private-kernel-tail-to-public';
-    case 'PrivateKernelResetFullArtifact':
-      return 'private-kernel-reset-full';
-    case 'PrivateKernelResetFullInnerArtifact':
-      return 'private-kernel-reset-full-inner';
-    case 'PrivateKernelResetBigArtifact':
-      return 'private-kernel-reset-big';
-    case 'PrivateKernelResetMediumArtifact':
-      return 'private-kernel-reset-medium';
-    case 'PrivateKernelResetSmallArtifact':
-      return 'private-kernel-reset-small';
-    case 'PrivateKernelResetTinyArtifact':
-      return 'private-kernel-reset-tiny';
     case 'EmptyNestedArtifact':
       return 'empty-nested';
     case 'PrivateKernelEmptyArtifact':
       return 'private-kernel-empty';
     default: {
-      const _foo: never = artifact;
+      if (artifact.startsWith('PrivateKernelReset')) {
+        return 'private-kernel-reset';
+      }
       throw new Error(`Unknown circuit type: ${artifact}`);
     }
   }

package/src/test/index.ts

@@ -1,2 +1,3 @@
 export * from './test_circuit_prover.js';
 export * from './test_verifier.js';
+export * from './test_avm.js';

package/src/test/test_avm.ts

@@ -0,0 +1,85 @@
+import {
+  AztecAddress,
+  ContractStorageRead,
+  ContractStorageUpdateRequest,
+  Gas,
+  GlobalVariables,
+  Header,
+  L2ToL1Message,
+  LogHash,
+  MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_CALL,
+  MAX_L2_TO_L1_MSGS_PER_CALL,
+  MAX_NOTE_HASHES_PER_CALL,
+  MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
+  MAX_NULLIFIERS_PER_CALL,
+  MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL,
+  MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
+  MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
+  MAX_PUBLIC_DATA_READS_PER_CALL,
+  MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
+  MAX_UNENCRYPTED_LOGS_PER_CALL,
+  NoteHash,
+  Nullifier,
+  PublicCircuitPublicInputs,
+  PublicInnerCallRequest,
+  ReadRequest,
+  RevertCode,
+  TreeLeafReadRequest,
+} from '@aztec/circuits.js';
+import { computeVarArgsHash } from '@aztec/circuits.js/hash';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { type PublicExecutionResult } from '@aztec/simulator';
+
+// TODO: pub somewhere more usable - copied from abstract phase manager
+export function getPublicInputs(result: PublicExecutionResult): PublicCircuitPublicInputs {
+  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),
+    startSideEffectCounter: result.startSideEffectCounter,
+    endSideEffectCounter: result.endSideEffectCounter,
+    returnsHash: computeVarArgsHash(result.returnValues),
+    noteHashReadRequests: padArrayEnd(
+      result.noteHashReadRequests,
+      TreeLeafReadRequest.empty(),
+      MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
+    ),
+    nullifierReadRequests: padArrayEnd(
+      result.nullifierReadRequests,
+      ReadRequest.empty(),
+      MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
+    ),
+    nullifierNonExistentReadRequests: padArrayEnd(
+      result.nullifierNonExistentReadRequests,
+      ReadRequest.empty(),
+      MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL,
+    ),
+    l1ToL2MsgReadRequests: padArrayEnd(
+      result.l1ToL2MsgReadRequests,
+      TreeLeafReadRequest.empty(),
+      MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_CALL,
+    ),
+    contractStorageReads: padArrayEnd(
+      result.contractStorageReads,
+      ContractStorageRead.empty(),
+      MAX_PUBLIC_DATA_READS_PER_CALL,
+    ),
+    contractStorageUpdateRequests: padArrayEnd(
+      result.contractStorageUpdateRequests,
+      ContractStorageUpdateRequest.empty(),
+      MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
+    ),
+    publicCallRequests: padArrayEnd([], PublicInnerCallRequest.empty(), MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL),
+    unencryptedLogsHashes: padArrayEnd(result.unencryptedLogsHashes, LogHash.empty(), MAX_UNENCRYPTED_LOGS_PER_CALL),
+    historicalHeader: Header.empty(),
+    globalVariables: GlobalVariables.empty(),
+    startGasLeft: Gas.from(result.startGasLeft),
+    endGasLeft: Gas.from(result.endGasLeft),
+    transactionFee: result.transactionFee,
+    // TODO(@just-mitch): need better mapping from simulator to revert code.
+    revertCode: result.reverted ? RevertCode.APP_LOGIC_REVERTED : RevertCode.OK,
+  });
+}

package/src/test/test_circuit_prover.ts

@@ -1,8 +1,6 @@
 import {
   type AvmProofAndVerificationKey,
   type PublicInputsAndRecursiveProof,
-  type PublicKernelNonTailRequest,
-  type PublicKernelTailRequest,
   type ServerCircuitProver,
   makePublicInputsAndRecursiveProof,
 } from '@aztec/circuit-types';
@@ -15,6 +13,7 @@ import {
   type BlockMergeRollupInputs,
   type BlockRootOrBlockMergePublicInputs,
   type BlockRootRollupInputs,
+  type EmptyBlockRootRollupInputs,
   EmptyNestedData,
   type KernelCircuitPublicInputs,
   type MergeRollupInputs,
@@ -22,7 +21,10 @@ import {
   type PrivateKernelEmptyInputData,
   PrivateKernelEmptyInputs,
   type Proof,
+  type PublicKernelCircuitPrivateInputs,
   type PublicKernelCircuitPublicInputs,
+  type PublicKernelInnerCircuitPrivateInputs,
+  type PublicKernelTailCircuitPrivateInputs,
   RECURSIVE_PROOF_LENGTH,
   type RecursiveProof,
   RootParityInput,
@@ -31,6 +33,7 @@ import {
   type RootRollupPublicInputs,
   TUBE_PROOF_LENGTH,
   type TubeInputs,
+  type VMCircuitPublicInputs,
   VerificationKeyData,
   makeEmptyProof,
   makeEmptyRecursiveProof,
@@ -50,6 +53,8 @@ import {
   convertBlockMergeRollupOutputsFromWitnessMap,
   convertBlockRootRollupInputsToWitnessMap,
   convertBlockRootRollupOutputsFromWitnessMap,
+  convertEmptyBlockRootRollupInputsToWitnessMap,
+  convertEmptyBlockRootRollupOutputsFromWitnessMap,
   convertMergeRollupInputsToWitnessMap,
   convertMergeRollupOutputsFromWitnessMap,
   convertPrivateKernelEmptyInputsToWitnessMap,
@@ -61,6 +66,10 @@ import {
   convertSimulatedBaseRollupInputsToWitnessMap,
   convertSimulatedBaseRollupOutputsFromWitnessMap,
   convertSimulatedPrivateKernelEmptyOutputsFromWitnessMap,
+  convertSimulatedPublicInnerInputsToWitnessMap,
+  convertSimulatedPublicInnerOutputFromWitnessMap,
+  convertSimulatedPublicMergeInputsToWitnessMap,
+  convertSimulatedPublicMergeOutputFromWitnessMap,
   convertSimulatedPublicTailInputsToWitnessMap,
   convertSimulatedPublicTailOutputFromWitnessMap,
   getVKSiblingPath,
@@ -69,8 +78,7 @@ import { type SimulationProvider, WASMSimulator, emitCircuitSimulationStats } fr
 import { type TelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
 import { ProverInstrumentation } from '../instrumentation.js';
-import { SimulatedPublicKernelArtifactMapping } from '../mappings/mappings.js';
-import { mapPublicKernelToCircuitName } from '../stats.js';
+import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
 
 /**
  * A class for use in testing situations (e2e, unit test, etc) and temporarily for assembling a block in the sequencer.
@@ -342,6 +350,41 @@ export class TestCircuitProver implements ServerCircuitProver {
     );
   }
 
+  /**
+   * Simulates the empty block root rollup circuit from its inputs.
+   * @param input - Inputs to the circuit.
+   * @returns The public inputs as outputs of the simulation.
+   */
+  @trackSpan('TestCircuitProver.getEmptyBlockRootRollupProof')
+  public async getEmptyBlockRootRollupProof(
+    input: EmptyBlockRootRollupInputs,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
+    const timer = new Timer();
+    const witnessMap = convertEmptyBlockRootRollupInputsToWitnessMap(input);
+
+    // use WASM here as it is faster for small circuits
+    const witness = await this.wasmSimulator.simulateCircuit(
+      witnessMap,
+      SimulatedServerCircuitArtifacts.EmptyBlockRootRollupArtifact,
+    );
+
+    const result = convertEmptyBlockRootRollupOutputsFromWitnessMap(witness);
+
+    this.instrumentation.recordDuration('simulationDuration', 'empty-block-root-rollup', timer);
+    emitCircuitSimulationStats(
+      'empty-block-root-rollup',
+      timer.ms(),
+      input.toBuffer().length,
+      result.toBuffer().length,
+      this.logger,
+    );
+    return makePublicInputsAndRecursiveProof(
+      result,
+      makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
+      ProtocolCircuitVks['EmptyBlockRootRollupArtifact'],
+    );
+  }
+
   /**
    * Simulates the block merge rollup circuit from its inputs.
    * @param input - Inputs to the circuit.
@@ -413,29 +456,53 @@ export class TestCircuitProver implements ServerCircuitProver {
     );
   }
 
-  @trackSpan('TestCircuitProver.getPublicKernelProof')
-  public async getPublicKernelProof(
-    kernelRequest: PublicKernelNonTailRequest,
-  ): Promise<PublicInputsAndRecursiveProof<PublicKernelCircuitPublicInputs>> {
+  @trackSpan('TestCircuitProver.getPublicKernelInnerProof')
+  public async getPublicKernelInnerProof(
+    inputs: PublicKernelInnerCircuitPrivateInputs,
+  ): Promise<PublicInputsAndRecursiveProof<VMCircuitPublicInputs>> {
     const timer = new Timer();
-    const kernelOps = SimulatedPublicKernelArtifactMapping[kernelRequest.type];
-    if (kernelOps === undefined) {
-      throw new Error(`Unable to prove for kernel type ${kernelRequest.type}`);
-    }
-    const witnessMap = kernelOps.convertInputs(kernelRequest.inputs);
 
-    const witness = await this.wasmSimulator.simulateCircuit(
-      witnessMap,
-      SimulatedServerCircuitArtifacts[kernelOps.artifact],
+    const artifact = 'PublicKernelInnerArtifact';
+    const circuitName = mapProtocolArtifactNameToCircuitName(artifact);
+
+    const witnessMap = convertSimulatedPublicInnerInputsToWitnessMap(inputs);
+    const witness = await this.wasmSimulator.simulateCircuit(witnessMap, SimulatedServerCircuitArtifacts[artifact]);
+
+    const result = convertSimulatedPublicInnerOutputFromWitnessMap(witness);
+    this.instrumentation.recordDuration('simulationDuration', circuitName, timer);
+    emitCircuitSimulationStats(
+      circuitName,
+      timer.ms(),
+      inputs.toBuffer().length,
+      result.toBuffer().length,
+      this.logger,
     );
+    await this.delay();
+    return makePublicInputsAndRecursiveProof(
+      result,
+      makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
+      ProtocolCircuitVks[artifact],
+    );
+  }
 
-    const result = kernelOps.convertOutputs(witness);
-    const circuitName = mapPublicKernelToCircuitName(kernelRequest.type);
+  @trackSpan('TestCircuitProver.getPublicKernelMergeProof')
+  public async getPublicKernelMergeProof(
+    inputs: PublicKernelCircuitPrivateInputs,
+  ): Promise<PublicInputsAndRecursiveProof<PublicKernelCircuitPublicInputs>> {
+    const timer = new Timer();
+
+    const artifact = 'PublicKernelMergeArtifact';
+    const circuitName = mapProtocolArtifactNameToCircuitName(artifact);
+
+    const witnessMap = convertSimulatedPublicMergeInputsToWitnessMap(inputs);
+    const witness = await this.wasmSimulator.simulateCircuit(witnessMap, SimulatedServerCircuitArtifacts[artifact]);
+
+    const result = convertSimulatedPublicMergeOutputFromWitnessMap(witness);
     this.instrumentation.recordDuration('simulationDuration', circuitName, timer);
     emitCircuitSimulationStats(
       circuitName,
       timer.ms(),
-      kernelRequest.inputs.toBuffer().length,
+      inputs.toBuffer().length,
       result.toBuffer().length,
       this.logger,
     );
@@ -443,28 +510,29 @@ export class TestCircuitProver implements ServerCircuitProver {
     return makePublicInputsAndRecursiveProof(
       result,
       makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
-      ProtocolCircuitVks[kernelOps.artifact],
+      ProtocolCircuitVks[artifact],
     );
   }
 
   @trackSpan('TestCircuitProver.getPublicTailProof')
   public async getPublicTailProof(
-    kernelRequest: PublicKernelTailRequest,
+    inputs: PublicKernelTailCircuitPrivateInputs,
   ): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
     const timer = new Timer();
-    const witnessMap = convertSimulatedPublicTailInputsToWitnessMap(kernelRequest.inputs);
+
+    const artifact = 'PublicKernelTailArtifact';
+    const circuitName = mapProtocolArtifactNameToCircuitName(artifact);
+
+    const witnessMap = convertSimulatedPublicTailInputsToWitnessMap(inputs);
     // use WASM here as it is faster for small circuits
-    const witness = await this.wasmSimulator.simulateCircuit(
-      witnessMap,
-      SimulatedServerCircuitArtifacts['PublicKernelTailArtifact'],
-    );
+    const witness = await this.wasmSimulator.simulateCircuit(witnessMap, SimulatedServerCircuitArtifacts[artifact]);
 
     const result = convertSimulatedPublicTailOutputFromWitnessMap(witness);
-    this.instrumentation.recordDuration('simulationDuration', 'public-kernel-tail', timer);
+    this.instrumentation.recordDuration('simulationDuration', circuitName, timer);
     emitCircuitSimulationStats(
-      'public-kernel-tail',
+      circuitName,
       timer.ms(),
-      kernelRequest.inputs.toBuffer().length,
+      inputs.toBuffer().length,
       result.toBuffer().length,
       this.logger,
     );
@@ -472,7 +540,7 @@ export class TestCircuitProver implements ServerCircuitProver {
     return makePublicInputsAndRecursiveProof(
       result,
       makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
-      ProtocolCircuitVks['PublicKernelTailArtifact'],
+      ProtocolCircuitVks[artifact],
     );
   }