@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/interfaces/proving-job.ts

@@ -1,32 +1,45 @@
 import {
-  AVM_PROOF_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 { EpochNumber, EpochNumberSchema } from '@aztec/foundation/branded-types';
 import type { ZodFor } from '@aztec/foundation/schemas';
 
 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 { 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 { PublicChonkVerifierPrivateInputs } from '../rollup/public_chonk_verifier_private_inputs.js';
+import { PublicChonkVerifierPublicInputs } from '../rollup/public_chonk_verifier_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> = {
@@ -34,15 +47,6 @@ export type ProofAndVerificationKey<N extends number> = {
   verificationKey: VerificationKeyData;
 };
 
-function schemaForRecursiveProofAndVerificationKey<N extends number>(
-  proofLength: N,
-): ZodFor<ProofAndVerificationKey<N>> {
-  return z.object({
-    proof: RecursiveProof.schemaFor(proofLength),
-    verificationKey: VerificationKeyData.schema,
-  });
-}
-
 export function makeProofAndVerificationKey<N extends number>(
   proof: RecursiveProof<N>,
   verificationKey: VerificationKeyData,
@@ -75,83 +79,98 @@ 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.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_CHONK_VERIFIER),
+    inputs: PublicChonkVerifierPrivateInputs.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.SINGLE_TX_BLOCK_ROOT_ROLLUP),
-    inputs: SingleTxBlockRootRollupInputs.schema,
+    type: z.literal(ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP),
+    inputs: BlockRootFirstRollupPrivateInputs.schema,
   }),
