@aztec/prover-client 0.63.1 → 0.65.0

package/src/proving_broker/proving_job_controller.ts

@@ -0,0 +1,148 @@
+import {
+  ProvingRequestType,
+  type ServerCircuitProver,
+  type V2ProofOutput,
+  type V2ProvingJob,
+  type V2ProvingJobId,
+} from '@aztec/circuit-types';
+
+export enum ProvingJobStatus {
+  IDLE = 'idle',
+  PROVING = 'proving',
+  DONE = 'done',
+}
+
+type ProvingJobCompletionCallback = (
+  error: Error | undefined,
+  result: V2ProofOutput | undefined,
+) => void | Promise<void>;
+
+export class ProvingJobController {
+  private status: ProvingJobStatus = ProvingJobStatus.IDLE;
+  private promise?: Promise<void>;
+  private abortController = new AbortController();
+
+  constructor(
+    private job: V2ProvingJob,
+    private startedAt: number,
+    private circuitProver: ServerCircuitProver,
+    private onComplete: ProvingJobCompletionCallback,
+  ) {}
+
+  public start(): void {
+    if (this.status !== ProvingJobStatus.IDLE) {
+      return;
+    }
+
+    this.status = ProvingJobStatus.PROVING;
+    this.promise = this.generateProof()
+      .then(
+        result => {
+          this.status = ProvingJobStatus.DONE;
+          return this.onComplete(undefined, result);
+        },
+        error => {
+          this.status = ProvingJobStatus.DONE;
+          if (error.name === 'AbortError') {
+            // Ignore abort errors
+            return;
+          }
+          return this.onComplete(error, undefined);
+        },
+      )
+      .catch(_ => {
+        // ignore completion errors
+      });
+  }
+
+  public getStatus(): ProvingJobStatus {
+    return this.status;
+  }
+
+  public abort(): void {
+    if (this.status !== ProvingJobStatus.PROVING) {
+      return;
+    }
+
+    this.abortController.abort();
+  }
+
+  public getJobId(): V2ProvingJobId {
+    return this.job.id;
+  }
+
+  public getStartedAt(): number {
+    return this.startedAt;
+  }
+
+  private async generateProof(): Promise<V2ProofOutput> {
+    const { type, inputs } = this.job;
+    const signal = this.abortController.signal;
+    switch (type) {
+      case ProvingRequestType.PUBLIC_VM: {
+        const value = await this.circuitProver.getAvmProof(inputs, signal);
+        return { type, value };
+      }
+
+      case ProvingRequestType.PRIVATE_BASE_ROLLUP: {
+        const value = await this.circuitProver.getPrivateBaseRollupProof(inputs, signal);
+        return { type, value };
+      }
+
+      case ProvingRequestType.PUBLIC_BASE_ROLLUP: {
+        const value = await this.circuitProver.getPublicBaseRollupProof(inputs, signal);
+        return { type, value };
+      }
+
+      case ProvingRequestType.MERGE_ROLLUP: {
+        const value = await this.circuitProver.getMergeRollupProof(inputs, signal);
+        return { type, value };
+      }
+
+      case ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP: {
+        const value = await this.circuitProver.getEmptyBlockRootRollupProof(inputs, signal);
+        return { type, value };
+      }
+
+      case ProvingRequestType.BLOCK_ROOT_ROLLUP: {
+        const value = await this.circuitProver.getBlockRootRollupProof(inputs, signal);
+        return { type, value };
+      }
+
+      case ProvingRequestType.BLOCK_MERGE_ROLLUP: {
+        const value = await this.circuitProver.getBlockMergeRollupProof(inputs, signal);
+        return { type, value };
+      }
+
+      case ProvingRequestType.ROOT_ROLLUP: {
+        const value = await this.circuitProver.getRootRollupProof(inputs, signal);
+        return { type, value };
+      }
+
+      case ProvingRequestType.BASE_PARITY: {
+        const value = await this.circuitProver.getBaseParityProof(inputs, signal);
+        return { type, value };
+      }
+
+      case ProvingRequestType.ROOT_PARITY: {
+        const value = await this.circuitProver.getRootParityProof(inputs, signal);
+        return { type, value };
+      }
+
+      case ProvingRequestType.PRIVATE_KERNEL_EMPTY: {
+        const value = await this.circuitProver.getEmptyPrivateKernelProof(inputs, signal);
+        return { type, value };
+      }
+
+      case ProvingRequestType.TUBE_PROOF: {
+        const value = await this.circuitProver.getTubeProof(inputs, signal);
+        return { type, value };
+      }
+
+      default: {
+        const _exhaustive: never = type;
+        return Promise.reject(new Error(`Invalid proof request type: ${type}`));
+      }
+    }
+  }
+}

package/src/test/mock_prover.ts

@@ -8,11 +8,22 @@ import {
 import {
   AVM_PROOF_LENGTH_IN_FIELDS,
   AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS,
+  type AvmCircuitInputs,
   type BaseOrMergeRollupPublicInputs,
+  type BaseParityInputs,
+  type BlockMergeRollupInputs,
   type BlockRootOrBlockMergePublicInputs,
+  type BlockRootRollupInputs,
+  type EmptyBlockRootRollupInputs,
   type KernelCircuitPublicInputs,
+  type MergeRollupInputs,
   NESTED_RECURSIVE_PROOF_LENGTH,
+  type PrivateBaseRollupInputs,
+  type PrivateKernelEmptyInputData,
+  type PublicBaseRollupInputs,
   RECURSIVE_PROOF_LENGTH,
+  type RootParityInputs,
+  type RootRollupInputs,
   type RootRollupPublicInputs,
   TUBE_PROOF_LENGTH,
   VerificationKeyData,
@@ -30,7 +41,7 @@ import {
 export class MockProver implements ServerCircuitProver {
   constructor() {}
 
-  getAvmProof() {
+  getAvmProof(_inputs: AvmCircuitInputs, _signal?: AbortSignal, _epochNumber?: number) {
     return Promise.resolve(
       makeProofAndVerificationKey(
         makeEmptyRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS),
@@ -39,7 +50,7 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getBaseParityProof() {
+  getBaseParityProof(_inputs: BaseParityInputs, _signal?: AbortSignal, _epochNumber?: number) {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeParityPublicInputs(),
@@ -49,7 +60,7 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getRootParityProof() {
+  getRootParityProof(_inputs: RootParityInputs, _signal?: AbortSignal, _epochNumber?: number) {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeParityPublicInputs(),
@@ -59,7 +70,11 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getPrivateBaseRollupProof(): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
+  getPrivateBaseRollupProof(
+    _baseRollupInput: PrivateBaseRollupInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeBaseOrMergeRollupPublicInputs(),
@@ -69,7 +84,11 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getPublicBaseRollupProof(): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
+  getPublicBaseRollupProof(
+    _inputs: PublicBaseRollupInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeBaseOrMergeRollupPublicInputs(),
@@ -79,7 +98,11 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getMergeRollupProof(): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
+  getMergeRollupProof(
+    _input: MergeRollupInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeBaseOrMergeRollupPublicInputs(),
@@ -89,7 +112,7 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getBlockMergeRollupProof() {
+  getBlockMergeRollupProof(_input: BlockMergeRollupInputs, _signal?: AbortSignal, _epochNumber?: number) {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeBlockRootOrBlockMergeRollupPublicInputs(),
@@ -99,7 +122,11 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getEmptyBlockRootRollupProof(): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
+  getEmptyBlockRootRollupProof(
+    _input: EmptyBlockRootRollupInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeBlockRootOrBlockMergeRollupPublicInputs(),
@@ -109,7 +136,11 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getBlockRootRollupProof(): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
+  getBlockRootRollupProof(
+    _input: BlockRootRollupInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeBlockRootOrBlockMergeRollupPublicInputs(),
@@ -119,7 +150,11 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getEmptyPrivateKernelProof(): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
+  getEmptyPrivateKernelProof(
+    _inputs: PrivateKernelEmptyInputData,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeKernelCircuitPublicInputs(),
@@ -129,7 +164,11 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getRootRollupProof(): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>> {
+  getRootRollupProof(
+    _input: RootRollupInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeRootRollupPublicInputs(),