@aztec/prover-client 0.42.0

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

@@ -0,0 +1,144 @@
+import {
+  type ProvingJob,
+  type ProvingJobSource,
+  type ProvingRequest,
+  type ProvingRequestResult,
+  ProvingRequestType,
+  type ServerCircuitProver,
+} from '@aztec/circuit-types';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { elapsed } from '@aztec/foundation/timer';
+
+import { ProvingError } from './proving-error.js';
+
+/**
+ * A helper class that encapsulates a circuit prover and connects it to a job source.
+ */
+export class ProverAgent {
+  private inFlightPromises = new Set<Promise<any>>();
+  private runningPromise?: RunningPromise;
+
+  constructor(
+    /** The prover implementation to defer jobs to */
+    private circuitProver: ServerCircuitProver,
+    /** How many proving jobs this agent can handle in parallel */
+    private maxConcurrency = 1,
+    /** How long to wait between jobs */
+    private pollIntervalMs = 100,
+    private log = createDebugLogger('aztec:prover-client:prover-agent'),
+  ) {}
+
+  setMaxConcurrency(maxConcurrency: number): void {
+    if (maxConcurrency < 1) {
+      throw new Error('Concurrency must be at least 1');
+    }
+    this.maxConcurrency = maxConcurrency;
+  }
+
+  setCircuitProver(circuitProver: ServerCircuitProver): void {
+    this.circuitProver = circuitProver;
+  }
+
+  isRunning() {
+    return this.runningPromise?.isRunning() ?? false;
+  }
+
+  start(jobSource: ProvingJobSource): void {
+    if (this.runningPromise) {
+      throw new Error('Agent is already running');
+    }
+
+    this.runningPromise = new RunningPromise(async () => {
+      while (this.inFlightPromises.size < this.maxConcurrency) {
+        const job = await jobSource.getProvingJob();
+        if (!job) {
+          // job source is fully drained, sleep for a bit and try again
+          return;
+        }
+
+        const promise = this.work(jobSource, job).finally(() => this.inFlightPromises.delete(promise));
+        this.inFlightPromises.add(promise);
+      }
+    }, this.pollIntervalMs);
+
+    this.runningPromise.start();
+    this.log.info('Agent started');
+  }
+
+  async stop(): Promise<void> {
+    if (!this.runningPromise?.isRunning()) {
+      return;
+    }
+
+    await this.runningPromise.stop();
+    this.runningPromise = undefined;
+
+    this.log.info('Agent stopped');
+  }
+
+  private async work(jobSource: ProvingJobSource, job: ProvingJob<ProvingRequest>): Promise<void> {
+    try {
+      const [time, result] = await elapsed(this.getProof(job.request));
+      await jobSource.resolveProvingJob(job.id, result);
+      this.log.debug(
+        `Processed proving job id=${job.id} type=${ProvingRequestType[job.request.type]} duration=${time}ms`,
+      );
+    } catch (err) {
+      this.log.error(`Error processing proving job id=${job.id} type=${ProvingRequestType[job.request.type]}: ${err}`);
+      await jobSource.rejectProvingJob(job.id, new ProvingError((err as any)?.message ?? String(err)));
+    }
+  }
+
+  private getProof(request: ProvingRequest): Promise<ProvingRequestResult<typeof type>> {
+    const { type, inputs } = request;
+    switch (type) {
+      case ProvingRequestType.PUBLIC_VM: {
+        return this.circuitProver.getAvmProof(inputs);
+      }
+
+      case ProvingRequestType.PUBLIC_KERNEL_NON_TAIL: {
+        return this.circuitProver.getPublicKernelProof({
+          type: request.kernelType,
+          inputs,
+        });
+      }
+
+      case ProvingRequestType.PUBLIC_KERNEL_TAIL: {
+        return this.circuitProver.getPublicTailProof({
+          type: request.kernelType,
+          inputs,
+        });
+      }
+
+      case ProvingRequestType.BASE_ROLLUP: {
+        return this.circuitProver.getBaseRollupProof(inputs);
+      }
+
+      case ProvingRequestType.MERGE_ROLLUP: {
+        return this.circuitProver.getMergeRollupProof(inputs);
+      }
+
+      case ProvingRequestType.ROOT_ROLLUP: {
+        return this.circuitProver.getRootRollupProof(inputs);
+      }
+
+      case ProvingRequestType.BASE_PARITY: {
+        return this.circuitProver.getBaseParityProof(inputs);
+      }
+
+      case ProvingRequestType.ROOT_PARITY: {
+        return this.circuitProver.getRootParityProof(inputs);
+      }
+
+      case ProvingRequestType.PRIVATE_KERNEL_EMPTY: {
+        return this.circuitProver.getEmptyPrivateKernelProof(inputs);
+      }
+
+      default: {
+        const _exhaustive: never = type;
+        return Promise.reject(new Error(`Invalid proof request type: ${type}`));
+      }
+    }
+  }
+}

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

