@aztec/prover-client 3.0.0-nightly.20251026 → 3.0.0-nightly.20251030-2

package/src/mocks/test_context.ts

@@ -1,4 +1,5 @@
 import type { BBProverConfig } from '@aztec/bb-prover';
+import { TestCircuitProver } from '@aztec/bb-prover';
 import { SpongeBlob } from '@aztec/blob-lib';
 import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
 import { padArrayEnd, times, timesParallel } from '@aztec/foundation/collection';
@@ -13,7 +14,8 @@ import { SimpleContractDataSource } from '@aztec/simulator/public/fixtures';
 import { PublicProcessorFactory } from '@aztec/simulator/server';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { EthAddress, getBlockBlobFields } from '@aztec/stdlib/block';
+import { EthAddress } from '@aztec/stdlib/block';
+import { getCheckpointBlobFields } from '@aztec/stdlib/checkpoint';
 import type { ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
 import type { CheckpointConstantData } from '@aztec/stdlib/rollup';
 import { makeBloatedProcessedTx } from '@aztec/stdlib/testing';
@@ -24,9 +26,6 @@ import { NativeWorldStateService } from '@aztec/world-state/native';
 
 import { promises as fs } from 'fs';
 
-// TODO(#12613) This means of sharing test code is not ideal.
-// eslint-disable-next-line import/no-relative-packages
-import { TestCircuitProver } from '../../../bb-prover/src/test/test_circuit_prover.js';
 import { buildBlockWithCleanDB } from '../block-factory/light.js';
 import { getTreeSnapshot } from '../orchestrator/block-building-helpers.js';
 import type { BlockProvingState } from '../orchestrator/block-proving-state.js';
@@ -284,9 +283,8 @@ export class TestContext {
       );
     });
 
