@aztec/prover-client 3.0.0-nightly.20250908 → 3.0.0-nightly.20250911

package/dest/test/mock_prover.js

@@ -1,8 +1,8 @@
-import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH, TUBE_PROOF_LENGTH } from '@aztec/constants';
+import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, AVM_V2_VERIFICATION_KEY_LENGTH_IN_FIELDS_PADDED, NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH } from '@aztec/constants';
 import { times } from '@aztec/foundation/collection';
 import { makeProofAndVerificationKey, makePublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
 import { makeEmptyRecursiveProof, makeRecursiveProof } from '@aztec/stdlib/proofs';
-import { makeBaseOrMergeRollupPublicInputs, makeBlockRootOrBlockMergeRollupPublicInputs, makeParityPublicInputs, makeRootRollupPublicInputs } from '@aztec/stdlib/testing';
+import { makeBaseOrMergeRollupPublicInputs, makeBlockRootOrBlockMergeRollupPublicInputs, makeParityPublicInputs, makePrivateToPublicKernelCircuitPublicInputs, makeRootRollupPublicInputs } from '@aztec/stdlib/testing';
 import { VerificationKeyData } from '@aztec/stdlib/vks';
 import { InlineProofStore } from '../proving_broker/proof_store/index.js';
 import { ProvingAgent } from '../proving_broker/proving_agent.js';
@@ -52,6 +52,9 @@ export class MockProver {
     getRootParityProof(_inputs, _signal, _epochNumber) {
         return Promise.resolve(makePublicInputsAndRecursiveProof(makeParityPublicInputs(), makeRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH), VerificationKeyData.makeFakeHonk()));
     }
+    getPublicTubeProof(_inputs, _signal, _epochNumber) {
+        return Promise.resolve(makePublicInputsAndRecursiveProof(makePrivateToPublicKernelCircuitPublicInputs(), makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()));
+    }
     getPrivateBaseRollupProof(_baseRollupInput, _signal, _epochNumber) {
         return Promise.resolve(makePublicInputsAndRecursiveProof(makeBaseOrMergeRollupPublicInputs(), makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()));
     }
@@ -79,7 +82,4 @@ export class MockProver {
     getRootRollupProof(_input, _signal, _epochNumber) {
         return Promise.resolve(makePublicInputsAndRecursiveProof(makeRootRollupPublicInputs(), makeRecursiveProof(RECURSIVE_PROOF_LENGTH), VerificationKeyData.makeFakeHonk()));
     }
-    getTubeProof() {
-        return Promise.resolve(makeProofAndVerificationKey(makeRecursiveProof(TUBE_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()));
-    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/prover-client",
-  "version": "3.0.0-nightly.20250908",
+  "version": "3.0.0-nightly.20250911",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -68,19 +68,19 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb-prover": "3.0.0-nightly.20250908",
-    "@aztec/blob-lib": "3.0.0-nightly.20250908",
-    "@aztec/constants": "3.0.0-nightly.20250908",
-    "@aztec/ethereum": "3.0.0-nightly.20250908",
-    "@aztec/foundation": "3.0.0-nightly.20250908",
-    "@aztec/kv-store": "3.0.0-nightly.20250908",
-    "@aztec/noir-protocol-circuits-types": "3.0.0-nightly.20250908",
-    "@aztec/noir-types": "3.0.0-nightly.20250908",
-    "@aztec/protocol-contracts": "3.0.0-nightly.20250908",
-    "@aztec/simulator": "3.0.0-nightly.20250908",
-    "@aztec/stdlib": "3.0.0-nightly.20250908",
-    "@aztec/telemetry-client": "3.0.0-nightly.20250908",
-    "@aztec/world-state": "3.0.0-nightly.20250908",
+    "@aztec/bb-prover": "3.0.0-nightly.20250911",
+    "@aztec/blob-lib": "3.0.0-nightly.20250911",
+    "@aztec/constants": "3.0.0-nightly.20250911",
+    "@aztec/ethereum": "3.0.0-nightly.20250911",
+    "@aztec/foundation": "3.0.0-nightly.20250911",
+    "@aztec/kv-store": "3.0.0-nightly.20250911",
+    "@aztec/noir-protocol-circuits-types": "3.0.0-nightly.20250911",
+    "@aztec/noir-types": "3.0.0-nightly.20250911",
+    "@aztec/protocol-contracts": "3.0.0-nightly.20250911",
+    "@aztec/simulator": "3.0.0-nightly.20250911",
+    "@aztec/stdlib": "3.0.0-nightly.20250911",
+    "@aztec/telemetry-client": "3.0.0-nightly.20250911",
+    "@aztec/world-state": "3.0.0-nightly.20250911",
     "@google-cloud/storage": "^7.15.0",
     "@iarna/toml": "^2.2.5",
     "commander": "^12.1.0",
@@ -90,7 +90,7 @@
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@aztec/noir-contracts.js": "3.0.0-nightly.20250908",
+    "@aztec/noir-contracts.js": "3.0.0-nightly.20250911",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",

package/src/orchestrator/block-building-helpers.ts

@@ -1,6 +1,7 @@
 import { BatchedBlobAccumulator, Blob, type SpongeBlob } from '@aztec/blob-lib';
 import {
   ARCHIVE_HEIGHT,
+  CIVC_PROOF_LENGTH,
   MAX_CONTRACT_CLASS_LOGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
@@ -16,16 +17,18 @@ import { makeTuple } from '@aztec/foundation/array';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { sha256ToField, sha256Trunc } from '@aztec/foundation/crypto';
 import { BLS12Point, Fr } from '@aztec/foundation/fields';
-import { type Tuple, assertLength, toFriendlyJSON } from '@aztec/foundation/serialize';
+import { type Bufferable, type Tuple, assertLength, toFriendlyJSON } from '@aztec/foundation/serialize';
 import { MembershipWitness, MerkleTreeCalculator, computeUnbalancedMerkleTreeRoot } from '@aztec/foundation/trees';
-import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { getVkData } from '@aztec/noir-protocol-circuits-types/server/vks';
+import { getVKIndex, getVKSiblingPath, getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
 import { computeFeePayerBalanceLeafSlot } from '@aztec/protocol-contracts/fee-juice';
 import { PublicDataHint } from '@aztec/stdlib/avm';
 import { Body } from '@aztec/stdlib/block';
-import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import type { MerkleTreeWriteOperations, PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
 import { ContractClassLogFields } from '@aztec/stdlib/logs';
 import type { ParityPublicInputs } from '@aztec/stdlib/parity';
+import { Proof, ProofData, RecursiveProof } from '@aztec/stdlib/proofs';
 import {
   type BaseOrMergeRollupPublicInputs,
   BlockConstantData,
@@ -33,6 +36,7 @@ import {
   PrivateBaseRollupHints,
   PrivateBaseStateDiffHints,
   PublicBaseRollupHints,
+  PublicTubePrivateInputs,
 } from '@aztec/stdlib/rollup';
 import {
   AppendOnlyTreeSnapshot,
@@ -49,8 +53,10 @@ import {
   PartialStateReference,
   type ProcessedTx,
   StateReference,
+  Tx,
   TxEffect,
 } from '@aztec/stdlib/tx';
+import { VkData } from '@aztec/stdlib/vks';
 import { Attributes, type Span, runInSpan } from '@aztec/telemetry-client';
 import type { MerkleTreeReadOperations } from '@aztec/world-state';
 
@@ -246,6 +252,23 @@ export async function getPublicDataHint(db: MerkleTreeWriteOperations, leafSlot:
   return new PublicDataHint(new Fr(leafSlot), value, membershipWitness, leafPreimage);
 }
 
+export function getCivcProofFromTx(tx: Tx | ProcessedTx) {
+  const proofFields = tx.clientIvcProof.proof;
+  const numPublicInputs = proofFields.length - CIVC_PROOF_LENGTH;
+  const binaryProof = new Proof(Buffer.concat(proofFields.map(field => field.toBuffer())), numPublicInputs);
+  const proofFieldsWithoutPublicInputs = proofFields.slice(numPublicInputs);
+  return new RecursiveProof(proofFieldsWithoutPublicInputs, binaryProof, true, CIVC_PROOF_LENGTH);
+}
+
+export function getPublicTubePrivateInputsFromTx(tx: Tx | ProcessedTx) {
+  const proofData = new ProofData(
+    tx.data.toPrivateToPublicKernelCircuitPublicInputs(),
+    getCivcProofFromTx(tx),
+    getVkData('HidingKernelToPublic'),
+  );
+  return new PublicTubePrivateInputs(proofData);
+}
+
 export const buildBlobHints = runInSpan(
   'BlockBuilderHelpers',
   'buildBlobHints',
@@ -555,3 +578,12 @@ export function validateTx(tx: ProcessedTx) {
     throw new Error(`Empty public data tree in tx: ${toFriendlyJSON(tx)}`);
   }
 }
+
+export function toProofData<T extends Bufferable, PROOF_LENGTH extends number>(
+  { inputs, proof, verificationKey }: PublicInputsAndRecursiveProof<T, PROOF_LENGTH>,
+  vkIndex?: number,
+) {
+  const leafIndex = vkIndex || getVKIndex(verificationKey.keyAsFields);
+  const vkData = new VkData(verificationKey, leafIndex, getVKSiblingPath(leafIndex));
+  return new ProofData(inputs, proof, vkData);
+}

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

@@ -3,14 +3,14 @@ import type {
   ARCHIVE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-  TUBE_PROOF_LENGTH,
 } from '@aztec/constants';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { Fr } from '@aztec/foundation/fields';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
 import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import type { ProofAndVerificationKey, PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
+import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
+import type { PrivateToPublicKernelCircuitPublicInputs } from '@aztec/stdlib/kernel';
 import type { Proof } from '@aztec/stdlib/proofs';
 import {
   BlockMergeRollupInputs,
@@ -54,7 +54,15 @@ export class EpochProvingState {
   private provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED;
 
   // Map from tx hash to tube proof promise. Used when kickstarting tube proofs before tx processing.
-  public readonly cachedTubeProofs = new Map<string, Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>>>();
+  public readonly cachedTubeProofs = new Map<
+    string,
+    Promise<
+      PublicInputsAndRecursiveProof<
+        PrivateToPublicKernelCircuitPublicInputs,
+        typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+      >
+    >
+  >();
 
   public blocks: (BlockProvingState | undefined)[] = [];
 

package/src/orchestrator/orchestrator.ts

@@ -2,9 +2,9 @@ import { BlobAccumulatorPublicInputs, FinalBlobBatchingChallenges } from '@aztec
 import {
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
+  NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   NUM_BASE_PARITY_PER_ROOT_PARITY,
-  type TUBE_PROOF_LENGTH,
 } from '@aztec/constants';
 import { padArrayEnd, times } from '@aztec/foundation/collection';
 import { AbortError } from '@aztec/foundation/error';
@@ -22,16 +22,17 @@ import type {
   EpochProver,
   ForkMerkleTreeOperations,
   MerkleTreeWriteOperations,
-  ProofAndVerificationKey,
+  PublicInputsAndRecursiveProof,
   ServerCircuitProver,
 } from '@aztec/stdlib/interfaces/server';
+import type { PrivateToPublicKernelCircuitPublicInputs } from '@aztec/stdlib/kernel';
 import { BaseParityInputs } from '@aztec/stdlib/parity';
 import {
   type BaseRollupHints,
   EmptyBlockRootRollupInputs,
   PrivateBaseRollupInputs,
+  PublicTubePrivateInputs,
   SingleTxBlockRootRollupInputs,
-  TubeInputs,
 } from '@aztec/stdlib/rollup';
 import type { CircuitName } from '@aztec/stdlib/stats';
 import { type AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
@@ -50,6 +51,7 @@ import { inspect } from 'util';
 import {
   buildHeaderAndBodyFromTxs,
   getLastSiblingPath,
+  getPublicTubePrivateInputsFromTx,
   getRootTreeSiblingPath,
   getSubtreeSiblingPath,
   getTreeSnapshot,
@@ -230,10 +232,13 @@ export class ProvingOrchestrator implements EpochProver {
         const [hints, treeSnapshots] = await this.prepareTransaction(tx, provingState);
         const txProvingState = new TxProvingState(tx, hints, treeSnapshots);
         const txIndex = provingState.addNewTx(txProvingState);
-        this.getOrEnqueueTube(provingState, txIndex);
         if (txProvingState.requireAvmProof) {
+          this.getOrEnqueueTube(provingState, txIndex);
           logger.debug(`Enqueueing public VM for tx ${txIndex}`);
           this.enqueueVM(provingState, txIndex);
+        } else {
+          logger.debug(`Enqueueing base rollup for private-only tx ${txIndex}`);
+          this.enqueueBaseRollup(provingState, txIndex);
         }
       } catch (err: any) {
         throw new Error(`Error adding transaction ${tx.hash.toString()} to block ${blockNumber}: ${err.message}`, {
@@ -252,12 +257,21 @@ export class ProvingOrchestrator implements EpochProver {
     if (!this.provingState?.verifyState()) {
       throw new Error(`Invalid proving state, call startNewEpoch before starting tube circuits`);
     }
-    for (const tx of txs) {
+    const publicTxs = txs.filter(tx => tx.data.forPublic);
+    for (const tx of publicTxs) {
       const txHash = tx.getTxHash().toString();
-      const tubeInputs = new TubeInputs(!!tx.data.forPublic, tx.clientIvcProof);
-      const tubeProof = promiseWithResolvers<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>>();
+      const privateInputs = getPublicTubePrivateInputsFromTx(tx);
+      const tubeProof =
+        promiseWithResolvers<
+          PublicInputsAndRecursiveProof<
+            PrivateToPublicKernelCircuitPublicInputs,
+            typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+          >
+        >();
       logger.debug(`Starting tube circuit for tx ${txHash}`);
-      this.doEnqueueTube(txHash, tubeInputs, proof => tubeProof.resolve(proof));
+      this.doEnqueueTube(txHash, privateInputs, proof => {
+        tubeProof.resolve(proof);
+      });
       this.provingState?.cachedTubeProofs.set(txHash, tubeProof.promise);
     }
     return Promise.resolve();
@@ -519,8 +533,6 @@ export class ProvingOrchestrator implements EpochProver {
 
     const db = this.dbs.get(provingState.blockNumber)!;
 
-    // We build the base rollup inputs using a mock proof and verification key.
-    // These will be overwritten later once we have proven the tube circuit and any public kernels
     const [ms, hints] = await elapsed(
       insertSideEffectsAndBuildBaseRollupHints(
         tx,
@@ -593,8 +605,8 @@ export class ProvingOrchestrator implements EpochProver {
     );
   }
 
-  // Enqueues the tube circuit for a given transaction index, or reuses the one already enqueued
-  // Once completed, will enqueue the next circuit, either a public kernel or the base rollup
+  // Enqueues the public tube circuit for a given transaction index, or reuses the one already enqueued.
+  // Once completed, will enqueue the the public tx base rollup.
   private getOrEnqueueTube(provingState: BlockProvingState, txIndex: number) {
     if (!provingState.verifyState()) {
       logger.debug('Not running tube circuit, state invalid');
@@ -603,12 +615,17 @@ export class ProvingOrchestrator implements EpochProver {
 
     const txProvingState = provingState.getTxProvingState(txIndex);
     const txHash = txProvingState.processedTx.hash.toString();
-
-    const handleResult = (result: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>) => {
+    NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH;
+    const handleResult = (
+      result: PublicInputsAndRecursiveProof<
+        PrivateToPublicKernelCircuitPublicInputs,
+        typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+      >,
+    ) => {
       logger.debug(`Got tube proof for tx index: ${txIndex}`, { txHash });
-      txProvingState.setTubeProof(result);
+      txProvingState.setPublicTubeProof(result);
       this.provingState?.cachedTubeProofs.delete(txHash);
-      this.checkAndEnqueueNextTxCircuit(provingState, txIndex);
+      this.checkAndEnqueueBaseRollup(provingState, txIndex);
     };
 
     if (this.provingState?.cachedTubeProofs.has(txHash)) {
@@ -618,13 +635,18 @@ export class ProvingOrchestrator implements EpochProver {
     }
 
     logger.debug(`Enqueuing tube circuit for tx index: ${txIndex}`);
-    this.doEnqueueTube(txHash, txProvingState.getTubeInputs(), handleResult);
+    this.doEnqueueTube(txHash, txProvingState.getPublicTubePrivateInputs(), handleResult);
   }
 
   private doEnqueueTube(
     txHash: string,
-    inputs: TubeInputs,
-    handler: (result: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>) => void,
+    inputs: PublicTubePrivateInputs,
+    handler: (
+      result: PublicInputsAndRecursiveProof<
+        PrivateToPublicKernelCircuitPublicInputs,
+        typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+      >,
+    ) => void,
     provingState: EpochProvingState | BlockProvingState = this.provingState!,
   ) {
     if (!provingState?.verifyState()) {
@@ -636,12 +658,12 @@ export class ProvingOrchestrator implements EpochProver {
       provingState,
       wrapCallbackInSpan(
         this.tracer,
-        'ProvingOrchestrator.prover.getTubeProof',
+        'ProvingOrchestrator.prover.getPublicTubeProof',
         {
           [Attributes.TX_HASH]: txHash,
-          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'tube-circuit' satisfies CircuitName,
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'public-tube' satisfies CircuitName,
         },
-        signal => this.prover.getTubeProof(inputs, signal, this.provingState!.epochNumber),
+        signal => this.prover.getPublicTubeProof(inputs, signal, this.provingState!.epochNumber),
       ),
       handler,
     );
@@ -1012,11 +1034,11 @@ export class ProvingOrchestrator implements EpochProver {
     this.deferredProving(provingState, doAvmProving, proofAndVk => {
       logger.debug(`Proven VM for tx index: ${txIndex}`);
       txProvingState.setAvmProof(proofAndVk);
-      this.checkAndEnqueueNextTxCircuit(provingState, txIndex);
+      this.checkAndEnqueueBaseRollup(provingState, txIndex);
     });
   }
 
-  private checkAndEnqueueNextTxCircuit(provingState: BlockProvingState, txIndex: number) {
+  private checkAndEnqueueBaseRollup(provingState: BlockProvingState, txIndex: number) {
     const txProvingState = provingState.getTxProvingState(txIndex);
     if (!txProvingState.ready()) {
       return;

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

@@ -1,36 +1,39 @@
 import {
   AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
   AVM_VK_INDEX,
-  PRIVATE_TUBE_VK_INDEX,
-  PUBLIC_TUBE_VK_INDEX,
-  type TUBE_PROOF_LENGTH,
+  NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
 } from '@aztec/constants';
+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 } from '@aztec/stdlib/interfaces/server';
+import type { ProofAndVerificationKey, PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
+import type { PrivateToPublicKernelCircuitPublicInputs } from '@aztec/stdlib/kernel';
+import { ProofData } from '@aztec/stdlib/proofs';
 import {
   AvmProofData,
   type BaseRollupHints,
   PrivateBaseRollupHints,
   PrivateBaseRollupInputs,
-  PrivateTubeData,
   PublicBaseRollupHints,
   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 { getCivcProofFromTx, getPublicTubePrivateInputsFromTx, 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 tube?: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>;
+  private publicTube?: PublicInputsAndRecursiveProof<
+    PrivateToPublicKernelCircuitPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
   private avm?: ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;
 
   constructor(
@@ -44,17 +47,17 @@ export class TxProvingState {
   }
 
   public ready() {
-    return !!this.tube && (!this.requireAvmProof || !!this.avm);
-  }
-
-  public getTubeInputs() {
-    return new TubeInputs(!!this.processedTx.data.forPublic, this.processedTx.clientIvcProof);
+    return !this.requireAvmProof || (!!this.avm && !!this.publicTube);
   }
 
   public getAvmInputs(): AvmCircuitInputs {
     return this.processedTx.avmProvingRequest!.inputs;
   }
 
+  public getPublicTubePrivateInputs() {
+    return getPublicTubePrivateInputsFromTx(this.processedTx);
+  }
+
   public getBaseRollupTypeAndInputs() {
     if (this.requireAvmProof) {
       return {
@@ -69,8 +72,13 @@ export class TxProvingState {
     }
   }
 
-  public setTubeProof(tubeProofAndVk: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>) {
-    this.tube = tubeProofAndVk;
+  public setPublicTubeProof(
+    publicTubeProofAndVk: PublicInputsAndRecursiveProof<
+      PrivateToPublicKernelCircuitPublicInputs,
+      typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+    >,
+  ) {
+    this.publicTube = publicTubeProofAndVk;
   }
 
   public setAvmProof(avmProofAndVk: ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>) {
@@ -78,39 +86,34 @@ export class TxProvingState {
   }
 
   #getPrivateBaseInputs() {
-    if (!this.tube) {
-      throw new Error('Tx not ready for proving base rollup.');
+    if (!(this.baseRollupHints instanceof PrivateBaseRollupHints)) {
+      throw new Error('Mismatched base rollup hints, expected private base rollup hints');
     }
 
-    const vkData = this.#getVkData(this.tube!.verificationKey, PRIVATE_TUBE_VK_INDEX);
-    const tubeData = new PrivateTubeData(
+    const privateTailProofData = new ProofData(
       this.processedTx.data.toPrivateToRollupKernelCircuitPublicInputs(),
-      this.tube.proof,
-      vkData,
+      getCivcProofFromTx(this.processedTx),
+      getVkData('HidingKernelToRollup'),
     );
 
-    if (!(this.baseRollupHints instanceof PrivateBaseRollupHints)) {
-      throw new Error('Mismatched base rollup hints, expected private base rollup hints');
-    }
-    return new PrivateBaseRollupInputs(tubeData, this.baseRollupHints);
+    return new PrivateBaseRollupInputs(privateTailProofData, this.baseRollupHints);
   }
 
   #getPublicBaseInputs() {
     if (!this.processedTx.avmProvingRequest) {
       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.publicTube) {
+      throw new Error('Tx not ready for proving base rollup: public 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 tubeData = new PublicTubeData(
-      this.processedTx.data.toPrivateToPublicKernelCircuitPublicInputs(),
-      this.tube.proof,
-      this.#getVkData(this.tube!.verificationKey, PUBLIC_TUBE_VK_INDEX),
-    );
+    const publicTubeProofData = toProofData(this.publicTube);
 
     const avmProofData = new AvmProofData(
       this.processedTx.avmProvingRequest.inputs.publicInputs,
@@ -118,11 +121,7 @@ export class TxProvingState {
       this.#getVkData(this.avm!.verificationKey, AVM_VK_INDEX),
     );
 
-    if (!(this.baseRollupHints instanceof PublicBaseRollupHints)) {
-      throw new Error('Mismatched base rollup hints, expected public base rollup hints');
-    }
-
-    return new PublicBaseRollupInputs(tubeData, avmProofData, this.baseRollupHints);
+    return new PublicBaseRollupInputs(publicTubeProofData, avmProofData, this.baseRollupHints);
   }
 
   #getVkData(verificationKey: VerificationKeyData, vkIndex: number) {

package/src/proving_broker/broker_prover_facade.ts

@@ -3,7 +3,6 @@ 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';
@@ -23,6 +22,7 @@ import {
   type ServerCircuitProver,
   makeProvingJobId,
 } from '@aztec/stdlib/interfaces/server';
+import type { PrivateToPublicKernelCircuitPublicInputs } from '@aztec/stdlib/kernel';
 import type { BaseParityInputs, ParityPublicInputs, RootParityInputs } from '@aztec/stdlib/parity';
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
 import type {
@@ -35,10 +35,10 @@ import type {
   PaddingBlockRootRollupInputs,
   PrivateBaseRollupInputs,
   PublicBaseRollupInputs,
+  PublicTubePrivateInputs,
   RootRollupInputs,
   RootRollupPublicInputs,
   SingleTxBlockRootRollupInputs,
-  TubeInputs,
 } from '@aztec/stdlib/rollup';
 
 import { InlineProofStore, type ProofStore } from './proof_store/index.js';
@@ -520,6 +520,26 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
       signal,
     );
   }
+
+  getPublicTubeProof(
+    inputs: PublicTubePrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<
+    PublicInputsAndRecursiveProof<
+      PrivateToPublicKernelCircuitPublicInputs,
+      typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+    >
+  > {
+    return this.enqueueJob(
+      this.generateId(ProvingRequestType.PUBLIC_TUBE, inputs, epochNumber),
+      ProvingRequestType.PUBLIC_TUBE,
+      inputs,
+      epochNumber,
+      signal,
+    );
+  }
+
   getPrivateBaseRollupProof(
     baseRollupInput: PrivateBaseRollupInputs,
     signal?: AbortSignal,
@@ -580,20 +600,6 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
     );
   }
 
-  getTubeProof(
-    tubeInput: TubeInputs,
-    signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>> {
-    return this.enqueueJob(
-      this.generateId(ProvingRequestType.TUBE_PROOF, tubeInput, epochNumber),
-      ProvingRequestType.TUBE_PROOF,
-      tubeInput,
-      epochNumber,
-      signal,
-    );
-  }
-
   private generateId(type: ProvingRequestType, inputs: { toBuffer(): Buffer }, epochNumber = 0) {
     const inputsHash = sha256(inputs.toBuffer());
     return makeProvingJobId(epochNumber, type, inputsHash.toString('hex'));

package/src/proving_broker/proving_broker.ts

@@ -44,7 +44,7 @@ type EnqueuedProvingJob = Pick<ProvingJob, 'id' | 'epochNumber'>;
 export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Traceable {
   private queues: ProvingQueues = {
     [ProvingRequestType.PUBLIC_VM]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
-    [ProvingRequestType.TUBE_PROOF]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
+    [ProvingRequestType.PUBLIC_TUBE]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
 
     [ProvingRequestType.PRIVATE_BASE_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
     [ProvingRequestType.PUBLIC_BASE_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
@@ -681,7 +681,7 @@ export const PROOF_TYPES_IN_PRIORITY_ORDER: ProvingRequestType[] = [
   ProvingRequestType.PUBLIC_BASE_ROLLUP,
   ProvingRequestType.PRIVATE_BASE_ROLLUP,
   ProvingRequestType.PUBLIC_VM,
-  ProvingRequestType.TUBE_PROOF,
+  ProvingRequestType.PUBLIC_TUBE,
   ProvingRequestType.ROOT_PARITY,
   ProvingRequestType.BASE_PARITY,
   ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP,

package/src/proving_broker/proving_job_controller.ts

@@ -128,6 +128,10 @@ export class ProvingJobController {
         return await this.circuitProver.getAvmProof(inputs, undefined, signal, this.epochNumber);
       }
 
+      case ProvingRequestType.PUBLIC_TUBE: {
+        return await this.circuitProver.getPublicTubeProof(inputs, signal, this.epochNumber);
+      }
+
       case ProvingRequestType.PRIVATE_BASE_ROLLUP: {
         return await this.circuitProver.getPrivateBaseRollupProof(inputs, signal, this.epochNumber);
       }
@@ -172,10 +176,6 @@ export class ProvingJobController {
         return await this.circuitProver.getRootParityProof(inputs, signal, this.epochNumber);
       }
 
-      case ProvingRequestType.TUBE_PROOF: {
-        return await this.circuitProver.getTubeProof(inputs, signal, this.epochNumber);
-      }
-
       default: {
         const _exhaustive: never = type;
         return Promise.reject(new Error(`Invalid proof request type: ${type}`));