@aztec/prover-client 0.0.0-test.0

package/src/orchestrator/orchestrator_metrics.ts

@@ -0,0 +1,22 @@
+import { type Histogram, Metrics, type TelemetryClient, type Tracer, ValueType } from '@aztec/telemetry-client';
+
+export class ProvingOrchestratorMetrics {
+  public readonly tracer: Tracer;
+
+  private baseRollupInputsDuration: Histogram;
+
+  constructor(client: TelemetryClient, name = 'ProvingOrchestrator') {
+    this.tracer = client.getTracer(name);
+    const meter = client.getMeter(name);
+
+    this.baseRollupInputsDuration = meter.createHistogram(Metrics.PROVING_ORCHESTRATOR_BASE_ROLLUP_INPUTS_DURATION, {
+      unit: 'ms',
+      description: 'Duration to build base rollup inputs',
+      valueType: ValueType.INT,
+    });
+  }
+
+  recordBaseRollupInputs(durationMs: number) {
+    this.baseRollupInputsDuration.record(Math.ceil(durationMs));
+  }
+}

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

@@ -0,0 +1,139 @@
+import { type AVM_PROOF_LENGTH_IN_FIELDS, AVM_VK_INDEX, type TUBE_PROOF_LENGTH, TUBE_VK_INDEX } from '@aztec/constants';
+import { getVKIndex, 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 {
+  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 { VkWitnessData } from '@aztec/stdlib/vks';
+
+/**
+ * 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 avm?: ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>;
+
+  constructor(
+    public readonly processedTx: ProcessedTx,
+    private readonly baseRollupHints: BaseRollupHints,
+    public readonly treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>,
+  ) {}
+
+  get requireAvmProof() {
+    return !!this.processedTx.avmProvingRequest;
+  }
+
+  public ready() {
+    return !!this.tube && (!this.requireAvmProof || !!this.avm);
+  }
+
+  public getTubeInputs() {
+    return new TubeInputs(this.processedTx.clientIvcProof);
+  }
+
+  public getAvmInputs(): AvmCircuitInputs {
+    return this.processedTx.avmProvingRequest!.inputs;
+  }
+
+  public getBaseRollupTypeAndInputs() {
+    if (this.requireAvmProof) {
+      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.toPrivateToRollupKernelCircuitPublicInputs(),
+      this.tube.proof,
+      vkData,
+    );
+
+    if (!(this.baseRollupHints instanceof PrivateBaseRollupHints)) {
+      throw new Error('Mismatched base rollup hints, expected private base rollup hints');
+    }
+    return new PrivateBaseRollupInputs(tubeData, 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.avm) {
+      throw new Error('Tx not ready for proving base rollup: avm proof undefined');
+    }
+
+    const tubeData = new PublicTubeData(
+      this.processedTx.data.toPrivateToPublicKernelCircuitPublicInputs(),
+      this.tube.proof,
+      this.#getTubeVkData(),
+    );
+
+    const avmProofData = new AvmProofData(
+      this.processedTx.avmProvingRequest.inputs.publicInputs,
+      this.avm.proof,
+      this.#getAvmVkData(),
+    );
+
+    if (!(this.baseRollupHints instanceof PublicBaseRollupHints)) {
+      throw new Error('Mismatched base rollup hints, expected public base rollup hints');
+    }
+
+    return new PublicBaseRollupInputs(tubeData, avmProofData, this.baseRollupHints);
+  }
+
+  #getTubeVkData() {
+    let vkIndex = TUBE_VK_INDEX;
+    try {
+      vkIndex = getVKIndex(this.tube!.verificationKey);
+    } catch (_ignored) {
+      // TODO(#7410) The VK for the tube won't be in the tree for now, so we manually set it to the tube vk index
+    }
+    const vkPath = getVKSiblingPath(vkIndex);
+
+    return new VkWitnessData(this.tube!.verificationKey, vkIndex, vkPath);
+  }
+
+  #getAvmVkData() {
+    const vkIndex = AVM_VK_INDEX;
+    const vkPath = getVKSiblingPath(vkIndex);
+    return new VkWitnessData(this.avm!.verificationKey, AVM_VK_INDEX, vkPath);
+  }
+}

package/src/prover-client/factory.ts

@@ -0,0 +1,14 @@
+import type { ForkMerkleTreeOperations, ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+import type { ProverClientConfig } from '../config.js';
+import { ProverClient } from './prover-client.js';
+
+export function createProverClient(
+  config: ProverClientConfig,
+  worldState: ForkMerkleTreeOperations,
+  broker: ProvingJobBroker,
+  telemetry: TelemetryClient = getTelemetryClient(),
+) {
+  return ProverClient.new(config, worldState, broker, telemetry);
+}

package/src/prover-client/index.ts

@@ -0,0 +1,2 @@
+export * from './factory.js';
+export * from './prover-client.js';

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

@@ -0,0 +1,162 @@
+import { type ACVMConfig, type BBConfig, BBNativeRollupProver, TestCircuitProver } from '@aztec/bb-prover';
+import { times } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { NativeACVMSimulator } from '@aztec/simulator/server';
+import type {
+  ActualProverConfig,
+  EpochProver,
+  EpochProverManager,
+  ForkMerkleTreeOperations,
+  ProvingJobBroker,
+  ProvingJobConsumer,
+  ProvingJobProducer,
+  ServerCircuitProver,
+} from '@aztec/stdlib/interfaces/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, 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 orchestratorClient: ProvingJobProducer,
+    private agentClient?: ProvingJobConsumer,
+    private telemetry: TelemetryClient = getTelemetryClient(),
+    private log = createLogger('prover-client:tx-prover'),
+  ) {
+    this.proofStore = new InlineProofStore();
+    this.failedProofStore = this.config.failedProofStore ? createProofStore(this.config.failedProofStore) : undefined;
+  }
+
+  public createEpochProver(): EpochProver {
+    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 {
+    return this.config.proverId ?? Fr.ZERO;
+  }
+
+  async updateProverConfig(config: Partial<ProverClientConfig>): Promise<void> {
+    const newConfig = { ...this.config, ...config };
+
+    if (
+      newConfig.realProofs !== this.config.realProofs ||
+      newConfig.proverAgentCount !== this.config.proverAgentCount
+    ) {
+      await this.stopAgents();
+      await this.createAndStartAgents();
+    }
+
+    this.config = newConfig;
+  }
+
+  /**
+   * Starts the prover instance
+   */
+  public async start(): Promise<void> {
+    if (this.running) {
+      return Promise.resolve();
+    }
+
+    this.running = true;
+    await this.createAndStartAgents();
+  }
+
+  /**
+   * Stops the prover instance
+   */
+  public async stop() {
+    if (!this.running) {
+      return;
+    }
+    this.running = false;
+    await this.stopAgents();
+  }
+
+  /**
+   * Creates a new prover client and starts it
+   * @param config - The prover configuration.
+   * @param worldState - An instance of the world state
+   * @returns An instance of the prover, constructed and started.
+   */
+  public static async new(
+    config: ProverClientConfig,
+    worldState: ForkMerkleTreeOperations,
+    broker: ProvingJobBroker,
+    telemetry: TelemetryClient = getTelemetryClient(),
+  ) {
+    const prover = new ProverClient(config, worldState, broker, broker, telemetry);
+    await prover.start();
+    return prover;
+  }
+
+  public getProvingJobSource(): ProvingJobConsumer {
+    if (!this.agentClient) {
+      throw new Error('Agent client not provided');
+    }
+
+    return this.agentClient;
+  }
+
+  private async createAndStartAgents(): Promise<void> {
+    if (this.agents.length > 0) {
+      throw new Error('Agents already started');
+    }
+
+    if (!this.agentClient) {
+      throw new Error('Agent client not provided');
+    }
+
+    const proofStore = new InlineProofStore();
+    const prover = await buildServerCircuitProver(this.config, this.telemetry);
+    this.agents = times(
+      this.config.proverAgentCount,
+      () =>
+        new ProvingAgent(
+          this.agentClient!,
+          proofStore,
+          prover,
+          [],
+          this.config.proverAgentPollIntervalMs,
+          this.telemetry,
+        ),
+    );
+
+    await Promise.all(this.agents.map(agent => agent.start()));
+  }
+
+  private async stopAgents() {
+    await Promise.all(this.agents.map(agent => agent.stop()));
+  }
+}
+
+export function buildServerCircuitProver(
+  config: ActualProverConfig & ACVMConfig & BBConfig,
+  telemetry: TelemetryClient,
+): Promise<ServerCircuitProver> {
+  if (config.realProofs) {
+    return BBNativeRollupProver.new(config, telemetry);
+  }
+
+  const simulationProvider = config.acvmBinaryPath
+    ? new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath)
+    : undefined;
+
+  return Promise.resolve(new TestCircuitProver(simulationProvider, config, telemetry));
+}

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

@@ -0,0 +1,51 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { L2Block } 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 { 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[]): Promise<void> {
+    return 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[],
+    previousBlockHeader: BlockHeader,
+  ): Promise<void> {
+    return this.orchestrator.startNewBlock(globalVariables, l1ToL2Messages, previousBlockHeader);
+  }
+  addTxs(txs: ProcessedTx[]): Promise<void> {
+    return this.orchestrator.addTxs(txs);
+  }
+}