@aztec/prover-client 0.69.0 → 0.69.1-devnet

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

@@ -1,4 +1,5 @@
 import { type MerkleTreeId, type ProcessedTx, type ProofAndVerificationKey } from '@aztec/circuit-types';
+import { type CircuitName } from '@aztec/circuit-types/stats';
 import {
   type AVM_PROOF_LENGTH_IN_FIELDS,
   AVM_VK_INDEX,
@@ -18,7 +19,7 @@ import {
   PublicTubeData,
   TubeInputs,
 } from '@aztec/circuits.js/rollup';
-import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types';
+import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vks';
 
 /**
  * Helper class to manage the proving cycle of a transaction
@@ -51,16 +52,39 @@ export class TxProvingState {
     return this.processedTx.avmProvingRequest!.inputs;
   }
 
-  public getPrivateBaseInputs() {
+  public getBaseRollupTypeAndInputs() {
     if (this.requireAvmProof) {
-      throw new Error('Should create public base rollup for a tx requiring avm proof.');
+      return {
+        rollupType: 'public-base-rollup' satisfies CircuitName,
+        inputs: this.#getPublicBaseInputs(),
+      };
+    } else {
+      return {
+        rollupType: 'private-base-rollup' satisfies CircuitName,
+        inputs: this.#getPrivateBaseInputs(),
+      };
     }
+  }
+
+  public setTubeProof(tubeProofAndVk: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>) {
+    this.tube = tubeProofAndVk;
+  }
+
+  public setAvmProof(avmProofAndVk: ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>) {
+    this.avm = avmProofAndVk;
+  }
+
+  #getPrivateBaseInputs() {
     if (!this.tube) {
       throw new Error('Tx not ready for proving base rollup.');
     }
 
-    const vkData = this.getTubeVkData();
-    const tubeData = new PrivateTubeData(this.processedTx.data.toKernelCircuitPublicInputs(), this.tube.proof, vkData);
+    const vkData = this.#getTubeVkData();
+    const tubeData = new PrivateTubeData(
+      this.processedTx.data.toPrivateToRollupKernelCircuitPublicInputs(),
+      this.tube.proof,
+      vkData,
+    );
 
     if (!(this.baseRollupHints instanceof PrivateBaseRollupHints)) {
       throw new Error('Mismatched base rollup hints, expected private base rollup hints');
@@ -68,7 +92,7 @@ export class TxProvingState {
     return new PrivateBaseRollupInputs(tubeData, this.baseRollupHints);
   }
 
-  public getPublicBaseInputs() {
+  #getPublicBaseInputs() {
     if (!this.processedTx.avmProvingRequest) {
       throw new Error('Should create private base rollup for a tx not requiring avm proof.');
     }
@@ -80,15 +104,15 @@ export class TxProvingState {
     }
 
     const tubeData = new PublicTubeData(
-      this.processedTx.data.toPublicKernelCircuitPublicInputs(),
+      this.processedTx.data.toPrivateToPublicKernelCircuitPublicInputs(),
       this.tube.proof,
-      this.getTubeVkData(),
+      this.#getTubeVkData(),
     );
 
     const avmProofData = new AvmProofData(
       this.processedTx.avmProvingRequest.inputs.output,
       this.avm.proof,
-      this.getAvmVkData(),
+      this.#getAvmVkData(),
     );
 
     if (!(this.baseRollupHints instanceof PublicBaseRollupHints)) {
@@ -98,15 +122,7 @@ export class TxProvingState {
     return new PublicBaseRollupInputs(tubeData, avmProofData, this.baseRollupHints);
   }
 
-  public assignTubeProof(tubeProofAndVk: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>) {
-    this.tube = tubeProofAndVk;
-  }
-
-  public assignAvmProof(avmProofAndVk: ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>) {
-    this.avm = avmProofAndVk;
-  }
-
-  private getTubeVkData() {
+  #getTubeVkData() {
     let vkIndex = TUBE_VK_INDEX;
     try {
       vkIndex = getVKIndex(this.tube!.verificationKey);
@@ -118,7 +134,7 @@ export class TxProvingState {
     return new VkWitnessData(this.tube!.verificationKey, vkIndex, vkPath);
   }
 
-  private getAvmVkData() {
+  #getAvmVkData() {
     const vkIndex = AVM_VK_INDEX;
     const vkPath = getVKSiblingPath(vkIndex);
     return new VkWitnessData(this.avm!.verificationKey, AVM_VK_INDEX, vkPath);

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

@@ -12,11 +12,9 @@ import type {
   AVM_PROOF_LENGTH_IN_FIELDS,
   AvmCircuitInputs,
   BaseParityInputs,
-  KernelCircuitPublicInputs,
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   ParityPublicInputs,
-  PrivateKernelEmptyInputData,
   RECURSIVE_PROOF_LENGTH,
   RootParityInputs,
   TUBE_PROOF_LENGTH,
@@ -32,6 +30,7 @@ import {
   type PublicBaseRollupInputs,
   type RootRollupInputs,
   type RootRollupPublicInputs,
+  type SingleTxBlockRootRollupInputs,
   type TubeInputs,
 } from '@aztec/circuits.js/rollup';
 import { randomBytes } from '@aztec/foundation/crypto';
@@ -271,16 +270,6 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     return promise.then(({ result }) => result);
   }
 
-  getEmptyPrivateKernelProof(
-    inputs: PrivateKernelEmptyInputData,
-    signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<KernelCircuitPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  > {
-    return this.enqueue(ProvingRequestType.PRIVATE_KERNEL_EMPTY, inputs, signal, epochNumber);
-  }
-
   getTubeProof(
     inputs: TubeInputs,
     signal?: AbortSignal,
@@ -361,6 +350,16 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     return this.enqueue(ProvingRequestType.BLOCK_ROOT_ROLLUP, inputs, signal, epochNumber);
   }
 
+  getSingleTxBlockRootRollupProof(
+    inputs: SingleTxBlockRootRollupInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    return this.enqueue(ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP, inputs, signal, epochNumber);
+  }
+
   getEmptyBlockRootRollupProof(
     inputs: EmptyBlockRootRollupInputs,
     signal?: AbortSignal,

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

@@ -209,6 +209,10 @@ export class ProverAgent implements ProverAgentApi, Traceable {
         return this.circuitProver.getBlockRootRollupProof(inputs);
       }
 
+      case ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP: {
+        return this.circuitProver.getSingleTxBlockRootRollupProof(inputs);
+      }
+
       case ProvingRequestType.BLOCK_MERGE_ROLLUP: {
         return this.circuitProver.getBlockMergeRollupProof(inputs);
       }
@@ -225,10 +229,6 @@ export class ProverAgent implements ProverAgentApi, Traceable {
         return this.circuitProver.getRootParityProof(inputs);
       }
 
-      case ProvingRequestType.PRIVATE_KERNEL_EMPTY: {
-        return this.circuitProver.getEmptyPrivateKernelProof(inputs);
-      }
-
       case ProvingRequestType.TUBE_PROOF: {
         return this.circuitProver.getTubeProof(inputs);
       }

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

@@ -20,6 +20,7 @@ import { ProvingOrchestrator } from '../orchestrator/orchestrator.js';
 import { BrokerCircuitProverFacade } from '../proving_broker/broker_prover_facade.js';
 import { InlineProofStore } from '../proving_broker/proof_store.js';
 import { ProvingAgent } from '../proving_broker/proving_agent.js';
+import { ServerEpochProver } from './server-epoch-prover.js';
 
 /** Manages proving of epochs by orchestrating the proving of individual blocks relying on a pool of prover agents. */
 export class ProverClient implements EpochProverManager {
@@ -39,12 +40,9 @@ export class ProverClient implements EpochProverManager {
   }
 
   public createEpochProver(): EpochProver {
-    return new ProvingOrchestrator(
-      this.worldState,
-      new BrokerCircuitProverFacade(this.orchestratorClient),
-      this.telemetry,
-      this.config.proverId,
-    );
+    const facade = new BrokerCircuitProverFacade(this.orchestratorClient);
+    const orchestrator = new ProvingOrchestrator(this.worldState, facade, this.telemetry, this.config.proverId);
+    return new ServerEpochProver(facade, orchestrator);
   }
 
   public getProverId(): Fr {

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

@@ -0,0 +1,44 @@
+import { type EpochProver, type L2Block, type ProcessedTx, type Tx } from '@aztec/circuit-types';
+import { type BlockHeader, type Fr, type GlobalVariables, type Proof } from '@aztec/circuits.js';
+import { type RootRollupPublicInputs } from '@aztec/circuits.js/rollup';
+
+import { type ProvingOrchestrator } from '../orchestrator/orchestrator.js';
+import { type BrokerCircuitProverFacade } from '../proving_broker/broker_prover_facade.js';
+
+/** Encapsulates the proving orchestrator and the broker facade */
+export class ServerEpochProver implements EpochProver {
+  constructor(private facade: BrokerCircuitProverFacade, private orchestrator: ProvingOrchestrator) {}
+
+  startNewEpoch(epochNumber: number, firstBlockNumber: number, totalNumBlocks: number): void {
+    this.orchestrator.startNewEpoch(epochNumber, firstBlockNumber, totalNumBlocks);
+    this.facade.start();
+  }
+  startTubeCircuits(txs: Tx[]): void {
+    this.orchestrator.startTubeCircuits(txs);
+  }
+  setBlockCompleted(blockNumber: number, expectedBlockHeader?: BlockHeader): Promise<L2Block> {
+    return this.orchestrator.setBlockCompleted(blockNumber, expectedBlockHeader);
+  }
+  finaliseEpoch(): Promise<{ publicInputs: RootRollupPublicInputs; proof: Proof }> {
+    return this.orchestrator.finaliseEpoch();
+  }
+  cancel(): void {
+    this.orchestrator.cancel();
+  }
+  getProverId(): Fr {
+    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[]): Promise<void> {
+    return this.orchestrator.startNewBlock(globalVariables, l1ToL2Messages);
+  }
+  addTxs(txs: ProcessedTx[]): Promise<void> {
+    return this.orchestrator.addTxs(txs);
+  }
+}