-  z.object({ type: z.literal(ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP), inputs: EmptyBlockRootRollupInputs.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_SINGLE_TX_FIRST_ROLLUP),
+    inputs: BlockRootSingleTxFirstRollupPrivateInputs.schema,
+  }),
+  z.object({
+    type: z.literal(ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP),
+    inputs: BlockRootEmptyTxFirstRollupPrivateInputs.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.PUBLIC_CHONK_VERIFIER:
+      return PublicChonkVerifierPrivateInputs;
+    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}`);
@@ -163,70 +182,125 @@ 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.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_CHONK_VERIFIER]: PublicChonkVerifierPrivateInputs;
+  [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', [
   z.object({
     type: z.literal(ProvingRequestType.PUBLIC_VM),
-    result: schemaForRecursiveProofAndVerificationKey(AVM_PROOF_LENGTH_IN_FIELDS),
+    result: RecursiveProof.schemaFor(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED),
   }),
   z.object({
-    type: z.literal(ProvingRequestType.PRIVATE_BASE_ROLLUP),
+    type: z.literal(ProvingRequestType.PUBLIC_CHONK_VERIFIER),
     result: schemaForPublicInputsAndRecursiveProof(
-      BaseOrMergeRollupPublicInputs.schema,
+      PublicChonkVerifierPublicInputs.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.BLOCK_ROOT_FIRST_ROLLUP),
+    result: schemaForPublicInputsAndRecursiveProof(
+      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,
     ),
   }),
@@ -235,84 +309,115 @@ 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_PROOF_LENGTH_IN_FIELDS>;
-  [ProvingRequestType.PRIVATE_BASE_ROLLUP]: PublicInputsAndRecursiveProof<
-    BaseOrMergeRollupPublicInputs,
+  [ProvingRequestType.PUBLIC_VM]: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;
+  [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: PublicInputsAndRecursiveProof<
+    PublicChonkVerifierPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
-  [ProvingRequestType.PUBLIC_BASE_ROLLUP]: PublicInputsAndRecursiveProof<
-    BaseOrMergeRollupPublicInputs,
+  [ProvingRequestType.PRIVATE_TX_BASE_ROLLUP]: PublicInputsAndRecursiveProof<
+    TxRollupPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
-  [ProvingRequestType.MERGE_ROLLUP]: PublicInputsAndRecursiveProof<
-    BaseOrMergeRollupPublicInputs,
+  [ProvingRequestType.PUBLIC_TX_BASE_ROLLUP]: PublicInputsAndRecursiveProof<
+    TxRollupPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
-  [ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP]: PublicInputsAndRecursiveProof<
-    BlockRootOrBlockMergePublicInputs,
+  [ProvingRequestType.TX_MERGE_ROLLUP]: PublicInputsAndRecursiveProof<
+    TxRollupPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >;
-  [ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP]: PublicInputsAndRecursiveProof<
-    BlockRootOrBlockMergePublicInputs,
+  [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: PublicInputsAndRecursiveProof<
+    BlockRollupPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: PublicInputsAndRecursiveProof<
+    BlockRollupPublicInputs,
+    typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+  >;
+  [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] };
 
 export const ProvingJobId = z.string();
 
-export const ProofUri = z.string().brand('ProvingJobUri');
-export type ProofUri = z.infer<typeof ProofUri>;
+export type ProofUri = string & z.$brand<'ProvingJobUri'>;
+export const ProofUri: ZodFor<ProofUri> = z.string().transform(value => value as ProofUri);
 
 export type ProvingJobId = z.infer<typeof ProvingJobId>;
-export const ProvingJob = z.object({
+
+type ProvingJobShape = {
+  id: ProvingJobId;
+  type: ProvingRequestType;
+  epochNumber: EpochNumber;
+  inputsUri: ProofUri;
+};
+
+export const ProvingJob: z.ZodType<ProvingJobShape, any> = z.object({
   id: ProvingJobId,
   type: z.nativeEnum(ProvingRequestType),
-  epochNumber: z.number(),
+  epochNumber: EpochNumberSchema,
   inputsUri: ProofUri,
 });
 
-export const makeProvingJobId = (epochNumber: number, type: ProvingRequestType, inputsHash: string) => {
+export const makeProvingJobId = (epochNumber: EpochNumber, type: ProvingRequestType, inputsHash: string) => {
   return `${epochNumber}:${ProvingRequestType[type]}:${inputsHash}`;
 };
 
-export const getEpochFromProvingJobId = (id: ProvingJobId) => {
+export const getEpochFromProvingJobId = (id: ProvingJobId): EpochNumber => {
   const components = id.split(':');
   const epochNumber = components.length < 1 ? Number.NaN : parseInt(components[0], 10);
   if (!Number.isSafeInteger(epochNumber) || epochNumber < 0) {
     throw new Error(`Proving Job ID ${id} does not contain valid epoch`);
   }
-  return epochNumber;
+  return EpochNumber(epochNumber);
 };
 
 export type ProvingJob = z.infer<typeof ProvingJob>;

package/src/interfaces/public_state_source.ts

@@ -0,0 +1,9 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+
+/** Provides a view into public contract state */
+export interface PublicStateSource {
+  /** Returns the value for a given slot at a given contract. */
+  storageRead: (contractAddress: AztecAddress, slot: Fr) => Promise<Fr>;
+}

package/src/interfaces/public_storage_override.ts

@@ -0,0 +1,26 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+
+import { z } from 'zod';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+import { schemas } from '../schemas/schemas.js';
+
+/**
+ * A single public-storage override to inject before simulation. Identifies a slot in
+ * (contract, raw slot) space, not by leafSlot — the simulator computes the leafSlot internally
+ * via `computePublicDataTreeLeafSlot`.
+ */
+export type PublicStorageOverride = {
+  /** Contract that owns the storage slot. */
+  contract: AztecAddress;
+  /** Raw storage slot within the contract (not yet hashed into a tree key). */
+  slot: Fr;
+  /** Value to place at that slot for the duration of the simulation. */
+  value: Fr;
+};
+
+export const PublicStorageOverrideSchema = z.object({
+  contract: schemas.AztecAddress,
+  slot: schemas.Fr,
+  value: schemas.Fr,
+});

package/src/interfaces/server.ts

@@ -1,9 +1,22 @@
+export * from './allowed_element.js';
+export * from './api_limit.js';
 export * from './archiver.js';
+export * from './aztec-node.js';
+export * from './block_response.js';
+export * from './chain_tips.js';
+export * from './checkpoint_parameter.js';
+export * from './checkpoint_response.js';
+export * from './l1_publish_info.js';
 export * from './block-builder.js';
 export * from './configs.js';
 export * from './epoch-prover.js';
+export * from './l2_logs_source.js';
+export * from './merkle_tree_operations.js';
+export * from './p2p-bootstrap.js';
+export * from './p2p.js';
 export * from './processed-tx-handler.js';
 export * from './prover-agent.js';
+export * from './prover-broker.js';
 export * from './prover-client.js';
 export * from './prover-coordination.js';
 export * from './prover-node.js';
@@ -11,9 +24,7 @@ export * from './proving-job-source.js';
 export * from './proving-job.js';
 export * from './server_circuit_prover.js';
 export * from './service.js';
+export * from './slasher.js';
+export * from './tx_provider.js';
+export * from './validator.js';
 export * from './world_state.js';
-export * from './prover-broker.js';
-export * from './p2p.js';
-export * from './p2p-bootstrap.js';
-export * from './l2_logs_source.js';
-export * from './merkle_tree_operations.js';