@@ -0,0 +1,9 @@
+export class ProvingError extends Error {
+  override toString() {
+    return this.message;
+  }
+
+  static fromString(message: string) {
+    return new ProvingError(message);
+  }
+}

package/src/prover-agent/rpc.ts

@@ -0,0 +1,91 @@
+import { type ProvingJobSource } from '@aztec/circuit-types';
+import {
+  AvmCircuitInputs,
+  BaseOrMergeRollupPublicInputs,
+  BaseParityInputs,
+  BaseRollupInputs,
+  Fr,
+  Header,
+  KernelCircuitPublicInputs,
+  MergeRollupInputs,
+  ParityPublicInputs,
+  Proof,
+  PublicKernelCircuitPrivateInputs,
+  PublicKernelCircuitPublicInputs,
+  PublicKernelTailCircuitPrivateInputs,
+  RecursiveProof,
+  RootParityInput,
+  RootParityInputs,
+  RootRollupInputs,
+  RootRollupPublicInputs,
+  VerificationKeyData,
+} from '@aztec/circuits.js';
+import { createJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
+import { JsonRpcServer } from '@aztec/foundation/json-rpc/server';
+
+import { ProvingError } from './proving-error.js';
+
+export function createProvingJobSourceServer(queue: ProvingJobSource): JsonRpcServer {
+  return new JsonRpcServer(
+    queue,
+    {
+      Header,
+      Fr,
+      AvmCircuitInputs,
+      BaseParityInputs,
+      BaseOrMergeRollupPublicInputs,
+      BaseRollupInputs,
+      MergeRollupInputs,
+      ParityPublicInputs,
+      Proof,
+      RootParityInput,
+      RootParityInputs,
+      RootRollupInputs,
+      RootRollupPublicInputs,
+      PublicKernelCircuitPrivateInputs,
+      PublicKernelCircuitPublicInputs,
+      PublicKernelTailCircuitPrivateInputs,
+      KernelCircuitPublicInputs,
+      ProvingError,
+      RecursiveProof,
+      VerificationKeyData,
+    },
+    {},
+  );
+}
+
+export function createProvingJobSourceClient(
+  url: string,
+  namespace?: string,
+  fetch = makeFetch([1, 2, 3], false),
+): ProvingJobSource {
+  return createJsonRpcClient(
+    url,
+    {
+      Header,
+      Fr,
+      AvmCircuitInputs,
+      BaseParityInputs,
+      BaseOrMergeRollupPublicInputs,
+      BaseRollupInputs,
+      MergeRollupInputs,
+      ParityPublicInputs,
+      Proof,
+      RootParityInput,
+      RootParityInputs,
+      RootRollupInputs,
+      RootRollupPublicInputs,
+      PublicKernelCircuitPrivateInputs,
+      PublicKernelCircuitPublicInputs,
+      PublicKernelTailCircuitPrivateInputs,
+      KernelCircuitPublicInputs,
+      ProvingError,
+      RecursiveProof,
+      VerificationKeyData,
+    },
+    {},
+    false,
+    namespace,
+    fetch,
+  ) as ProvingJobSource;
+}

package/src/tx-prover/tx-prover.ts

@@ -0,0 +1,171 @@
+import { BBNativeRollupProver, TestCircuitProver } from '@aztec/bb-prover';
+import { type ProcessedTx } from '@aztec/circuit-types';
+import {
+  type BlockResult,
+  type ProverClient,
+  type ProvingJobSource,
+  type ProvingTicket,
+  type ServerCircuitProver,
+} from '@aztec/circuit-types/interfaces';
+import { type Fr, type GlobalVariables, type Header, type VerificationKeys } from '@aztec/circuits.js';
+import { NativeACVMSimulator } from '@aztec/simulator';
+import { type WorldStateSynchronizer } from '@aztec/world-state';
+
+import { type ProverClientConfig } from '../config.js';
+import { ProvingOrchestrator } from '../orchestrator/orchestrator.js';
+import { MemoryProvingQueue } from '../prover-agent/memory-proving-queue.js';
+import { ProverAgent } from '../prover-agent/prover-agent.js';
+
+/**
+ * A prover accepting individual transaction requests
+ */
+export class TxProver implements ProverClient {
+  private orchestrator: ProvingOrchestrator;
+  private queue = new MemoryProvingQueue();
+  private running = false;
+
+  private constructor(
+    private config: ProverClientConfig,
+    private worldStateSynchronizer: WorldStateSynchronizer,
+    private vks: VerificationKeys,
+    private agent?: ProverAgent,
+    initialHeader?: Header,
+  ) {
+    this.orchestrator = new ProvingOrchestrator(worldStateSynchronizer.getLatest(), this.queue, initialHeader);
+  }
+
+  async updateProverConfig(config: Partial<ProverClientConfig & { vks: VerificationKeys }>): Promise<void> {
+    const newConfig = { ...this.config, ...config };
+
+    if (config.vks) {
+      this.vks = config.vks;
+    }
+
+    if (newConfig.realProofs !== this.config.realProofs && this.agent) {
+      const circuitProver = await TxProver.buildCircuitProver(newConfig);
+      this.agent.setCircuitProver(circuitProver);
+    }
+
+    if (this.config.proverAgentConcurrency !== newConfig.proverAgentConcurrency) {
+      this.agent?.setMaxConcurrency(newConfig.proverAgentConcurrency);
+    }
+
+    if (!this.config.realProofs && newConfig.realProofs) {
+      this.orchestrator.reset();
+    }
+
+    this.config = newConfig;
+  }
+
+  /**
+   * Starts the prover instance
+   */
+  public start() {
+    if (this.running) {
+      return Promise.resolve();
+    }
+
+    this.running = true;
+    this.agent?.start(this.queue);
+    return Promise.resolve();
+  }
+
+  /**
+   * Stops the prover instance
+   */
+  public async stop() {
+    if (!this.running) {
+      return;
+    }
+    this.running = false;
+    await this.agent?.stop();
+  }
+
+  /**
+   * Creates a new prover client and starts it
+   * @param config - The prover configuration.
+   * @param vks - The verification keys for the prover
+   * @param worldStateSynchronizer - An instance of the world state
+   * @returns An instance of the prover, constructed and started.
+   */
+  public static async new(
+    config: ProverClientConfig,
+    vks: VerificationKeys,
+    worldStateSynchronizer: WorldStateSynchronizer,
+    initialHeader?: Header,
+  ) {
+    const agent = config.proverAgentEnabled
+      ? new ProverAgent(
+          await TxProver.buildCircuitProver(config),
+          config.proverAgentConcurrency,
+          config.proverAgentPollInterval,
+        )
+      : undefined;
+
+    const prover = new TxProver(config, worldStateSynchronizer, vks, agent, initialHeader);
+    await prover.start();
+    return prover;
+  }
+
+  private static async buildCircuitProver(config: ProverClientConfig): Promise<ServerCircuitProver> {
+    if (config.realProofs) {
+      return await BBNativeRollupProver.new(config);
+    }
+
+    const simulationProvider = config.acvmBinaryPath
+      ? new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath)
+      : undefined;
+
+    return new TestCircuitProver(simulationProvider);
+  }
+
+  /**
+   * Cancels any block that is currently being built and prepares for a new one to be built
+   * @param numTxs - The complete size of the block, must be a power of 2
+   * @param globalVariables - The global variables for this block
+   * @param l1ToL2Messages - The set of L1 to L2 messages to be included in this block
+   */
+  public async startNewBlock(
+    numTxs: number,
+    globalVariables: GlobalVariables,
+    newL1ToL2Messages: Fr[],
+  ): Promise<ProvingTicket> {
+    const previousBlockNumber = globalVariables.blockNumber.toNumber() - 1;
+    await this.worldStateSynchronizer.syncImmediate(previousBlockNumber);
+    return this.orchestrator.startNewBlock(numTxs, globalVariables, newL1ToL2Messages, this.vks);
+  }
+
+  /**
+   * Add a processed transaction to the current block
+   * @param tx - The transaction to be added
+   */
+  public addNewTx(tx: ProcessedTx): Promise<void> {
+    return this.orchestrator.addNewTx(tx);
+  }
+
+  /**
+   * Cancels the block currently being proven. Proofs already bring built may continue but further proofs should not be started.
+   */
+  public cancelBlock(): void {
+    this.orchestrator.cancelBlock();
+  }
+
+  /**
+   * Performs the final archive tree insertion for this block and returns the L2Block and Proof instances
+   */
+  public finaliseBlock(): Promise<BlockResult> {
+    return this.orchestrator.finaliseBlock();
+  }
+
+  /**
+   * Mark the block as having all the transactions it is going to contain.
+   * Will pad the block to it's complete size with empty transactions and prove all the way to the root rollup.
+   */
+  public setBlockCompleted(): Promise<void> {
+    return this.orchestrator.setBlockCompleted();
+  }
+
+  public getProvingJobSource(): ProvingJobSource {
+    return this.queue;
+  }
+}