@aztec/prover-client 0.60.0 → 0.62.0

package/src/orchestrator/tx-proving-state.ts

@@ -1,43 +1,29 @@
 import {
-  AVM_REQUEST,
-  type AvmProvingRequest,
+  EncryptedNoteTxL2Logs,
+  EncryptedTxL2Logs,
   type MerkleTreeId,
   type ProcessedTx,
-  ProvingRequestType,
-  type PublicKernelRequest,
+  type ProofAndVerificationKey,
+  UnencryptedTxL2Logs,
 } from '@aztec/circuit-types';
 import {
+  type AVM_PROOF_LENGTH_IN_FIELDS,
+  AVM_VK_INDEX,
   type AppendOnlyTreeSnapshot,
-  type BaseRollupInputs,
-  type NESTED_RECURSIVE_PROOF_LENGTH,
-  type Proof,
-  type RECURSIVE_PROOF_LENGTH,
+  AvmProofData,
+  type BaseRollupHints,
+  Fr,
+  PrivateBaseRollupInputs,
+  PrivateTubeData,
+  PublicBaseRollupInputs,
   type RecursiveProof,
-  type VerificationKeyData,
-  makeEmptyProof,
+  type TUBE_PROOF_LENGTH,
+  TUBE_VK_INDEX,
+  TubeInputs,
+  VMCircuitPublicInputs,
+  VkWitnessData,
 } from '@aztec/circuits.js';
