@aztec/prover-client 0.69.1 → 0.71.0

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,15 +52,34 @@ 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 vkData = this.#getTubeVkData();
     const tubeData = new PrivateTubeData(
       this.processedTx.data.toPrivateToRollupKernelCircuitPublicInputs(),
       this.tube.proof,
@@ -72,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.');
     }
@@ -84,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)) {
@@ -102,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);
@@ -122,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

@@ -15,8 +15,6 @@ import type {
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   ParityPublicInputs,
-  PrivateKernelEmptyInputData,
-  PrivateToRollupKernelCircuitPublicInputs,
   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';
@@ -41,7 +40,7 @@ import { type PromiseWithResolvers, RunningPromise, promiseWithResolvers } from
 import { PriorityMemoryQueue } from '@aztec/foundation/queue';
 import { type TelemetryClient, type Tracer, trackSpan } from '@aztec/telemetry-client';
 
-import { InlineProofStore, type ProofStore } from '../proving_broker/proof_store.js';
+import { InlineProofStore, type ProofStore } from '../proving_broker/proof_store/index.js';
 import { ProvingQueueMetrics } from './queue_metrics.js';
 
 type ProvingJobWithResolvers<T extends ProvingRequestType = ProvingRequestType> = ProvingJob &
@@ -271,19 +270,6 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     return promise.then(({ result }) => result);
   }
 
-  getEmptyPrivateKernelProof(
-    inputs: PrivateKernelEmptyInputData,
-    signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<
-      PrivateToRollupKernelCircuitPublicInputs,
-      typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
-    >
-  > {
-    return this.enqueue(ProvingRequestType.PRIVATE_KERNEL_EMPTY, inputs, signal, epochNumber);
-  }
-
   getTubeProof(
     inputs: TubeInputs,
     signal?: AbortSignal,
@@ -364,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

@@ -11,10 +11,16 @@ import {
 import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import { elapsed } from '@aztec/foundation/timer';
-import { Attributes, type TelemetryClient, type Traceable, type Tracer, trackSpan } from '@aztec/telemetry-client';
-import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
+import {
+  Attributes,
+  type TelemetryClient,
+  type Traceable,
+  type Tracer,
+  getTelemetryClient,
+  trackSpan,
+} from '@aztec/telemetry-client';
 
-import { InlineProofStore } from '../proving_broker/proof_store.js';
+import { InlineProofStore } from '../proving_broker/proof_store/index.js';
 
 const PRINT_THRESHOLD_NS = 6e10; // 60 seconds
 
@@ -42,7 +48,7 @@ export class ProverAgent implements ProverAgentApi, Traceable {
     /** How long to wait between jobs */
     private pollIntervalMs = 100,
     /** Telemetry client */
-    private telemetry: TelemetryClient = new NoopTelemetryClient(),
+    telemetry: TelemetryClient = getTelemetryClient(),
     /** Logger */
     private log = createLogger('prover-client:prover-agent'),
   ) {
@@ -209,6 +215,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 +235,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/factory.ts

@@ -1,6 +1,5 @@
 import { type ForkMerkleTreeOperations, type ProvingJobBroker } from '@aztec/circuit-types';
-import { type TelemetryClient } from '@aztec/telemetry-client';
-import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { type ProverClientConfig } from '../config.js';
 import { ProverClient } from './prover-client.js';
@@ -9,7 +8,7 @@ export function createProverClient(
   config: ProverClientConfig,
   worldState: ForkMerkleTreeOperations,
   broker: ProvingJobBroker,
-  telemetry: TelemetryClient = new NoopTelemetryClient(),
+  telemetry: TelemetryClient = getTelemetryClient(),
 ) {
   return ProverClient.new(config, worldState, broker, telemetry);
 }

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

@@ -12,39 +12,40 @@ import {
 import { Fr } from '@aztec/circuits.js';
 import { times } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
-import { NativeACVMSimulator } from '@aztec/simulator';
-import { type TelemetryClient } from '@aztec/telemetry-client';
+import { NativeACVMSimulator } from '@aztec/simulator/server';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { type ProverClientConfig } from '../config.js';
 import { ProvingOrchestrator } from '../orchestrator/orchestrator.js';
 import { BrokerCircuitProverFacade } from '../proving_broker/broker_prover_facade.js';
-import { InlineProofStore } from '../proving_broker/proof_store.js';
+import { InlineProofStore, type ProofStore, createProofStore } from '../proving_broker/proof_store/index.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 {
   private running = false;
   private agents: ProvingAgent[] = [];
 
+  private proofStore: ProofStore;
+  private failedProofStore: ProofStore | undefined;
+
   private constructor(
     private config: ProverClientConfig,
     private worldState: ForkMerkleTreeOperations,
-    private telemetry: TelemetryClient,
     private orchestratorClient: ProvingJobProducer,
     private agentClient?: ProvingJobConsumer,
+    private telemetry: TelemetryClient = getTelemetryClient(),
     private log = createLogger('prover-client:tx-prover'),
   ) {
-    // TODO(palla/prover-node): Cache the paddingTx here, and not in each proving orchestrator,
-    // so it can be reused across multiple ones and not recomputed every time.
+    this.proofStore = new InlineProofStore();
+    this.failedProofStore = this.config.failedProofStore ? createProofStore(this.config.failedProofStore) : undefined;
   }
 
   public createEpochProver(): EpochProver {
-    return new ProvingOrchestrator(
-      this.worldState,
-      new BrokerCircuitProverFacade(this.orchestratorClient),
-      this.telemetry,
-      this.config.proverId,
-    );
+    const facade = new BrokerCircuitProverFacade(this.orchestratorClient, this.proofStore, this.failedProofStore);
+    const orchestrator = new ProvingOrchestrator(this.worldState, facade, this.config.proverId, this.telemetry);
+    return new ServerEpochProver(facade, orchestrator);
   }
 
   public getProverId(): Fr {
@@ -62,10 +63,6 @@ export class ProverClient implements EpochProverManager {
       await this.createAndStartAgents();
     }
 
-    if (!this.config.realProofs && newConfig.realProofs) {
-      // TODO(palla/prover-node): Reset padding tx here once we cache it at this class
-    }
-
     this.config = newConfig;
   }
 
@@ -102,9 +99,9 @@ export class ProverClient implements EpochProverManager {
     config: ProverClientConfig,
     worldState: ForkMerkleTreeOperations,
     broker: ProvingJobBroker,
-    telemetry: TelemetryClient,
+    telemetry: TelemetryClient = getTelemetryClient(),
   ) {
-    const prover = new ProverClient(config, worldState, telemetry, broker, broker);
+    const prover = new ProverClient(config, worldState, broker, broker, telemetry);
     await prover.start();
     return prover;
   }
@@ -135,9 +132,9 @@ export class ProverClient implements EpochProverManager {
           this.agentClient!,
           proofStore,
           prover,
-          this.telemetry,
           [],
           this.config.proverAgentPollIntervalMs,
+          this.telemetry,
         ),
     );
 
@@ -161,5 +158,5 @@ export function buildServerCircuitProver(
     ? new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath)
     : undefined;
 
-  return Promise.resolve(new TestCircuitProver(telemetry, simulationProvider, config));
+  return Promise.resolve(new TestCircuitProver(simulationProvider, config, telemetry));
 }

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);
+  }
+}