@aztec/prover-client 0.0.0-test.0

package/src/proving_broker/rpc.ts

@@ -0,0 +1,95 @@
+import { createSafeJsonRpcClient } from '@aztec/foundation/json-rpc/client';
+import type { SafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
+import {
+  type GetProvingJobResponse,
+  ProofUri,
+  ProvingJob,
+  type ProvingJobBroker,
+  type ProvingJobConsumer,
+  ProvingJobId,
+  type ProvingJobProducer,
+  ProvingJobStatus,
+} from '@aztec/stdlib/interfaces/server';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+import { type ApiSchemaFor, optional } from '@aztec/stdlib/schemas';
+import { type ComponentsVersions, getVersioningResponseHandler } from '@aztec/stdlib/versioning';
+import { createTracedJsonRpcServer, makeTracedFetch } from '@aztec/telemetry-client';
+
+import { z } from 'zod';
+
+const ProvingJobFilterSchema = z.object({
+  allowList: z.array(z.nativeEnum(ProvingRequestType)),
+});
+
+const GetProvingJobResponse = z.object({
+  job: ProvingJob,
+  time: z.number(),
+});
+
+export const ProvingJobProducerSchema: ApiSchemaFor<ProvingJobProducer> = {
+  enqueueProvingJob: z.function().args(ProvingJob).returns(ProvingJobStatus),
+  getProvingJobStatus: z.function().args(ProvingJobId).returns(ProvingJobStatus),
+  cancelProvingJob: z.function().args(ProvingJobId).returns(z.void()),
+  getCompletedJobs: z.function().args(z.array(ProvingJobId)).returns(z.array(ProvingJobId)),
+};
+
+export const ProvingJobConsumerSchema: ApiSchemaFor<ProvingJobConsumer> = {
+  getProvingJob: z.function().args(optional(ProvingJobFilterSchema)).returns(GetProvingJobResponse.optional()),
+  reportProvingJobError: z
+    .function()
+    .args(ProvingJobId, z.string(), optional(z.boolean()), optional(ProvingJobFilterSchema))
+    .returns(GetProvingJobResponse.optional()),
+  reportProvingJobProgress: z
+    .function()
+    .args(ProvingJobId, z.number(), optional(ProvingJobFilterSchema))
+    .returns(GetProvingJobResponse.optional()),
+  reportProvingJobSuccess: z
+    .function()
+    .args(ProvingJobId, ProofUri, optional(ProvingJobFilterSchema))
+    .returns(GetProvingJobResponse.optional()),
+};
+
+export const ProvingJobBrokerSchema: ApiSchemaFor<ProvingJobBroker> = {
+  ...ProvingJobConsumerSchema,
+  ...ProvingJobProducerSchema,
+};
+
+export function createProvingBrokerServer(broker: ProvingJobBroker): SafeJsonRpcServer {
+  return createTracedJsonRpcServer(broker, ProvingJobBrokerSchema);
+}
+
+export function createProvingJobBrokerClient(
+  url: string,
+  versions: Partial<ComponentsVersions>,
+  fetch = makeTracedFetch([1, 2, 3], false),
+): ProvingJobBroker {
+  return createSafeJsonRpcClient(url, ProvingJobBrokerSchema, {
+    namespaceMethods: 'proverBroker',
+    fetch,
+    onResponse: getVersioningResponseHandler(versions),
+  });
+}
+
+export function createProvingJobProducerClient(
+  url: string,
+  versions: Partial<ComponentsVersions>,
+  fetch = makeTracedFetch([1, 2, 3], false),
+): ProvingJobProducer {
+  return createSafeJsonRpcClient(url, ProvingJobProducerSchema, {
+    namespaceMethods: 'provingJobProducer',
+    fetch,
+    onResponse: getVersioningResponseHandler(versions),
+  });
+}
+
+export function createProvingJobConsumerClient(
+  url: string,
+  versions: Partial<ComponentsVersions>,
+  fetch = makeTracedFetch([1, 2, 3], false),
+): ProvingJobConsumer {
+  return createSafeJsonRpcClient(url, ProvingJobConsumerSchema, {
+    namespaceMethods: 'provingJobConsumer',
+    fetch,
+    onResponse: getVersioningResponseHandler(versions),
+  });
+}

package/src/test/mock_prover.ts

@@ -0,0 +1,253 @@
+import {
+  AVM_PROOF_LENGTH_IN_FIELDS,
+  AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS,
+  NESTED_RECURSIVE_PROOF_LENGTH,
+  NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+  RECURSIVE_PROOF_LENGTH,
+  TUBE_PROOF_LENGTH,
+} from '@aztec/constants';
+import { times } from '@aztec/foundation/collection';
+import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
+import {
+  type ProofAndVerificationKey,
+  type ProvingJob,
+  type ProvingJobId,
+  type ProvingJobProducer,
+  type ProvingJobStatus,
+  type PublicInputsAndRecursiveProof,
+  type ServerCircuitProver,
+  makeProofAndVerificationKey,
+  makePublicInputsAndRecursiveProof,
+} from '@aztec/stdlib/interfaces/server';
+import type { BaseParityInputs, RootParityInputs } from '@aztec/stdlib/parity';
+import { makeEmptyRecursiveProof, makeRecursiveProof } from '@aztec/stdlib/proofs';
+import type {
+  BaseOrMergeRollupPublicInputs,
+  BlockMergeRollupInputs,
+  BlockRootOrBlockMergePublicInputs,
+  BlockRootRollupInputs,
+  EmptyBlockRootRollupInputs,
+  MergeRollupInputs,
+  PrivateBaseRollupInputs,
+  PublicBaseRollupInputs,
+  RootRollupInputs,
+  RootRollupPublicInputs,
+  SingleTxBlockRootRollupInputs,
+} from '@aztec/stdlib/rollup';
+import {
+  makeBaseOrMergeRollupPublicInputs,
+  makeBlockRootOrBlockMergeRollupPublicInputs,
+  makeParityPublicInputs,
+  makeRootRollupPublicInputs,
+} from '@aztec/stdlib/testing';
+import { VerificationKeyData } from '@aztec/stdlib/vks';
+
+import { InlineProofStore, type ProofStore } from '../proving_broker/proof_store/index.js';
+import { ProvingAgent } from '../proving_broker/proving_agent.js';
+import { ProvingBroker } from '../proving_broker/proving_broker.js';
+import { InMemoryBrokerDatabase } from '../proving_broker/proving_broker_database/memory.js';
+
+export class TestBroker implements ProvingJobProducer {
+  private broker: ProvingBroker;
+  private agents: ProvingAgent[];
+
+  constructor(
+    agentCount: number,
+    prover: ServerCircuitProver,
+    private proofStore: ProofStore = new InlineProofStore(),
+    agentPollInterval = 100,
+  ) {
+    this.broker = new ProvingBroker(new InMemoryBrokerDatabase());
+    this.agents = times(
+      agentCount,
+      () => new ProvingAgent(this.broker, proofStore, prover, undefined, agentPollInterval),
+    );
+  }
+
+  public async start() {
+    await this.broker.start();
+    this.agents.forEach(agent => agent.start());
+  }
+
+  public async stop() {
+    await Promise.all(this.agents.map(agent => agent.stop()));
+    await this.broker.stop();
+  }
+
+  public getProofStore(): ProofStore {
+    return this.proofStore;
+  }
+
+  enqueueProvingJob(job: ProvingJob): Promise<ProvingJobStatus> {
+    return this.broker.enqueueProvingJob(job);
+  }
+  getProvingJobStatus(id: ProvingJobId): Promise<ProvingJobStatus> {
+    return this.broker.getProvingJobStatus(id);
+  }
+  cancelProvingJob(id: string): Promise<void> {
+    return this.broker.cancelProvingJob(id);
+  }
+
+  getCompletedJobs(ids: ProvingJobId[]): Promise<ProvingJobId[]> {
+    return this.broker.getCompletedJobs(ids);
+  }
+}
+
+export class MockProver implements ServerCircuitProver {
+  constructor() {}
+
+  getAvmProof(_inputs: AvmCircuitInputs, _signal?: AbortSignal, _epochNumber?: number) {
+    return Promise.resolve(
+      makeProofAndVerificationKey(
+        makeEmptyRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS),
+        VerificationKeyData.makeFake(AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS),
+      ),
+    );
+  }
+
+  getBaseParityProof(_inputs: BaseParityInputs, _signal?: AbortSignal, _epochNumber?: number) {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeParityPublicInputs(),
+        makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
+        VerificationKeyData.makeFakeHonk(),
+      ),
+    );
+  }
+
+  getRootParityProof(_inputs: RootParityInputs, _signal?: AbortSignal, _epochNumber?: number) {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeParityPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
+        VerificationKeyData.makeFakeHonk(),
+      ),
+    );
+  }
+
+  getPrivateBaseRollupProof(
+    _baseRollupInput: PrivateBaseRollupInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<
+    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBaseOrMergeRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getPublicBaseRollupProof(
+    _inputs: PublicBaseRollupInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<
+    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBaseOrMergeRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getMergeRollupProof(
+    _input: MergeRollupInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<
+    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBaseOrMergeRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getBlockMergeRollupProof(_input: BlockMergeRollupInputs, _signal?: AbortSignal, _epochNumber?: number) {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getEmptyBlockRootRollupProof(
+    _input: EmptyBlockRootRollupInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getBlockRootRollupProof(
+    _input: BlockRootRollupInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getSingleTxBlockRootRollupProof(
+    _input: SingleTxBlockRootRollupInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeHonk(),
+      ),
+    );
+  }
+
+  getRootRollupProof(
+    _input: RootRollupInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeRootRollupPublicInputs(),
+        makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
+        VerificationKeyData.makeFakeHonk(),
+      ),
+    );
+  }
+
+  getTubeProof(): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>> {
+    return Promise.resolve(
+      makeProofAndVerificationKey(makeRecursiveProof(TUBE_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()),
+    );
+  }
+}