@aztec/prover-client 0.0.1-fake-c83136db25 → 0.0.1-fake-ceab37513c

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

@@ -1,50 +1,42 @@
 import {
   AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
   AVM_VK_INDEX,
-  NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+  PRIVATE_TUBE_VK_INDEX,
+  PUBLIC_TUBE_VK_INDEX,
+  type TUBE_PROOF_LENGTH,
 } from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/fields';
-import { getVkData } from '@aztec/noir-protocol-circuits-types/server/vks';
 import { getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
-import type { ProofAndVerificationKey, PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
-import { ProofData } from '@aztec/stdlib/proofs';
+import type { ProofAndVerificationKey } from '@aztec/stdlib/interfaces/server';
 import {
+  AvmProofData,
   type BaseRollupHints,
   PrivateBaseRollupHints,
-  PrivateTxBaseRollupPrivateInputs,
+  PrivateBaseRollupInputs,
+  PrivateTubeData,
   PublicBaseRollupHints,
-  PublicChonkVerifierPublicInputs,
-  PublicTxBaseRollupPrivateInputs,
+  PublicBaseRollupInputs,
+  PublicTubeData,
+  TubeInputs,
 } from '@aztec/stdlib/rollup';
 import type { CircuitName } from '@aztec/stdlib/stats';
 import type { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
 import type { ProcessedTx } from '@aztec/stdlib/tx';
 import { VerificationKeyData, VkData } from '@aztec/stdlib/vks';
 
-import {
-  getChonkProofFromTx,
-  getPublicChonkVerifierPrivateInputsFromTx,
-  toProofData,
-} from './block-building-helpers.js';
-
 /**
  * Helper class to manage the proving cycle of a transaction
  * This includes the public VMs and the public kernels
  * Also stores the inputs to the base rollup for this transaction and the tree snapshots
  */
 export class TxProvingState {
-  private publicChonkVerifier?: PublicInputsAndRecursiveProof<
-    PublicChonkVerifierPublicInputs,
-    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
-  >;
+  private tube?: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>;
   private avm?: ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;
 
   constructor(
     public readonly processedTx: ProcessedTx,
     private readonly baseRollupHints: BaseRollupHints,
     public readonly treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>,
-    private readonly proverId: Fr,
   ) {}
 
   get requireAvmProof() {
@@ -52,38 +44,33 @@ export class TxProvingState {
   }
 
   public ready() {
-    return !this.requireAvmProof || (!!this.avm && !!this.publicChonkVerifier);
+    return !!this.tube && (!this.requireAvmProof || !!this.avm);
   }
 
-  public getAvmInputs(): AvmCircuitInputs {
-    return this.processedTx.avmProvingRequest!.inputs;
+  public getTubeInputs() {
+    return new TubeInputs(!!this.processedTx.data.forPublic, this.processedTx.clientIvcProof);
   }
 
-  public getPublicChonkVerifierPrivateInputs() {
-    return getPublicChonkVerifierPrivateInputsFromTx(this.processedTx, this.proverId);
+  public getAvmInputs(): AvmCircuitInputs {
+    return this.processedTx.avmProvingRequest!.inputs;
   }
 
   public getBaseRollupTypeAndInputs() {
     if (this.requireAvmProof) {
       return {
-        rollupType: 'rollup-tx-base-public' satisfies CircuitName,
+        rollupType: 'public-base-rollup' satisfies CircuitName,
         inputs: this.#getPublicBaseInputs(),
       };
     } else {
       return {
-        rollupType: 'rollup-tx-base-private' satisfies CircuitName,
+        rollupType: 'private-base-rollup' satisfies CircuitName,
         inputs: this.#getPrivateBaseInputs(),
       };
     }
   }
 
-  public setPublicChonkVerifierProof(
-    publicChonkVerifierProofAndVk: PublicInputsAndRecursiveProof<
-      PublicChonkVerifierPublicInputs,
-      typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
-    >,
-  ) {
-    this.publicChonkVerifier = publicChonkVerifierProofAndVk;
+  public setTubeProof(tubeProofAndVk: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>) {
+    this.tube = tubeProofAndVk;
   }
 
   public setAvmProof(avmProofAndVk: ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>) {
@@ -91,47 +78,54 @@ export class TxProvingState {
   }
 
   #getPrivateBaseInputs() {
-    if (!(this.baseRollupHints instanceof PrivateBaseRollupHints)) {
-      throw new Error('Mismatched base rollup hints, expected private base rollup hints');
+    if (!this.tube) {
+      throw new Error('Tx not ready for proving base rollup.');
     }
 
-    const privateTailProofData = new ProofData(
+    const vkData = this.#getVkData(this.tube!.verificationKey, PRIVATE_TUBE_VK_INDEX);
+    const tubeData = new PrivateTubeData(
       this.processedTx.data.toPrivateToRollupKernelCircuitPublicInputs(),
-      getChonkProofFromTx(this.processedTx),
-      getVkData('HidingKernelToRollup'),
+      this.tube.proof,
+      vkData,
     );
 
-    return new PrivateTxBaseRollupPrivateInputs(privateTailProofData, this.baseRollupHints);
+    if (!(this.baseRollupHints instanceof PrivateBaseRollupHints)) {
+      throw new Error('Mismatched base rollup hints, expected private base rollup hints');
+    }
+    return new PrivateBaseRollupInputs(tubeData, this.baseRollupHints);
   }
 
   #getPublicBaseInputs() {
     if (!this.processedTx.avmProvingRequest) {
       throw new Error('Should create private base rollup for a tx not requiring avm proof.');
     }
-    if (!this.publicChonkVerifier) {
-      throw new Error('Tx not ready for proving base rollup: public chonk verifier proof undefined');
+    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');
     }
-    if (!(this.baseRollupHints instanceof PublicBaseRollupHints)) {
-      throw new Error('Mismatched base rollup hints, expected public base rollup hints');
-    }
 
-    const publicChonkVerifierProofData = toProofData(this.publicChonkVerifier);
+    const tubeData = new PublicTubeData(
+      this.processedTx.data.toPrivateToPublicKernelCircuitPublicInputs(),
+      this.tube.proof,
+      this.#getVkData(this.tube!.verificationKey, PUBLIC_TUBE_VK_INDEX),
+    );
 
-    const avmProofData = new ProofData(
+    const avmProofData = new AvmProofData(
       this.processedTx.avmProvingRequest.inputs.publicInputs,
       this.avm.proof,
       this.#getVkData(this.avm!.verificationKey, AVM_VK_INDEX),
     );
 
-    return new PublicTxBaseRollupPrivateInputs(publicChonkVerifierProofData, avmProofData, this.baseRollupHints);
+    if (!(this.baseRollupHints instanceof PublicBaseRollupHints)) {
+      throw new Error('Mismatched base rollup hints, expected public base rollup hints');
+    }
+
+    return new PublicBaseRollupInputs(tubeData, avmProofData, this.baseRollupHints);
   }
 
   #getVkData(verificationKey: VerificationKeyData, vkIndex: number) {
-    // TODO(#17162): Add avm vk hash to the tree and call `getVkData('AVM')` instead.
-    // Below will return a path to an empty leaf.
     const vkPath = getVKSiblingPath(vkIndex);
     return new VkData(verificationKey, vkIndex, vkPath);
   }

package/src/prover-client/server-epoch-prover.ts

@@ -1,11 +1,10 @@
 import type { BatchedBlob, FinalBlobBatchingChallenges } from '@aztec/blob-lib';
 import type { Fr } from '@aztec/foundation/fields';
-import type { EthAddress } from '@aztec/stdlib/block';
+import type { EthAddress, L2Block } from '@aztec/stdlib/block';
 import type { EpochProver } from '@aztec/stdlib/interfaces/server';
 import type { Proof } from '@aztec/stdlib/proofs';
-import type { CheckpointConstantData, RootRollupPublicInputs } from '@aztec/stdlib/rollup';
-import type { BlockHeader, ProcessedTx, Tx } from '@aztec/stdlib/tx';
-import type { UInt64 } from '@aztec/stdlib/types';
+import type { RootRollupPublicInputs } from '@aztec/stdlib/rollup';
+import type { BlockHeader, GlobalVariables, ProcessedTx, Tx } from '@aztec/stdlib/tx';
 
 import type { ProvingOrchestrator } from '../orchestrator/orchestrator.js';
 import type { BrokerCircuitProverFacade } from '../proving_broker/broker_prover_facade.js';
@@ -19,33 +18,17 @@ export class ServerEpochProver implements EpochProver {
 
   startNewEpoch(
     epochNumber: number,
-    totalNumCheckpoints: number,
+    firstBlockNumber: number,
+    totalNumBlocks: number,
     finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
   ): void {
-    this.orchestrator.startNewEpoch(epochNumber, totalNumCheckpoints, finalBlobBatchingChallenges);
+    this.orchestrator.startNewEpoch(epochNumber, firstBlockNumber, totalNumBlocks, finalBlobBatchingChallenges);
     this.facade.start();
   }
-  startNewCheckpoint(
-    checkpointIndex: number,
-    constants: CheckpointConstantData,
-    l1ToL2Messages: Fr[],
-    totalNumBlocks: number,
-    totalNumBlobFields: number,
-    headerOfLastBlockInPreviousCheckpoint: BlockHeader,
-  ): Promise<void> {
-    return this.orchestrator.startNewCheckpoint(
-      checkpointIndex,
-      constants,
-      l1ToL2Messages,
-      totalNumBlocks,
-      totalNumBlobFields,
-      headerOfLastBlockInPreviousCheckpoint,
-    );
-  }
-  startChonkVerifierCircuits(txs: Tx[]): Promise<void> {
-    return this.orchestrator.startChonkVerifierCircuits(txs);
+  startTubeCircuits(txs: Tx[]): Promise<void> {
+    return this.orchestrator.startTubeCircuits(txs);
   }
-  setBlockCompleted(blockNumber: number, expectedBlockHeader?: BlockHeader): Promise<BlockHeader> {
+  setBlockCompleted(blockNumber: number, expectedBlockHeader?: BlockHeader): Promise<L2Block> {
     return this.orchestrator.setBlockCompleted(blockNumber, expectedBlockHeader);
   }
   finalizeEpoch(): Promise<{ publicInputs: RootRollupPublicInputs; proof: Proof; batchedBlobInputs: BatchedBlob }> {
@@ -57,12 +40,19 @@ export class ServerEpochProver implements EpochProver {
   getProverId(): EthAddress {
     return this.orchestrator.getProverId();
   }
+  getBlock(index: number): L2Block {
+    return this.orchestrator.getBlock(index);
+  }
   async stop(): Promise<void> {
     await this.facade.stop();
     await this.orchestrator.stop();
   }
-  startNewBlock(blockNumber: number, timestamp: UInt64, totalNumTxs: number): Promise<void> {
-    return this.orchestrator.startNewBlock(blockNumber, timestamp, totalNumTxs);
+  startNewBlock(
+    globalVariables: GlobalVariables,
+    l1ToL2Messages: Fr[],
+    previousBlockHeader: BlockHeader,
+  ): Promise<void> {
+    return this.orchestrator.startNewBlock(globalVariables, l1ToL2Messages, previousBlockHeader);
   }
   addTxs(txs: ProcessedTx[]): Promise<void> {
     return this.orchestrator.addTxs(txs);

package/src/proving_broker/broker_prover_facade.ts

@@ -3,6 +3,7 @@ import type {
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
+  TUBE_PROOF_LENGTH,
 } from '@aztec/constants';
 import { sha256 } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
@@ -22,29 +23,22 @@ import {
   type ServerCircuitProver,
   makeProvingJobId,
 } from '@aztec/stdlib/interfaces/server';
-import type { ParityBasePrivateInputs, ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity';
+import type { BaseParityInputs, ParityPublicInputs, RootParityInputs } from '@aztec/stdlib/parity';
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
 import type {
-  BlockMergeRollupPrivateInputs,
-  BlockRollupPublicInputs,
-  BlockRootEmptyTxFirstRollupPrivateInputs,
-  BlockRootFirstRollupPrivateInputs,
-  BlockRootRollupPrivateInputs,
-  BlockRootSingleTxFirstRollupPrivateInputs,
-  BlockRootSingleTxRollupPrivateInputs,
-  CheckpointMergeRollupPrivateInputs,
-  CheckpointPaddingRollupPrivateInputs,
-  CheckpointRollupPublicInputs,
-  CheckpointRootRollupPrivateInputs,
-  CheckpointRootSingleBlockRollupPrivateInputs,
-  PrivateTxBaseRollupPrivateInputs,
-  PublicChonkVerifierPrivateInputs,
-  PublicChonkVerifierPublicInputs,
-  PublicTxBaseRollupPrivateInputs,
-  RootRollupPrivateInputs,
+  BaseOrMergeRollupPublicInputs,
+  BlockMergeRollupInputs,
+  BlockRootOrBlockMergePublicInputs,
+  BlockRootRollupInputs,
+  EmptyBlockRootRollupInputs,
+  MergeRollupInputs,
+  PaddingBlockRootRollupInputs,
+  PrivateBaseRollupInputs,
+  PublicBaseRollupInputs,
+  RootRollupInputs,
   RootRollupPublicInputs,
-  TxMergeRollupPrivateInputs,
-  TxRollupPublicInputs,
+  SingleTxBlockRootRollupInputs,
+  TubeInputs,
 } from '@aztec/stdlib/rollup';
 
 import { InlineProofStore, type ProofStore } from './proof_store/index.js';
@@ -418,248 +412,183 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
   }
 
   getBaseParityProof(
-    inputs: ParityBasePrivateInputs,
+    inputs: BaseParityInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>> {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.PARITY_BASE, inputs, epochNumber),
-      ProvingRequestType.PARITY_BASE,
+      this.generateId(ProvingRequestType.BASE_PARITY, inputs, epochNumber),
+      ProvingRequestType.BASE_PARITY,
       inputs,
       epochNumber,
       signal,
     );
   }
 
-  getTxMergeRollupProof(
-    input: TxMergeRollupPrivateInputs,
-    signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
-    return this.enqueueJob(
-      this.generateId(ProvingRequestType.TX_MERGE_ROLLUP, input, epochNumber),
-      ProvingRequestType.TX_MERGE_ROLLUP,
-      input,
-      epochNumber,
-      signal,
-    );
-  }
-
-  getPublicChonkVerifierProof(
-    inputs: PublicChonkVerifierPrivateInputs,
+  getBlockMergeRollupProof(
+    input: BlockMergeRollupInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.PUBLIC_CHONK_VERIFIER, inputs, epochNumber),
-      ProvingRequestType.PUBLIC_CHONK_VERIFIER,
-      inputs,
-      epochNumber,
-      signal,
-    );
-  }
-
-  getPrivateTxBaseRollupProof(
-    baseRollupInput: PrivateTxBaseRollupPrivateInputs,
-    signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
-    return this.enqueueJob(
-      this.generateId(ProvingRequestType.PRIVATE_TX_BASE_ROLLUP, baseRollupInput, epochNumber),
-      ProvingRequestType.PRIVATE_TX_BASE_ROLLUP,
-      baseRollupInput,
-      epochNumber,
-      signal,
-    );
-  }
-
-  getPublicTxBaseRollupProof(
-    inputs: PublicTxBaseRollupPrivateInputs,
-    signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
-    return this.enqueueJob(
-      this.generateId(ProvingRequestType.PUBLIC_TX_BASE_ROLLUP, inputs, epochNumber),
-      ProvingRequestType.PUBLIC_TX_BASE_ROLLUP,
-      inputs,
-      epochNumber,
-      signal,
-    );
-  }
-
-  getRootParityProof(
-    inputs: ParityRootPrivateInputs,
-    signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>> {
-    return this.enqueueJob(
-      this.generateId(ProvingRequestType.PARITY_ROOT, inputs, epochNumber),
-      ProvingRequestType.PARITY_ROOT,
-      inputs,
-      epochNumber,
-      signal,
-    );
-  }
-
-  getBlockRootFirstRollupProof(
-    input: BlockRootFirstRollupPrivateInputs,
-    signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
-    return this.enqueueJob(
-      this.generateId(ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP, input, epochNumber),
-      ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP,
+      this.generateId(ProvingRequestType.BLOCK_MERGE_ROLLUP, input, epochNumber),
+      ProvingRequestType.BLOCK_MERGE_ROLLUP,
       input,
       epochNumber,
       signal,
     );
   }
 
-  getBlockRootSingleTxFirstRollupProof(
-    input: BlockRootSingleTxFirstRollupPrivateInputs,
+  getBlockRootRollupProof(
+    input: BlockRootRollupInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+  ): Promise<
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP, input, epochNumber),
-      ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP,
+      this.generateId(ProvingRequestType.BLOCK_ROOT_ROLLUP, input, epochNumber),
+      ProvingRequestType.BLOCK_ROOT_ROLLUP,
       input,
       epochNumber,
       signal,
     );
   }
 
-  getBlockRootEmptyTxFirstRollupProof(
-    input: BlockRootEmptyTxFirstRollupPrivateInputs,
+  getSingleTxBlockRootRollupProof(
+    input: SingleTxBlockRootRollupInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+  ): Promise<
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP, input, epochNumber),
-      ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP,
+      this.generateId(ProvingRequestType.BLOCK_ROOT_ROLLUP, input, epochNumber),
+      ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP,
       input,
       epochNumber,
       signal,
     );
   }
 
-  getBlockRootRollupProof(
-    input: BlockRootRollupPrivateInputs,
+  getEmptyBlockRootRollupProof(
+    input: EmptyBlockRootRollupInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+  ): Promise<
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.BLOCK_ROOT_ROLLUP, input, epochNumber),
-      ProvingRequestType.BLOCK_ROOT_ROLLUP,
+      this.generateId(ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP, input, epochNumber),
+      ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP,
       input,
       epochNumber,
       signal,
     );
   }
 
-  getBlockRootSingleTxRollupProof(
-    input: BlockRootSingleTxRollupPrivateInputs,
+  getPaddingBlockRootRollupProof(
+    input: PaddingBlockRootRollupInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+  ): Promise<
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP, input, epochNumber),
-      ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP,
+      this.generateId(ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP, input, epochNumber),
+      ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP,
       input,
       epochNumber,
       signal,
     );
   }
 
-  getBlockMergeRollupProof(
-    input: BlockMergeRollupPrivateInputs,
+  getMergeRollupProof(
+    input: MergeRollupInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+  ): Promise<
+    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.BLOCK_MERGE_ROLLUP, input, epochNumber),
-      ProvingRequestType.BLOCK_MERGE_ROLLUP,
+      this.generateId(ProvingRequestType.MERGE_ROLLUP, input, epochNumber),
+      ProvingRequestType.MERGE_ROLLUP,
       input,
       epochNumber,
       signal,
     );
   }
-
-  getCheckpointRootRollupProof(
-    input: CheckpointRootRollupPrivateInputs,
+  getPrivateBaseRollupProof(
+    baseRollupInput: PrivateBaseRollupInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.CHECKPOINT_ROOT_ROLLUP, input, epochNumber),
-      ProvingRequestType.CHECKPOINT_ROOT_ROLLUP,
-      input,
+      this.generateId(ProvingRequestType.PRIVATE_BASE_ROLLUP, baseRollupInput, epochNumber),
+      ProvingRequestType.PRIVATE_BASE_ROLLUP,
+      baseRollupInput,
       epochNumber,
       signal,
     );
   }
 
-  getCheckpointRootSingleBlockRollupProof(
-    input: CheckpointRootSingleBlockRollupPrivateInputs,
+  getPublicBaseRollupProof(
+    inputs: PublicBaseRollupInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP, input, epochNumber),
-      ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP,
-      input,
+      this.generateId(ProvingRequestType.PUBLIC_BASE_ROLLUP, inputs, epochNumber),
+      ProvingRequestType.PUBLIC_BASE_ROLLUP,
+      inputs,
       epochNumber,
       signal,
     );
   }
 
-  getCheckpointPaddingRollupProof(
-    input: CheckpointPaddingRollupPrivateInputs,
+  getRootParityProof(
+    inputs: RootParityInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  > {
+  ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>> {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.CHECKPOINT_PADDING_ROLLUP, input, epochNumber),
-      ProvingRequestType.CHECKPOINT_PADDING_ROLLUP,
-      input,
+      this.generateId(ProvingRequestType.ROOT_PARITY, inputs, epochNumber),
+      ProvingRequestType.ROOT_PARITY,
+      inputs,
       epochNumber,
       signal,
     );
   }
 
-  getCheckpointMergeRollupProof(
-    input: CheckpointMergeRollupPrivateInputs,
+  getRootRollupProof(
+    input: RootRollupInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  > {
+  ): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs, typeof RECURSIVE_PROOF_LENGTH>> {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.CHECKPOINT_MERGE_ROLLUP, input, epochNumber),
-      ProvingRequestType.CHECKPOINT_MERGE_ROLLUP,
+      this.generateId(ProvingRequestType.ROOT_ROLLUP, input, epochNumber),
+      ProvingRequestType.ROOT_ROLLUP,
       input,
       epochNumber,
       signal,
     );
   }
 
-  getRootRollupProof(
-    input: RootRollupPrivateInputs,
+  getTubeProof(
+    tubeInput: TubeInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs, typeof RECURSIVE_PROOF_LENGTH>> {
+  ): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>> {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.ROOT_ROLLUP, input, epochNumber),
-      ProvingRequestType.ROOT_ROLLUP,
-      input,
+      this.generateId(ProvingRequestType.TUBE_PROOF, tubeInput, epochNumber),
+      ProvingRequestType.TUBE_PROOF,
+      tubeInput,
       epochNumber,
       signal,
     );

package/src/proving_broker/fixtures.ts

@@ -3,7 +3,7 @@ import { type ProofUri, type ProvingJobId, makeProvingJobId } from '@aztec/stdli
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
 
 export function makeRandomProvingJobId(epochNumber?: number): ProvingJobId {
-  return makeProvingJobId(epochNumber ?? 1, ProvingRequestType.PARITY_BASE, randomBytes(8).toString('hex'));
+  return makeProvingJobId(epochNumber ?? 1, ProvingRequestType.BASE_PARITY, randomBytes(8).toString('hex'));
 }
 
 export function makeInputsUri(): ProofUri {

package/src/proving_broker/proof_store/index.ts

@@ -1,4 +1,3 @@
 export * from './proof_store.js';
 export * from './inline_proof_store.js';
 export * from './factory.js';
-export * from './gcs_proof_store.js';