fix(fast-inbox): dispatch block-root proving on the rollupType discriminant (A-1432)

The same-block input reshape made the private-inputs classes structurally
assignable, so the orchestrator's instanceof chain collapsed the union to
never (TS2358). Type the block-root selection as a discriminated union and
switch on rollupType instead.

Author: spalladino

yarn-project/prover-client/src/orchestrator/block-proving-state.ts

@@ -39,6 +39,17 @@ export type ProofState<T, PROOF_LENGTH extends number> = {
   isProving?: boolean;
 };
 
+/**
+ * The block-root rollup flavor a block proves with and its private inputs, discriminated by circuit name so callers
+ * can dispatch to the matching prover entrypoint with the correctly-typed inputs.
+ */
+export type BlockRootRollupTypeAndInputs =
+  | { rollupType: 'rollup-block-root-first'; inputs: BlockRootFirstRollupPrivateInputs }
+  | { rollupType: 'rollup-block-root-first-single-tx'; inputs: BlockRootSingleTxFirstRollupPrivateInputs }
+  | { rollupType: 'rollup-block-root-first-empty-tx'; inputs: BlockRootEmptyTxFirstRollupPrivateInputs }
+  | { rollupType: 'rollup-block-root-single-tx'; inputs: BlockRootSingleTxRollupPrivateInputs }
+  | { rollupType: 'rollup-block-root'; inputs: BlockRootRollupPrivateInputs };
+
 /**
  * The current state of the proving schedule for a given block. Managed by ProvingState.
  * Contains the raw inputs and intermediate state to generate every constituent proof in the tree.
@@ -280,7 +291,7 @@ export class BlockProvingState {
     return new TxMergeRollupPrivateInputs([toProofData(left), toProofData(right)]);
   }
 
-  public getBlockRootRollupTypeAndInputs() {
+  public getBlockRootRollupTypeAndInputs(): BlockRootRollupTypeAndInputs {
     const provingOutputs = this.#getChildProvingOutputsForBlockRoot();
     if (!provingOutputs.every(p => !!p)) {
       throw new Error('At least one child is not ready for the block root rollup.');
@@ -324,7 +335,10 @@ export class BlockProvingState {
     }
   }
 
-  #getFirstBlockRootRollupTypeAndInputs([leftRollup, rightRollup]: RollupHonkProofData<TxRollupPublicInputs>[]) {
+  #getFirstBlockRootRollupTypeAndInputs([
+    leftRollup,
+    rightRollup,
+  ]: RollupHonkProofData<TxRollupPublicInputs>[]): BlockRootRollupTypeAndInputs {
     const messageBundle = this.#getMessageBundle();
     const frontierHint = this.#getFrontierHint();
 

yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.ts

@@ -28,10 +28,6 @@ import type { ParityPublicInputs } from '@aztec/stdlib/parity';
 import {
   type BaseRollupHints,
   type BlockRollupPublicInputs,
-  BlockRootEmptyTxFirstRollupPrivateInputs,
-  BlockRootFirstRollupPrivateInputs,
-  BlockRootSingleTxFirstRollupPrivateInputs,
-  BlockRootSingleTxRollupPrivateInputs,
   CheckpointConstantData,
   PrivateTxBaseRollupPrivateInputs,
   type PublicChonkVerifierPublicInputs,
@@ -754,7 +750,9 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler {
       return;
     }
 
-    const { rollupType, inputs } = provingState.getBlockRootRollupTypeAndInputs();
+    // Kept whole (not destructured) so the switch on the `rollupType` discriminant narrows `inputs` per case.
+    const rollup = provingState.getBlockRootRollupTypeAndInputs();
+    const rollupType = rollup.rollupType;
 
     this.logger.debug(`Enqueuing ${rollupType} for block ${provingState.blockNumber}.`);
 
@@ -763,16 +761,17 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler {
       this.wrapCircuitCall(
         'getBlockRootRollupProof',
         signal => {
-          if (inputs instanceof BlockRootFirstRollupPrivateInputs) {
-            return this.prover.getBlockRootFirstRollupProof(inputs, signal, provingState.epochNumber);
-          } else if (inputs instanceof BlockRootSingleTxFirstRollupPrivateInputs) {
-            return this.prover.getBlockRootSingleTxFirstRollupProof(inputs, signal, provingState.epochNumber);
-          } else if (inputs instanceof BlockRootEmptyTxFirstRollupPrivateInputs) {
-            return this.prover.getBlockRootEmptyTxFirstRollupProof(inputs, signal, provingState.epochNumber);
-          } else if (inputs instanceof BlockRootSingleTxRollupPrivateInputs) {
-            return this.prover.getBlockRootSingleTxRollupProof(inputs, signal, provingState.epochNumber);
-          } else {
-            return this.prover.getBlockRootRollupProof(inputs, signal, provingState.epochNumber);
+          switch (rollup.rollupType) {
+            case 'rollup-block-root-first':
+              return this.prover.getBlockRootFirstRollupProof(rollup.inputs, signal, provingState.epochNumber);
+            case 'rollup-block-root-first-single-tx':
+              return this.prover.getBlockRootSingleTxFirstRollupProof(rollup.inputs, signal, provingState.epochNumber);
+            case 'rollup-block-root-first-empty-tx':
+              return this.prover.getBlockRootEmptyTxFirstRollupProof(rollup.inputs, signal, provingState.epochNumber);
+            case 'rollup-block-root-single-tx':
+              return this.prover.getBlockRootSingleTxRollupProof(rollup.inputs, signal, provingState.epochNumber);
+            case 'rollup-block-root':
+              return this.prover.getBlockRootRollupProof(rollup.inputs, signal, provingState.epochNumber);
           }
         },
         { [Attributes.PROTOCOL_CIRCUIT_NAME]: rollupType },