@aztec/prover-client 4.0.0-nightly.20250907 → 4.0.0-nightly.20260107

package/src/orchestrator/orchestrator_metrics.ts

@@ -1,17 +1,9 @@
-import {
-  type Histogram,
-  Metrics,
-  type TelemetryClient,
-  type Tracer,
-  type UpDownCounter,
-  ValueType,
-} from '@aztec/telemetry-client';
+import { type Histogram, Metrics, type TelemetryClient, type Tracer, ValueType } from '@aztec/telemetry-client';
 
 export class ProvingOrchestratorMetrics {
   public readonly tracer: Tracer;
 
   private baseRollupInputsDuration: Histogram;
-  private avmFallbackCount: UpDownCounter;
 
   constructor(client: TelemetryClient, name = 'ProvingOrchestrator') {
     this.tracer = client.getTracer(name);
@@ -22,20 +14,9 @@ export class ProvingOrchestratorMetrics {
       description: 'Duration to build base rollup inputs',
       valueType: ValueType.INT,
     });
-
-    this.avmFallbackCount = meter.createUpDownCounter(Metrics.PROVING_ORCHESTRATOR_AVM_FALLBACK_COUNT, {
-      description: 'How many times the AVM fallback was used',
-      valueType: ValueType.INT,
-    });
-
-    this.avmFallbackCount.add(0);
   }
 
   recordBaseRollupInputs(durationMs: number) {
     this.baseRollupInputsDuration.record(Math.ceil(durationMs));
   }
-
-  incAvmFallback() {
-    this.avmFallbackCount.add(1);
-  }
 }

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

@@ -1,28 +1,26 @@
-import {
-  AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
-  AVM_VK_INDEX,
-  PRIVATE_TUBE_VK_INDEX,
-  PUBLIC_TUBE_VK_INDEX,
-  type TUBE_PROOF_LENGTH,
-} from '@aztec/constants';
-import { getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { getVkData } from '@aztec/noir-protocol-circuits-types/server/vks';
 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 { ProofData, ProofDataForFixedVk } from '@aztec/stdlib/proofs';
 import {
-  AvmProofData,
   type BaseRollupHints,
   PrivateBaseRollupHints,
-  PrivateBaseRollupInputs,
-  PrivateTubeData,
+  PrivateTxBaseRollupPrivateInputs,
   PublicBaseRollupHints,
-  PublicBaseRollupInputs,
-  PublicTubeData,
-  TubeInputs,
+  PublicChonkVerifierPublicInputs,
+  PublicTxBaseRollupPrivateInputs,
 } 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
@@ -30,13 +28,17 @@ import { VerificationKeyData, VkData } from '@aztec/stdlib/vks';
  * 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 publicChonkVerifier?: PublicInputsAndRecursiveProof<
+    PublicChonkVerifierPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_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() {
@@ -44,33 +46,38 @@ 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.publicChonkVerifier);
   }
 
   public getAvmInputs(): AvmCircuitInputs {
     return this.processedTx.avmProvingRequest!.inputs;
   }
 
+  public getPublicChonkVerifierPrivateInputs() {
+    return getPublicChonkVerifierPrivateInputsFromTx(this.processedTx, this.proverId);
+  }
+
   public getBaseRollupTypeAndInputs() {
     if (this.requireAvmProof) {
       return {
-        rollupType: 'public-base-rollup' satisfies CircuitName,
+        rollupType: 'rollup-tx-base-public' satisfies CircuitName,
         inputs: this.#getPublicBaseInputs(),
       };
     } else {
       return {
-        rollupType: 'private-base-rollup' satisfies CircuitName,
+        rollupType: 'rollup-tx-base-private' satisfies CircuitName,
         inputs: this.#getPrivateBaseInputs(),
       };
     }
   }
 
-  public setTubeProof(tubeProofAndVk: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>) {
-    this.tube = tubeProofAndVk;
+  public setPublicChonkVerifierProof(
+    publicChonkVerifierProofAndVk: PublicInputsAndRecursiveProof<
+      PublicChonkVerifierPublicInputs,
+      typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+    >,
+  ) {
+    this.publicChonkVerifier = publicChonkVerifierProofAndVk;
   }
 
   public setAvmProof(avmProofAndVk: ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>) {
@@ -78,55 +85,40 @@ 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,
+      getChonkProofFromTx(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 PrivateTxBaseRollupPrivateInputs(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.publicChonkVerifier) {
+      throw new Error('Tx not ready for proving base rollup: public chonk verifier 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 publicChonkVerifierProofData = toProofData(this.publicChonkVerifier);
 
-    const avmProofData = new AvmProofData(
+    const avmProofData = new ProofDataForFixedVk(
       this.processedTx.avmProvingRequest.inputs.publicInputs,
       this.avm.proof,
-      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);
-  }
-
-  #getVkData(verificationKey: VerificationKeyData, vkIndex: number) {
-    const vkPath = getVKSiblingPath(vkIndex);
-    return new VkData(verificationKey, vkIndex, vkPath);
+    return new PublicTxBaseRollupPrivateInputs(publicChonkVerifierProofData, avmProofData, this.baseRollupHints);
   }
 }

package/src/prover-client/factory.ts

@@ -1,4 +1,8 @@
-import type { ForkMerkleTreeOperations, ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
+import type {
+  ForkMerkleTreeOperations,
+  ProvingJobBroker,
+  ReadonlyWorldStateAccess,
+} from '@aztec/stdlib/interfaces/server';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import type { ProverClientConfig } from '../config.js';
@@ -6,7 +10,7 @@ import { ProverClient } from './prover-client.js';
 
 export function createProverClient(
   config: ProverClientConfig,
-  worldState: ForkMerkleTreeOperations,
+  worldState: ForkMerkleTreeOperations & ReadonlyWorldStateAccess,
   broker: ProvingJobBroker,
   telemetry: TelemetryClient = getTelemetryClient(),
 ) {

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

@@ -11,6 +11,7 @@ import {
   type ProvingJobBroker,
   type ProvingJobConsumer,
   type ProvingJobProducer,
+  type ReadonlyWorldStateAccess,
   type ServerCircuitProver,
   tryStop,
 } from '@aztec/stdlib/interfaces/server';
@@ -33,7 +34,7 @@ export class ProverClient implements EpochProverManager {
 
   private constructor(
     private config: ProverClientConfig,
-    private worldState: ForkMerkleTreeOperations,
+    private worldState: ForkMerkleTreeOperations & ReadonlyWorldStateAccess,
     private orchestratorClient: ProvingJobProducer,
     private agentClient?: ProvingJobConsumer,
     private telemetry: TelemetryClient = getTelemetryClient(),
@@ -99,7 +100,7 @@ export class ProverClient implements EpochProverManager {
    */
   public static async new(
     config: ProverClientConfig,
-    worldState: ForkMerkleTreeOperations,
+    worldState: ForkMerkleTreeOperations & ReadonlyWorldStateAccess,
     broker: ProvingJobBroker,
     telemetry: TelemetryClient = getTelemetryClient(),
   ) {

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

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