-
-export enum TX_PROVING_CODE {
-  NOT_READY,
-  READY,
-  COMPLETED,
-}
-
-export type PublicFunction = {
-  vmRequest: AvmProvingRequest | undefined;
-  vmProof: Proof | undefined;
-  previousProofType: ProvingRequestType;
-  previousKernelProven: boolean;
-  publicKernelRequest: PublicKernelRequest;
-};
-
-// Type encapsulating the instruction to the orchestrator as to what
-// needs to be proven next
-export type TxProvingInstruction = {
-  code: TX_PROVING_CODE;
-  function: PublicFunction | undefined;
-  functionIndex?: number;
-};
+import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types';
 
 /**
  * Helper class to manage the proving cycle of a transaction
@@ -45,153 +31,127 @@ export type TxProvingInstruction = {
  * Also stores the inputs to the base rollup for this transaction and the tree snapshots
  */
 export class TxProvingState {
-  private publicFunctions: PublicFunction[] = [];
+  private tube?: ProofAndVerificationKey<RecursiveProof<typeof TUBE_PROOF_LENGTH>>;
+  private avm?: ProofAndVerificationKey<RecursiveProof<typeof AVM_PROOF_LENGTH_IN_FIELDS>>;
 
   constructor(
     public readonly processedTx: ProcessedTx,
-    public readonly baseRollupInputs: BaseRollupInputs,
+    private readonly baseRollupHints: BaseRollupHints,
     public readonly treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>,
-  ) {
-    let previousProofType = ProvingRequestType.TUBE_PROOF;
-    for (let i = 0; i < processedTx.publicProvingRequests.length; i++) {
-      const provingRequest = processedTx.publicProvingRequests[i];
-      const publicKernelRequest = provingRequest.type === AVM_REQUEST ? provingRequest.kernelRequest : provingRequest;
-      const vmRequest = provingRequest.type === AVM_REQUEST ? provingRequest : undefined;
-      // TODO(#7124): Remove this temporary hack.
-      // There's no previous kernel for the first inner kernel in a chain of AvmProvingRequests.
-      // Setting its previousKernelProven to be true so that it will be ready once the vm proof is generated.
-      const previousKernelProven = !!vmRequest && previousProofType !== ProvingRequestType.PUBLIC_KERNEL_INNER;
-      const vmProof = provingRequest.type === ProvingRequestType.PUBLIC_KERNEL_TAIL ? makeEmptyProof() : undefined;
-      const publicFunction: PublicFunction = {
-        vmRequest,
-        vmProof,
-        previousProofType,
-        previousKernelProven,
-        publicKernelRequest: {
-          type: publicKernelRequest.type,
-          // We take a deep copy (clone) of the inputs to be modified here and passed to the prover.
-          // bb-prover will also modify the inputs by reference.
-          inputs: publicKernelRequest.inputs.clone(),
-        } as PublicKernelRequest,
-      };
-      this.publicFunctions.push(publicFunction);
-      previousProofType = publicKernelRequest.type;
-    }
+  ) {}
 
-    if (this.publicFunctions.length > 0) {
-      // The first merge kernel takes the tube proof.
-      const firstKernelIndex = this.publicFunctions.findIndex(
-        fn => fn.publicKernelRequest.type === ProvingRequestType.PUBLIC_KERNEL_MERGE,
-      );
-      this.publicFunctions[firstKernelIndex].previousProofType = ProvingRequestType.TUBE_PROOF;
-    }
+  get requireAvmProof() {
+    return !!this.processedTx.avmProvingRequest;
   }
 
-  // Updates the transaction's proving state after completion of a kernel proof
-  // Returns an instruction as to the next stage of tx proving
-  public getNextPublicKernelFromKernelProof(
-    provenIndex: number,
-    proof: RecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>,
-    verificationKey: VerificationKeyData,
-  ): TxProvingInstruction {
-    const kernelRequest = this.getPublicFunctionState(provenIndex).publicKernelRequest;
-    const provenIsInner = kernelRequest.type === ProvingRequestType.PUBLIC_KERNEL_INNER;
-    // If the proven request is not an inner kernel, its next kernel should not be an inner kernel either.
-    const nextFunctionIndex = provenIsInner
-      ? provenIndex + 1
-      : this.publicFunctions.findIndex(
-          (fn, i) => i > provenIndex && fn.publicKernelRequest.type !== ProvingRequestType.PUBLIC_KERNEL_INNER,
-        );
-    if (nextFunctionIndex >= this.publicFunctions.length || nextFunctionIndex === -1) {
-      // The next kernel index is greater than our set of functions, we are done!
-      return { code: TX_PROVING_CODE.COMPLETED, function: undefined };
-    }
+  public ready() {
+    return !!this.tube && (!this.requireAvmProof || !!this.avm);
+  }
 
-    // There is more work to do, are we ready?
-    const nextFunction = this.publicFunctions[nextFunctionIndex];
-
-    if (provenIsInner && nextFunction.publicKernelRequest.type !== ProvingRequestType.PUBLIC_KERNEL_INNER) {
-      // TODO(#7124): Remove this temporary hack.
-      // If the proven request is inner (with vm proof) and the next one is regular kernel, set the vmProof to be
-      // not undefined.
-      // This should eventually be a real vm proof of the entire enqueued call.
-      nextFunction.vmProof = makeEmptyProof();
-    } else {
-      // pass both the proof and verification key forward to the next circuit
-      nextFunction.publicKernelRequest.inputs.previousKernel.proof = proof;
-      nextFunction.publicKernelRequest.inputs.previousKernel.vk = verificationKey;
-
-      // We need to update this so the state machine knows this proof is ready
-      nextFunction.previousKernelProven = true;
-      nextFunction.previousProofType = kernelRequest.type;
-    }
+  public getTubeInputs() {
+    return new TubeInputs(this.processedTx.clientIvcProof);
+  }
+
+  public getAvmInputs() {
+    return this.processedTx.avmProvingRequest!.inputs;
+  }
 
-    if (nextFunction.vmProof === undefined || !nextFunction.previousKernelProven) {
-      // The VM proof for the next function is not ready
-      return { code: TX_PROVING_CODE.NOT_READY, function: undefined };
+  public getPrivateBaseInputs() {
+    if (this.requireAvmProof) {
+      throw new Error('Should create public base rollup for a tx requiring avm proof.');
     }
+    if (!this.tube) {
+      throw new Error('Tx not ready for proving base rollup.');
+    }
+
+    const vkData = this.getTubeVkData();
+    const tubeData = new PrivateTubeData(this.processedTx.data, this.tube.proof, vkData);
 
-    // The VM proof is ready, we can continue
-    return { code: TX_PROVING_CODE.READY, function: nextFunction, functionIndex: nextFunctionIndex };
+    return new PrivateBaseRollupInputs(tubeData, this.baseRollupHints);
   }
 
-  // Updates the transaction's proving state after completion of a tube proof
-  // Returns an instruction as to the next stage of tx proving
-  public getNextPublicKernelFromTubeProof(
-    proof: RecursiveProof<typeof RECURSIVE_PROOF_LENGTH>,
-    verificationKey: VerificationKeyData,
-  ): TxProvingInstruction {
-    const nextFunctionIndex = this.publicFunctions.findIndex(
-      (fn, i) => i > 0 && fn.previousProofType === ProvingRequestType.TUBE_PROOF,
-    );
-    if (nextFunctionIndex === -1) {
-      // There are no public functions to be processed, we are done!
-      return { code: TX_PROVING_CODE.COMPLETED, function: undefined };
+  public getPublicBaseInputs() {
+    if (!this.requireAvmProof) {
+      throw new Error('Should create private base rollup for a tx not requiring avm proof.');
+    }
+    if (!this.tube) {
+      throw new Error('Tx not ready for proving base rollup: tube proof undefined');
+    }
+    if (!this.avm) {
+      throw new Error('Tx not ready for proving base rollup: avm proof undefined');
     }
 
-    // There is more work to do, are we ready?
-    const nextFunction = this.publicFunctions[nextFunctionIndex];
+    // Temporary hack.
+    // Passing this.processedTx.data to the tube, which is the output of the simulated public_kernel_tail,
+    // so that the output of the public base will contain all the side effects.
+    // This should be the output of the private_kernel_tail_to_public when the output of the avm proof is the result of
+    // simulating the entire public call stack.
+    const tubeData = new PrivateTubeData(this.processedTx.data, this.tube.proof, this.getTubeVkData());
+
+    const avmProofData = new AvmProofData(
+      VMCircuitPublicInputs.empty(), // TODO
+      this.avm.proof,
+      this.getAvmVkData(),
+    );
 
-    // pass both the proof and verification key forward to the next circuit
-    nextFunction.publicKernelRequest.inputs.previousKernel.proof = proof;
-    nextFunction.publicKernelRequest.inputs.previousKernel.vk = verificationKey;
+    return new PublicBaseRollupInputs(tubeData, avmProofData, this.baseRollupHints);
+  }
 
-    // We need to update this so the state machine knows this proof is ready
-    nextFunction.previousKernelProven = true;
-    if (nextFunction.vmProof === undefined) {
-      // The VM proof for the next function is not ready
-      return { code: TX_PROVING_CODE.NOT_READY, function: undefined };
-    }
+  public assignTubeProof(tubeProofAndVk: ProofAndVerificationKey<RecursiveProof<typeof TUBE_PROOF_LENGTH>>) {
+    this.tube = tubeProofAndVk;
+  }
 
-    // The VM proof is ready, we can continue
-    return { code: TX_PROVING_CODE.READY, function: nextFunction, functionIndex: nextFunctionIndex };
+  public assignAvmProof(avmProofAndVk: ProofAndVerificationKey<RecursiveProof<typeof AVM_PROOF_LENGTH_IN_FIELDS>>) {
+    this.avm = avmProofAndVk;
   }
 
-  // Updates the transaction's proving state after completion of a VM proof
-  // Returns an instruction as to the next stage of tx proving
-  public getNextPublicKernelFromVMProof(provenIndex: number, proof: Proof): TxProvingInstruction {
-    const provenFunction = this.publicFunctions[provenIndex];
-    provenFunction.vmProof = proof;
+  public verifyStateOrReject(): string | undefined {
+    const kernelPublicInputs = this.processedTx.data;
+
+    const txNoteEncryptedLogs = EncryptedNoteTxL2Logs.hashNoteLogs(
+      kernelPublicInputs.end.noteEncryptedLogsHashes.filter(log => !log.isEmpty()).map(log => log.value.toBuffer()),
+    );
+    if (!txNoteEncryptedLogs.equals(this.processedTx.noteEncryptedLogs.hash())) {
+      return `Note encrypted logs hash mismatch: ${Fr.fromBuffer(txNoteEncryptedLogs)} === ${Fr.fromBuffer(
+        this.processedTx.noteEncryptedLogs.hash(),
+      )}`;
+    }
 
-    if (!provenFunction.previousKernelProven) {
-      // The previous kernel is not yet ready
-      return { code: TX_PROVING_CODE.NOT_READY, function: undefined };
+    const txEncryptedLogs = EncryptedTxL2Logs.hashSiloedLogs(
+      kernelPublicInputs.end.encryptedLogsHashes.filter(log => !log.isEmpty()).map(log => log.getSiloedHash()),
+    );
+    if (!txEncryptedLogs.equals(this.processedTx.encryptedLogs.hash())) {
+      // @todo This rejection messages is never seen. Never making it out to the logs
+      return `Encrypted logs hash mismatch: ${Fr.fromBuffer(txEncryptedLogs)} === ${Fr.fromBuffer(
+        this.processedTx.encryptedLogs.hash(),
+      )}`;
+    }
+
+    const txUnencryptedLogs = UnencryptedTxL2Logs.hashSiloedLogs(
+      kernelPublicInputs.end.unencryptedLogsHashes.filter(log => !log.isEmpty()).map(log => log.getSiloedHash()),
+    );
+    if (!txUnencryptedLogs.equals(this.processedTx.unencryptedLogs.hash())) {
+      return `Unencrypted logs hash mismatch: ${Fr.fromBuffer(txUnencryptedLogs)} === ${Fr.fromBuffer(
+        this.processedTx.unencryptedLogs.hash(),
+      )}`;
     }
-    // The previous kernel is ready so we can prove this kernel
-    return { code: TX_PROVING_CODE.READY, function: provenFunction, functionIndex: provenIndex };
   }
 
-  // Returns the public function state at the given index
-  // Throws if out of bounds
-  public getPublicFunctionState(functionIndex: number) {
-    if (functionIndex < 0 || functionIndex >= this.publicFunctions.length) {
-      throw new Error(`Requested public function index was out of bounds`);
+  private getTubeVkData() {
+    let vkIndex = TUBE_VK_INDEX;
+    try {
+      vkIndex = getVKIndex(this.tube!.verificationKey);
+    } catch (_ignored) {
+      // TODO(#7410) The VK for the tube won't be in the tree for now, so we manually set it to the tube vk index
     }
-    return this.publicFunctions[functionIndex];
+    const vkPath = getVKSiblingPath(vkIndex);
+
+    return new VkWitnessData(this.tube!.verificationKey, vkIndex, vkPath);
   }
 
-  // Returns the number of public kernels required by this transaction
-  public getNumPublicKernels() {
-    return this.publicFunctions.length;
+  private getAvmVkData() {
+    const vkIndex = AVM_VK_INDEX;
+    const vkPath = getVKSiblingPath(vkIndex);
+    return new VkWitnessData(this.avm!.verificationKey, AVM_VK_INDEX, vkPath);
   }
 }

package/src/prover-agent/memory-proving-queue.ts

@@ -9,10 +9,10 @@ import {
   type ServerCircuitProver,
 } from '@aztec/circuit-types';
 import type {
+  AVM_PROOF_LENGTH_IN_FIELDS,
   AvmCircuitInputs,
   BaseOrMergeRollupPublicInputs,
   BaseParityInputs,
-  BaseRollupInputs,
   BlockMergeRollupInputs,
   BlockRootOrBlockMergePublicInputs,
   BlockRootRollupInputs,
@@ -20,12 +20,9 @@ import type {
   KernelCircuitPublicInputs,
   MergeRollupInputs,
   NESTED_RECURSIVE_PROOF_LENGTH,
+  PrivateBaseRollupInputs,
   PrivateKernelEmptyInputData,
-  Proof,
-  PublicKernelCircuitPrivateInputs,
-  PublicKernelCircuitPublicInputs,
-  PublicKernelInnerCircuitPrivateInputs,
-  PublicKernelTailCircuitPrivateInputs,
+  PublicBaseRollupInputs,
   RECURSIVE_PROOF_LENGTH,
   RecursiveProof,
   RootParityInput,
@@ -33,7 +30,6 @@ import type {
   RootRollupInputs,
   RootRollupPublicInputs,
   TubeInputs,
-  VMCircuitPublicInputs,
 } from '@aztec/circuits.js';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { AbortError, TimeoutError } from '@aztec/foundation/error';
@@ -316,16 +312,20 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     return this.enqueue({ type: ProvingRequestType.ROOT_PARITY, inputs }, signal, epochNumber);
   }
 
-  /**
-   * Creates a proof for the given input.
-   * @param input - Input to the circuit.
-   */
-  getBaseRollupProof(
-    baseRollupInput: BaseRollupInputs,
+  getPrivateBaseRollupProof(
+    inputs: PrivateBaseRollupInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
+    return this.enqueue({ type: ProvingRequestType.PRIVATE_BASE_ROLLUP, inputs }, signal, epochNumber);
+  }
+
+  getPublicBaseRollupProof(
+    inputs: PublicBaseRollupInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
-    return this.enqueue({ type: ProvingRequestType.BASE_ROLLUP, inputs: baseRollupInput }, signal, epochNumber);
+    return this.enqueue({ type: ProvingRequestType.PUBLIC_BASE_ROLLUP, inputs }, signal, epochNumber);
   }
 
   /**
@@ -384,42 +384,6 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     return this.enqueue({ type: ProvingRequestType.ROOT_ROLLUP, inputs: input }, signal, epochNumber);
   }
 
-  /**
-   * Create a public kernel inner proof.
-   * @param kernelRequest - Object containing the details of the proof required
-   */
-  getPublicKernelInnerProof(
-    inputs: PublicKernelInnerCircuitPrivateInputs,
-    signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<VMCircuitPublicInputs>> {
-    return this.enqueue({ type: ProvingRequestType.PUBLIC_KERNEL_INNER, inputs }, signal, epochNumber);
-  }
-
-  /**
-   * Create a public kernel merge proof.
-   * @param kernelRequest - Object containing the details of the proof required
-   */
-  getPublicKernelMergeProof(
-    inputs: PublicKernelCircuitPrivateInputs,
-    signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<PublicKernelCircuitPublicInputs>> {
-    return this.enqueue({ type: ProvingRequestType.PUBLIC_KERNEL_MERGE, inputs }, signal, epochNumber);
-  }
-
-  /**
-   * Create a public kernel tail proof.
-   * @param kernelRequest - Object containing the details of the proof required
-   */
-  getPublicTailProof(
-    inputs: PublicKernelTailCircuitPrivateInputs,
-    signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
-    return this.enqueue({ type: ProvingRequestType.PUBLIC_KERNEL_TAIL, inputs }, signal, epochNumber);
-  }
-
   /**
    * Creates an AVM proof.
    */
@@ -427,7 +391,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     inputs: AvmCircuitInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<ProofAndVerificationKey<Proof>> {
+  ): Promise<ProofAndVerificationKey<RecursiveProof<typeof AVM_PROOF_LENGTH_IN_FIELDS>>> {
     return this.enqueue({ type: ProvingRequestType.PUBLIC_VM, inputs }, signal, epochNumber);
   }
 

package/src/prover-agent/prover-agent.ts

@@ -161,20 +161,12 @@ export class ProverAgent {
         return this.circuitProver.getAvmProof(inputs);
       }
 
-      case ProvingRequestType.PUBLIC_KERNEL_INNER: {
-        return this.circuitProver.getPublicKernelInnerProof(inputs);
+      case ProvingRequestType.PRIVATE_BASE_ROLLUP: {
+        return this.circuitProver.getPrivateBaseRollupProof(inputs);
       }
 
-      case ProvingRequestType.PUBLIC_KERNEL_MERGE: {
-        return this.circuitProver.getPublicKernelMergeProof(inputs);
-      }
-
-      case ProvingRequestType.PUBLIC_KERNEL_TAIL: {
-        return this.circuitProver.getPublicTailProof(inputs);
-      }
-
-      case ProvingRequestType.BASE_ROLLUP: {
-        return this.circuitProver.getBaseRollupProof(inputs);
+      case ProvingRequestType.PUBLIC_BASE_ROLLUP: {
+        return this.circuitProver.getPublicBaseRollupProof(inputs);
       }
 
       case ProvingRequestType.MERGE_ROLLUP: {

package/src/prover-agent/rpc.ts

@@ -4,7 +4,6 @@ import {
   AztecAddress,
   BaseOrMergeRollupPublicInputs,
   BaseParityInputs,
-  BaseRollupInputs,
   BlockMergeRollupInputs,
   BlockRootOrBlockMergePublicInputs,
   BlockRootRollupInputs,
@@ -15,12 +14,11 @@ import {
   KernelCircuitPublicInputs,
   MergeRollupInputs,
   ParityPublicInputs,
+  PrivateBaseRollupInputs,
   PrivateKernelEmptyInputData,
   Proof,
-  PublicKernelCircuitPrivateInputs,
+  PublicBaseRollupInputs,
   PublicKernelCircuitPublicInputs,
-  PublicKernelInnerCircuitPrivateInputs,
-  PublicKernelTailCircuitPrivateInputs,
   RecursiveProof,
   RootParityInput,
   RootParityInputs,
@@ -43,7 +41,8 @@ export function createProvingJobSourceServer(queue: ProvingJobSource): JsonRpcSe
       AvmCircuitInputs,
       BaseOrMergeRollupPublicInputs,
       BaseParityInputs,
-      BaseRollupInputs,
+      PrivateBaseRollupInputs,
+      PublicBaseRollupInputs,
       Fr,
       Header,
       KernelCircuitPublicInputs,
@@ -53,10 +52,7 @@ export function createProvingJobSourceServer(queue: ProvingJobSource): JsonRpcSe
       ProvingError,
       PrivateKernelEmptyInputData,
       VMCircuitPublicInputs,
-      PublicKernelInnerCircuitPrivateInputs,
-      PublicKernelCircuitPrivateInputs,
       PublicKernelCircuitPublicInputs,
-      PublicKernelTailCircuitPrivateInputs,
       RecursiveProof,
       RootParityInput,
       RootParityInputs,
@@ -84,7 +80,8 @@ export function createProvingJobSourceClient(
       AvmCircuitInputs,
       BaseOrMergeRollupPublicInputs,
       BaseParityInputs,
-      BaseRollupInputs,
+      PrivateBaseRollupInputs,
+      PublicBaseRollupInputs,
       Fr,
       Header,
       KernelCircuitPublicInputs,
@@ -94,10 +91,7 @@ export function createProvingJobSourceClient(
       ProvingError,
       PrivateKernelEmptyInputData,
       VMCircuitPublicInputs,
-      PublicKernelInnerCircuitPrivateInputs,
-      PublicKernelCircuitPrivateInputs,
       PublicKernelCircuitPublicInputs,
-      PublicKernelTailCircuitPrivateInputs,
       RecursiveProof,
       RootParityInput,
       RootParityInputs,

package/src/test/mock_prover.ts

@@ -6,28 +6,25 @@ import {
   makePublicInputsAndRecursiveProof,
 } from '@aztec/circuit-types';
 import {
+  AVM_PROOF_LENGTH_IN_FIELDS,
   AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS,
   type BaseOrMergeRollupPublicInputs,
   type BlockRootOrBlockMergePublicInputs,
   type KernelCircuitPublicInputs,
-  type PublicKernelCircuitPublicInputs,
   RECURSIVE_PROOF_LENGTH,
   type RecursiveProof,
   type RootRollupPublicInputs,
   TUBE_PROOF_LENGTH,
-  type VMCircuitPublicInputs,
   VerificationKeyData,
-  makeEmptyProof,
+  makeEmptyRecursiveProof,
   makeRecursiveProof,
 } from '@aztec/circuits.js';
 import {
   makeBaseOrMergeRollupPublicInputs,
   makeBlockRootOrBlockMergeRollupPublicInputs,
   makeKernelCircuitPublicInputs,
-  makePublicKernelCircuitPublicInputs,
   makeRootParityInput,
   makeRootRollupPublicInputs,
-  makeVMCircuitPublicInputs,
 } from '@aztec/circuits.js/testing';
 
 export class MockProver implements ServerCircuitProver {
@@ -36,7 +33,7 @@ export class MockProver implements ServerCircuitProver {
   getAvmProof() {
     return Promise.resolve(
       makeProofAndVerificationKey(
-        makeEmptyProof(),
+        makeEmptyRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS),
         VerificationKeyData.makeFake(AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS),
       ),
     );
@@ -50,7 +47,7 @@ export class MockProver implements ServerCircuitProver {
     return Promise.resolve(makeRootParityInput(RECURSIVE_PROOF_LENGTH));
   }
 
-  getBaseRollupProof() {
+  getPrivateBaseRollupProof(): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeBaseOrMergeRollupPublicInputs(),
@@ -60,7 +57,7 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getMergeRollupProof(): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
+  getPublicBaseRollupProof(): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeBaseOrMergeRollupPublicInputs(),
@@ -70,17 +67,17 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getBlockMergeRollupProof() {
+  getMergeRollupProof(): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeBaseOrMergeRollupPublicInputs(),
         makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
         VerificationKeyData.makeFakeHonk(),
       ),
     );
   }
 
-  getEmptyBlockRootRollupProof(): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
+  getBlockMergeRollupProof() {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeBlockRootOrBlockMergeRollupPublicInputs(),
@@ -90,7 +87,7 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getBlockRootRollupProof(): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
+  getEmptyBlockRootRollupProof(): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeBlockRootOrBlockMergeRollupPublicInputs(),
@@ -100,17 +97,17 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getEmptyPrivateKernelProof(): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
+  getBlockRootRollupProof(): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeKernelCircuitPublicInputs(),
+        makeBlockRootOrBlockMergeRollupPublicInputs(),
         makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
         VerificationKeyData.makeFakeHonk(),
       ),
     );
   }
 
-  getEmptyTubeProof(): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
+  getEmptyPrivateKernelProof(): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeKernelCircuitPublicInputs(),
@@ -120,27 +117,7 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getPublicKernelInnerProof(): Promise<PublicInputsAndRecursiveProof<VMCircuitPublicInputs>> {
-    return Promise.resolve(
-      makePublicInputsAndRecursiveProof(
-        makeVMCircuitPublicInputs(),
-        makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
-        VerificationKeyData.makeFakeHonk(),
-      ),
-    );
-  }
-
-  getPublicKernelMergeProof(): Promise<PublicInputsAndRecursiveProof<PublicKernelCircuitPublicInputs>> {
-    return Promise.resolve(
-      makePublicInputsAndRecursiveProof(
-        makePublicKernelCircuitPublicInputs(),
-        makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
-        VerificationKeyData.makeFakeHonk(),
-      ),
-    );
-  }
-
-  getPublicTailProof(): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
+  getEmptyTubeProof(): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeKernelCircuitPublicInputs(),