@aztec/prover-client 0.0.0-test.1 → 0.0.1-commit.0b941701

package/src/proving_broker/proving_job_controller.ts

@@ -1,3 +1,6 @@
+import { EpochNumber } from '@aztec/foundation/branded-types';
+import { randomBytes } from '@aztec/foundation/crypto/random';
+import { AbortError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import type {
   ProvingJobId,
@@ -9,38 +12,29 @@ import { ProvingRequestType } from '@aztec/stdlib/proofs';
 
 export enum ProvingJobControllerStatus {
   IDLE = 'idle',
-  PROVING = 'proving',
+  RUNNING = 'running',
   DONE = 'done',
-  ABORTED = 'aborted',
-}
-
-interface ProvingJobCompletionCallback<T extends ProvingRequestType = ProvingRequestType> {
-  (
-    jobId: ProvingJobId,
-    type: T,
-    error: Error | undefined,
-    result: ProvingJobResultsMap[T] | undefined,
-  ): void | Promise<void>;
 }
 
 export class ProvingJobController {
   private status: ProvingJobControllerStatus = ProvingJobControllerStatus.IDLE;
   private promise?: Promise<void>;
   private abortController = new AbortController();
+  private result?: ProvingJobResultsMap[ProvingRequestType] | Error;
 
   constructor(
     private jobId: ProvingJobId,
     private inputs: ProvingJobInputs,
-    private epochNumber: number,
+    private epochNumber: EpochNumber,
     private startedAt: number,
     private circuitProver: ServerCircuitProver,
-    private onComplete: ProvingJobCompletionCallback,
-    private log = createLogger('prover-client:proving-agent:job-controller'),
+    private onComplete: () => void,
+    private log = createLogger('prover-client:proving-agent:job-controller-' + randomBytes(4).toString('hex')),
   ) {}
 
   public start(): void {
     if (this.status !== ProvingJobControllerStatus.IDLE) {
-      this.log.verbose(
+      this.log.warn(
         `Job controller for jobId=${this.jobId} not starting because it is not idle currentStatus=${this.status}`,
         {
           currentStatus: this.status,
@@ -50,63 +44,23 @@ export class ProvingJobController {
       return;
     }
 
-    this.status = ProvingJobControllerStatus.PROVING;
-    this.log.verbose(`Job controller started jobId=${this.jobId}`, {
+    this.promise = this.run();
+
+    this.log.info(`Job controller started jobId=${this.jobId}`, {
       jobId: this.jobId,
     });
-
-    this.promise = this.generateProof()
-      .then(
-        result => {
-          if (this.status === ProvingJobControllerStatus.ABORTED) {
-            this.log.warn(`Job controller for jobId=${this.jobId} completed successfully but job was aborted`, {
-              currentStatus: this.status,
-              jobId: this.jobId,
-            });
-            return;
-          }
-          this.status = ProvingJobControllerStatus.DONE;
-          this.log.verbose(`Job controller for jobId=${this.jobId} completed successfully`, {
-            jobId: this.jobId,
-          });
-          return this.onComplete(this.jobId, this.inputs.type, undefined, result);
-        },
-        error => {
-          if (this.status === ProvingJobControllerStatus.ABORTED) {
-            this.log.warn(`Job controller for jobId=${this.jobId} finished with an error but job was aborted`, {
-              currentStatus: this.status,
-              jobId: this.jobId,
-            });
-            return;
-          }
-
-          if (error.name === 'AbortError') {
-            // Ignore abort errors
-            return;
-          }
-
-          this.log.verbose(`Job controller for jobId=${this.jobId} finished with an error`, {
-            jobId: this.jobId,
-            err: error,
-          });
-
-          this.status = ProvingJobControllerStatus.DONE;
-          return this.onComplete(this.jobId, this.inputs.type, error, undefined);
-        },
-      )
-      .catch(err => {
-        this.log.error(`Job constroller failed to send result for jobId=${this.jobId}: ${err}`, err, {
-          jobId: this.jobId,
-        });
-      });
   }
 
   public getStatus(): ProvingJobControllerStatus {
     return this.status;
   }
 
+  public getResult(): ProvingJobResultsMap[ProvingRequestType] | Error | undefined {
+    return this.result;
+  }
+
   public abort(): void {
-    if (this.status !== ProvingJobControllerStatus.PROVING) {
+    if (this.status !== ProvingJobControllerStatus.RUNNING) {
       this.log.warn(`Tried to abort job controller for jobId=${this.jobId} but it is not running`, {
         currentStatus: this.status,
         jobId: this.jobId,
@@ -114,9 +68,8 @@ export class ProvingJobController {
       return;
     }
 
-    this.status = ProvingJobControllerStatus.ABORTED;
     this.abortController.abort();
-    this.log.verbose(`Aborted job controller for jobId=${this.jobId}`, {
+    this.log.warn(`Aborted job controller for jobId=${this.jobId}`, {
       jobId: this.jobId,
     });
   }
@@ -125,6 +78,10 @@ export class ProvingJobController {
     return this.jobId;
   }
 
+  public getProofType(): ProvingRequestType {
+    return this.inputs.type;
+  }
+
   public getStartedAt(): number {
     return this.startedAt;
   }
@@ -133,6 +90,36 @@ export class ProvingJobController {
     return ProvingRequestType[this.inputs.type];
   }
 
+  private run = async () => {
+    this.status = ProvingJobControllerStatus.RUNNING;
+    let result: ProvingJobResultsMap[ProvingRequestType] | Error;
+    try {
+      result = await this.generateProof();
+    } catch (err) {
+      if (err && err instanceof Error) {
+        result = err;
+      } else {
+        result = new Error('Unknown proving error: ' + String(err), { cause: err });
+      }
+    }
+
+    if (this.abortController.signal.aborted) {
+      this.log.warn(`Job controller for jobId=${this.jobId} completed but job was aborted`, {
+        currentStatus: this.status,
+        jobId: this.jobId,
+      });
+      result = new AbortError('Proof was aborted');
+    }
+
+    this.result = result;
+    this.status = ProvingJobControllerStatus.DONE;
+    try {
+      this.onComplete();
+    } catch (err) {
+      this.log.warn(`On complete handler error: ${err}`, { jobId: this.jobId });
+    }
+  };
+
   private async generateProof(): Promise<ProvingJobResultsMap[ProvingRequestType]> {
     const { type, inputs } = this.inputs;
     const signal = this.abortController.signal;
@@ -141,50 +128,74 @@ export class ProvingJobController {
         return await this.circuitProver.getAvmProof(inputs, signal, this.epochNumber);
       }
 
-      case ProvingRequestType.PRIVATE_BASE_ROLLUP: {
-        return await this.circuitProver.getPrivateBaseRollupProof(inputs, signal, this.epochNumber);
+      case ProvingRequestType.PUBLIC_CHONK_VERIFIER: {
+        return await this.circuitProver.getPublicChonkVerifierProof(inputs, signal, this.epochNumber);
+      }
+
+      case ProvingRequestType.PRIVATE_TX_BASE_ROLLUP: {
+        return await this.circuitProver.getPrivateTxBaseRollupProof(inputs, signal, this.epochNumber);
       }
 
-      case ProvingRequestType.PUBLIC_BASE_ROLLUP: {
-        return await this.circuitProver.getPublicBaseRollupProof(inputs, signal, this.epochNumber);
+      case ProvingRequestType.PUBLIC_TX_BASE_ROLLUP: {
+        return await this.circuitProver.getPublicTxBaseRollupProof(inputs, signal, this.epochNumber);
       }
 
-      case ProvingRequestType.MERGE_ROLLUP: {
-        return await this.circuitProver.getMergeRollupProof(inputs, signal, this.epochNumber);
+      case ProvingRequestType.TX_MERGE_ROLLUP: {
+        return await this.circuitProver.getTxMergeRollupProof(inputs, signal, this.epochNumber);
       }
 
-      case ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP: {
-        return await this.circuitProver.getEmptyBlockRootRollupProof(inputs, signal, this.epochNumber);
+      case ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP: {
+        return await this.circuitProver.getBlockRootFirstRollupProof(inputs, signal, this.epochNumber);
+      }
+
+      case ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP: {
+        return await this.circuitProver.getBlockRootSingleTxFirstRollupProof(inputs, signal, this.epochNumber);
+      }
+
+      case ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP: {
+        return await this.circuitProver.getBlockRootEmptyTxFirstRollupProof(inputs, signal, this.epochNumber);
       }
 
       case ProvingRequestType.BLOCK_ROOT_ROLLUP: {
         return await this.circuitProver.getBlockRootRollupProof(inputs, signal, this.epochNumber);
       }
 
-      case ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP: {
-        return await this.circuitProver.getSingleTxBlockRootRollupProof(inputs, signal, this.epochNumber);
+      case ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP: {
+        return await this.circuitProver.getBlockRootSingleTxRollupProof(inputs, signal, this.epochNumber);
       }
 
       case ProvingRequestType.BLOCK_MERGE_ROLLUP: {
         return await this.circuitProver.getBlockMergeRollupProof(inputs, signal, this.epochNumber);
       }
 
+      case ProvingRequestType.CHECKPOINT_ROOT_ROLLUP: {
+        return await this.circuitProver.getCheckpointRootRollupProof(inputs, signal, this.epochNumber);
+      }
+
+      case ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP: {
+        return await this.circuitProver.getCheckpointRootSingleBlockRollupProof(inputs, signal, this.epochNumber);
+      }
+
+      case ProvingRequestType.CHECKPOINT_PADDING_ROLLUP: {
+        return await this.circuitProver.getCheckpointPaddingRollupProof(inputs, signal, this.epochNumber);
+      }
+
+      case ProvingRequestType.CHECKPOINT_MERGE_ROLLUP: {
+        return await this.circuitProver.getCheckpointMergeRollupProof(inputs, signal, this.epochNumber);
+      }
+
       case ProvingRequestType.ROOT_ROLLUP: {
         return await this.circuitProver.getRootRollupProof(inputs, signal, this.epochNumber);
       }
 
-      case ProvingRequestType.BASE_PARITY: {
+      case ProvingRequestType.PARITY_BASE: {
         return await this.circuitProver.getBaseParityProof(inputs, signal, this.epochNumber);
       }
 
-      case ProvingRequestType.ROOT_PARITY: {
+      case ProvingRequestType.PARITY_ROOT: {
         return await this.circuitProver.getRootParityProof(inputs, signal, this.epochNumber);
       }
 
-      case ProvingRequestType.TUBE_PROOF: {
-        return await this.circuitProver.getTubeProof(inputs, signal, this.epochNumber);
-      }
-
       default: {
         const _exhaustive: never = type;
         return Promise.reject(new Error(`Invalid proof request type: ${type}`));

package/src/proving_broker/rpc.ts

@@ -1,5 +1,4 @@
 import { createSafeJsonRpcClient } from '@aztec/foundation/json-rpc/client';
-import type { SafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
 import {
   type GetProvingJobResponse,
   ProofUri,
@@ -13,7 +12,7 @@ import {
 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 { makeTracedFetch } from '@aztec/telemetry-client';
 
 import { z } from 'zod';
 
@@ -54,10 +53,6 @@ export const ProvingJobBrokerSchema: ApiSchemaFor<ProvingJobBroker> = {
   ...ProvingJobProducerSchema,
 };
 
-export function createProvingBrokerServer(broker: ProvingJobBroker): SafeJsonRpcServer {
-  return createTracedJsonRpcServer(broker, ProvingJobBrokerSchema);
-}
-
 export function createProvingJobBrokerClient(
   url: string,
   versions: Partial<ComponentsVersions>,

package/src/test/mock_proof_store.ts

@@ -0,0 +1,14 @@
+import type { ProvingJobId } from '@aztec/stdlib/interfaces/server';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+
+// Mock ProofStore for faster benchmarks with realistic Cloud Storage URIs
+export class MockProofStore {
+  private mockCounter = 0;
+  private readonly bucketName = 'aztec-proving-benchmarks';
+  private readonly basePath = 'proving-jobs';
+
+  saveProofInput(jobId: ProvingJobId, type: ProvingRequestType): Promise<string> {
+    const uri = `gs://${this.bucketName}/${this.basePath}/inputs/${type}/${jobId}`;
+    return Promise.resolve(uri as any);
+  }
+}

package/src/test/mock_prover.ts

@@ -1,44 +1,51 @@
 import {
-  AVM_PROOF_LENGTH_IN_FIELDS,
-  AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS,
+  AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
   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 type { ParityBasePrivateInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity';
 import { makeEmptyRecursiveProof, makeRecursiveProof } from '@aztec/stdlib/proofs';
 import type {
-  BaseOrMergeRollupPublicInputs,
-  BlockMergeRollupInputs,
-  BlockRootOrBlockMergePublicInputs,
-  BlockRootRollupInputs,
-  EmptyBlockRootRollupInputs,
-  MergeRollupInputs,
-  PrivateBaseRollupInputs,
-  PublicBaseRollupInputs,
-  RootRollupInputs,
+  BlockMergeRollupPrivateInputs,
+  BlockRollupPublicInputs,
+  BlockRootEmptyTxFirstRollupPrivateInputs,
+  BlockRootFirstRollupPrivateInputs,
+  BlockRootRollupPrivateInputs,
+  BlockRootSingleTxFirstRollupPrivateInputs,
+  BlockRootSingleTxRollupPrivateInputs,
+  CheckpointMergeRollupPrivateInputs,
+  CheckpointPaddingRollupPrivateInputs,
+  CheckpointRollupPublicInputs,
+  CheckpointRootRollupPrivateInputs,
+  CheckpointRootSingleBlockRollupPrivateInputs,
+  PrivateTxBaseRollupPrivateInputs,
+  PublicChonkVerifierPrivateInputs,
+  PublicChonkVerifierPublicInputs,
+  PublicTxBaseRollupPrivateInputs,
+  RootRollupPrivateInputs,
   RootRollupPublicInputs,
-  SingleTxBlockRootRollupInputs,
+  TxMergeRollupPrivateInputs,
+  TxRollupPublicInputs,
 } from '@aztec/stdlib/rollup';
 import {
-  makeBaseOrMergeRollupPublicInputs,
-  makeBlockRootOrBlockMergeRollupPublicInputs,
+  makeBlockRollupPublicInputs,
+  makeCheckpointRollupPublicInputs,
   makeParityPublicInputs,
+  makePublicChonkVerifierPublicInputs,
   makeRootRollupPublicInputs,
+  makeTxRollupPublicInputs,
 } from '@aztec/stdlib/testing';
 import { VerificationKeyData } from '@aztec/stdlib/vks';
 
@@ -97,15 +104,10 @@ 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),
-      ),
-    );
+    return Promise.resolve(makeEmptyRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED));
   }
 
-  getBaseParityProof(_inputs: BaseParityInputs, _signal?: AbortSignal, _epochNumber?: number) {
+  getBaseParityProof(_inputs: ParityBasePrivateInputs, _signal?: AbortSignal, _epochNumber?: number) {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeParityPublicInputs(),
@@ -115,7 +117,7 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getRootParityProof(_inputs: RootParityInputs, _signal?: AbortSignal, _epochNumber?: number) {
+  getRootParityProof(_inputs: ParityRootPrivateInputs, _signal?: AbortSignal, _epochNumber?: number) {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeParityPublicInputs(),
@@ -125,114 +127,210 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getPrivateBaseRollupProof(
-    _baseRollupInput: PrivateBaseRollupInputs,
+  getPublicChonkVerifierProof(
+    _inputs: PublicChonkVerifierPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBaseOrMergeRollupPublicInputs(),
+        makePublicChonkVerifierPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getPublicBaseRollupProof(
-    _inputs: PublicBaseRollupInputs,
+  getPrivateTxBaseRollupProof(
+    _baseRollupInput: PrivateTxBaseRollupPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  > {
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBaseOrMergeRollupPublicInputs(),
+        makeTxRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getMergeRollupProof(
-    _input: MergeRollupInputs,
+  getPublicTxBaseRollupProof(
+    _inputs: PublicTxBaseRollupPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  > {
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeTxRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getTxMergeRollupProof(
+    _input: TxMergeRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeTxRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getBlockRootFirstRollupProof(
+    _input: BlockRootFirstRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBaseOrMergeRollupPublicInputs(),
+        makeBlockRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getBlockMergeRollupProof(_input: BlockMergeRollupInputs, _signal?: AbortSignal, _epochNumber?: number) {
+  getBlockRootSingleTxFirstRollupProof(
+    _input: BlockRootSingleTxFirstRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeHonk(),
+      ),
+    );
+  }
+
+  getBlockRootEmptyTxFirstRollupProof(
+    _input: BlockRootEmptyTxFirstRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeBlockRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getEmptyBlockRootRollupProof(
-    _input: EmptyBlockRootRollupInputs,
+  getBlockRootRollupProof(
+    _input: BlockRootRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getBlockRootSingleTxRollupProof(
+    _input: BlockRootSingleTxRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeHonk(),
+      ),
+    );
+  }
+
+  getBlockMergeRollupProof(_input: BlockMergeRollupPrivateInputs, _signal?: AbortSignal, _epochNumber?: number) {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getCheckpointRootRollupProof(
+    _input: CheckpointRootRollupPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeCheckpointRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getBlockRootRollupProof(
-    _input: BlockRootRollupInputs,
+  getCheckpointRootSingleBlockRollupProof(
+    _input: CheckpointRootSingleBlockRollupPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeCheckpointRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getSingleTxBlockRootRollupProof(
-    _input: SingleTxBlockRootRollupInputs,
+  getCheckpointMergeRollupProof(
+    _input: CheckpointMergeRollupPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeCheckpointRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
-        VerificationKeyData.makeFakeHonk(),
+        VerificationKeyData.makeFakeRollupHonk(),
+      ),
+    );
+  }
+
+  getCheckpointPaddingRollupProof(
+    _input: CheckpointPaddingRollupPrivateInputs,
+    _signal?: AbortSignal,
+    _epochNumber?: number,
+  ): Promise<
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeCheckpointRollupPublicInputs(),
+        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
+        VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
   getRootRollupProof(
-    _input: RootRollupInputs,
+    _input: RootRollupPrivateInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>> {
@@ -244,10 +342,4 @@ export class MockProver implements ServerCircuitProver {
       ),
     );
   }
-
-  getTubeProof(): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>> {
-    return Promise.resolve(
-      makeProofAndVerificationKey(makeRecursiveProof(TUBE_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()),
-    );
-  }
 }

package/dest/bin/get-proof-inputs.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=get-proof-inputs.d.ts.map

package/dest/bin/get-proof-inputs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-proof-inputs.d.ts","sourceRoot":"","sources":["../../src/bin/get-proof-inputs.ts"],"names":[],"mappings":""}