@aztec/prover-client 0.61.0 → 0.63.0

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

@@ -16,11 +16,10 @@ import {
   PrivateBaseRollupInputs,
   PrivateTubeData,
   PublicBaseRollupInputs,
-  type RecursiveProof,
+  PublicTubeData,
   type TUBE_PROOF_LENGTH,
   TUBE_VK_INDEX,
   TubeInputs,
-  VMCircuitPublicInputs,
   VkWitnessData,
 } from '@aztec/circuits.js';
 import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types';
@@ -31,8 +30,8 @@ import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-type
  * Also stores the inputs to the base rollup for this transaction and the tree snapshots
  */
 export class TxProvingState {
-  private tube?: ProofAndVerificationKey<RecursiveProof<typeof TUBE_PROOF_LENGTH>>;
-  private avm?: ProofAndVerificationKey<RecursiveProof<typeof AVM_PROOF_LENGTH_IN_FIELDS>>;
+  private tube?: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>;
+  private avm?: ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>;
 
   constructor(
     public readonly processedTx: ProcessedTx,
@@ -65,13 +64,13 @@ export class TxProvingState {
     }
 
     const vkData = this.getTubeVkData();
-    const tubeData = new PrivateTubeData(this.processedTx.data, this.tube.proof, vkData);
+    const tubeData = new PrivateTubeData(this.processedTx.data.toKernelCircuitPublicInputs(), this.tube.proof, vkData);
 
     return new PrivateBaseRollupInputs(tubeData, this.baseRollupHints);
   }
 
   public getPublicBaseInputs() {
-    if (!this.requireAvmProof) {
+    if (!this.processedTx.avmProvingRequest) {
       throw new Error('Should create private base rollup for a tx not requiring avm proof.');
     }
     if (!this.tube) {
@@ -81,15 +80,14 @@ export class TxProvingState {
       throw new Error('Tx not ready for proving base rollup: avm proof undefined');
     }
 
-    // Temporary hack.
-    // Passing this.processedTx.data to the tube, which is the output of the simulated public_kernel_tail,
-    // so that the output of the public base will contain all the side effects.
-    // This should be the output of the private_kernel_tail_to_public when the output of the avm proof is the result of
-    // simulating the entire public call stack.
-    const tubeData = new PrivateTubeData(this.processedTx.data, this.tube.proof, this.getTubeVkData());
+    const tubeData = new PublicTubeData(
+      this.processedTx.data.toPublicKernelCircuitPublicInputs(),
+      this.tube.proof,
+      this.getTubeVkData(),
+    );
 
     const avmProofData = new AvmProofData(
-      VMCircuitPublicInputs.empty(), // TODO
+      this.processedTx.avmProvingRequest.inputs.output,
       this.avm.proof,
       this.getAvmVkData(),
     );
@@ -97,42 +95,57 @@ export class TxProvingState {
     return new PublicBaseRollupInputs(tubeData, avmProofData, this.baseRollupHints);
   }
 
-  public assignTubeProof(tubeProofAndVk: ProofAndVerificationKey<RecursiveProof<typeof TUBE_PROOF_LENGTH>>) {
+  public assignTubeProof(tubeProofAndVk: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>) {
     this.tube = tubeProofAndVk;
   }
 
-  public assignAvmProof(avmProofAndVk: ProofAndVerificationKey<RecursiveProof<typeof AVM_PROOF_LENGTH_IN_FIELDS>>) {
+  public assignAvmProof(avmProofAndVk: ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>) {
     this.avm = avmProofAndVk;
   }
 
   public verifyStateOrReject(): string | undefined {
-    const kernelPublicInputs = this.processedTx.data;
-
-    const txNoteEncryptedLogs = EncryptedNoteTxL2Logs.hashNoteLogs(
-      kernelPublicInputs.end.noteEncryptedLogsHashes.filter(log => !log.isEmpty()).map(log => log.value.toBuffer()),
+    const txEffect = this.processedTx.txEffect;
+    const fromPrivate = this.processedTx.data;
+
+    const noteEncryptedLogsHashes = [
+      fromPrivate.forRollup?.end.noteEncryptedLogsHashes || [],
+      fromPrivate.forPublic?.nonRevertibleAccumulatedData.noteEncryptedLogsHashes || [],
+      fromPrivate.forPublic?.revertibleAccumulatedData.noteEncryptedLogsHashes || [],
+    ].flat();
+    const txNoteEncryptedLogsHash = EncryptedNoteTxL2Logs.hashNoteLogs(
+      noteEncryptedLogsHashes.filter(log => !log.isEmpty()).map(log => log.value.toBuffer()),
     );
-    if (!txNoteEncryptedLogs.equals(this.processedTx.noteEncryptedLogs.hash())) {
-      return `Note encrypted logs hash mismatch: ${Fr.fromBuffer(txNoteEncryptedLogs)} === ${Fr.fromBuffer(
-        this.processedTx.noteEncryptedLogs.hash(),
+    if (!txNoteEncryptedLogsHash.equals(txEffect.noteEncryptedLogs.hash())) {
+      return `Note encrypted logs hash mismatch: ${Fr.fromBuffer(txNoteEncryptedLogsHash)} === ${Fr.fromBuffer(
+        txEffect.noteEncryptedLogs.hash(),
       )}`;
     }
 
-    const txEncryptedLogs = EncryptedTxL2Logs.hashSiloedLogs(
-      kernelPublicInputs.end.encryptedLogsHashes.filter(log => !log.isEmpty()).map(log => log.getSiloedHash()),
+    const encryptedLogsHashes = [
+      fromPrivate.forRollup?.end.encryptedLogsHashes || [],
+      fromPrivate.forPublic?.nonRevertibleAccumulatedData.encryptedLogsHashes || [],
+      fromPrivate.forPublic?.revertibleAccumulatedData.encryptedLogsHashes || [],
+    ].flat();
+    const txEncryptedLogsHash = EncryptedTxL2Logs.hashSiloedLogs(
+      encryptedLogsHashes.filter(log => !log.isEmpty()).map(log => log.getSiloedHash()),
     );
-    if (!txEncryptedLogs.equals(this.processedTx.encryptedLogs.hash())) {
+    if (!txEncryptedLogsHash.equals(txEffect.encryptedLogs.hash())) {
       // @todo This rejection messages is never seen. Never making it out to the logs
-      return `Encrypted logs hash mismatch: ${Fr.fromBuffer(txEncryptedLogs)} === ${Fr.fromBuffer(
-        this.processedTx.encryptedLogs.hash(),
+      return `Encrypted logs hash mismatch: ${Fr.fromBuffer(txEncryptedLogsHash)} === ${Fr.fromBuffer(
+        txEffect.encryptedLogs.hash(),
       )}`;
     }
 
-    const txUnencryptedLogs = UnencryptedTxL2Logs.hashSiloedLogs(
-      kernelPublicInputs.end.unencryptedLogsHashes.filter(log => !log.isEmpty()).map(log => log.getSiloedHash()),
+    const avmOutput = this.processedTx.avmProvingRequest?.inputs.output;
+    const unencryptedLogsHashes = avmOutput
+      ? avmOutput.accumulatedData.unencryptedLogsHashes
+      : fromPrivate.forRollup!.end.unencryptedLogsHashes;
+    const txUnencryptedLogsHash = UnencryptedTxL2Logs.hashSiloedLogs(
+      unencryptedLogsHashes.filter(log => !log.isEmpty()).map(log => log.getSiloedHash()),
     );
-    if (!txUnencryptedLogs.equals(this.processedTx.unencryptedLogs.hash())) {
-      return `Unencrypted logs hash mismatch: ${Fr.fromBuffer(txUnencryptedLogs)} === ${Fr.fromBuffer(
-        this.processedTx.unencryptedLogs.hash(),
+    if (!txUnencryptedLogsHash.equals(txEffect.unencryptedLogs.hash())) {
+      return `Unencrypted logs hash mismatch: ${Fr.fromBuffer(txUnencryptedLogsHash)} === ${Fr.fromBuffer(
+        txEffect.unencryptedLogs.hash(),
       )}`;
     }
   }

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

@@ -3,7 +3,7 @@ import {
   type ProvingJob,
   type ProvingJobSource,
   type ProvingRequest,
-  type ProvingRequestResult,
+  type ProvingRequestResultFor,
   ProvingRequestType,
   type PublicInputsAndRecursiveProof,
   type ServerCircuitProver,
@@ -20,12 +20,11 @@ import type {
   KernelCircuitPublicInputs,
   MergeRollupInputs,
   NESTED_RECURSIVE_PROOF_LENGTH,
+  ParityPublicInputs,
   PrivateBaseRollupInputs,
   PrivateKernelEmptyInputData,
   PublicBaseRollupInputs,
   RECURSIVE_PROOF_LENGTH,
-  RecursiveProof,
-  RootParityInput,
   RootParityInputs,
   RootRollupInputs,
   RootRollupPublicInputs,
@@ -42,7 +41,7 @@ import { type TelemetryClient } from '@aztec/telemetry-client';
 import { ProvingQueueMetrics } from './queue_metrics.js';
 
 type ProvingJobWithResolvers<T extends ProvingRequest = ProvingRequest> = ProvingJob<T> &
-  PromiseWithResolvers<ProvingRequestResult<T['type']>> & {
+  PromiseWithResolvers<ProvingRequestResultFor<T['type']>> & {
     signal?: AbortSignal;
     epochNumber?: number;
     attempts: number;
@@ -131,7 +130,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     }
   }
 
-  resolveProvingJob<T extends ProvingRequestType>(jobId: string, result: ProvingRequestResult<T>): Promise<void> {
+  resolveProvingJob<T extends ProvingRequestType>(jobId: string, result: ProvingRequestResultFor<T>): Promise<void> {
     if (!this.runningPromise.isRunning()) {
       throw new Error('Proving queue is not running.');
     }
@@ -150,7 +149,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     return Promise.resolve();
   }
 
-  rejectProvingJob(jobId: string, err: any): Promise<void> {
+  rejectProvingJob(jobId: string, reason: string): Promise<void> {
     if (!this.runningPromise.isRunning()) {
       throw new Error('Proving queue is not running.');
     }
@@ -171,7 +170,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     if (job.attempts < MAX_RETRIES && job.request.type !== ProvingRequestType.PUBLIC_VM) {
       job.attempts++;
       this.log.warn(
-        `Job id=${job.id} type=${ProvingRequestType[job.request.type]} failed with error: ${err}. Retry ${
+        `Job id=${job.id} type=${ProvingRequestType[job.request.type]} failed with error: ${reason}. Retry ${
           job.attempts
         }/${MAX_RETRIES}`,
       );
@@ -181,8 +180,8 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
         job.request.type === ProvingRequestType.PUBLIC_VM && !process.env.AVM_PROVING_STRICT
           ? this.log.warn
           : this.log.error;
-      logFn(`Job id=${job.id} type=${ProvingRequestType[job.request.type]} failed with error: ${err}`);
-      job.reject(err);
+      logFn(`Job id=${job.id} type=${ProvingRequestType[job.request.type]} failed with error: ${reason}`);
+      job.reject(new Error(reason));
     }
     return Promise.resolve();
   }
@@ -228,12 +227,12 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     request: T,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<ProvingRequestResult<T['type']>> {
+  ): Promise<ProvingRequestResultFor<T['type']>['result']> {
     if (!this.runningPromise.isRunning()) {
       return Promise.reject(new Error('Proving queue is not running.'));
     }
 
-    const { promise, resolve, reject } = promiseWithResolvers<ProvingRequestResult<T['type']>>();
+    const { promise, resolve, reject } = promiseWithResolvers<ProvingRequestResultFor<T['type']>>();
     const item: ProvingJobWithResolvers<T> = {
       id: this.generateId(),
       request,
@@ -261,7 +260,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     const byteSize = serializeToBuffer(item.request.inputs).length;
     this.metrics.recordNewJob(item.request.type, byteSize);
 
-    return promise;
+    return promise.then(({ result }) => result);
   }
 
   getEmptyPrivateKernelProof(
@@ -276,18 +275,10 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     inputs: TubeInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<ProofAndVerificationKey<RecursiveProof<typeof RECURSIVE_PROOF_LENGTH>>> {
+  ): Promise<ProofAndVerificationKey<typeof RECURSIVE_PROOF_LENGTH>> {
     return this.enqueue({ type: ProvingRequestType.TUBE_PROOF, inputs }, signal, epochNumber);
   }
 
-  getEmptyTubeProof(
-    inputs: PrivateKernelEmptyInputData,
-    signal?: AbortSignal,
-    epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
-    return this.enqueue({ type: ProvingRequestType.PRIVATE_KERNEL_EMPTY, inputs }, signal, epochNumber);
-  }
-
   /**
    * Creates a proof for the given input.
    * @param input - Input to the circuit.
@@ -296,7 +287,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     inputs: BaseParityInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<RootParityInput<typeof RECURSIVE_PROOF_LENGTH>> {
+  ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>> {
     return this.enqueue({ type: ProvingRequestType.BASE_PARITY, inputs }, signal, epochNumber);
   }
 
@@ -308,7 +299,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     inputs: RootParityInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<RootParityInput<typeof NESTED_RECURSIVE_PROOF_LENGTH>> {
+  ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>> {
     return this.enqueue({ type: ProvingRequestType.ROOT_PARITY, inputs }, signal, epochNumber);
   }
 
@@ -391,7 +382,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     inputs: AvmCircuitInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<ProofAndVerificationKey<RecursiveProof<typeof AVM_PROOF_LENGTH_IN_FIELDS>>> {
+  ): Promise<ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>> {
     return this.enqueue({ type: ProvingRequestType.PUBLIC_VM, inputs }, signal, epochNumber);
   }
 

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

@@ -1,23 +1,23 @@
 import {
+  type ProverAgentApi,
   type ProvingJob,
   type ProvingJobSource,
   type ProvingRequest,
-  type ProvingRequestResult,
+  type ProvingRequestResultFor,
   ProvingRequestType,
   type ServerCircuitProver,
+  makeProvingRequestResult,
 } 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';
-
 const PRINT_THRESHOLD_NS = 6e10; // 60 seconds
 
 /**
  * A helper class that encapsulates a circuit prover and connects it to a job source.
  */
-export class ProverAgent {
+export class ProverAgent implements ProverAgentApi {
   private inFlightPromises = new Map<
     string,
     {
@@ -38,11 +38,12 @@ export class ProverAgent {
     private log = createDebugLogger('aztec:prover-client:prover-agent'),
   ) {}
 
-  setMaxConcurrency(maxConcurrency: number): void {
+  setMaxConcurrency(maxConcurrency: number): Promise<void> {
     if (maxConcurrency < 1) {
       throw new Error('Concurrency must be at least 1');
     }
     this.maxConcurrency = maxConcurrency;
+    return Promise.resolve();
   }
 
   setCircuitProver(circuitProver: ServerCircuitProver): void {
@@ -50,11 +51,17 @@ export class ProverAgent {
   }
 
   isRunning() {
+    return Promise.resolve(this.#isRunning());
+  }
+
+  #isRunning() {
     return this.runningPromise?.isRunning() ?? false;
   }
 
-  getCurrentJobs(): { id: string; type: string }[] {
-    return Array.from(this.inFlightPromises.values()).map(({ id, type }) => ({ id, type: ProvingRequestType[type] }));
+  getCurrentJobs(): Promise<{ id: string; type: string }[]> {
+    return Promise.resolve(
+      Array.from(this.inFlightPromises.values()).map(({ id, type }) => ({ id, type: ProvingRequestType[type] })),
+    );
   }
 
   start(jobSource: ProvingJobSource): void {
@@ -123,15 +130,17 @@ export class ProverAgent {
     this.log.info('Agent stopped');
   }
 
-  private async work(jobSource: ProvingJobSource, job: ProvingJob<ProvingRequest>): Promise<void> {
+  private async work<TRequest extends ProvingRequest>(
+    jobSource: ProvingJobSource,
+    job: ProvingJob<TRequest>,
+  ): Promise<void> {
     try {
       this.log.debug(`Picked up proving job id=${job.id} type=${ProvingRequestType[job.request.type]}`);
+      const type: TRequest['type'] = job.request.type;
       const [time, result] = await elapsed(this.getProof(job.request));
-      if (this.isRunning()) {
-        this.log.verbose(
-          `Processed proving job id=${job.id} type=${ProvingRequestType[job.request.type]} duration=${time}ms`,
-        );
-        await jobSource.resolveProvingJob(job.id, result);
+      if (this.#isRunning()) {
+        this.log.verbose(`Processed proving job id=${job.id} type=${ProvingRequestType[type]} duration=${time}ms`);
+        await jobSource.resolveProvingJob(job.id, makeProvingRequestResult(type, result));
       } else {
         this.log.verbose(
           `Dropping proving job id=${job.id} type=${
@@ -141,20 +150,24 @@ export class ProverAgent {
       }
     } catch (err) {
       const type = ProvingRequestType[job.request.type];
-      if (this.isRunning()) {
+      if (this.#isRunning()) {
         if (job.request.type === ProvingRequestType.PUBLIC_VM && !process.env.AVM_PROVING_STRICT) {
           this.log.warn(`Expected error processing VM proving job id=${job.id} type=${type}: ${err}`);
         } else {
           this.log.error(`Error processing proving job id=${job.id} type=${type}: ${err}`, err);
         }
-        await jobSource.rejectProvingJob(job.id, new ProvingError((err as any)?.message ?? String(err)));
+        const reason = (err as any)?.message ?? String(err);
+        await jobSource.rejectProvingJob(job.id, reason);
       } else {
         this.log.verbose(`Dropping proving job id=${job.id} type=${type}: agent stopped: ${(err as any).stack || err}`);
       }
     }
   }
 
-  private getProof(request: ProvingRequest): Promise<ProvingRequestResult<typeof type>> {
+  private getProof<TRequest extends ProvingRequest>(
+    request: TRequest,
+  ): Promise<ProvingRequestResultFor<TRequest['type']>['result']>;
+  private getProof(request: ProvingRequest): Promise<ProvingRequestResultFor<typeof type>['result']> {
     const { type, inputs } = request;
     switch (type) {
       case ProvingRequestType.PUBLIC_VM: {

package/src/prover-agent/rpc.ts

@@ -1,133 +1,22 @@
-import { type ProvingJobSource } from '@aztec/circuit-types';
-import {
-  AvmCircuitInputs,
-  AztecAddress,
-  BaseOrMergeRollupPublicInputs,
-  BaseParityInputs,
-  BlockMergeRollupInputs,
-  BlockRootOrBlockMergePublicInputs,
-  BlockRootRollupInputs,
-  EmptyBlockRootRollupInputs,
-  EthAddress,
-  Fr,
-  Header,
-  KernelCircuitPublicInputs,
-  MergeRollupInputs,
-  ParityPublicInputs,
-  PrivateBaseRollupInputs,
-  PrivateKernelEmptyInputData,
-  Proof,
-  PublicBaseRollupInputs,
-  PublicKernelCircuitPublicInputs,
-  RecursiveProof,
-  RootParityInput,
-  RootParityInputs,
-  RootRollupInputs,
-  RootRollupPublicInputs,
-  TubeInputs,
-  VMCircuitPublicInputs,
-  VerificationKeyData,
-} from '@aztec/circuits.js';
-import { createJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
-import { JsonRpcServer } from '@aztec/foundation/json-rpc/server';
+import { ProverAgentApiSchema, type ProvingJobSource, ProvingJobSourceSchema } from '@aztec/circuit-types';
+import { createSafeJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
+import { createSafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
 
 import { type ProverAgent } from './prover-agent.js';
-import { ProvingError } from './proving-error.js';
 
-export function createProvingJobSourceServer(queue: ProvingJobSource): JsonRpcServer {
-  return new JsonRpcServer(
-    queue,
-    {
-      AvmCircuitInputs,
-      BaseOrMergeRollupPublicInputs,
-      BaseParityInputs,
-      PrivateBaseRollupInputs,
-      PublicBaseRollupInputs,
-      Fr,
-      Header,
-      KernelCircuitPublicInputs,
-      MergeRollupInputs,
-      ParityPublicInputs,
-      Proof,
-      ProvingError,
-      PrivateKernelEmptyInputData,
-      VMCircuitPublicInputs,
-      PublicKernelCircuitPublicInputs,
-      RecursiveProof,
-      RootParityInput,
-      RootParityInputs,
-      RootRollupInputs,
-      RootRollupPublicInputs,
-      TubeInputs,
-      VerificationKeyData,
-      BlockRootOrBlockMergePublicInputs,
-      BlockMergeRollupInputs,
-      BlockRootRollupInputs,
-      EmptyBlockRootRollupInputs,
-    },
-    {},
-  );
+export function createProvingJobSourceServer(queue: ProvingJobSource) {
+  return createSafeJsonRpcServer(queue, ProvingJobSourceSchema);
 }
 
-export function createProvingJobSourceClient(
-  url: string,
-  namespace?: string,
-  fetch = makeFetch([1, 2, 3], false),
-): ProvingJobSource {
-  return createJsonRpcClient(
-    url,
-    {
-      AvmCircuitInputs,
-      BaseOrMergeRollupPublicInputs,
-      BaseParityInputs,
-      PrivateBaseRollupInputs,
-      PublicBaseRollupInputs,
-      Fr,
-      Header,
-      KernelCircuitPublicInputs,
-      MergeRollupInputs,
-      ParityPublicInputs,
-      Proof,
-      ProvingError,
-      PrivateKernelEmptyInputData,
-      VMCircuitPublicInputs,
-      PublicKernelCircuitPublicInputs,
-      RecursiveProof,
-      RootParityInput,
-      RootParityInputs,
-      RootRollupPublicInputs,
-      RootRollupInputs,
-      TubeInputs,
-      VerificationKeyData,
-      BlockRootOrBlockMergePublicInputs,
-      BlockMergeRollupInputs,
-      BlockRootRollupInputs,
-      EmptyBlockRootRollupInputs,
-    },
-    {},
-    false,
-    namespace,
-    fetch,
-  ) as ProvingJobSource;
+export function createProvingJobSourceClient(url: string, fetch = makeFetch([1, 2, 3], false)): ProvingJobSource {
+  return createSafeJsonRpcClient(url, ProvingJobSourceSchema, false, 'provingJobSource', fetch);
 }
 
 /**
  * Wrap a ProverAgent instance with a JSON RPC HTTP server.
- * @param node - The ProverNode
+ * @param agent - The Prover Agent
  * @returns An JSON-RPC HTTP server
  */
 export function createProverAgentRpcServer(agent: ProverAgent) {
-  const rpc = new JsonRpcServer(
-    agent,
-    {
-      AztecAddress,
-      EthAddress,
-      Fr,
-      Header,
-    },
-    {},
-    // disable methods
-    ['start', 'stop', 'setCircuitProver', 'work', 'getProof'],
-  );
-  return rpc;
+  return createSafeJsonRpcServer(agent, ProverAgentApiSchema);
 }