@aztec/prover-client 0.0.1-fake-c83136db25 → 0.0.1-fake-ceab37513c

package/src/proving_broker/proving_broker.ts

@@ -44,33 +44,21 @@ type EnqueuedProvingJob = Pick<ProvingJob, 'id' | 'epochNumber'>;
 export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Traceable {
   private queues: ProvingQueues = {
     [ProvingRequestType.PUBLIC_VM]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
-    [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
+    [ProvingRequestType.TUBE_PROOF]: 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.PRIVATE_BASE_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
+    [ProvingRequestType.PUBLIC_BASE_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
+    [ProvingRequestType.MERGE_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
     [ProvingRequestType.ROOT_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
 
     [ProvingRequestType.BLOCK_MERGE_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
-    [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
-    [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(
-      provingJobComparator,
-    ),
-    [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(
-      provingJobComparator,
-    ),
     [ProvingRequestType.BLOCK_ROOT_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
-    [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
+    [ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
+    [ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
+    [ProvingRequestType.PADDING_BLOCK_ROOT_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
 
-    [ProvingRequestType.CHECKPOINT_ROOT_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
-    [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(
-      provingJobComparator,
-    ),
-    [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
-    [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
-
-    [ProvingRequestType.PARITY_BASE]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
-    [ProvingRequestType.PARITY_ROOT]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
+    [ProvingRequestType.BASE_PARITY]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
+    [ProvingRequestType.ROOT_PARITY]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
   };
 
   // holds a copy of the database in memory in order to quickly fulfill requests
@@ -685,22 +673,16 @@ function proofTypeComparator(a: ProvingRequestType, b: ProvingRequestType): -1 |
  * is to get picked up by agents
  */
 export const PROOF_TYPES_IN_PRIORITY_ORDER: ProvingRequestType[] = [
-  ProvingRequestType.ROOT_ROLLUP,
-  ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP,
-  ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP,
-  ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP,
   ProvingRequestType.BLOCK_ROOT_ROLLUP,
-  ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP,
+  ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP,
   ProvingRequestType.BLOCK_MERGE_ROLLUP,
-  ProvingRequestType.CHECKPOINT_ROOT_ROLLUP,
-  ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP,
-  ProvingRequestType.CHECKPOINT_MERGE_ROLLUP,
-  ProvingRequestType.CHECKPOINT_PADDING_ROLLUP,
-  ProvingRequestType.TX_MERGE_ROLLUP,
-  ProvingRequestType.PUBLIC_TX_BASE_ROLLUP,
-  ProvingRequestType.PRIVATE_TX_BASE_ROLLUP,
+  ProvingRequestType.ROOT_ROLLUP,
+  ProvingRequestType.MERGE_ROLLUP,
+  ProvingRequestType.PUBLIC_BASE_ROLLUP,
+  ProvingRequestType.PRIVATE_BASE_ROLLUP,
   ProvingRequestType.PUBLIC_VM,
-  ProvingRequestType.PUBLIC_CHONK_VERIFIER,
-  ProvingRequestType.PARITY_ROOT,
-  ProvingRequestType.PARITY_BASE,
+  ProvingRequestType.TUBE_PROOF,
+  ProvingRequestType.ROOT_PARITY,
+  ProvingRequestType.BASE_PARITY,
+  ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP,
 ];

package/src/proving_broker/proving_job_controller.ts

@@ -128,74 +128,54 @@ export class ProvingJobController {
         return await this.circuitProver.getAvmProof(inputs, undefined, signal, this.epochNumber);
       }
 
-      case ProvingRequestType.PUBLIC_CHONK_VERIFIER: {
-        return await this.circuitProver.getPublicChonkVerifierProof(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.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.PADDING_BLOCK_ROOT_ROLLUP: {
+        return await this.circuitProver.getPaddingBlockRootRollupProof(inputs, signal, this.epochNumber);
       }
 
       case ProvingRequestType.BLOCK_ROOT_ROLLUP: {
         return await this.circuitProver.getBlockRootRollupProof(inputs, signal, this.epochNumber);
       }
 
-      case ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP: {
-        return await this.circuitProver.getBlockRootSingleTxRollupProof(inputs, signal, this.epochNumber);
+      case ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP: {
+        return await this.circuitProver.getSingleTxBlockRootRollupProof(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.PARITY_BASE: {
+      case ProvingRequestType.BASE_PARITY: {
         return await this.circuitProver.getBaseParityProof(inputs, signal, this.epochNumber);
       }
 
-      case ProvingRequestType.PARITY_ROOT: {
+      case ProvingRequestType.ROOT_PARITY: {
         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/test/mock_prover.ts

@@ -4,10 +4,12 @@ import {
   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,
@@ -17,37 +19,27 @@ import {
   makeProofAndVerificationKey,
   makePublicInputsAndRecursiveProof,
 } from '@aztec/stdlib/interfaces/server';
-import type { ParityBasePrivateInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity';
+import type { BaseParityInputs, RootParityInputs } from '@aztec/stdlib/parity';
 import { makeEmptyRecursiveProof, makeRecursiveProof } from '@aztec/stdlib/proofs';
 import type {
-  BlockMergeRollupPrivateInputs,
-  BlockRollupPublicInputs,
-  BlockRootEmptyTxFirstRollupPrivateInputs,
-  BlockRootFirstRollupPrivateInputs,
-  BlockRootRollupPrivateInputs,
-  BlockRootSingleTxFirstRollupPrivateInputs,
-  BlockRootSingleTxRollupPrivateInputs,
-  CheckpointMergeRollupPrivateInputs,
-  CheckpointPaddingRollupPrivateInputs,
-  CheckpointRollupPublicInputs,
-  CheckpointRootRollupPrivateInputs,
-  CheckpointRootSingleBlockRollupPrivateInputs,
-  PrivateTxBaseRollupPrivateInputs,
-  PublicChonkVerifierPrivateInputs,
-  PublicChonkVerifierPublicInputs,
-  PublicTxBaseRollupPrivateInputs,
-  RootRollupPrivateInputs,
+  BaseOrMergeRollupPublicInputs,
+  BlockMergeRollupInputs,
+  BlockRootOrBlockMergePublicInputs,
+  BlockRootRollupInputs,
+  EmptyBlockRootRollupInputs,
+  MergeRollupInputs,
+  PaddingBlockRootRollupInputs,
+  PrivateBaseRollupInputs,
+  PublicBaseRollupInputs,
+  RootRollupInputs,
   RootRollupPublicInputs,
-  TxMergeRollupPrivateInputs,
-  TxRollupPublicInputs,
+  SingleTxBlockRootRollupInputs,
 } from '@aztec/stdlib/rollup';
 import {
-  makeBlockRollupPublicInputs,
-  makeCheckpointRollupPublicInputs,
+  makeBaseOrMergeRollupPublicInputs,
+  makeBlockRootOrBlockMergeRollupPublicInputs,
   makeParityPublicInputs,
-  makePublicChonkVerifierPublicInputs,
   makeRootRollupPublicInputs,
-  makeTxRollupPublicInputs,
 } from '@aztec/stdlib/testing';
 import { VerificationKeyData } from '@aztec/stdlib/vks';
 
@@ -119,7 +111,7 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getBaseParityProof(_inputs: ParityBasePrivateInputs, _signal?: AbortSignal, _epochNumber?: number) {
+  getBaseParityProof(_inputs: BaseParityInputs, _signal?: AbortSignal, _epochNumber?: number) {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeParityPublicInputs(),
@@ -129,7 +121,7 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getRootParityProof(_inputs: ParityRootPrivateInputs, _signal?: AbortSignal, _epochNumber?: number) {
+  getRootParityProof(_inputs: RootParityInputs, _signal?: AbortSignal, _epochNumber?: number) {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeParityPublicInputs(),
@@ -139,210 +131,130 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getPublicChonkVerifierProof(
-    _inputs: PublicChonkVerifierPrivateInputs,
+  getPrivateBaseRollupProof(
+    _baseRollupInput: PrivateBaseRollupInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makePublicChonkVerifierPublicInputs(),
+        makeBaseOrMergeRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getPrivateTxBaseRollupProof(
-    _baseRollupInput: PrivateTxBaseRollupPrivateInputs,
+  getPublicBaseRollupProof(
+    _inputs: PublicBaseRollupInputs,
     _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(),
-      ),
-    );
-  }
-
-  getPublicTxBaseRollupProof(
-    _inputs: PublicTxBaseRollupPrivateInputs,
-    _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(),
-      ),
-    );
-  }
-
-  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(
-        makeBlockRollupPublicInputs(),
-        makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
-        VerificationKeyData.makeFakeRollupHonk(),
-      ),
-    );
-  }
-
-  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>> {
+  ): Promise<
+    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBlockRollupPublicInputs(),
+        makeBaseOrMergeRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getBlockRootRollupProof(
-    _input: BlockRootRollupPrivateInputs,
+  getMergeRollupProof(
+    _input: MergeRollupInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
-  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>> {
+  ): Promise<
+    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBlockRollupPublicInputs(),
+        makeBaseOrMergeRollupPublicInputs(),
         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) {
+  getBlockMergeRollupProof(_input: BlockMergeRollupInputs, _signal?: AbortSignal, _epochNumber?: number) {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeBlockRollupPublicInputs(),
+        makeBlockRootOrBlockMergeRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getCheckpointRootRollupProof(
-    _input: CheckpointRootRollupPrivateInputs,
+  getEmptyBlockRootRollupProof(
+    _input: EmptyBlockRootRollupInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeCheckpointRollupPublicInputs(),
+        makeBlockRootOrBlockMergeRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getCheckpointRootSingleBlockRollupProof(
-    _input: CheckpointRootSingleBlockRollupPrivateInputs,
+  getPaddingBlockRootRollupProof(
+    _input: PaddingBlockRootRollupInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeCheckpointRollupPublicInputs(),
+        makeBlockRootOrBlockMergeRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getCheckpointMergeRollupProof(
-    _input: CheckpointMergeRollupPrivateInputs,
+  getBlockRootRollupProof(
+    _input: BlockRootRollupInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeCheckpointRollupPublicInputs(),
+        makeBlockRootOrBlockMergeRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
         VerificationKeyData.makeFakeRollupHonk(),
       ),
     );
   }
 
-  getCheckpointPaddingRollupProof(
-    _input: CheckpointPaddingRollupPrivateInputs,
+  getSingleTxBlockRootRollupProof(
+    _input: SingleTxBlockRootRollupInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
-        makeCheckpointRollupPublicInputs(),
+        makeBlockRootOrBlockMergeRollupPublicInputs(),
         makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH),
-        VerificationKeyData.makeFakeRollupHonk(),
+        VerificationKeyData.makeFakeHonk(),
       ),
     );
   }
 
   getRootRollupProof(
-    _input: RootRollupPrivateInputs,
+    _input: RootRollupInputs,
     _signal?: AbortSignal,
     _epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>> {
@@ -354,4 +266,10 @@ export class MockProver implements ServerCircuitProver {
       ),
     );
   }
+
+  getTubeProof(): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>> {
+    return Promise.resolve(
+      makeProofAndVerificationKey(makeRecursiveProof(TUBE_PROOF_LENGTH), VerificationKeyData.makeFakeRollupHonk()),
+    );
+  }
 }

package/dest/orchestrator/checkpoint-proving-state.d.ts

@@ -1,63 +0,0 @@
-import { BatchedBlobAccumulator, type FinalBlobBatchingChallenges } from '@aztec/blob-lib';
-import { type ARCHIVE_HEIGHT, type L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import type { Tuple } from '@aztec/foundation/serialize';
-import { type TreeNodeLocation } from '@aztec/foundation/trees';
-import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
-import { ParityBasePrivateInputs } from '@aztec/stdlib/parity';
-import { BlockMergeRollupPrivateInputs, BlockRollupPublicInputs, CheckpointConstantData, CheckpointRollupPublicInputs, CheckpointRootRollupPrivateInputs, CheckpointRootSingleBlockRollupPrivateInputs } from '@aztec/stdlib/rollup';
-import type { CircuitName } from '@aztec/stdlib/stats';
-import type { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
-import type { BlockHeader } from '@aztec/stdlib/tx';
-import type { UInt64 } from '@aztec/stdlib/types';
-import { BlockProvingState } from './block-proving-state.js';
-import type { EpochProvingState } from './epoch-proving-state.js';
-export declare class CheckpointProvingState {
-    #private;
-    readonly index: number;
-    readonly constants: CheckpointConstantData;
-    readonly totalNumBlocks: number;
-    private readonly totalNumBlobFields;
-    private readonly finalBlobBatchingChallenges;
-    private readonly headerOfLastBlockInPreviousCheckpoint;
-    private readonly lastArchiveSiblingPath;
-    private readonly l1ToL2Messages;
-    private readonly lastL1ToL2MessageTreeSnapshot;
-    private readonly lastL1ToL2MessageSubtreeRootSiblingPath;
-    private readonly newL1ToL2MessageTreeSnapshot;
-    private readonly newL1ToL2MessageSubtreeRootSiblingPath;
-    parentEpoch: EpochProvingState;
-    private onBlobAccumulatorSet;
-    private blockProofs;
-    private checkpointRootProof;
-    private blocks;
-    private startBlobAccumulator;
-    private endBlobAccumulator;
-    private blobFields;
-    private error;
-    readonly firstBlockNumber: number;
-    constructor(index: number, constants: CheckpointConstantData, totalNumBlocks: number, totalNumBlobFields: number, finalBlobBatchingChallenges: FinalBlobBatchingChallenges, headerOfLastBlockInPreviousCheckpoint: BlockHeader, lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, l1ToL2Messages: Fr[], lastL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, lastL1ToL2MessageSubtreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH>, newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, newL1ToL2MessageSubtreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH>, parentEpoch: EpochProvingState, onBlobAccumulatorSet: (checkpoint: CheckpointProvingState) => void);
-    get epochNumber(): number;
-    startNewBlock(blockNumber: number, timestamp: UInt64, totalNumTxs: number, lastArchiveTreeSnapshot: AppendOnlyTreeSnapshot, lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>): Promise<BlockProvingState>;
-    isAcceptingBlocks(): boolean;
-    setBlockRootRollupProof(blockIndex: number, provingOutput: PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): TreeNodeLocation;
-    tryStartProvingBlockMerge(location: TreeNodeLocation): boolean;
-    setBlockMergeRollupProof(location: TreeNodeLocation, provingOutput: PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
-    tryStartProvingCheckpointRoot(): boolean;
-    setCheckpointRootRollupProof(provingOutput: PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): TreeNodeLocation;
-    getBaseParityInputs(baseParityIndex: number): ParityBasePrivateInputs;
-    accumulateBlobs(startBlobAccumulator: BatchedBlobAccumulator): Promise<BatchedBlobAccumulator | undefined>;
-    getEndBlobAccumulator(): BatchedBlobAccumulator | undefined;
-    getParentLocation(location: TreeNodeLocation): TreeNodeLocation;
-    getBlockMergeRollupInputs(mergeLocation: TreeNodeLocation): BlockMergeRollupPrivateInputs;
-    getCheckpointRootRollupType(): CircuitName;
-    getCheckpointRootRollupInputs(): CheckpointRootSingleBlockRollupPrivateInputs | CheckpointRootRollupPrivateInputs;
-    getBlockProvingStateByBlockNumber(blockNumber: number): BlockProvingState | undefined;
-    isReadyForBlockMerge(location: TreeNodeLocation): boolean;
-    isReadyForCheckpointRoot(): boolean;
-    verifyState(): boolean;
-    getError(): string | undefined;
-    cancel(): void;
-    reject(reason: string): void;
-}
-//# sourceMappingURL=checkpoint-proving-state.d.ts.map

package/dest/orchestrator/checkpoint-proving-state.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"checkpoint-proving-state.d.ts","sourceRoot":"","sources":["../../src/orchestrator/checkpoint-proving-state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,KAAK,2BAA2B,EAAc,MAAM,iBAAiB,CAAC;AACvG,OAAO,EACL,KAAK,cAAc,EAGnB,KAAK,6CAA6C,EAClD,KAAK,yCAAyC,EAE/C,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAc,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,KAAK,gBAAgB,EAAuB,MAAM,yBAAyB,CAAC;AAErF,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AACrF,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,EACL,6BAA6B,EAC7B,uBAAuB,EACvB,sBAAsB,EACtB,4BAA4B,EAE5B,iCAAiC,EACjC,4CAA4C,EAC7C,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAGlD,OAAO,EAAE,iBAAiB,EAAmB,MAAM,0BAA0B,CAAC;AAC9E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,qBAAa,sBAAsB;;aAef,KAAK,EAAE,MAAM;aACb,SAAS,EAAE,sBAAsB;aACjC,cAAc,EAAE,MAAM;IACtC,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,2BAA2B;IAC5C,OAAO,CAAC,QAAQ,CAAC,qCAAqC;IACtD,OAAO,CAAC,QAAQ,CAAC,sBAAsB;IACvC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAE/B,OAAO,CAAC,QAAQ,CAAC,6BAA6B;IAC9C,OAAO,CAAC,QAAQ,CAAC,uCAAuC;IAKxD,OAAO,CAAC,QAAQ,CAAC,4BAA4B;IAC7C,OAAO,CAAC,QAAQ,CAAC,sCAAsC;IAIhD,WAAW,EAAE,iBAAiB;IACrC,OAAO,CAAC,oBAAoB;IAnC9B,OAAO,CAAC,WAAW,CAEjB;IACF,OAAO,CAAC,mBAAmB,CAEb;IACd,OAAO,CAAC,MAAM,CAAyC;IACvD,OAAO,CAAC,oBAAoB,CAAqC;IACjE,OAAO,CAAC,kBAAkB,CAAqC;IAC/D,OAAO,CAAC,UAAU,CAAmB;IACrC,OAAO,CAAC,KAAK,CAAqB;IAClC,SAAgB,gBAAgB,EAAE,MAAM,CAAC;gBAGvB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,sBAAsB,EACjC,cAAc,EAAE,MAAM,EACrB,kBAAkB,EAAE,MAAM,EAC1B,2BAA2B,EAAE,2BAA2B,EACxD,qCAAqC,EAAE,WAAW,EAClD,sBAAsB,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,cAAc,CAAC,EACxD,cAAc,EAAE,EAAE,EAAE,EAEpB,6BAA6B,EAAE,sBAAsB,EACrD,uCAAuC,EAAE,KAAK,CAC7D,EAAE,EACF,OAAO,6CAA6C,CACrD,EAEgB,4BAA4B,EAAE,sBAAsB,EACpD,sCAAsC,EAAE,KAAK,CAC5D,EAAE,EACF,OAAO,6CAA6C,CACrD,EACM,WAAW,EAAE,iBAAiB,EAC7B,oBAAoB,EAAE,CAAC,UAAU,EAAE,sBAAsB,KAAK,IAAI;IAM5E,IAAW,WAAW,IAAI,MAAM,CAE/B;IAEY,aAAa,CACxB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,uBAAuB,EAAE,sBAAsB,EAC/C,sBAAsB,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,cAAc,CAAC,GACvD,OAAO,CAAC,iBAAiB,CAAC;IA2CtB,iBAAiB;IAIjB,uBAAuB,CAC5B,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,6BAA6B,CAC1C,uBAAuB,EACvB,OAAO,yCAAyC,CACjD,GACA,gBAAgB;IAIZ,yBAAyB,CAAC,QAAQ,EAAE,gBAAgB;IASpD,wBAAwB,CAC7B,QAAQ,EAAE,gBAAgB,EAC1B,aAAa,EAAE,6BAA6B,CAC1C,uBAAuB,EACvB,OAAO,yCAAyC,CACjD;IAKI,6BAA6B;IAS7B,4BAA4B,CACjC,aAAa,EAAE,6BAA6B,CAC1C,4BAA4B,EAC5B,OAAO,yCAAyC,CACjD,GACA,gBAAgB;IAKZ,mBAAmB,CAAC,eAAe,EAAE,MAAM;IAYrC,eAAe,CAAC,oBAAoB,EAAE,sBAAsB;IAclE,qBAAqB;IAIrB,iBAAiB,CAAC,QAAQ,EAAE,gBAAgB;IAI5C,yBAAyB,CAAC,aAAa,EAAE,gBAAgB;IASzD,2BAA2B,IAAI,WAAW;IAI1C,6BAA6B;IAgC7B,iCAAiC,CAAC,WAAW,EAAE,MAAM;IAKrD,oBAAoB,CAAC,QAAQ,EAAE,gBAAgB;IAI/C,wBAAwB;IAKxB,WAAW;IAIX,QAAQ;IAKR,MAAM;IAIN,MAAM,CAAC,MAAM,EAAE,MAAM;CAW7B"}