@aztec/stdlib 2.1.0-rc.9 → 3.0.0-devnet.2

package/src/interfaces/proving-job.ts

@@ -3,7 +3,6 @@ import {
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
-  TUBE_PROOF_LENGTH,
 } from '@aztec/constants';
 import type { ZodFor } from '@aztec/foundation/schemas';
 
@@ -11,23 +10,35 @@ import { z } from 'zod';
 
 import { AvmCircuitInputs } from '../avm/avm.js';
 import { AvmProvingRequestSchema } from '../avm/avm_proving_request.js';
-import { BaseParityInputs } from '../parity/base_parity_inputs.js';
+import { ParityBasePrivateInputs } from '../parity/parity_base_private_inputs.js';
 import { ParityPublicInputs } from '../parity/parity_public_inputs.js';
-import { RootParityInputs } from '../parity/root_parity_inputs.js';
+import { ParityRootPrivateInputs } from '../parity/parity_root_private_inputs.js';
 import { ProvingRequestType } from '../proofs/proving_request_type.js';
 import { RecursiveProof } from '../proofs/recursive_proof.js';
-import { BaseOrMergeRollupPublicInputs } from '../rollup/base_or_merge_rollup_public_inputs.js';
-import { BlockMergeRollupInputs } from '../rollup/block_merge_rollup.js';
-import { BlockRootOrBlockMergePublicInputs } from '../rollup/block_root_or_block_merge_public_inputs.js';
-import { BlockRootRollupInputs, SingleTxBlockRootRollupInputs } from '../rollup/block_root_rollup.js';
-import { EmptyBlockRootRollupInputs } from '../rollup/empty_block_root_rollup_inputs.js';
-import { PaddingBlockRootRollupInputs } from '../rollup/index.js';
-import { MergeRollupInputs } from '../rollup/merge_rollup.js';
-import { PrivateBaseRollupInputs } from '../rollup/private_base_rollup_inputs.js';
-import { PublicBaseRollupInputs } from '../rollup/public_base_rollup_inputs.js';
-import { RootRollupInputs, RootRollupPublicInputs } from '../rollup/root_rollup.js';
-import { TubeInputs } from '../rollup/tube_inputs.js';
-import type { ServerCircuitName } from '../stats/index.js';
+import { BlockMergeRollupPrivateInputs } from '../rollup/block_merge_rollup_private_inputs.js';
+import { BlockRollupPublicInputs } from '../rollup/block_rollup_public_inputs.js';
+import {
+  BlockRootEmptyTxFirstRollupPrivateInputs,
+  BlockRootFirstRollupPrivateInputs,
+  BlockRootRollupPrivateInputs,
+  BlockRootSingleTxFirstRollupPrivateInputs,
+  BlockRootSingleTxRollupPrivateInputs,
+} from '../rollup/block_root_rollup_private_inputs.js';
+import { CheckpointMergeRollupPrivateInputs } from '../rollup/checkpoint_merge_rollup_private_inputs.js';
+import { CheckpointRollupPublicInputs } from '../rollup/checkpoint_rollup_public_inputs.js';
+import {
+  CheckpointPaddingRollupPrivateInputs,
+  CheckpointRootRollupPrivateInputs,
+  CheckpointRootSingleBlockRollupPrivateInputs,
+} from '../rollup/checkpoint_root_rollup_private_inputs.js';
+import { PrivateTxBaseRollupPrivateInputs } from '../rollup/private_tx_base_rollup_private_inputs.js';
+import { PublicTubePrivateInputs } from '../rollup/public_tube_private_inputs.js';
+import { PublicTubePublicInputs } from '../rollup/public_tube_public_inputs.js';
+import { PublicTxBaseRollupPrivateInputs } from '../rollup/public_tx_base_rollup_private_inputs.js';
+import { RootRollupPrivateInputs } from '../rollup/root_rollup_private_inputs.js';
+import { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs.js';
+import { TxMergeRollupPrivateInputs } from '../rollup/tx_merge_rollup_private_inputs.js';
+import { TxRollupPublicInputs } from '../rollup/tx_rollup_public_inputs.js';
 import { VerificationKeyData } from '../vks/verification_key.js';
 
 export type ProofAndVerificationKey<N extends number> = {
@@ -76,91 +87,95 @@ export function makePublicInputsAndRecursiveProof<T, N extends number = typeof N
   return { inputs, proof, verificationKey };
 }
 
-export function mapProvingRequestTypeToCircuitName(type: ProvingRequestType): ServerCircuitName {
-  switch (type) {
-    case ProvingRequestType.PUBLIC_VM:
-      return 'avm-circuit';
-    case ProvingRequestType.PRIVATE_BASE_ROLLUP:
-      return 'private-base-rollup';
-    case ProvingRequestType.PUBLIC_BASE_ROLLUP:
-      return 'public-base-rollup';
-    case ProvingRequestType.MERGE_ROLLUP:
-      return 'merge-rollup';
-    case ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP:
-      return 'empty-block-root-rollup';
-    case ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP:
-      return 'padding-block-root-rollup';
-    case ProvingRequestType.BLOCK_ROOT_ROLLUP:
-      return 'block-root-rollup';
-    case ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP:
-      return 'single-tx-block-root-rollup';
-    case ProvingRequestType.BLOCK_MERGE_ROLLUP:
-      return 'block-merge-rollup';
-    case ProvingRequestType.ROOT_ROLLUP:
-      return 'root-rollup';
-    case ProvingRequestType.BASE_PARITY:
-      return 'base-parity';
-    case ProvingRequestType.ROOT_PARITY:
-      return 'root-parity';
-    case ProvingRequestType.TUBE_PROOF:
-      return 'tube-circuit';
-    default: {
-      const _exhaustive: never = type;
-      throw new Error(`Cannot find circuit name for proving request type: ${type}`);
-    }
-  }
-}
-
 export const ProvingJobInputs = z.discriminatedUnion('type', [
   AvmProvingRequestSchema,
-  z.object({ type: z.literal(ProvingRequestType.BASE_PARITY), inputs: BaseParityInputs.schema }),
-  z.object({ type: z.literal(ProvingRequestType.ROOT_PARITY), inputs: RootParityInputs.schema }),
-  z.object({ type: z.literal(ProvingRequestType.PRIVATE_BASE_ROLLUP), inputs: PrivateBaseRollupInputs.schema }),
-  z.object({ type: z.literal(ProvingRequestType.PUBLIC_BASE_ROLLUP), inputs: PublicBaseRollupInputs.schema }),
-  z.object({ type: z.literal(ProvingRequestType.MERGE_ROLLUP), inputs: MergeRollupInputs.schema }),
-  z.object({ type: z.literal(ProvingRequestType.BLOCK_ROOT_ROLLUP), inputs: BlockRootRollupInputs.schema }),
+  z.object({ type: z.literal(ProvingRequestType.PARITY_BASE), inputs: ParityBasePrivateInputs.schema }),
+  z.object({ type: z.literal(ProvingRequestType.PARITY_ROOT), inputs: ParityRootPrivateInputs.schema }),
+  z.object({ type: z.literal(ProvingRequestType.PUBLIC_TUBE), inputs: PublicTubePrivateInputs.schema }),
+  z.object({
+    type: z.literal(ProvingRequestType.PRIVATE_TX_BASE_ROLLUP),
+    inputs: PrivateTxBaseRollupPrivateInputs.schema,
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.PUBLIC_TX_BASE_ROLLUP),
+    inputs: PublicTxBaseRollupPrivateInputs.schema,
+  }),
+  z.object({ type: z.literal(ProvingRequestType.TX_MERGE_ROLLUP), inputs: TxMergeRollupPrivateInputs.schema }),
+  z.object({
+    type: z.literal(ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP),
+    inputs: BlockRootFirstRollupPrivateInputs.schema,
+  }),
   z.object({
-    type: z.literal(ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP),
-    inputs: SingleTxBlockRootRollupInputs.schema,
+    type: z.literal(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP),
+    inputs: BlockRootSingleTxFirstRollupPrivateInputs.schema,
   }),
-  z.object({ type: z.literal(ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP), inputs: EmptyBlockRootRollupInputs.schema }),
   z.object({
-    type: z.literal(ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP),
-    inputs: PaddingBlockRootRollupInputs.schema,
+    type: z.literal(ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP),
+    inputs: BlockRootEmptyTxFirstRollupPrivateInputs.schema,
   }),
-  z.object({ type: z.literal(ProvingRequestType.BLOCK_MERGE_ROLLUP), inputs: BlockMergeRollupInputs.schema }),
-  z.object({ type: z.literal(ProvingRequestType.ROOT_ROLLUP), inputs: RootRollupInputs.schema }),
-  z.object({ type: z.literal(ProvingRequestType.TUBE_PROOF), inputs: TubeInputs.schema }),
+  z.object({ type: z.literal(ProvingRequestType.BLOCK_ROOT_ROLLUP), inputs: BlockRootRollupPrivateInputs.schema }),
+  z.object({
+    type: z.literal(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP),
+    inputs: BlockRootSingleTxRollupPrivateInputs.schema,
+  }),
+  z.object({ type: z.literal(ProvingRequestType.BLOCK_MERGE_ROLLUP), inputs: BlockMergeRollupPrivateInputs.schema }),
+  z.object({
+    type: z.literal(ProvingRequestType.CHECKPOINT_ROOT_ROLLUP),
+    inputs: CheckpointRootRollupPrivateInputs.schema,
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP),
+    inputs: CheckpointRootSingleBlockRollupPrivateInputs.schema,
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.CHECKPOINT_PADDING_ROLLUP),
+    inputs: CheckpointPaddingRollupPrivateInputs.schema,
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.CHECKPOINT_MERGE_ROLLUP),
+    inputs: CheckpointMergeRollupPrivateInputs.schema,
+  }),
+  z.object({ type: z.literal(ProvingRequestType.ROOT_ROLLUP), inputs: RootRollupPrivateInputs.schema }),
 ]);
 
 export function getProvingJobInputClassFor(type: ProvingRequestType) {
   switch (type) {
     case ProvingRequestType.PUBLIC_VM:
       return AvmCircuitInputs;
-    case ProvingRequestType.PRIVATE_BASE_ROLLUP:
-      return PrivateBaseRollupInputs;
-    case ProvingRequestType.PUBLIC_BASE_ROLLUP:
-      return PublicBaseRollupInputs;
-    case ProvingRequestType.MERGE_ROLLUP:
-      return MergeRollupInputs;
-    case ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP:
-      return EmptyBlockRootRollupInputs;
-    case ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP:
-      return PaddingBlockRootRollupInputs;
+    case ProvingRequestType.PUBLIC_TUBE:
+      return PublicTubePrivateInputs;
+    case ProvingRequestType.PRIVATE_TX_BASE_ROLLUP:
+      return PrivateTxBaseRollupPrivateInputs;
+    case ProvingRequestType.PUBLIC_TX_BASE_ROLLUP:
+      return PublicTxBaseRollupPrivateInputs;
+    case ProvingRequestType.TX_MERGE_ROLLUP:
+      return TxMergeRollupPrivateInputs;
+    case ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP:
+      return BlockRootFirstRollupPrivateInputs;
+    case ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP:
+      return BlockRootSingleTxFirstRollupPrivateInputs;
+    case ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP:
+      return BlockRootEmptyTxFirstRollupPrivateInputs;
     case ProvingRequestType.BLOCK_ROOT_ROLLUP:
-      return BlockRootRollupInputs;
-    case ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP:
-      return SingleTxBlockRootRollupInputs;
+      return BlockRootRollupPrivateInputs;
+    case ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP:
+      return BlockRootSingleTxRollupPrivateInputs;
     case ProvingRequestType.BLOCK_MERGE_ROLLUP:
-      return BlockMergeRollupInputs;
+      return BlockMergeRollupPrivateInputs;
+    case ProvingRequestType.CHECKPOINT_ROOT_ROLLUP:
+      return CheckpointRootRollupPrivateInputs;
+    case ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP:
+      return CheckpointRootSingleBlockRollupPrivateInputs;
+    case ProvingRequestType.CHECKPOINT_PADDING_ROLLUP:
+      return CheckpointPaddingRollupPrivateInputs;
+    case ProvingRequestType.CHECKPOINT_MERGE_ROLLUP:
+      return CheckpointMergeRollupPrivateInputs;
     case ProvingRequestType.ROOT_ROLLUP:
-      return RootRollupInputs;
-    case ProvingRequestType.BASE_PARITY:
-      return BaseParityInputs;
-    case ProvingRequestType.ROOT_PARITY:
-      return RootParityInputs;
-    case ProvingRequestType.TUBE_PROOF:
-      return TubeInputs;
+      return RootRollupPrivateInputs;
+    case ProvingRequestType.PARITY_BASE:
+      return ParityBasePrivateInputs;
+    case ProvingRequestType.PARITY_ROOT:
+      return ParityRootPrivateInputs;
     default: {
       const _exhaustive: never = type;
       throw new Error(`Cannot find circuit inputs class for proving type ${type}`);
@@ -172,18 +187,23 @@ export type ProvingJobInputs = z.infer<typeof ProvingJobInputs>;
 
 export type ProvingJobInputsMap = {
   [ProvingRequestType.PUBLIC_VM]: AvmCircuitInputs;
-  [ProvingRequestType.PRIVATE_BASE_ROLLUP]: PrivateBaseRollupInputs;
-  [ProvingRequestType.PUBLIC_BASE_ROLLUP]: PublicBaseRollupInputs;
-  [ProvingRequestType.MERGE_ROLLUP]: MergeRollupInputs;
-  [ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP]: EmptyBlockRootRollupInputs;
-  [ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP]: PaddingBlockRootRollupInputs;
-  [ProvingRequestType.BLOCK_ROOT_ROLLUP]: BlockRootRollupInputs;
-  [ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP]: SingleTxBlockRootRollupInputs;
-  [ProvingRequestType.BLOCK_MERGE_ROLLUP]: BlockMergeRollupInputs;
-  [ProvingRequestType.ROOT_ROLLUP]: RootRollupInputs;
-  [ProvingRequestType.BASE_PARITY]: BaseParityInputs;
-  [ProvingRequestType.ROOT_PARITY]: RootParityInputs;
-  [ProvingRequestType.TUBE_PROOF]: TubeInputs;
+  [ProvingRequestType.PUBLIC_TUBE]: PublicTubePrivateInputs;
+  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: PrivateTxBaseRollupPrivateInputs;
+  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: PublicTxBaseRollupPrivateInputs;
+  [ProvingRequestType.TX_MERGE_ROLLUP]: TxMergeRollupPrivateInputs;
+  [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: BlockRootFirstRollupPrivateInputs;
+  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: BlockRootSingleTxFirstRollupPrivateInputs;
+  [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: BlockRootEmptyTxFirstRollupPrivateInputs;
+  [ProvingRequestType.BLOCK_ROOT_ROLLUP]: BlockRootRollupPrivateInputs;
+  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP]: BlockRootSingleTxRollupPrivateInputs;
+  [ProvingRequestType.BLOCK_MERGE_ROLLUP]: BlockMergeRollupPrivateInputs;
+  [ProvingRequestType.CHECKPOINT_ROOT_ROLLUP]: CheckpointRootRollupPrivateInputs;
+  [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: CheckpointRootSingleBlockRollupPrivateInputs;
+  [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: CheckpointPaddingRollupPrivateInputs;
+  [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: CheckpointMergeRollupPrivateInputs;
+  [ProvingRequestType.ROOT_ROLLUP]: RootRollupPrivateInputs;
+  [ProvingRequestType.PARITY_BASE]: ParityBasePrivateInputs;
+  [ProvingRequestType.PARITY_ROOT]: ParityRootPrivateInputs;
 };
 
 export const ProvingJobResult = z.discriminatedUnion('type', [
@@ -192,58 +212,100 @@ export const ProvingJobResult = z.discriminatedUnion('type', [
     result: schemaForRecursiveProofAndVerificationKey(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED),
   }),
   z.object({
-    type: z.literal(ProvingRequestType.PRIVATE_BASE_ROLLUP),
+    type: z.literal(ProvingRequestType.PUBLIC_TUBE),
     result: schemaForPublicInputsAndRecursiveProof(
-      BaseOrMergeRollupPublicInputs.schema,
+      PublicTubePublicInputs.schema,
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
     ),
   }),
   z.object({
-    type: z.literal(ProvingRequestType.PUBLIC_BASE_ROLLUP),
+    type: z.literal(ProvingRequestType.PRIVATE_TX_BASE_ROLLUP),
     result: schemaForPublicInputsAndRecursiveProof(
-      BaseOrMergeRollupPublicInputs.schema,
+      TxRollupPublicInputs.schema,
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
     ),
   }),
   z.object({
-    type: z.literal(ProvingRequestType.MERGE_ROLLUP),
+    type: z.literal(ProvingRequestType.PUBLIC_TX_BASE_ROLLUP),
     result: schemaForPublicInputsAndRecursiveProof(
-      BaseOrMergeRollupPublicInputs.schema,
+      TxRollupPublicInputs.schema,
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
     ),
   }),
   z.object({
-    type: z.literal(ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP),
+    type: z.literal(ProvingRequestType.TX_MERGE_ROLLUP),
     result: schemaForPublicInputsAndRecursiveProof(
-      BlockRootOrBlockMergePublicInputs.schema,
+      TxRollupPublicInputs.schema,
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
     ),
   }),
   z.object({
-    type: z.literal(ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP),
+    type: z.literal(ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP),
     result: schemaForPublicInputsAndRecursiveProof(
-      BlockRootOrBlockMergePublicInputs.schema,
+      BlockRollupPublicInputs.schema,
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+    ),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(
+      BlockRollupPublicInputs.schema,
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+    ),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(
+      BlockRollupPublicInputs.schema,
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
     ),
   }),
   z.object({
     type: z.literal(ProvingRequestType.BLOCK_ROOT_ROLLUP),
     result: schemaForPublicInputsAndRecursiveProof(
-      BlockRootOrBlockMergePublicInputs.schema,
+      BlockRollupPublicInputs.schema,
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
     ),
   }),
   z.object({
-    type: z.literal(ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP),
+    type: z.literal(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP),
     result: schemaForPublicInputsAndRecursiveProof(
-      BlockRootOrBlockMergePublicInputs.schema,
+      BlockRollupPublicInputs.schema,
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
     ),
   }),
   z.object({
     type: z.literal(ProvingRequestType.BLOCK_MERGE_ROLLUP),
     result: schemaForPublicInputsAndRecursiveProof(
-      BlockRootOrBlockMergePublicInputs.schema,
+      BlockRollupPublicInputs.schema,
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+    ),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.CHECKPOINT_ROOT_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(
+      CheckpointRollupPublicInputs.schema,
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+    ),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(
+      CheckpointRollupPublicInputs.schema,
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+    ),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.CHECKPOINT_PADDING_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(
+      CheckpointRollupPublicInputs.schema,
+      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+    ),
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.CHECKPOINT_MERGE_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(
+      CheckpointRollupPublicInputs.schema,
       NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
     ),
   }),
@@ -252,60 +314,79 @@ export const ProvingJobResult = z.discriminatedUnion('type', [
     result: schemaForPublicInputsAndRecursiveProof(RootRollupPublicInputs.schema, NESTED_RECURSIVE_PROOF_LENGTH),
   }),
   z.object({
-    type: z.literal(ProvingRequestType.BASE_PARITY),
+    type: z.literal(ProvingRequestType.PARITY_BASE),
     result: schemaForPublicInputsAndRecursiveProof(ParityPublicInputs.schema, RECURSIVE_PROOF_LENGTH),
   }),
   z.object({
-    type: z.literal(ProvingRequestType.ROOT_PARITY),
+    type: z.literal(ProvingRequestType.PARITY_ROOT),
     result: schemaForPublicInputsAndRecursiveProof(ParityPublicInputs.schema, NESTED_RECURSIVE_PROOF_LENGTH),
   }),
-  z.object({
-    type: z.literal(ProvingRequestType.TUBE_PROOF),
-    result: schemaForRecursiveProofAndVerificationKey(TUBE_PROOF_LENGTH),
-  }),
 ]);
 export type ProvingJobResult = z.infer<typeof ProvingJobResult>;
 export type ProvingJobResultsMap = {
   [ProvingRequestType.PUBLIC_VM]: ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;
-  [ProvingRequestType.PRIVATE_BASE_ROLLUP]: PublicInputsAndRecursiveProof<
-    BaseOrMergeRollupPublicInputs,
+  [ProvingRequestType.PUBLIC_TUBE]: PublicInputsAndRecursiveProof<
+    PublicTubePublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: PublicInputsAndRecursiveProof<
+    TxRollupPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
-  [ProvingRequestType.PUBLIC_BASE_ROLLUP]: PublicInputsAndRecursiveProof<
-    BaseOrMergeRollupPublicInputs,
+  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: PublicInputsAndRecursiveProof<
+    TxRollupPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
-  [ProvingRequestType.MERGE_ROLLUP]: PublicInputsAndRecursiveProof<
-    BaseOrMergeRollupPublicInputs,
+  [ProvingRequestType.TX_MERGE_ROLLUP]: PublicInputsAndRecursiveProof<
+    TxRollupPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
-  [ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP]: PublicInputsAndRecursiveProof<
-    BlockRootOrBlockMergePublicInputs,
+  [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: PublicInputsAndRecursiveProof<
+    BlockRollupPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
-  [ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP]: PublicInputsAndRecursiveProof<
-    BlockRootOrBlockMergePublicInputs,
+  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: PublicInputsAndRecursiveProof<
+    BlockRollupPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
-  [ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP]: PublicInputsAndRecursiveProof<
-    BlockRootOrBlockMergePublicInputs,
+  [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: PublicInputsAndRecursiveProof<
+    BlockRollupPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
   [ProvingRequestType.BLOCK_ROOT_ROLLUP]: PublicInputsAndRecursiveProof<
-    BlockRootOrBlockMergePublicInputs,
+    BlockRollupPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP]: PublicInputsAndRecursiveProof<
+    BlockRollupPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
   [ProvingRequestType.BLOCK_MERGE_ROLLUP]: PublicInputsAndRecursiveProof<
-    BlockRootOrBlockMergePublicInputs,
+    BlockRollupPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [ProvingRequestType.CHECKPOINT_ROOT_ROLLUP]: PublicInputsAndRecursiveProof<
+    CheckpointRollupPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: PublicInputsAndRecursiveProof<
+    CheckpointRollupPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: PublicInputsAndRecursiveProof<
+    CheckpointRollupPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: PublicInputsAndRecursiveProof<
+    CheckpointRollupPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
   [ProvingRequestType.ROOT_ROLLUP]: PublicInputsAndRecursiveProof<RootRollupPublicInputs>;
-  [ProvingRequestType.BASE_PARITY]: PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>;
-  [ProvingRequestType.ROOT_PARITY]: PublicInputsAndRecursiveProof<
+  [ProvingRequestType.PARITY_BASE]: PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>;
+  [ProvingRequestType.PARITY_ROOT]: PublicInputsAndRecursiveProof<
     ParityPublicInputs,
     typeof NESTED_RECURSIVE_PROOF_LENGTH
   >;
-  [ProvingRequestType.TUBE_PROOF]: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>;
 };
 
 export type ProvingRequestResultFor<T extends ProvingRequestType> = { type: T; result: ProvingJobResultsMap[T] };