-    const blockBlobFields = blockTxs.map(txs => getBlockBlobFields(txs.map(tx => tx.txEffect)));
-    const totalNumBlobFields = blockBlobFields.reduce((acc, curr) => acc + curr.length, 0);
-    const spongeBlobState = SpongeBlob.init(totalNumBlobFields);
+    const blobFields = getCheckpointBlobFields(blockTxs.map(txs => txs.map(tx => tx.txEffect)));
+    const spongeBlobState = await SpongeBlob.init(blobFields.length);
 
     const blocks: { header: BlockHeader; txs: ProcessedTx[] }[] = [];
     for (let i = 0; i < numBlocks; i++) {
@@ -306,12 +304,13 @@ export class TestContext {
 
       await this.worldState.handleL2BlockAndMessages(block, blockMsgs, isFirstBlock);
 
-      await spongeBlobState.absorb(blockBlobFields[i]);
+      const blockBlobFields = block.body.toBlobFields();
+      await spongeBlobState.absorb(blockBlobFields);
 
       blocks.push({ header, txs });
     }
 
-    return { blocks, l1ToL2Messages, blobFields: blockBlobFields.flat() };
+    return { blocks, l1ToL2Messages, blobFields };
   }
 
   public async processPublicFunctions(

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

@@ -1,7 +1,14 @@
-import { BatchedBlob, BatchedBlobAccumulator, Blob, SpongeBlob } from '@aztec/blob-lib';
+import {
+  BatchedBlob,
+  BatchedBlobAccumulator,
+  SpongeBlob,
+  computeBlobsHashFromBlobs,
+  getBlobCommitmentsFromBlobs,
+  getBlobsPerL1Block,
+} from '@aztec/blob-lib';
 import {
   ARCHIVE_HEIGHT,
-  CIVC_PROOF_LENGTH,
+  CHONK_PROOF_LENGTH,
   MAX_CONTRACT_CLASS_LOGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
@@ -15,8 +22,8 @@ import {
 } from '@aztec/constants';
 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 { sha256Trunc } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
 import { type Bufferable, type Tuple, assertLength, toFriendlyJSON } from '@aztec/foundation/serialize';
 import {
   MembershipWitness,
@@ -27,6 +34,7 @@ import { getVkData } from '@aztec/noir-protocol-circuits-types/server/vks';
 import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { computeFeePayerBalanceLeafSlot } from '@aztec/protocol-contracts/fee-juice';
 import { Body, L2BlockHeader, getBlockBlobFields } from '@aztec/stdlib/block';
+import { getCheckpointBlobFields } from '@aztec/stdlib/checkpoint';
 import type { MerkleTreeWriteOperations, PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
 import { ContractClassLogFields } from '@aztec/stdlib/logs';
 import { Proof, ProofData, RecursiveProof } from '@aztec/stdlib/proofs';
@@ -35,7 +43,7 @@ import {
   BlockRollupPublicInputs,
   PrivateBaseRollupHints,
   PublicBaseRollupHints,
-  PublicTubePrivateInputs,
+  PublicChonkVerifierPrivateInputs,
   TreeSnapshotDiffHints,
 } from '@aztec/stdlib/rollup';
 import {
@@ -209,60 +217,53 @@ export const insertSideEffectsAndBuildBaseRollupHints = runInSpan(
   },
 );
 
-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 getChonkProofFromTx(tx: Tx | ProcessedTx) {
+  const publicInputs = tx.data.publicInputs().toFields();
+
+  const binaryProof = new Proof(
+    Buffer.concat(tx.chonkProof.attachPublicInputs(publicInputs).fieldsWithPublicInputs.map(field => field.toBuffer())),
+    publicInputs.length,
+  );
+  return new RecursiveProof(tx.chonkProof.fields, binaryProof, true, CHONK_PROOF_LENGTH);
 }
 
-export function getPublicTubePrivateInputsFromTx(tx: Tx | ProcessedTx, proverId: Fr) {
+export function getPublicChonkVerifierPrivateInputsFromTx(tx: Tx | ProcessedTx, proverId: Fr) {
   const proofData = new ProofData(
     tx.data.toPrivateToPublicKernelCircuitPublicInputs(),
-    getCivcProofFromTx(tx),
+    getChonkProofFromTx(tx),
     getVkData('HidingKernelToPublic'),
   );
-  return new PublicTubePrivateInputs(proofData, proverId);
+  return new PublicChonkVerifierPrivateInputs(proofData, proverId);
 }
 
 // Build "hints" as the private inputs for the checkpoint root rollup circuit.
 // The `blobCommitments` will be accumulated and checked in the root rollup against the `finalBlobChallenges`.
-// The `blobsHash` will be validated on L1 against the blob fields.
-export const buildBlobHints = runInSpan(
-  'BlockBuilderHelpers',
-  'buildBlobHints',
-  async (_span: Span, blobFields: Fr[]) => {
-    const blobs = await Blob.getBlobsPerBlock(blobFields);
-    // TODO(#13430): The blobsHash is confusingly similar to blobCommitmentsHash, calculated from below blobCommitments:
-    // - blobsHash := sha256([blobhash_0, ..., blobhash_m]) = a hash of all blob hashes in a block with m+1 blobs inserted into the header, exists so a user can cross check blobs.
-    // - blobCommitmentsHash := sha256( ...sha256(sha256(C_0), C_1) ... C_n) = iteratively calculated hash of all blob commitments in an epoch with n+1 blobs (see calculateBlobCommitmentsHash()),
-    //   exists so we can validate injected commitments to the rollup circuits correspond to the correct real blobs.
-    // We may be able to combine these values e.g. blobCommitmentsHash := sha256( ...sha256(sha256(blobshash_0), blobshash_1) ... blobshash_l) for an epoch with l+1 blocks.
-    const blobCommitments = blobs.map(b => BLS12Point.decompress(b.commitment));
-    const blobsHash = new Fr(getBlobsHashFromBlobs(blobs));
-    return { blobCommitments, blobs, blobsHash };
-  },
-);
+// The `blobsHash` will be validated on L1 against the submitted blob data.
+export const buildBlobHints = (blobFields: Fr[]) => {
+  const blobs = getBlobsPerL1Block(blobFields);
+  const blobCommitments = getBlobCommitmentsFromBlobs(blobs);
+  const blobsHash = computeBlobsHashFromBlobs(blobs);
+  return { blobCommitments, blobs, blobsHash };
+};
 
-// Build the data required to prove the txs in an epoch. Currently only used in tests.
+// Build the data required to prove the txs in an epoch. Currently only used in tests. It assumes 1 block per checkpoint.
 export const buildBlobDataFromTxs = async (txsPerCheckpoint: ProcessedTx[][]) => {
-  const blobFields = txsPerCheckpoint.map(txs => getBlockBlobFields(txs.map(tx => tx.txEffect)));
+  const blobFields = txsPerCheckpoint.map(txs => getCheckpointBlobFields([txs.map(tx => tx.txEffect)]));
   const finalBlobChallenges = await buildFinalBlobChallenges(blobFields);
   return { blobFieldsLengths: blobFields.map(fields => fields.length), finalBlobChallenges };
 };
 
 export const buildFinalBlobChallenges = async (blobFieldsPerCheckpoint: Fr[][]) => {
-  const blobs = await Promise.all(blobFieldsPerCheckpoint.map(blobFields => Blob.getBlobsPerBlock(blobFields)));
-  return await BatchedBlob.precomputeBatchedBlobChallenges(blobs.flat());
+  const blobs = blobFieldsPerCheckpoint.map(blobFields => getBlobsPerL1Block(blobFields));
+  return await BatchedBlob.precomputeBatchedBlobChallenges(blobs);
 };
 
 export const accumulateBlobs = runInSpan(
   'BlockBuilderHelpers',
   'accumulateBlobs',
   async (_span: Span, blobFields: Fr[], startBlobAccumulator: BatchedBlobAccumulator) => {
-    const blobs = await Blob.getBlobsPerBlock(blobFields);
-    const endBlobAccumulator = startBlobAccumulator.accumulateBlobs(blobs);
+    const blobs = getBlobsPerL1Block(blobFields);
+    const endBlobAccumulator = await startBlobAccumulator.accumulateBlobs(blobs);
     return endBlobAccumulator;
   },
 );
@@ -326,16 +327,18 @@ export const buildHeaderAndBodyFromTxs = runInSpan(
     const outHash = txOutHashes.length === 0 ? Fr.ZERO : new Fr(computeCompressedUnbalancedMerkleTreeRoot(txOutHashes));
 
     const parityShaRoot = await computeInHashFromL1ToL2Messages(l1ToL2Messages);
-    const blobFields = body.toBlobFields();
-    const blobsHash = getBlobsHashFromBlobs(await Blob.getBlobsPerBlock(blobFields));
+    const blockBlobFields = body.toBlobFields();
+    // TODO(#17027): This only works when there's one block per checkpoint.
+    const blobFields = [new Fr(blockBlobFields.length + 1)].concat(blockBlobFields);
+    const blobsHash = computeBlobsHashFromBlobs(getBlobsPerL1Block(blobFields));
 
     const contentCommitment = new ContentCommitment(blobsHash, parityShaRoot, outHash);
 
     const fees = txEffects.reduce((acc, tx) => acc.add(tx.transactionFee), Fr.ZERO);
     const manaUsed = txs.reduce((acc, tx) => acc.add(new Fr(tx.gasUsed.billedGas.l2Gas)), Fr.ZERO);
 
-    const endSpongeBlob = startSpongeBlob?.clone() ?? SpongeBlob.init(blobFields.length);
-    await endSpongeBlob.absorb(blobFields);
+    const endSpongeBlob = startSpongeBlob?.clone() ?? (await SpongeBlob.init(blobFields.length));
+    await endSpongeBlob.absorb(blockBlobFields);
     const spongeBlobHash = await endSpongeBlob.squeeze();
 
     const header = new L2BlockHeader(
@@ -397,18 +400,6 @@ export async function computeInHashFromL1ToL2Messages(unpaddedL1ToL2Messages: Fr
   return new Fr(await parityCalculator.computeTreeRoot(l1ToL2Messages.map(msg => msg.toBuffer())));
 }
 
-export function getBlobsHashFromBlobs(inputs: Blob[]): Fr {
-  return sha256ToField(inputs.map(b => b.getEthVersionedBlobHash()));
-}
-
-// Note: tested against the constant values in block_root/empty_block_root_rollup_inputs.nr, set by block_building_helpers.test.ts.
-// Having this separate fn hopefully makes it clear how we treat empty blocks and their blobs, and won't break if we decide to change how
-// getBlobsPerBlock() works on empty input.
-export async function getEmptyBlockBlobsHash(): Promise<Fr> {
-  const blobHash = (await Blob.getBlobsPerBlock([])).map(b => b.getEthVersionedBlobHash());
-  return sha256ToField(blobHash);
-}
-
 export async function getLastSiblingPath<TID extends MerkleTreeId>(treeId: TID, db: MerkleTreeReadOperations) {
   const { size } = await db.getTreeInfo(treeId);
   const path = await db.getSiblingPath(treeId, size - 1n);

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

@@ -9,7 +9,6 @@ import {
 import { Fr } from '@aztec/foundation/fields';
 import { type Tuple, assertLength } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
-import { getBlockBlobFields } from '@aztec/stdlib/block';
 import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
 import { type ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity';
 import type { RollupHonkProofData } from '@aztec/stdlib/proofs';
@@ -239,8 +238,8 @@ export class BlockProvingState {
     return this.endSpongeBlob;
   }
 
-  public getBlockBlobFields() {
-    return getBlockBlobFields(this.txs.map(t => t.processedTx.txEffect));
+  public getTxEffects() {
+    return this.txs.map(t => t.processedTx.txEffect);
   }
 
   public getParentLocation(location: TreeNodeLocation) {

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

@@ -1,4 +1,4 @@
-import { BatchedBlobAccumulator, BlobAccumulator, type FinalBlobBatchingChallenges, SpongeBlob } from '@aztec/blob-lib';
+import { BatchedBlobAccumulator, type FinalBlobBatchingChallenges, SpongeBlob } from '@aztec/blob-lib';
 import {
   type ARCHIVE_HEIGHT,
   BLOBS_PER_BLOCK,
@@ -11,6 +11,7 @@ import { padArrayEnd } from '@aztec/foundation/collection';
 import { BLS12Point, Fr } from '@aztec/foundation/fields';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
+import { getCheckpointBlobFields } from '@aztec/stdlib/checkpoint';
 import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
 import { ParityBasePrivateInputs } from '@aztec/stdlib/parity';
 import {
@@ -41,6 +42,7 @@ export class CheckpointProvingState {
   private blocks: (BlockProvingState | undefined)[] = [];
   private startBlobAccumulator: BatchedBlobAccumulator | undefined;
   private endBlobAccumulator: BatchedBlobAccumulator | undefined;
+  private blobFields: Fr[] | undefined;
   private error: string | undefined;
   public readonly firstBlockNumber: number;
 
@@ -76,13 +78,13 @@ export class CheckpointProvingState {
     return this.parentEpoch.epochNumber;
   }
 
-  public startNewBlock(
+  public async startNewBlock(
     blockNumber: number,
     timestamp: UInt64,
     totalNumTxs: number,
     lastArchiveTreeSnapshot: AppendOnlyTreeSnapshot,
     lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
-  ): BlockProvingState {
+  ): Promise<BlockProvingState> {
     const index = blockNumber - this.firstBlockNumber;
     if (index >= this.totalNumBlocks) {
       throw new Error(`Unable to start a new block at index ${index}. Expected at most ${this.totalNumBlocks} blocks.`);
@@ -97,7 +99,7 @@ export class CheckpointProvingState {
       index === 0 ? this.lastL1ToL2MessageSubtreeRootSiblingPath : this.newL1ToL2MessageSubtreeRootSiblingPath;
 
     const startSpongeBlob =
-      index === 0 ? SpongeBlob.init(this.totalNumBlobFields) : this.blocks[index - 1]?.getEndSpongeBlob();
+      index === 0 ? await SpongeBlob.init(this.totalNumBlobFields) : this.blocks[index - 1]?.getEndSpongeBlob();
     if (!startSpongeBlob) {
       throw new Error(
         'Cannot start a new block before the trees have progressed from the tx effects in the previous block.',
@@ -194,8 +196,8 @@ export class CheckpointProvingState {
       return;
     }
 
-    const blobFields = this.blocks.flatMap(b => b!.getBlockBlobFields());
-    this.endBlobAccumulator = await accumulateBlobs(blobFields, startBlobAccumulator);
+    this.blobFields = getCheckpointBlobFields(this.blocks.map(b => b!.getTxEffects()));
+    this.endBlobAccumulator = await accumulateBlobs(this.blobFields, startBlobAccumulator);
     this.startBlobAccumulator = startBlobAccumulator;
 
     this.onBlobAccumulatorSet(this);
@@ -224,7 +226,7 @@ export class CheckpointProvingState {
     return this.totalNumBlocks === 1 ? 'rollup-checkpoint-root-single-block' : 'rollup-checkpoint-root';
   }
 
-  public async getCheckpointRootRollupInputs() {
+  public getCheckpointRootRollupInputs() {
     const proofs = this.#getChildProofsForRoot();
     const nonEmptyProofs = proofs.filter(p => !!p);
     if (proofs.length !== nonEmptyProofs.length) {
@@ -234,13 +236,15 @@ export class CheckpointProvingState {
       throw new Error('Start blob accumulator is not set.');
     }
 
-    const blobFields = this.blocks.flatMap(b => b!.getBlockBlobFields());
-    const { blobCommitments, blobsHash } = await buildBlobHints(blobFields);
+    // `blobFields` must've been set if `startBlobAccumulator` is set (in `accumulateBlobs`).
+    const blobFields = this.blobFields!;
+
+    const { blobCommitments, blobsHash } = buildBlobHints(blobFields);
 
     const hints = CheckpointRootRollupHints.from({
       previousBlockHeader: this.headerOfLastBlockInPreviousCheckpoint,
       previousArchiveSiblingPath: this.lastArchiveSiblingPath,
-      startBlobAccumulator: BlobAccumulator.fromBatchedBlobAccumulator(this.startBlobAccumulator),
+      startBlobAccumulator: this.startBlobAccumulator.toBlobAccumulator(),
       finalBlobChallenges: this.finalBlobBatchingChallenges,
       blobFields: padArrayEnd(blobFields, Fr.ZERO, FIELDS_PER_BLOB * BLOBS_PER_BLOCK),
       blobCommitments: padArrayEnd(blobCommitments, BLS12Point.ZERO, BLOBS_PER_BLOCK),

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

@@ -15,7 +15,7 @@ import {
   CheckpointMergeRollupPrivateInputs,
   CheckpointPaddingRollupPrivateInputs,
   CheckpointRollupPublicInputs,
-  PublicTubePublicInputs,
+  PublicChonkVerifierPublicInputs,
   RootRollupPrivateInputs,
   type RootRollupPublicInputs,
 } from '@aztec/stdlib/rollup';
@@ -57,10 +57,12 @@ export class EpochProvingState {
   private finalBatchedBlob: BatchedBlob | undefined;
   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<
+  // Map from tx hash to chonk verifier proof promise. Used when kickstarting chonk verifier proofs before tx processing.
+  public readonly cachedChonkVerifierProofs = new Map<
     string,
-    Promise<PublicInputsAndRecursiveProof<PublicTubePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>
+    Promise<
+      PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    >
   >();
 
   constructor(
@@ -236,7 +238,7 @@ export class EpochProvingState {
     if (!this.endBlobAccumulator) {
       throw new Error('End blob accumulator not ready.');
     }
-    this.finalBatchedBlob = await this.endBlobAccumulator.finalize();
+    this.finalBatchedBlob = await this.endBlobAccumulator.finalize(true /* verifyProof */);
   }
 
   public getParentLocation(location: TreeNodeLocation) {

package/src/orchestrator/orchestrator.ts

@@ -1,4 +1,4 @@
-import { BatchedBlob, BlobAccumulator, FinalBlobBatchingChallenges, SpongeBlob } from '@aztec/blob-lib';
+import { BatchedBlob, FinalBlobBatchingChallenges, SpongeBlob } from '@aztec/blob-lib';
 import {
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
@@ -34,8 +34,8 @@ import {
   CheckpointConstantData,
   CheckpointRootSingleBlockRollupPrivateInputs,
   PrivateTxBaseRollupPrivateInputs,
-  PublicTubePrivateInputs,
-  PublicTubePublicInputs,
+  PublicChonkVerifierPrivateInputs,
+  PublicChonkVerifierPublicInputs,
   RootRollupPublicInputs,
 } from '@aztec/stdlib/rollup';
 import type { CircuitName } from '@aztec/stdlib/stats';
@@ -57,7 +57,7 @@ import {
   buildBlockHeaderFromTxs,
   buildHeaderFromCircuitOutputs,
   getLastSiblingPath,
-  getPublicTubePrivateInputsFromTx,
+  getPublicChonkVerifierPrivateInputsFromTx,
   getRootTreeSiblingPath,
   getSubtreeSiblingPath,
   getTreeSnapshot,
@@ -230,7 +230,7 @@ export class ProvingOrchestrator implements EpochProver {
     const lastArchiveTreeSnapshot = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
     const lastArchiveSiblingPath = await getRootTreeSiblingPath(MerkleTreeId.ARCHIVE, db);
 
-    const blockProvingState = checkpointProvingState.startNewBlock(
+    const blockProvingState = await checkpointProvingState.startNewBlock(
       blockNumber,
       timestamp,
       totalNumTxs,
@@ -327,7 +327,7 @@ export class ProvingOrchestrator implements EpochProver {
         const txProvingState = new TxProvingState(tx, hints, treeSnapshots, this.proverId.toField());
         const txIndex = provingState.addNewTx(txProvingState);
         if (txProvingState.requireAvmProof) {
-          this.getOrEnqueueTube(provingState, txIndex);
+          this.getOrEnqueueChonkVerifier(provingState, txIndex);
           logger.debug(`Enqueueing public VM for tx ${txIndex}`);
           this.enqueueVM(provingState, txIndex);
         } else {
@@ -350,27 +350,30 @@ export class ProvingOrchestrator implements EpochProver {
   }
 
   /**
-   * Kickstarts tube circuits for the specified txs. These will be used during epoch proving.
-   * Note that if the tube circuits are not started this way, they will be started nontheless after processing.
+   * Kickstarts chonk verifier circuits for the specified txs. These will be used during epoch proving.
+   * Note that if the chonk verifier circuits are not started this way, they will be started nontheless after processing.
    */
-  @trackSpan('ProvingOrchestrator.startTubeCircuits')
-  public startTubeCircuits(txs: Tx[]) {
+  @trackSpan('ProvingOrchestrator.startChonkVerifierCircuits')
+  public startChonkVerifierCircuits(txs: Tx[]) {
     if (!this.provingState?.verifyState()) {
-      throw new Error(`Empty epoch proving state. call startNewEpoch before starting tube circuits.`);
+      throw new Error(`Empty epoch proving state. call startNewEpoch before starting chonk verifier circuits.`);
     }
     const publicTxs = txs.filter(tx => tx.data.forPublic);
     for (const tx of publicTxs) {
       const txHash = tx.getTxHash().toString();
-      const privateInputs = getPublicTubePrivateInputsFromTx(tx, this.proverId.toField());
+      const privateInputs = getPublicChonkVerifierPrivateInputsFromTx(tx, this.proverId.toField());
       const tubeProof =
         promiseWithResolvers<
-          PublicInputsAndRecursiveProof<PublicTubePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+          PublicInputsAndRecursiveProof<
+            PublicChonkVerifierPublicInputs,
+            typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+          >
         >();
-      logger.debug(`Starting tube circuit for tx ${txHash}`);
-      this.doEnqueueTube(txHash, privateInputs, proof => {
+      logger.debug(`Starting chonk verifier circuit for tx ${txHash}`);
+      this.doEnqueueChonkVerifier(txHash, privateInputs, proof => {
         tubeProof.resolve(proof);
       });
-      this.provingState.cachedTubeProofs.set(txHash, tubeProof.promise);
+      this.provingState.cachedChonkVerifierProofs.set(txHash, tubeProof.promise);
     }
     return Promise.resolve();
   }
@@ -643,7 +646,7 @@ export class ProvingOrchestrator implements EpochProver {
     db: MerkleTreeWriteOperations,
   ): Promise<[BaseRollupHints, TreeSnapshots]> {
     // 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
+    // These will be overwritten later once we have proven the chonk verifier circuit and any public kernels
     const [ms, hints] = await elapsed(
       insertSideEffectsAndBuildBaseRollupHints(
         tx,
@@ -720,11 +723,11 @@ export class ProvingOrchestrator implements EpochProver {
     );
   }
 
-  // Enqueues the public tube circuit for a given transaction index, or reuses the one already enqueued.
+  // Enqueues the public chonk verifier 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) {
+  private getOrEnqueueChonkVerifier(provingState: BlockProvingState, txIndex: number) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running tube circuit, state invalid');
+      logger.debug('Not running chonk verifier circuit, state invalid');
       return;
     }
 
@@ -732,34 +735,40 @@ export class ProvingOrchestrator implements EpochProver {
     const txHash = txProvingState.processedTx.hash.toString();
     NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH;
     const handleResult = (
-      result: PublicInputsAndRecursiveProof<PublicTubePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>,
+      result: PublicInputsAndRecursiveProof<
+        PublicChonkVerifierPublicInputs,
+        typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+      >,
     ) => {
-      logger.debug(`Got tube proof for tx index: ${txIndex}`, { txHash });
-      txProvingState.setPublicTubeProof(result);
-      this.provingState?.cachedTubeProofs.delete(txHash);
+      logger.debug(`Got chonk verifier proof for tx index: ${txIndex}`, { txHash });
+      txProvingState.setPublicChonkVerifierProof(result);
+      this.provingState?.cachedChonkVerifierProofs.delete(txHash);
       this.checkAndEnqueueBaseRollup(provingState, txIndex);
     };
 
-    if (this.provingState?.cachedTubeProofs.has(txHash)) {
-      logger.debug(`Tube proof already enqueued for tx index: ${txIndex}`, { txHash });
-      void this.provingState!.cachedTubeProofs.get(txHash)!.then(handleResult);
+    if (this.provingState?.cachedChonkVerifierProofs.has(txHash)) {
+      logger.debug(`Chonk verifier proof already enqueued for tx index: ${txIndex}`, { txHash });
+      void this.provingState!.cachedChonkVerifierProofs.get(txHash)!.then(handleResult);
       return;
     }
 
-    logger.debug(`Enqueuing tube circuit for tx index: ${txIndex}`);
-    this.doEnqueueTube(txHash, txProvingState.getPublicTubePrivateInputs(), handleResult);
+    logger.debug(`Enqueuing chonk verifier circuit for tx index: ${txIndex}`);
+    this.doEnqueueChonkVerifier(txHash, txProvingState.getPublicChonkVerifierPrivateInputs(), handleResult);
   }
 
-  private doEnqueueTube(
+  private doEnqueueChonkVerifier(
     txHash: string,
-    inputs: PublicTubePrivateInputs,
+    inputs: PublicChonkVerifierPrivateInputs,
     handler: (
-      result: PublicInputsAndRecursiveProof<PublicTubePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>,
+      result: PublicInputsAndRecursiveProof<
+        PublicChonkVerifierPublicInputs,
+        typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+      >,
     ) => void,
     provingState: EpochProvingState | BlockProvingState = this.provingState!,
   ) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running tube circuit, state invalid');
+      logger.debug('Not running chonk verifier circuit, state invalid');
       return;
     }
 
@@ -767,12 +776,12 @@ export class ProvingOrchestrator implements EpochProver {
       provingState,
       wrapCallbackInSpan(
         this.tracer,
-        'ProvingOrchestrator.prover.getPublicTubeProof',
+        'ProvingOrchestrator.prover.getPublicChonkVerifierProof',
         {
           [Attributes.TX_HASH]: txHash,
-          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'tube-public' satisfies CircuitName,
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'chonk-verifier-public' satisfies CircuitName,
         },
-        signal => this.prover.getPublicTubeProof(inputs, signal, provingState.epochNumber),
+        signal => this.prover.getPublicChonkVerifierProof(inputs, signal, provingState.epochNumber),
       ),
       handler,
     );
@@ -988,6 +997,8 @@ export class ProvingOrchestrator implements EpochProver {
 
     logger.debug(`Enqueuing ${rollupType} for checkpoint ${provingState.index}.`);
 
+    const inputs = provingState.getCheckpointRootRollupInputs();
+
     this.deferredProving(
       provingState,
       wrapCallbackInSpan(
@@ -996,8 +1007,7 @@ export class ProvingOrchestrator implements EpochProver {
         {
           [Attributes.PROTOCOL_CIRCUIT_NAME]: rollupType,
         },
-        async signal => {
-          const inputs = await provingState.getCheckpointRootRollupInputs();
+        signal => {
           if (inputs instanceof CheckpointRootSingleBlockRollupPrivateInputs) {
             return this.prover.getCheckpointRootSingleBlockRollupProof(inputs, signal, provingState.epochNumber);
           } else {
@@ -1006,9 +1016,7 @@ export class ProvingOrchestrator implements EpochProver {
         },
       ),
       result => {
-        const computedEndBlobAccumulatorState = BlobAccumulator.fromBatchedBlobAccumulator(
-          provingState.getEndBlobAccumulator()!,
-        );
+        const computedEndBlobAccumulatorState = provingState.getEndBlobAccumulator()!.toBlobAccumulator();
         const circuitEndBlobAccumulatorState = result.inputs.endBlobAccumulator;
         if (!circuitEndBlobAccumulatorState.equals(computedEndBlobAccumulatorState)) {
           logger.error(
@@ -1256,7 +1264,7 @@ export class ProvingOrchestrator implements EpochProver {
       return;
     }
 
-    // We must have completed all proving (tube proof and (if required) vm proof are generated), we now move to the base rollup.
+    // We must have completed all proving (chonk verifier proof and (if required) vm proof are generated), we now move to the base rollup.
     logger.debug(`Public functions completed for tx ${txIndex} enqueueing base rollup`);
 
     this.enqueueBaseRollup(provingState, txIndex);