@aztec/prover-client 3.0.0-nightly.20250918 → 3.0.0-nightly.20250920

package/src/orchestrator/orchestrator.ts

@@ -34,7 +34,7 @@ import {
   BlockRootSingleTxRollupPrivateInputs,
   CheckpointConstantData,
   CheckpointRootSingleBlockRollupPrivateInputs,
-  PrivateBaseRollupInputs,
+  PrivateTxBaseRollupPrivateInputs,
   PublicTubePrivateInputs,
   RootRollupPublicInputs,
 } from '@aztec/stdlib/rollup';
@@ -119,7 +119,6 @@ export class ProvingOrchestrator implements EpochProver {
 
   public startNewEpoch(
     epochNumber: number,
-    firstCheckpointNumber: Fr,
     totalNumCheckpoints: number,
     finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
   ) {
@@ -134,7 +133,6 @@ export class ProvingOrchestrator implements EpochProver {
     logger.info(`Starting epoch ${epochNumber} with ${totalNumCheckpoints} checkpoints.`);
     this.provingState = new EpochProvingState(
       epochNumber,
-      firstCheckpointNumber,
       totalNumCheckpoints,
       finalBlobBatchingChallenges,
       provingState => this.checkAndEnqueueCheckpointRootRollup(provingState),
@@ -145,6 +143,7 @@ export class ProvingOrchestrator implements EpochProver {
   }
 
   public async startNewCheckpoint(
+    checkpointIndex: number,
     constants: CheckpointConstantData,
     l1ToL2Messages: Fr[],
     totalNumBlocks: number,
@@ -178,6 +177,7 @@ export class ProvingOrchestrator implements EpochProver {
     } = await this.updateL1ToL2MessageTree(l1ToL2Messages, db);
 
     this.provingState.startNewCheckpoint(
+      checkpointIndex,
       constants,
       totalNumBlocks,
       totalNumBlobFields,
@@ -694,23 +694,25 @@ export class ProvingOrchestrator implements EpochProver {
       wrapCallbackInSpan(
         this.tracer,
         `ProvingOrchestrator.prover.${
-          inputs instanceof PrivateBaseRollupInputs ? 'getPrivateBaseRollupProof' : 'getPublicBaseRollupProof'
+          inputs instanceof PrivateTxBaseRollupPrivateInputs
+            ? 'getPrivateTxBaseRollupProof'
+            : 'getPublicTxBaseRollupProof'
         }`,
         {
           [Attributes.TX_HASH]: processedTx.hash.toString(),
           [Attributes.PROTOCOL_CIRCUIT_NAME]: rollupType,
         },
         signal => {
-          if (inputs instanceof PrivateBaseRollupInputs) {
-            return this.prover.getPrivateBaseRollupProof(inputs, signal, provingState.epochNumber);
+          if (inputs instanceof PrivateTxBaseRollupPrivateInputs) {
+            return this.prover.getPrivateTxBaseRollupProof(inputs, signal, provingState.epochNumber);
           } else {
-            return this.prover.getPublicBaseRollupProof(inputs, signal, provingState.epochNumber);
+            return this.prover.getPublicTxBaseRollupProof(inputs, signal, provingState.epochNumber);
           }
         },
       ),
       result => {
         logger.debug(`Completed proof for ${rollupType} for tx ${processedTx.hash.toString()}`);
-        validatePartialState(result.inputs.end, txProvingState.treeSnapshots);
+        validatePartialState(result.inputs.endPartialState, txProvingState.treeSnapshots);
         const leafLocation = provingState.setBaseRollupProof(txIndex, result);
         if (provingState.totalNumTxs === 1) {
           this.checkAndEnqueueBlockRootRollup(provingState);
@@ -777,7 +779,7 @@ export class ProvingOrchestrator implements EpochProver {
         'ProvingOrchestrator.prover.getPublicTubeProof',
         {
           [Attributes.TX_HASH]: txHash,
-          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'public-tube' satisfies CircuitName,
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'tube-public' satisfies CircuitName,
         },
         signal => this.prover.getPublicTubeProof(inputs, signal, provingState.epochNumber),
       ),
@@ -804,11 +806,11 @@ export class ProvingOrchestrator implements EpochProver {
       provingState,
       wrapCallbackInSpan(
         this.tracer,
-        'ProvingOrchestrator.prover.getMergeRollupProof',
+        'ProvingOrchestrator.prover.getTxMergeRollupProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'merge-rollup' satisfies CircuitName,
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'rollup-tx-merge' satisfies CircuitName,
         },
-        signal => this.prover.getMergeRollupProof(inputs, signal, provingState.epochNumber),
+        signal => this.prover.getTxMergeRollupProof(inputs, signal, provingState.epochNumber),
       ),
       result => {
         provingState.setMergeRollupProof(location, result);
@@ -898,7 +900,7 @@ export class ProvingOrchestrator implements EpochProver {
         this.tracer,
         'ProvingOrchestrator.prover.getBaseParityProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'base-parity' satisfies CircuitName,
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'parity-base' satisfies CircuitName,
         },
         signal => this.prover.getBaseParityProof(inputs, signal, provingState.epochNumber),
       ),
@@ -930,7 +932,7 @@ export class ProvingOrchestrator implements EpochProver {
       return;
     }
 
-    const inputs = provingState.getRootParityInputs();
+    const inputs = provingState.getParityRootInputs();
 
     this.deferredProving(
       provingState,
@@ -938,7 +940,7 @@ export class ProvingOrchestrator implements EpochProver {
         this.tracer,
         'ProvingOrchestrator.prover.getRootParityProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'root-parity' satisfies CircuitName,
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'parity-root' satisfies CircuitName,
         },
         signal => this.prover.getRootParityProof(inputs, signal, provingState.epochNumber),
       ),
@@ -969,7 +971,7 @@ export class ProvingOrchestrator implements EpochProver {
         this.tracer,
         'ProvingOrchestrator.prover.getBlockMergeRollupProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'block-merge-rollup' satisfies CircuitName,
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'rollup-block-merge' satisfies CircuitName,
         },
         signal => this.prover.getBlockMergeRollupProof(inputs, signal, provingState.epochNumber),
       ),
@@ -1060,7 +1062,7 @@ export class ProvingOrchestrator implements EpochProver {
         this.tracer,
         'ProvingOrchestrator.prover.getCheckpointMergeRollupProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'checkpoint-merge-rollup' satisfies CircuitName,
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'rollup-checkpoint-merge' satisfies CircuitName,
         },
         signal => this.prover.getCheckpointMergeRollupProof(inputs, signal, provingState.epochNumber),
       ),
@@ -1093,7 +1095,7 @@ export class ProvingOrchestrator implements EpochProver {
         this.tracer,
         'ProvingOrchestrator.prover.getCheckpointPaddingRollupProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'checkpoint-padding-rollup' satisfies CircuitName,
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'rollup-checkpoint-padding' satisfies CircuitName,
         },
         signal => this.prover.getCheckpointPaddingRollupProof(inputs, signal, provingState.epochNumber),
       ),
@@ -1122,7 +1124,7 @@ export class ProvingOrchestrator implements EpochProver {
         this.tracer,
         'ProvingOrchestrator.prover.getRootRollupProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'root-rollup' satisfies CircuitName,
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'rollup-root' satisfies CircuitName,
         },
         signal => this.prover.getRootRollupProof(inputs, signal, provingState.epochNumber),
       ),

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

@@ -13,9 +13,9 @@ import {
   AvmProofData,
   type BaseRollupHints,
   PrivateBaseRollupHints,
-  PrivateBaseRollupInputs,
+  PrivateTxBaseRollupPrivateInputs,
   PublicBaseRollupHints,
-  PublicBaseRollupInputs,
+  PublicTxBaseRollupPrivateInputs,
 } from '@aztec/stdlib/rollup';
 import type { CircuitName } from '@aztec/stdlib/stats';
 import type { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
@@ -61,12 +61,12 @@ export class TxProvingState {
   public getBaseRollupTypeAndInputs() {
     if (this.requireAvmProof) {
       return {
-        rollupType: 'public-base-rollup' satisfies CircuitName,
+        rollupType: 'rollup-tx-base-public' satisfies CircuitName,
         inputs: this.#getPublicBaseInputs(),
       };
     } else {
       return {
-        rollupType: 'private-base-rollup' satisfies CircuitName,
+        rollupType: 'rollup-tx-base-private' satisfies CircuitName,
         inputs: this.#getPrivateBaseInputs(),
       };
     }
@@ -96,7 +96,7 @@ export class TxProvingState {
       getVkData('HidingKernelToRollup'),
     );
 
-    return new PrivateBaseRollupInputs(privateTailProofData, this.baseRollupHints);
+    return new PrivateTxBaseRollupPrivateInputs(privateTailProofData, this.baseRollupHints);
   }
 
   #getPublicBaseInputs() {
@@ -121,7 +121,7 @@ export class TxProvingState {
       this.#getVkData(this.avm!.verificationKey, AVM_VK_INDEX),
     );
 
-    return new PublicBaseRollupInputs(publicTubeProofData, avmProofData, this.baseRollupHints);
+    return new PublicTxBaseRollupPrivateInputs(publicTubeProofData, avmProofData, this.baseRollupHints);
   }
 
   #getVkData(verificationKey: VerificationKeyData, vkIndex: number) {

package/src/prover-client/server-epoch-prover.ts

@@ -19,19 +19,14 @@ export class ServerEpochProver implements EpochProver {
 
   startNewEpoch(
     epochNumber: number,
-    firstCheckpointNumber: Fr,
     totalNumCheckpoints: number,
     finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
   ): void {
-    this.orchestrator.startNewEpoch(
-      epochNumber,
-      firstCheckpointNumber,
-      totalNumCheckpoints,
-      finalBlobBatchingChallenges,
-    );
+    this.orchestrator.startNewEpoch(epochNumber, totalNumCheckpoints, finalBlobBatchingChallenges);
     this.facade.start();
   }
   startNewCheckpoint(
+    checkpointIndex: number,
     constants: CheckpointConstantData,
     l1ToL2Messages: Fr[],
     totalNumBlocks: number,
@@ -39,6 +34,7 @@ export class ServerEpochProver implements EpochProver {
     headerOfLastBlockInPreviousCheckpoint: BlockHeader,
   ): Promise<void> {
     return this.orchestrator.startNewCheckpoint(
+      checkpointIndex,
       constants,
       l1ToL2Messages,
       totalNumBlocks,

package/src/proving_broker/broker_prover_facade.ts

@@ -23,10 +23,9 @@ import {
   makeProvingJobId,
 } from '@aztec/stdlib/interfaces/server';
 import type { PrivateToPublicKernelCircuitPublicInputs } from '@aztec/stdlib/kernel';
-import type { BaseParityInputs, ParityPublicInputs, RootParityInputs } from '@aztec/stdlib/parity';
+import type { ParityBasePrivateInputs, ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity';
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
 import type {
-  BaseOrMergeRollupPublicInputs,
   BlockMergeRollupPrivateInputs,
   BlockRollupPublicInputs,
   BlockRootEmptyTxFirstRollupPrivateInputs,
@@ -39,12 +38,13 @@ import type {
   CheckpointRollupPublicInputs,
   CheckpointRootRollupPrivateInputs,
   CheckpointRootSingleBlockRollupPrivateInputs,
-  MergeRollupInputs,
-  PrivateBaseRollupInputs,
-  PublicBaseRollupInputs,
+  PrivateTxBaseRollupPrivateInputs,
   PublicTubePrivateInputs,
+  PublicTxBaseRollupPrivateInputs,
   RootRollupPrivateInputs,
   RootRollupPublicInputs,
+  TxMergeRollupPrivateInputs,
+  TxRollupPublicInputs,
 } from '@aztec/stdlib/rollup';
 
 import { InlineProofStore, type ProofStore } from './proof_store/index.js';
@@ -418,29 +418,27 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
   }
 
   getBaseParityProof(
-    inputs: BaseParityInputs,
+    inputs: ParityBasePrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>> {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.BASE_PARITY, inputs, epochNumber),
-      ProvingRequestType.BASE_PARITY,
+      this.generateId(ProvingRequestType.PARITY_BASE, inputs, epochNumber),
+      ProvingRequestType.PARITY_BASE,
       inputs,
       epochNumber,
       signal,
     );
   }
 
-  getMergeRollupProof(
-    input: MergeRollupInputs,
+  getTxMergeRollupProof(
+    input: TxMergeRollupPrivateInputs,
     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 this.enqueueJob(
-      this.generateId(ProvingRequestType.MERGE_ROLLUP, input, epochNumber),
-      ProvingRequestType.MERGE_ROLLUP,
+      this.generateId(ProvingRequestType.TX_MERGE_ROLLUP, input, epochNumber),
+      ProvingRequestType.TX_MERGE_ROLLUP,
       input,
       epochNumber,
       signal,
@@ -466,32 +464,28 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
     );
   }
 
-  getPrivateBaseRollupProof(
-    baseRollupInput: PrivateBaseRollupInputs,
+  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 this.enqueueJob(
-      this.generateId(ProvingRequestType.PRIVATE_BASE_ROLLUP, baseRollupInput, epochNumber),
-      ProvingRequestType.PRIVATE_BASE_ROLLUP,
+      this.generateId(ProvingRequestType.PRIVATE_TX_BASE_ROLLUP, baseRollupInput, epochNumber),
+      ProvingRequestType.PRIVATE_TX_BASE_ROLLUP,
       baseRollupInput,
       epochNumber,
       signal,
     );
   }
 
-  getPublicBaseRollupProof(
-    inputs: PublicBaseRollupInputs,
+  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 this.enqueueJob(
-      this.generateId(ProvingRequestType.PUBLIC_BASE_ROLLUP, inputs, epochNumber),
-      ProvingRequestType.PUBLIC_BASE_ROLLUP,
+      this.generateId(ProvingRequestType.PUBLIC_TX_BASE_ROLLUP, inputs, epochNumber),
+      ProvingRequestType.PUBLIC_TX_BASE_ROLLUP,
       inputs,
       epochNumber,
       signal,
@@ -499,13 +493,13 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
   }
 
   getRootParityProof(
-    inputs: RootParityInputs,
+    inputs: ParityRootPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>> {
     return this.enqueueJob(
-      this.generateId(ProvingRequestType.ROOT_PARITY, inputs, epochNumber),
-      ProvingRequestType.ROOT_PARITY,
+      this.generateId(ProvingRequestType.PARITY_ROOT, inputs, epochNumber),
+      ProvingRequestType.PARITY_ROOT,
       inputs,
       epochNumber,
       signal,

package/src/proving_broker/fixtures.ts

@@ -3,7 +3,7 @@ import { type ProofUri, type ProvingJobId, makeProvingJobId } from '@aztec/stdli
 import { ProvingRequestType } from '@aztec/stdlib/proofs';
 
 export function makeRandomProvingJobId(epochNumber?: number): ProvingJobId {
-  return makeProvingJobId(epochNumber ?? 1, ProvingRequestType.BASE_PARITY, randomBytes(8).toString('hex'));
+  return makeProvingJobId(epochNumber ?? 1, ProvingRequestType.PARITY_BASE, randomBytes(8).toString('hex'));
 }
 
 export function makeInputsUri(): ProofUri {

package/src/proving_broker/proof_store/index.ts

@@ -1,3 +1,4 @@
 export * from './proof_store.js';
 export * from './inline_proof_store.js';
 export * from './factory.js';
+export * from './gcs_proof_store.js';

package/src/proving_broker/proving_broker.ts

@@ -46,9 +46,9 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Tr
     [ProvingRequestType.PUBLIC_VM]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
     [ProvingRequestType.PUBLIC_TUBE]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
 
-    [ProvingRequestType.PRIVATE_BASE_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
-    [ProvingRequestType.PUBLIC_BASE_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
-    [ProvingRequestType.MERGE_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
+    [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
+    [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
+    [ProvingRequestType.TX_MERGE_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
     [ProvingRequestType.ROOT_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
 
     [ProvingRequestType.BLOCK_MERGE_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
@@ -69,8 +69,8 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Tr
     [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
     [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
 
-    [ProvingRequestType.BASE_PARITY]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
-    [ProvingRequestType.ROOT_PARITY]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
+    [ProvingRequestType.PARITY_BASE]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
+    [ProvingRequestType.PARITY_ROOT]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
   };
 
   // holds a copy of the database in memory in order to quickly fulfill requests
@@ -696,11 +696,11 @@ export const PROOF_TYPES_IN_PRIORITY_ORDER: ProvingRequestType[] = [
   ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP,
   ProvingRequestType.CHECKPOINT_MERGE_ROLLUP,
   ProvingRequestType.CHECKPOINT_PADDING_ROLLUP,
-  ProvingRequestType.MERGE_ROLLUP,
-  ProvingRequestType.PUBLIC_BASE_ROLLUP,
-  ProvingRequestType.PRIVATE_BASE_ROLLUP,
+  ProvingRequestType.TX_MERGE_ROLLUP,
+  ProvingRequestType.PUBLIC_TX_BASE_ROLLUP,
+  ProvingRequestType.PRIVATE_TX_BASE_ROLLUP,
   ProvingRequestType.PUBLIC_VM,
   ProvingRequestType.PUBLIC_TUBE,
-  ProvingRequestType.ROOT_PARITY,
-  ProvingRequestType.BASE_PARITY,
+  ProvingRequestType.PARITY_ROOT,
+  ProvingRequestType.PARITY_BASE,
 ];

package/src/proving_broker/proving_job_controller.ts

@@ -132,16 +132,16 @@ export class ProvingJobController {
         return await this.circuitProver.getPublicTubeProof(inputs, signal, this.epochNumber);
       }
 
-      case ProvingRequestType.PRIVATE_BASE_ROLLUP: {
-        return await this.circuitProver.getPrivateBaseRollupProof(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.BLOCK_ROOT_FIRST_ROLLUP: {
@@ -188,11 +188,11 @@ export class ProvingJobController {
         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);
       }
 

package/src/test/mock_prover.ts

@@ -18,10 +18,9 @@ import {
   makePublicInputsAndRecursiveProof,
 } from '@aztec/stdlib/interfaces/server';
 import type { PrivateToPublicKernelCircuitPublicInputs } from '@aztec/stdlib/kernel';
-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,
   BlockMergeRollupPrivateInputs,
   BlockRollupPublicInputs,
   BlockRootEmptyTxFirstRollupPrivateInputs,
@@ -34,20 +33,21 @@ import type {
   CheckpointRollupPublicInputs,
   CheckpointRootRollupPrivateInputs,
   CheckpointRootSingleBlockRollupPrivateInputs,
-  MergeRollupInputs,
-  PrivateBaseRollupInputs,
-  PublicBaseRollupInputs,
+  PrivateTxBaseRollupPrivateInputs,
   PublicTubePrivateInputs,
+  PublicTxBaseRollupPrivateInputs,
   RootRollupPrivateInputs,
   RootRollupPublicInputs,
+  TxMergeRollupPrivateInputs,
+  TxRollupPublicInputs,
 } from '@aztec/stdlib/rollup';
 import {
-  makeBaseOrMergeRollupPublicInputs,
   makeBlockRollupPublicInputs,
   makeCheckpointRollupPublicInputs,
   makeParityPublicInputs,
   makePrivateToPublicKernelCircuitPublicInputs,
   makeRootRollupPublicInputs,
+  makeTxRollupPublicInputs,
 } from '@aztec/stdlib/testing';
 import { VerificationKeyData } from '@aztec/stdlib/vks';
 
@@ -119,7 +119,7 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getBaseParityProof(_inputs: BaseParityInputs, _signal?: AbortSignal, _epochNumber?: number) {
+  getBaseParityProof(_inputs: ParityBasePrivateInputs, _signal?: AbortSignal, _epochNumber?: number) {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeParityPublicInputs(),
@@ -129,7 +129,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(),
@@ -158,48 +158,42 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getPrivateBaseRollupProof(
-    _baseRollupInput: PrivateBaseRollupInputs,
+  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(),
       ),
     );
   }
 
-  getPublicBaseRollupProof(
-    _inputs: PublicBaseRollupInputs,
+  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(
-        makeBaseOrMergeRollupPublicInputs(),
+        makeTxRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getMergeRollupProof(
-    _input: MergeRollupInputs,
+  getTxMergeRollupProof(
+    _input: TxMergeRollupPrivateInputs,
     _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(),
       ),

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":""}

package/dest/bin/get-proof-inputs.js

@@ -1,51 +0,0 @@
-/* eslint-disable no-console */ import { AVM_INPUTS_FILENAME } from '@aztec/bb-prover';
-import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
-import { createLogger } from '@aztec/foundation/log';
-import { ProvingJobInputs } from '@aztec/stdlib/interfaces/server';
-import { ProvingRequestType } from '@aztec/stdlib/proofs';
-import { mkdirSync, writeFileSync } from 'fs';
-import { createProofStoreForUri } from '../proving_broker/index.js';
-const logger = createLogger('prover-client:get-proof-inputs');
-function printUsage() {
-    console.error('Usage: get-proof-inputs <proof-uri> [out-dir=.]');
-}
-async function main() {
-    if (process.argv[2] === '--help') {
-        printUsage();
-        return;
-    }
-    const uri = process.argv[2];
-    const outDir = process.argv[3] || '.';
-    if (!uri) {
-        printUsage();
-        throw new Error('Missing proof URI');
-    }
-    mkdirSync(outDir, {
-        recursive: true
-    });
-    const proofStore = createProofStoreForUri(uri);
-    logger.info(`Processing uri ${uri}`);
-    const input = await proofStore.getProofInput(uri);
-    logger.info(`Found inputs for ${ProvingRequestType[input.type]}`);
-    writeProofInputs(input, outDir);
-    console.log(jsonParseWithSchema(jsonStringify(input), ProvingJobInputs).inputs);
-}
-// This mimics the behavior of bb-prover/src/bb/execute.ts
-function writeProofInputs(input, outDir) {
-    switch(input.type){
-        case ProvingRequestType.PUBLIC_VM:
-            {
-                writeFileSync(`${outDir}/${AVM_INPUTS_FILENAME}`, input.inputs.serializeWithMessagePack());
-                logger.info(`Wrote AVM inputs to ${AVM_INPUTS_FILENAME}`);
-                break;
-            }
-        default:
-            {
-                throw new Error(`Unimplemented proving request type: ${ProvingRequestType[input.type]}`);
-            }
-    }
-}
-main().catch((err)=>{
-    console.error(err);
-    process.exit(1);
-});