@aztec/prover-client 0.0.0-test.1 → 0.0.1-commit.023c3e5

package/src/orchestrator/orchestrator.ts

@@ -1,43 +1,48 @@
+import { BatchedBlob, FinalBlobBatchingChallenges, SpongeBlob } from '@aztec/blob-lib/types';
 import {
-  AVM_PROOF_LENGTH_IN_FIELDS,
-  AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS,
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
-  L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
+  L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
+  NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   NUM_BASE_PARITY_PER_ROOT_PARITY,
-  type TUBE_PROOF_LENGTH,
 } from '@aztec/constants';
-import { padArrayEnd, times } from '@aztec/foundation/collection';
+import { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { AbortError } from '@aztec/foundation/error';
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { assertLength } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
 import { elapsed } from '@aztec/foundation/timer';
 import type { TreeNodeLocation } from '@aztec/foundation/trees';
-import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { L2Block } from '@aztec/stdlib/block';
+import { EthAddress } from '@aztec/stdlib/block';
 import type {
   EpochProver,
   ForkMerkleTreeOperations,
   MerkleTreeWriteOperations,
-  ProofAndVerificationKey,
+  PublicInputsAndRecursiveProof,
+  ReadonlyWorldStateAccess,
   ServerCircuitProver,
 } from '@aztec/stdlib/interfaces/server';
-import { BaseParityInputs } from '@aztec/stdlib/parity';
-import { makeEmptyRecursiveProof } from '@aztec/stdlib/proofs';
+import type { Proof } from '@aztec/stdlib/proofs';
 import {
   type BaseRollupHints,
-  EmptyBlockRootRollupInputs,
-  PrivateBaseRollupInputs,
-  SingleTxBlockRootRollupInputs,
-  TubeInputs,
+  BlockRootEmptyTxFirstRollupPrivateInputs,
+  BlockRootFirstRollupPrivateInputs,
+  BlockRootSingleTxFirstRollupPrivateInputs,
+  BlockRootSingleTxRollupPrivateInputs,
+  CheckpointConstantData,
+  CheckpointRootSingleBlockRollupPrivateInputs,
+  PrivateTxBaseRollupPrivateInputs,
+  PublicChonkVerifierPrivateInputs,
+  PublicChonkVerifierPublicInputs,
+  RootRollupPublicInputs,
 } from '@aztec/stdlib/rollup';
 import type { CircuitName } from '@aztec/stdlib/stats';
 import { type AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
-import { type BlockHeader, type GlobalVariables, type ProcessedTx, type Tx, toNumBlobFields } from '@aztec/stdlib/tx';
-import { VerificationKeyData } from '@aztec/stdlib/vks';
+import type { BlockHeader, ProcessedTx, Tx } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
 import {
   Attributes,
   type TelemetryClient,
@@ -50,20 +55,26 @@ import {
 import { inspect } from 'util';
 
 import {
-  buildBaseRollupHints,
-  buildHeaderAndBodyFromTxs,
+  buildHeaderFromCircuitOutputs,
+  getLastSiblingPath,
+  getPublicChonkVerifierPrivateInputsFromTx,
   getRootTreeSiblingPath,
   getSubtreeSiblingPath,
   getTreeSnapshot,
+  insertSideEffectsAndBuildBaseRollupHints,
   validatePartialState,
   validateTx,
 } from './block-building-helpers.js';
 import type { BlockProvingState } from './block-proving-state.js';
+import type { CheckpointProvingState } from './checkpoint-proving-state.js';
 import { EpochProvingState, type ProvingResult, type TreeSnapshots } from './epoch-proving-state.js';
 import { ProvingOrchestratorMetrics } from './orchestrator_metrics.js';
 import { TxProvingState } from './tx-proving-state.js';
 
-const logger = createLogger('prover-client:orchestrator');
+type WorldStateFork = {
+  fork: MerkleTreeWriteOperations;
+  cleanupPromise: Promise<void> | undefined;
+};
 
 /**
  * Implements an event driven proving scheduler to build the recursive proof tree. The idea being:
@@ -85,14 +96,19 @@ export class ProvingOrchestrator implements EpochProver {
 
   private provingPromise: Promise<ProvingResult> | undefined = undefined;
   private metrics: ProvingOrchestratorMetrics;
-  private dbs: Map<number, MerkleTreeWriteOperations> = new Map();
+  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+  private dbs: Map<BlockNumber, WorldStateFork> = new Map();
+  private logger: Logger;
 
   constructor(
-    private dbProvider: ForkMerkleTreeOperations,
+    private dbProvider: ReadonlyWorldStateAccess & ForkMerkleTreeOperations,
     private prover: ServerCircuitProver,
-    private readonly proverId: Fr = Fr.ZERO,
+    private readonly proverId: EthAddress,
+    private readonly cancelJobsOnStop: boolean = false,
     telemetryClient: TelemetryClient = getTelemetryClient(),
+    bindings?: LoggerBindings,
   ) {
+    this.logger = createLogger('prover-client:orchestrator', bindings);
     this.metrics = new ProvingOrchestratorMetrics(telemetryClient, 'ProvingOrchestrator');
   }
 
@@ -100,73 +116,167 @@ export class ProvingOrchestrator implements EpochProver {
     return this.metrics.tracer;
   }
 
-  public getProverId(): Fr {
+  public getProverId(): EthAddress {
     return this.proverId;
   }
 
+  public getNumActiveForks() {
+    return this.dbs.size;
+  }
+
   public stop(): Promise<void> {
     this.cancel();
     return Promise.resolve();
   }
 
-  public startNewEpoch(epochNumber: number, firstBlockNumber: number, totalNumBlocks: number) {
+  public startNewEpoch(
+    epochNumber: EpochNumber,
+    totalNumCheckpoints: number,
+    finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
+  ) {
+    if (this.provingState?.verifyState()) {
+      throw new Error(
+        `Cannot start epoch ${epochNumber} when epoch ${this.provingState.epochNumber} is still being processed.`,
+      );
+    }
+
     const { promise: _promise, resolve, reject } = promiseWithResolvers<ProvingResult>();
     const promise = _promise.catch((reason): ProvingResult => ({ status: 'failure', reason }));
-    if (totalNumBlocks <= 0 || !Number.isInteger(totalNumBlocks)) {
-      throw new Error(`Invalid number of blocks for epoch (got ${totalNumBlocks})`);
-    }
-    logger.info(`Starting epoch ${epochNumber} with ${totalNumBlocks} blocks`);
-    this.provingState = new EpochProvingState(epochNumber, firstBlockNumber, totalNumBlocks, resolve, reject);
+    this.logger.info(`Starting epoch ${epochNumber} with ${totalNumCheckpoints} checkpoints.`);
+    this.provingState = new EpochProvingState(
+      epochNumber,
+      totalNumCheckpoints,
+      finalBlobBatchingChallenges,
+      provingState => this.checkAndEnqueueCheckpointRootRollup(provingState),
+      resolve,
+      reject,
+    );
     this.provingPromise = promise;
   }
 
   /**
-   * Starts off a new block
-   * @param globalVariables - The global variables for the block
-   * @param l1ToL2Messages - The l1 to l2 messages for the block
-   * @returns A proving ticket, containing a promise notifying of proving completion
+   * Starts a new checkpoint.
+   * @param checkpointIndex - The index of the checkpoint in the epoch.
+   * @param constants - The constants for this checkpoint.
+   * @param l1ToL2Messages - The set of L1 to L2 messages to be inserted at the beginning of this checkpoint.
+   * @param totalNumBlocks - The total number of blocks expected in the checkpoint (must be at least one).
+   * @param headerOfLastBlockInPreviousCheckpoint - The header of the last block in the previous checkpoint.
    */
-  @trackSpan('ProvingOrchestrator.startNewBlock', globalVariables => ({
-    [Attributes.BLOCK_NUMBER]: globalVariables.blockNumber.toNumber(),
-  }))
-  public async startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[], previousBlockHeader: BlockHeader) {
+  public async startNewCheckpoint(
+    checkpointIndex: number,
+    constants: CheckpointConstantData,
+    l1ToL2Messages: Fr[],
+    totalNumBlocks: number,
+    headerOfLastBlockInPreviousCheckpoint: BlockHeader,
+  ) {
     if (!this.provingState) {
-      throw new Error(`Invalid proving state, call startNewEpoch before starting a block`);
+      throw new Error('Empty epoch proving state. Call startNewEpoch before starting a checkpoint.');
     }
 
-    if (!this.provingState?.isAcceptingBlocks()) {
-      throw new Error(`Epoch not accepting further blocks`);
+    if (!this.provingState.isAcceptingCheckpoints()) {
+      throw new Error(`Epoch not accepting further checkpoints.`);
     }
 
-    logger.info(
-      `Starting block ${globalVariables.blockNumber.toNumber()} for slot ${globalVariables.slotNumber.toNumber()}`,
+    // Fork world state at the end of the immediately previous block.
+    const lastBlockNumber = headerOfLastBlockInPreviousCheckpoint.globalVariables.blockNumber;
+    const db = await this.dbProvider.fork(lastBlockNumber);
+
+    const firstBlockNumber = BlockNumber(lastBlockNumber + 1);
+    this.dbs.set(firstBlockNumber, { fork: db, cleanupPromise: undefined });
+
+    // Get archive sibling path before any block in this checkpoint lands.
+    const lastArchiveSiblingPath = await getLastSiblingPath(MerkleTreeId.ARCHIVE, db);
+
+    // Insert all the l1 to l2 messages into the db. And get the states before and after the insertion.
+    const {
+      lastL1ToL2MessageTreeSnapshot,
+      lastL1ToL2MessageSubtreeRootSiblingPath,
+      newL1ToL2MessageTreeSnapshot,
+      newL1ToL2MessageSubtreeRootSiblingPath,
+    } = await this.updateL1ToL2MessageTree(l1ToL2Messages, db);
+
+    this.provingState.startNewCheckpoint(
+      checkpointIndex,
+      constants,
+      totalNumBlocks,
+      headerOfLastBlockInPreviousCheckpoint,
+      lastArchiveSiblingPath,
+      l1ToL2Messages,
+      lastL1ToL2MessageTreeSnapshot,
+      lastL1ToL2MessageSubtreeRootSiblingPath,
+      newL1ToL2MessageTreeSnapshot,
+      newL1ToL2MessageSubtreeRootSiblingPath,
     );
+  }
 
-    // Fork world state at the end of the immediately previous block
-    const db = await this.dbProvider.fork(globalVariables.blockNumber.toNumber() - 1);
-    this.dbs.set(globalVariables.blockNumber.toNumber(), db);
+  /**
+   * Starts off a new block
+   * @param blockNumber - The block number
+   * @param timestamp - The timestamp of the block. This is only required for constructing the private inputs for the
+   * block that doesn't have any txs.
+   * @param totalNumTxs - The total number of txs in the block
+   */
+  @trackSpan('ProvingOrchestrator.startNewBlock', blockNumber => ({
+    [Attributes.BLOCK_NUMBER]: blockNumber,
+  }))
+  public async startNewBlock(blockNumber: BlockNumber, timestamp: UInt64, totalNumTxs: number) {
+    if (!this.provingState) {
+      throw new Error('Empty epoch proving state. Call startNewEpoch before starting a block.');
+    }
+
+    const checkpointProvingState = this.provingState.getCheckpointProvingStateByBlockNumber(blockNumber);
+    if (!checkpointProvingState) {
+      throw new Error(`Checkpoint not started. Call startNewCheckpoint first.`);
+    }
 
-    // we start the block by enqueueing all of the base parity circuits
-    const { l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, baseParityInputs } =
-      await this.prepareBaseParityInputs(l1ToL2Messages, db);
+    if (!checkpointProvingState.isAcceptingBlocks()) {
+      throw new Error(`Checkpoint not accepting further blocks.`);
+    }
 
-    // Get archive snapshot before this block lands
-    const lastArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
-    const newArchiveSiblingPath = await getRootTreeSiblingPath(MerkleTreeId.ARCHIVE, db);
+    const constants = checkpointProvingState.constants;
+    this.logger.info(`Starting block ${blockNumber} for slot ${constants.slotNumber}.`);
 
-    const blockProvingState = this.provingState!.startNewBlock(
-      globalVariables,
-      l1ToL2Messages,
-      l1ToL2MessageSubtreeSiblingPath,
-      l1ToL2MessageTreeSnapshotAfterInsertion,
-      lastArchive,
-      newArchiveSiblingPath,
-      previousBlockHeader,
+    // Fork the db only when it's not already set. The db for the first block is set in `startNewCheckpoint`.
+    if (!this.dbs.has(blockNumber)) {
+      // Fork world state at the end of the immediately previous block
+      const db = await this.dbProvider.fork(BlockNumber(blockNumber - 1));
+      this.dbs.set(blockNumber, { fork: db, cleanupPromise: undefined });
+    }
+    const db = this.dbs.get(blockNumber)!.fork;
+
+    // Get archive snapshot and sibling path before any txs in this block lands.
+    const lastArchiveTreeSnapshot = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
+    const lastArchiveSiblingPath = await getRootTreeSiblingPath(MerkleTreeId.ARCHIVE, db);
+
+    const blockProvingState = checkpointProvingState.startNewBlock(
+      blockNumber,
+      timestamp,
+      totalNumTxs,
+      lastArchiveTreeSnapshot,
+      lastArchiveSiblingPath,
     );
 
-    // Enqueue base parity circuits for the block
-    for (let i = 0; i < baseParityInputs.length; i++) {
-      this.enqueueBaseParityCircuit(blockProvingState, baseParityInputs[i], i);
+    // Enqueue base parity circuits for the first block in the checkpoint.
+    if (blockProvingState.index === 0) {
+      for (let i = 0; i < NUM_BASE_PARITY_PER_ROOT_PARITY; i++) {
+        this.enqueueBaseParityCircuit(checkpointProvingState, blockProvingState, i);
+      }
+    }
+
+    // Because `addTxs` won't be called for a block without txs, and that's where the sponge blob state is computed.
+    // We need to set its end sponge blob here, which will become the start sponge blob for the next block.
+    if (totalNumTxs === 0) {
+      const endState = await db.getStateReference();
+      blockProvingState.setEndState(endState);
+
+      const endSpongeBlob = blockProvingState.getStartSpongeBlob().clone();
+      const blockEndBlobFields = blockProvingState.getBlockEndBlobFields();
+      await endSpongeBlob.absorb(blockEndBlobFields);
+      blockProvingState.setEndSpongeBlob(endSpongeBlob);
+
+      // Try to accumulate the out hashes and blobs as far as we can:
+      await this.provingState.accumulateCheckpointOutHashes();
+      await this.provingState.setBlobAccumulators();
     }
   }
 
@@ -178,28 +288,40 @@ export class ProvingOrchestrator implements EpochProver {
     [Attributes.BLOCK_TXS_COUNT]: txs.length,
   }))
   public async addTxs(txs: ProcessedTx[]): Promise<void> {
+    if (!this.provingState) {
+      throw new Error(`Empty epoch proving state. Call startNewEpoch before adding txs.`);
+    }
+
     if (!txs.length) {
       // To avoid an ugly throw below. If we require an empty block, we can just call setBlockCompleted
       // on a block with no txs. We cannot do that here because we cannot find the blockNumber without any txs.
-      logger.warn(`Provided no txs to orchestrator addTxs.`);
+      this.logger.warn(`Provided no txs to orchestrator addTxs.`);
       return;
     }
-    const blockNumber = txs[0].constants.globalVariables.blockNumber.toNumber();
-    const provingState = this.provingState?.getBlockProvingStateByBlockNumber(blockNumber!);
+
+    const blockNumber = BlockNumber(txs[0].globalVariables.blockNumber);
+    const provingState = this.provingState.getBlockProvingStateByBlockNumber(blockNumber!);
     if (!provingState) {
-      throw new Error(`Block proving state for ${blockNumber} not found`);
+      throw new Error(`Proving state for block ${blockNumber} not found. Call startNewBlock first.`);
     }
 
-    if (provingState.totalNumTxs) {
+    if (provingState.totalNumTxs !== txs.length) {
+      throw new Error(
+        `Block ${blockNumber} should be filled with ${provingState.totalNumTxs} txs. Received ${txs.length} txs.`,
+      );
+    }
+
+    if (!provingState.isAcceptingTxs()) {
       throw new Error(`Block ${blockNumber} has been initialized with transactions.`);
     }
 
-    const numBlobFields = toNumBlobFields(txs);
-    provingState.startNewBlock(txs.length, numBlobFields);
+    this.logger.info(`Adding ${txs.length} transactions to block ${blockNumber}`);
+
+    const db = this.dbs.get(blockNumber)!.fork;
+    const lastArchive = provingState.lastArchiveTreeSnapshot;
+    const newL1ToL2MessageTreeSnapshot = provingState.newL1ToL2MessageTreeSnapshot;
+    const spongeBlobState = provingState.getStartSpongeBlob().clone();
 
-    logger.info(
-      `Adding ${txs.length} transactions with ${numBlobFields} blob fields to block ${provingState.blockNumber}`,
-    );
     for (const tx of txs) {
       try {
         if (!provingState.verifyState()) {
@@ -208,15 +330,32 @@ export class ProvingOrchestrator implements EpochProver {
 
         validateTx(tx);
 
-        logger.info(`Received transaction: ${tx.hash}`);
+        this.logger.debug(`Received transaction: ${tx.hash}`);
+
+        const startSpongeBlob = spongeBlobState.clone();
+        const [hints, treeSnapshots] = await this.prepareBaseRollupInputs(
+          tx,
+          lastArchive,
+          newL1ToL2MessageTreeSnapshot,
+          startSpongeBlob,
+          db,
+        );
 
-        const [hints, treeSnapshots] = await this.prepareTransaction(tx, provingState);
-        const txProvingState = new TxProvingState(tx, hints, treeSnapshots);
+        if (!provingState.verifyState()) {
+          throw new Error(`Unable to add transaction, preparing base inputs failed`);
+        }
+
+        await spongeBlobState.absorb(tx.txEffect.toBlobFields());
+
+        const txProvingState = new TxProvingState(tx, hints, treeSnapshots, this.proverId.toField());
         const txIndex = provingState.addNewTx(txProvingState);
-        this.getOrEnqueueTube(provingState, txIndex);
         if (txProvingState.requireAvmProof) {
-          logger.debug(`Enqueueing public VM for tx ${txIndex}`);
+          this.getOrEnqueueChonkVerifier(provingState, txIndex);
+          this.logger.debug(`Enqueueing public VM for tx ${txIndex}`);
           this.enqueueVM(provingState, txIndex);
+        } else {
+          this.logger.debug(`Enqueueing base rollup for private-only tx ${txIndex}`);
+          this.enqueueBaseRollup(provingState, txIndex);
         }
       } catch (err: any) {
         throw new Error(`Error adding transaction ${tx.hash.toString()} to block ${blockNumber}: ${err.message}`, {
@@ -224,122 +363,163 @@ export class ProvingOrchestrator implements EpochProver {
         });
       }
     }
+
+    const endState = await db.getStateReference();
+    provingState.setEndState(endState);
+
+    const blockEndBlobFields = provingState.getBlockEndBlobFields();
+    await spongeBlobState.absorb(blockEndBlobFields);
+
+    provingState.setEndSpongeBlob(spongeBlobState);
+
+    // Txs have been added to the block. Now try to accumulate the out hashes and blobs as far as we can:
+    await this.provingState.accumulateCheckpointOutHashes();
+    await this.provingState.setBlobAccumulators();
   }
 
   /**
-   * Kickstarts tube circuits for the specified txs. These will be used during epoch proving.
-   * Note that if the tube circuits are not started this way, they will be started nontheless after processing.
+   * Kickstarts chonk verifier circuits for the specified txs. These will be used during epoch proving.
+   * Note that if the chonk verifier circuits are not started this way, they will be started nontheless after processing.
    */
-  @trackSpan('ProvingOrchestrator.startTubeCircuits')
-  public async startTubeCircuits(txs: Tx[]) {
+  @trackSpan('ProvingOrchestrator.startChonkVerifierCircuits')
+  public startChonkVerifierCircuits(txs: Tx[]) {
     if (!this.provingState?.verifyState()) {
-      throw new Error(`Invalid proving state, call startNewEpoch before starting tube circuits`);
+      throw new Error(`Empty epoch proving state. call startNewEpoch before starting chonk verifier circuits.`);
     }
-    for (const tx of txs) {
-      const txHash = (await tx.getTxHash()).toString();
-      const tubeInputs = new TubeInputs(tx.clientIvcProof);
-      const tubeProof = promiseWithResolvers<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>>();
-      logger.debug(`Starting tube circuit for tx ${txHash}`);
-      this.doEnqueueTube(txHash, tubeInputs, proof => tubeProof.resolve(proof));
-      this.provingState?.cachedTubeProofs.set(txHash, tubeProof.promise);
+    const publicTxs = txs.filter(tx => tx.data.forPublic);
+    for (const tx of publicTxs) {
+      const txHash = tx.getTxHash().toString();
+      const privateInputs = getPublicChonkVerifierPrivateInputsFromTx(tx, this.proverId.toField());
+      const tubeProof =
+        promiseWithResolvers<
+          PublicInputsAndRecursiveProof<
+            PublicChonkVerifierPublicInputs,
+            typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+          >
+        >();
+      this.logger.debug(`Starting chonk verifier circuit for tx ${txHash}`);
+      this.doEnqueueChonkVerifier(txHash, privateInputs, proof => {
+        tubeProof.resolve(proof);
+      });
+      this.provingState.cachedChonkVerifierProofs.set(txHash, tubeProof.promise);
     }
+    return Promise.resolve();
   }
 
   /**
    * Marks the block as completed.
    * Computes the block header and updates the archive tree.
    */
-  @trackSpan('ProvingOrchestrator.setBlockCompleted', (blockNumber: number) => ({
+  @trackSpan('ProvingOrchestrator.setBlockCompleted', (blockNumber: BlockNumber) => ({
     [Attributes.BLOCK_NUMBER]: blockNumber,
   }))
-  public async setBlockCompleted(blockNumber: number, expectedHeader?: BlockHeader): Promise<L2Block> {
+  public async setBlockCompleted(blockNumber: BlockNumber, expectedHeader?: BlockHeader): Promise<BlockHeader> {
     const provingState = this.provingState?.getBlockProvingStateByBlockNumber(blockNumber);
     if (!provingState) {
       throw new Error(`Block proving state for ${blockNumber} not found`);
     }
 
-    if (!provingState.spongeBlobState) {
-      // If we are completing an empty block, initialise the provingState.
-      // We will have 0 txs and no blob fields.
-      provingState.startNewBlock(0, 0);
+    // Abort with specific error for the block if there's one.
+    const error = provingState.getError();
+    if (error) {
+      throw new Error(`Block proving failed: ${error}`);
     }
 
+    // Abort if the proving state is not valid due to errors occurred elsewhere.
     if (!provingState.verifyState()) {
-      throw new Error(`Block proving failed: ${provingState.error}`);
+      throw new Error(`Invalid proving state when completing block ${blockNumber}.`);
     }
 
-    // And build the block header
-    logger.verbose(`Block ${blockNumber} completed. Assembling header.`);
-    await this.buildBlock(provingState, expectedHeader);
-
-    // If the proofs were faster than the block building, then we need to try the block root rollup again here
-    await this.checkAndEnqueueBlockRootRollup(provingState);
-    return provingState.block!;
-  }
-
-  /** Returns the block as built for a given index. */
-  public getBlock(index: number): L2Block {
-    const block = this.provingState?.blocks[index]?.block;
-    if (!block) {
-      throw new Error(`Block at index ${index} not available`);
+    if (provingState.isAcceptingTxs()) {
+      throw new Error(
+        `Block ${blockNumber} is still accepting txs. Call setBlockCompleted after all txs have been added.`,
+      );
     }
-    return block;
-  }
-
-  private async buildBlock(provingState: BlockProvingState, expectedHeader?: BlockHeader) {
-    // Collect all new nullifiers, commitments, and contracts from all txs in this block to build body
-    const txs = provingState.allTxs.map(a => a.processedTx);
 
-    // Get db for this block
-    const db = this.dbs.get(provingState.blockNumber)!;
-
-    // Given we've applied every change from this block, now assemble the block header
-    // and update the archive tree, so we're ready to start processing the next block
-    const { header, body } = await buildHeaderAndBodyFromTxs(
-      txs,
-      provingState.globalVariables,
-      provingState.newL1ToL2Messages,
-      db,
-    );
+    // Given we've applied every change from this block, now assemble the block header:
+    this.logger.verbose(`Block ${blockNumber} completed. Assembling header.`);
+    const header = await provingState.buildBlockHeader();
 
     if (expectedHeader && !header.equals(expectedHeader)) {
-      logger.error(`Block header mismatch: header=${header} expectedHeader=${expectedHeader}`);
+      this.logger.error(`Block header mismatch: header=${header} expectedHeader=${expectedHeader}`);
       throw new Error('Block header mismatch');
     }
 
-    logger.verbose(
+    // Get db for this block
+    const db = this.dbs.get(provingState.blockNumber)!.fork;
+
+    // Update the archive tree, so we're ready to start processing the next block:
+    this.logger.verbose(
       `Updating archive tree with block ${provingState.blockNumber} header ${(await header.hash()).toString()}`,
     );
     await db.updateArchive(header);
 
-    // Assemble the L2 block
-    const newArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
-    const l2Block = new L2Block(newArchive, header, body);
-
-    await this.verifyBuiltBlockAgainstSyncedState(l2Block, newArchive);
+    await this.verifyBuiltBlockAgainstSyncedState(provingState);
 
-    logger.verbose(`Orchestrator finalised block ${l2Block.number}`);
-    provingState.block = l2Block;
+    return header;
   }
 
   // Flagged as protected to disable in certain unit tests
-  protected async verifyBuiltBlockAgainstSyncedState(l2Block: L2Block, newArchive: AppendOnlyTreeSnapshot) {
-    const syncedArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.dbProvider.getSnapshot(l2Block.number));
+  protected async verifyBuiltBlockAgainstSyncedState(provingState: BlockProvingState) {
+    const builtBlockHeader = provingState.getBuiltBlockHeader();
+    if (!builtBlockHeader) {
+      this.logger.debug('Block header not built yet, skipping header check.');
+      return;
+    }
+
+    const output = provingState.getBlockRootRollupOutput();
+    if (!output) {
+      this.logger.debug('Block root rollup proof not built yet, skipping header check.');
+      return;
+    }
+    const header = await buildHeaderFromCircuitOutputs(output);
+
+    if (!(await header.hash()).equals(await builtBlockHeader.hash())) {
+      this.logger.error(`Block header mismatch.\nCircuit: ${inspect(header)}\nComputed: ${inspect(builtBlockHeader)}`);
+      provingState.reject(`Block header hash mismatch.`);
+      return;
+    }
+
+    // Get db for this block
+    const blockNumber = provingState.blockNumber;
+    const db = this.dbs.get(blockNumber)!.fork;
+
+    const newArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
+    const syncedArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.dbProvider.getSnapshot(blockNumber));
     if (!syncedArchive.equals(newArchive)) {
-      throw new Error(
-        `Archive tree mismatch for block ${l2Block.number}: world state synced to ${inspect(
+      this.logger.error(
+        `Archive tree mismatch for block ${blockNumber}: world state synced to ${inspect(
           syncedArchive,
         )} but built ${inspect(newArchive)}`,
       );
+      provingState.reject(`Archive tree mismatch.`);
+      return;
     }
+
+    const circuitArchive = output.newArchive;
+    if (!newArchive.equals(circuitArchive)) {
+      this.logger.error(`New archive mismatch.\nCircuit: ${output.newArchive}\nComputed: ${newArchive}`);
+      provingState.reject(`New archive mismatch.`);
+      return;
+    }
+
+    // TODO(palla/prover): This closes the fork only on the happy path. If this epoch orchestrator
+    // is aborted and never reaches this point, it will leak the fork. We need to add a global cleanup,
+    // but have to make sure it only runs once all operations are completed, otherwise some function here
+    // will attempt to access the fork after it was closed.
+    void this.cleanupDBFork(blockNumber);
   }
 
   /**
-   * Cancel any further proving
+   * Cancel any further proving.
+   * If cancelJobsOnStop is true, aborts all pending jobs with the broker (which marks them as 'Aborted').
+   * If cancelJobsOnStop is false (default), jobs remain in the broker queue and can be reused on restart/reorg.
    */
   public cancel() {
-    for (const controller of this.pendingProvingJobs) {
-      controller.abort();
+    if (this.cancelJobsOnStop) {
+      for (const controller of this.pendingProvingJobs) {
+        controller.abort();
+      }
     }
 
     this.provingState?.cancel();
@@ -348,9 +528,13 @@ export class ProvingOrchestrator implements EpochProver {
   /**
    * Returns the proof for the current epoch.
    */
-  public async finaliseEpoch() {
+  public async finalizeEpoch(): Promise<{
+    publicInputs: RootRollupPublicInputs;
+    proof: Proof;
+    batchedBlobInputs: BatchedBlob;
+  }> {
     if (!this.provingState || !this.provingPromise) {
-      throw new Error(`Invalid proving state, an epoch must be proven before it can be finalised`);
+      throw new Error(`Invalid proving state, an epoch must be proven before it can be finalized`);
     }
 
     const result = await this.provingPromise!;
@@ -358,6 +542,8 @@ export class ProvingOrchestrator implements EpochProver {
       throw new Error(`Epoch proving failed: ${result.reason}`);
     }
 
+    await this.provingState.finalizeBatchedBlob();
+
     const epochProofResult = this.provingState.getEpochProofResult();
 
     pushTestData('epochProofResult', {
@@ -368,18 +554,22 @@ export class ProvingOrchestrator implements EpochProver {
     return epochProofResult;
   }
 
-  /**
-   * Starts the proving process for the given transaction and adds it to our state
-   * @param tx - The transaction whose proving we wish to commence
-   * @param provingState - The proving state being worked on
-   */
-  private async prepareTransaction(tx: ProcessedTx, provingState: BlockProvingState) {
-    const txInputs = await this.prepareBaseRollupInputs(provingState, tx);
-    if (!txInputs) {
-      // This should not be possible
-      throw new Error(`Unable to add transaction, preparing base inputs failed`);
+  private async cleanupDBFork(blockNumber: BlockNumber): Promise<void> {
+    this.logger.debug(`Cleaning up world state fork for ${blockNumber}`);
+    const fork = this.dbs.get(blockNumber);
+    if (!fork) {
+      return;
+    }
+
+    try {
+      if (!fork.cleanupPromise) {
+        fork.cleanupPromise = fork.fork.close();
+      }
+      await fork.cleanupPromise;
+      this.dbs.delete(blockNumber);
+    } catch (err) {
+      this.logger.error(`Error closing db for block ${blockNumber}`, err);
     }
-    return txInputs;
   }
 
   /**
@@ -389,12 +579,12 @@ export class ProvingOrchestrator implements EpochProver {
    * @param job - The actual job, returns a promise notifying of the job's completion
    */
   private deferredProving<T>(
-    provingState: EpochProvingState | BlockProvingState | undefined,
+    provingState: EpochProvingState | CheckpointProvingState | BlockProvingState,
     request: (signal: AbortSignal) => Promise<T>,
     callback: (result: T) => void | Promise<void>,
   ) {
-    if (!provingState?.verifyState()) {
-      logger.debug(`Not enqueuing job, state no longer valid`);
+    if (!provingState.verifyState()) {
+      this.logger.debug(`Not enqueuing job, state no longer valid`);
       return;
     }
 
@@ -411,8 +601,8 @@ export class ProvingOrchestrator implements EpochProver {
         }
 
         const result = await request(controller.signal);
-        if (!provingState?.verifyState()) {
-          logger.debug(`State no longer valid, discarding result`);
+        if (!provingState.verifyState()) {
+          this.logger.debug(`State no longer valid, discarding result`);
           return;
         }
 
@@ -430,7 +620,7 @@ export class ProvingOrchestrator implements EpochProver {
           return;
         }
 
-        logger.error(`Error thrown when proving job`, err);
+        this.logger.error(`Error thrown when proving job`, err);
         provingState!.reject(`${err}`);
       } finally {
         const index = this.pendingProvingJobs.indexOf(controller);
@@ -444,52 +634,59 @@ export class ProvingOrchestrator implements EpochProver {
     setImmediate(() => void safeJob());
   }
 
-  private async prepareBaseParityInputs(l1ToL2Messages: Fr[], db: MerkleTreeWriteOperations) {
-    const l1ToL2MessagesPadded = padArrayEnd(
+  private async updateL1ToL2MessageTree(l1ToL2Messages: Fr[], db: MerkleTreeWriteOperations) {
+    const l1ToL2MessagesPadded = padArrayEnd<Fr, number>(
       l1ToL2Messages,
       Fr.ZERO,
       NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
       'Too many L1 to L2 messages',
     );
-    const baseParityInputs = times(NUM_BASE_PARITY_PER_ROOT_PARITY, i =>
-      BaseParityInputs.fromSlice(l1ToL2MessagesPadded, i, getVKTreeRoot()),
-    );
 
-    const l1ToL2MessageSubtreeSiblingPath = assertLength(
+    const lastL1ToL2MessageTreeSnapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
+    const lastL1ToL2MessageSubtreeRootSiblingPath = assertLength(
       await getSubtreeSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, L1_TO_L2_MSG_SUBTREE_HEIGHT, db),
-      L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
+      L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
     );
 
     // Update the local trees to include the new l1 to l2 messages
     await db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
-    const l1ToL2MessageTreeSnapshotAfterInsertion = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
+
+    const newL1ToL2MessageTreeSnapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
+    const newL1ToL2MessageSubtreeRootSiblingPath = assertLength(
+      await getSubtreeSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, L1_TO_L2_MSG_SUBTREE_HEIGHT, db),
+      L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
+    );
 
     return {
-      l1ToL2MessageSubtreeSiblingPath,
-      l1ToL2MessageTreeSnapshotAfterInsertion,
-      baseParityInputs,
+      lastL1ToL2MessageTreeSnapshot,
+      lastL1ToL2MessageSubtreeRootSiblingPath,
+      newL1ToL2MessageTreeSnapshot,
+      newL1ToL2MessageSubtreeRootSiblingPath,
     };
   }
 
   // Updates the merkle trees for a transaction. The first enqueued job for a transaction
-  @trackSpan('ProvingOrchestrator.prepareBaseRollupInputs', (_, tx) => ({
+  @trackSpan('ProvingOrchestrator.prepareBaseRollupInputs', tx => ({
     [Attributes.TX_HASH]: tx.hash.toString(),
   }))
   private async prepareBaseRollupInputs(
-    provingState: BlockProvingState,
     tx: ProcessedTx,
-  ): Promise<[BaseRollupHints, TreeSnapshots] | undefined> {
-    if (!provingState.verifyState() || !provingState.spongeBlobState) {
-      logger.debug('Not preparing base rollup inputs, state invalid');
-      return;
-    }
-
-    const db = this.dbs.get(provingState.blockNumber)!;
-
+    lastArchive: AppendOnlyTreeSnapshot,
+    newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot,
+    startSpongeBlob: SpongeBlob,
+    db: MerkleTreeWriteOperations,
+  ): Promise<[BaseRollupHints, TreeSnapshots]> {
     // We build the base rollup inputs using a mock proof and verification key.
-    // These will be overwritten later once we have proven the tube circuit and any public kernels
+    // These will be overwritten later once we have proven the chonk verifier circuit and any public kernels
     const [ms, hints] = await elapsed(
-      buildBaseRollupHints(tx, provingState.globalVariables, db, provingState.spongeBlobState),
+      insertSideEffectsAndBuildBaseRollupHints(
+        tx,
+        lastArchive,
+        newL1ToL2MessageTreeSnapshot,
+        startSpongeBlob,
+        this.proverId.toField(),
+        db,
+      ),
     );
 
     this.metrics.recordBaseRollupInputs(ms);
@@ -501,10 +698,6 @@ export class ProvingOrchestrator implements EpochProver {
     );
     const treeSnapshots: TreeSnapshots = new Map((await Promise.all(promises)).map(obj => [obj.key, obj.value]));
 
-    if (!provingState.verifyState()) {
-      logger.debug(`Discarding proving job, state no longer valid`);
-      return;
-    }
     return [hints, treeSnapshots];
   }
 
@@ -512,7 +705,12 @@ export class ProvingOrchestrator implements EpochProver {
   // Executes the next level of merge if all inputs are available
   private enqueueBaseRollup(provingState: BlockProvingState, txIndex: number) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running base rollup, state invalid');
+      this.logger.debug('Not running base rollup, state invalid');
+      return;
+    }
+
+    if (!provingState.tryStartProvingBase(txIndex)) {
+      this.logger.debug(`Base rollup for tx ${txIndex} already started.`);
       return;
     }
 
@@ -520,77 +718,88 @@ export class ProvingOrchestrator implements EpochProver {
     const { processedTx } = txProvingState;
     const { rollupType, inputs } = txProvingState.getBaseRollupTypeAndInputs();
 
-    logger.debug(`Enqueuing deferred proving base rollup for ${processedTx.hash.toString()}`);
+    this.logger.debug(`Enqueuing deferred proving base rollup for ${processedTx.hash.toString()}`);
 
     this.deferredProving(
       provingState,
       wrapCallbackInSpan(
         this.tracer,
         `ProvingOrchestrator.prover.${
-          inputs instanceof PrivateBaseRollupInputs ? 'getPrivateBaseRollupProof' : 'getPublicBaseRollupProof'
+          inputs instanceof PrivateTxBaseRollupPrivateInputs
+            ? 'getPrivateTxBaseRollupProof'
+            : 'getPublicTxBaseRollupProof'
         }`,
         {
           [Attributes.TX_HASH]: processedTx.hash.toString(),
-          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
           [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);
           }
         },
       ),
-      async result => {
-        logger.debug(`Completed proof for ${rollupType} for tx ${processedTx.hash.toString()}`);
-        validatePartialState(result.inputs.end, txProvingState.treeSnapshots);
+      result => {
+        this.logger.debug(`Completed proof for ${rollupType} for tx ${processedTx.hash.toString()}`);
+        validatePartialState(result.inputs.endTreeSnapshots, txProvingState.treeSnapshots);
         const leafLocation = provingState.setBaseRollupProof(txIndex, result);
         if (provingState.totalNumTxs === 1) {
-          await this.checkAndEnqueueBlockRootRollup(provingState);
+          this.checkAndEnqueueBlockRootRollup(provingState);
         } else {
-          await this.checkAndEnqueueNextMergeRollup(provingState, leafLocation);
+          this.checkAndEnqueueNextMergeRollup(provingState, leafLocation);
         }
       },
     );
   }
 
-  // Enqueues the tube circuit for a given transaction index, or reuses the one already enqueued
-  // Once completed, will enqueue the next circuit, either a public kernel or the base rollup
-  private getOrEnqueueTube(provingState: BlockProvingState, txIndex: number) {
+  // Enqueues the public chonk verifier circuit for a given transaction index, or reuses the one already enqueued.
+  // Once completed, will enqueue the the public tx base rollup.
+  private getOrEnqueueChonkVerifier(provingState: BlockProvingState, txIndex: number) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running tube circuit, state invalid');
+      this.logger.debug('Not running chonk verifier circuit, state invalid');
       return;
     }
 
     const txProvingState = provingState.getTxProvingState(txIndex);
     const txHash = txProvingState.processedTx.hash.toString();
-
-    const handleResult = (result: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>) => {
-      logger.debug(`Got tube proof for tx index: ${txIndex}`, { txHash });
-      txProvingState.setTubeProof(result);
-      this.provingState?.cachedTubeProofs.delete(txHash);
-      this.checkAndEnqueueNextTxCircuit(provingState, txIndex);
+    NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH;
+    const handleResult = (
+      result: PublicInputsAndRecursiveProof<
+        PublicChonkVerifierPublicInputs,
+        typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+      >,
+    ) => {
+      this.logger.debug(`Got chonk verifier proof for tx index: ${txIndex}`, { txHash });
+      txProvingState.setPublicChonkVerifierProof(result);
+      this.provingState?.cachedChonkVerifierProofs.delete(txHash);
+      this.checkAndEnqueueBaseRollup(provingState, txIndex);
     };
 
-    if (this.provingState?.cachedTubeProofs.has(txHash)) {
-      logger.debug(`Tube proof already enqueued for tx index: ${txIndex}`, { txHash });
-      void this.provingState!.cachedTubeProofs.get(txHash)!.then(handleResult);
+    if (this.provingState?.cachedChonkVerifierProofs.has(txHash)) {
+      this.logger.debug(`Chonk verifier proof already enqueued for tx index: ${txIndex}`, { txHash });
+      void this.provingState!.cachedChonkVerifierProofs.get(txHash)!.then(handleResult);
       return;
     }
 
-    logger.debug(`Enqueuing tube circuit for tx index: ${txIndex}`);
-    this.doEnqueueTube(txHash, txProvingState.getTubeInputs(), handleResult);
+    this.logger.debug(`Enqueuing chonk verifier circuit for tx index: ${txIndex}`);
+    this.doEnqueueChonkVerifier(txHash, txProvingState.getPublicChonkVerifierPrivateInputs(), handleResult);
   }
 
-  private doEnqueueTube(
+  private doEnqueueChonkVerifier(
     txHash: string,
-    inputs: TubeInputs,
-    handler: (result: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>) => void,
+    inputs: PublicChonkVerifierPrivateInputs,
+    handler: (
+      result: PublicInputsAndRecursiveProof<
+        PublicChonkVerifierPublicInputs,
+        typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
+      >,
+    ) => void,
     provingState: EpochProvingState | BlockProvingState = this.provingState!,
   ) {
-    if (!provingState?.verifyState()) {
-      logger.debug('Not running tube circuit, state invalid');
+    if (!provingState.verifyState()) {
+      this.logger.debug('Not running chonk verifier circuit, state invalid');
       return;
     }
 
@@ -598,13 +807,12 @@ export class ProvingOrchestrator implements EpochProver {
       provingState,
       wrapCallbackInSpan(
         this.tracer,
-        'ProvingOrchestrator.prover.getTubeProof',
+        'ProvingOrchestrator.prover.getPublicChonkVerifierProof',
         {
           [Attributes.TX_HASH]: txHash,
-          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
-          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'tube-circuit' satisfies CircuitName,
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'chonk-verifier-public' satisfies CircuitName,
         },
-        signal => this.prover.getTubeProof(inputs, signal, this.provingState!.epochNumber),
+        signal => this.prover.getPublicChonkVerifierProof(inputs, signal, provingState.epochNumber),
       ),
       handler,
     );
@@ -614,7 +822,12 @@ export class ProvingOrchestrator implements EpochProver {
   // Enqueues the next level of merge if all inputs are available
   private enqueueMergeRollup(provingState: BlockProvingState, location: TreeNodeLocation) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running merge rollup. State no longer valid.');
+      this.logger.debug('Not running merge rollup. State no longer valid.');
+      return;
+    }
+
+    if (!provingState.tryStartProvingMerge(location)) {
+      this.logger.debug('Merge rollup already started.');
       return;
     }
 
@@ -624,34 +837,34 @@ export class ProvingOrchestrator implements EpochProver {
       provingState,
       wrapCallbackInSpan(
         this.tracer,
-        'ProvingOrchestrator.prover.getMergeRollupProof',
+        'ProvingOrchestrator.prover.getTxMergeRollupProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
-          [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),
       ),
-      async result => {
+      result => {
         provingState.setMergeRollupProof(location, result);
-        await this.checkAndEnqueueNextMergeRollup(provingState, location);
+        this.checkAndEnqueueNextMergeRollup(provingState, location);
       },
     );
   }
 
   // Executes the block root rollup circuit
-  private async enqueueBlockRootRollup(provingState: BlockProvingState) {
+  private enqueueBlockRootRollup(provingState: BlockProvingState) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running block root rollup, state no longer valid');
+      this.logger.debug('Not running block root rollup, state no longer valid');
       return;
     }
 
-    provingState.blockRootRollupStarted = true;
+    if (!provingState.tryStartProvingBlockRoot()) {
+      this.logger.debug('Block root rollup already started.');
+      return;
+    }
 
-    const { rollupType, inputs } = await provingState.getBlockRootRollupTypeAndInputs(this.proverId);
+    const { rollupType, inputs } = provingState.getBlockRootRollupTypeAndInputs();
 
-    logger.debug(
-      `Enqueuing ${rollupType} for block ${provingState.blockNumber} with ${provingState.newL1ToL2Messages.length} l1 to l2 msgs.`,
-    );
+    this.logger.debug(`Enqueuing ${rollupType} for block ${provingState.blockNumber}.`);
 
     this.deferredProving(
       provingState,
@@ -659,64 +872,74 @@ export class ProvingOrchestrator implements EpochProver {
         this.tracer,
         'ProvingOrchestrator.prover.getBlockRootRollupProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
           [Attributes.PROTOCOL_CIRCUIT_NAME]: rollupType,
         },
         signal => {
-          if (inputs instanceof EmptyBlockRootRollupInputs) {
-            return this.prover.getEmptyBlockRootRollupProof(inputs, signal, provingState.epochNumber);
-          } else if (inputs instanceof SingleTxBlockRootRollupInputs) {
-            return this.prover.getSingleTxBlockRootRollupProof(inputs, signal, provingState.epochNumber);
+          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);
           }
         },
       ),
       async result => {
-        provingState.setBlockRootRollupProof(result);
-        const header = await provingState.buildHeaderFromProvingOutputs(logger);
-        if (!(await header.hash()).equals(await provingState.block!.header.hash())) {
-          logger.error(
-            `Block header mismatch\nCircuit:${inspect(header)}\nComputed:${inspect(provingState.block!.header)}`,
-          );
-          provingState.reject(`Block header hash mismatch`);
-        }
+        this.logger.debug(`Completed ${rollupType} proof for block ${provingState.blockNumber}`);
+
+        const leafLocation = provingState.setBlockRootRollupProof(result);
+        const checkpointProvingState = provingState.parentCheckpoint;
 
-        logger.debug(`Completed ${rollupType} proof for block ${provingState.block!.number}`);
-        // validatePartialState(result.inputs.end, tx.treeSnapshots); // TODO(palla/prover)
+        // If the proofs were slower than the block header building, then we need to try validating the block header hashes here.
+        await this.verifyBuiltBlockAgainstSyncedState(provingState);
 
-        const epochProvingState = this.provingState!;
-        const leafLocation = epochProvingState.setBlockRootRollupProof(provingState.index, result);
-        if (epochProvingState.totalNumBlocks === 1) {
-          await this.enqueueEpochPadding(epochProvingState);
+        if (checkpointProvingState.totalNumBlocks === 1) {
+          this.checkAndEnqueueCheckpointRootRollup(checkpointProvingState);
         } else {
-          this.checkAndEnqueueNextBlockMergeRollup(epochProvingState, leafLocation);
+          this.checkAndEnqueueNextBlockMergeRollup(checkpointProvingState, leafLocation);
         }
+
+        // We are finished with the block at this point, ensure the fork is cleaned up
+        void this.cleanupDBFork(provingState.blockNumber);
       },
     );
   }
 
   // Executes the base parity circuit and stores the intermediate state for the root parity circuit
   // Enqueues the root parity circuit if all inputs are available
-  private enqueueBaseParityCircuit(provingState: BlockProvingState, inputs: BaseParityInputs, index: number) {
+  private enqueueBaseParityCircuit(
+    checkpointProvingState: CheckpointProvingState,
+    provingState: BlockProvingState,
+    baseParityIndex: number,
+  ) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running base parity. State no longer valid.');
+      this.logger.debug('Not running base parity. State no longer valid.');
+      return;
+    }
+
+    if (!provingState.tryStartProvingBaseParity(baseParityIndex)) {
+      this.logger.warn(`Base parity ${baseParityIndex} already started.`);
       return;
     }
 
+    const inputs = checkpointProvingState.getBaseParityInputs(baseParityIndex);
+
     this.deferredProving(
       provingState,
       wrapCallbackInSpan(
         this.tracer,
         'ProvingOrchestrator.prover.getBaseParityProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
-          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'base-parity' satisfies CircuitName,
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'parity-base' satisfies CircuitName,
         },
         signal => this.prover.getBaseParityProof(inputs, signal, provingState.epochNumber),
       ),
       provingOutput => {
-        provingState.setBaseParityProof(index, provingOutput);
+        provingState.setBaseParityProof(baseParityIndex, provingOutput);
         this.checkAndEnqueueRootParityCircuit(provingState);
       },
     );
@@ -734,11 +957,16 @@ export class ProvingOrchestrator implements EpochProver {
   // Enqueues the root rollup proof if all inputs are available
   private enqueueRootParityCircuit(provingState: BlockProvingState) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running root parity. State no longer valid.');
+      this.logger.debug('Not running root parity. State no longer valid.');
       return;
     }
 
-    const inputs = provingState.getRootParityInputs();
+    if (!provingState.tryStartProvingRootParity()) {
+      this.logger.debug('Root parity already started.');
+      return;
+    }
+
+    const inputs = provingState.getParityRootInputs();
 
     this.deferredProving(
       provingState,
@@ -746,36 +974,38 @@ export class ProvingOrchestrator implements EpochProver {
         this.tracer,
         'ProvingOrchestrator.prover.getRootParityProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
-          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'root-parity' satisfies CircuitName,
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'parity-root' satisfies CircuitName,
         },
         signal => this.prover.getRootParityProof(inputs, signal, provingState.epochNumber),
       ),
-      async result => {
+      result => {
         provingState.setRootParityProof(result);
-        await this.checkAndEnqueueBlockRootRollup(provingState);
+        this.checkAndEnqueueBlockRootRollup(provingState);
       },
     );
   }
 
   // Executes the block merge rollup circuit and stored the output as intermediate state for the parent merge/block root circuit
   // Enqueues the next level of merge if all inputs are available
-  private enqueueBlockMergeRollup(provingState: EpochProvingState, location: TreeNodeLocation) {
+  private enqueueBlockMergeRollup(provingState: CheckpointProvingState, location: TreeNodeLocation) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running block merge rollup. State no longer valid.');
+      this.logger.debug('Not running block merge rollup. State no longer valid.');
       return;
     }
 
-    const inputs = provingState.getBlockMergeRollupInputs(location);
+    if (!provingState.tryStartProvingBlockMerge(location)) {
+      this.logger.debug('Block merge rollup already started.');
+      return;
+    }
 
+    const inputs = provingState.getBlockMergeRollupInputs(location);
     this.deferredProving(
       provingState,
       wrapCallbackInSpan(
         this.tracer,
         'ProvingOrchestrator.prover.getBlockMergeRollupProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
-          [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),
       ),
@@ -786,30 +1016,125 @@ export class ProvingOrchestrator implements EpochProver {
     );
   }
 
-  private async enqueueEpochPadding(provingState: EpochProvingState) {
+  private enqueueCheckpointRootRollup(provingState: CheckpointProvingState) {
+    if (!provingState.verifyState()) {
+      this.logger.debug('Not running checkpoint root rollup. State no longer valid.');
+      return;
+    }
+
+    if (!provingState.tryStartProvingCheckpointRoot()) {
+      this.logger.debug('Checkpoint root rollup already started.');
+      return;
+    }
+
+    const rollupType = provingState.getCheckpointRootRollupType();
+
+    this.logger.debug(`Enqueuing ${rollupType} for checkpoint ${provingState.index}.`);
+
+    const inputs = provingState.getCheckpointRootRollupInputs();
+
+    this.deferredProving(
+      provingState,
+      wrapCallbackInSpan(
+        this.tracer,
+        'ProvingOrchestrator.prover.getCheckpointRootRollupProof',
+        {
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: rollupType,
+        },
+        signal => {
+          if (inputs instanceof CheckpointRootSingleBlockRollupPrivateInputs) {
+            return this.prover.getCheckpointRootSingleBlockRollupProof(inputs, signal, provingState.epochNumber);
+          } else {
+            return this.prover.getCheckpointRootRollupProof(inputs, signal, provingState.epochNumber);
+          }
+        },
+      ),
+      result => {
+        const computedEndBlobAccumulatorState = provingState.getEndBlobAccumulator()!.toBlobAccumulator();
+        const circuitEndBlobAccumulatorState = result.inputs.endBlobAccumulator;
+        if (!circuitEndBlobAccumulatorState.equals(computedEndBlobAccumulatorState)) {
+          this.logger.error(
+            `Blob accumulator state mismatch.\nCircuit: ${inspect(circuitEndBlobAccumulatorState)}\nComputed: ${inspect(
+              computedEndBlobAccumulatorState,
+            )}`,
+          );
+          provingState.reject(`Blob accumulator state mismatch.`);
+          return;
+        }
+
+        this.logger.debug(`Completed ${rollupType} proof for checkpoint ${provingState.index}.`);
+
+        const leafLocation = provingState.setCheckpointRootRollupProof(result);
+        const epochProvingState = provingState.parentEpoch;
+
+        if (epochProvingState.totalNumCheckpoints === 1) {
+          this.enqueueEpochPadding(epochProvingState);
+        } else {
+          this.checkAndEnqueueNextCheckpointMergeRollup(epochProvingState, leafLocation);
+        }
+      },
+    );
+  }
+
+  private enqueueCheckpointMergeRollup(provingState: EpochProvingState, location: TreeNodeLocation) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running epoch padding. State no longer valid.');
+      this.logger.debug('Not running checkpoint merge rollup. State no longer valid.');
       return;
     }
 
-    logger.debug('Padding epoch proof with an empty block root proof.');
+    if (!provingState.tryStartProvingCheckpointMerge(location)) {
+      this.logger.debug('Checkpoint merge rollup already started.');
+      return;
+    }
 
-    const inputs = await provingState.getPaddingBlockRootInputs(this.proverId);
+    const inputs = provingState.getCheckpointMergeRollupInputs(location);
 
     this.deferredProving(
       provingState,
       wrapCallbackInSpan(
         this.tracer,
-        'ProvingOrchestrator.prover.getEmptyBlockRootRollupProof',
+        'ProvingOrchestrator.prover.getCheckpointMergeRollupProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
-          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'empty-block-root-rollup' satisfies CircuitName,
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'rollup-checkpoint-merge' satisfies CircuitName,
         },
-        signal => this.prover.getEmptyBlockRootRollupProof(inputs, signal, provingState.epochNumber),
+        signal => this.prover.getCheckpointMergeRollupProof(inputs, signal, provingState.epochNumber),
       ),
       result => {
-        logger.debug('Completed proof for padding block root.');
-        provingState.setPaddingBlockRootProof(result);
+        this.logger.debug('Completed proof for checkpoint merge rollup.');
+        provingState.setCheckpointMergeRollupProof(location, result);
+        this.checkAndEnqueueNextCheckpointMergeRollup(provingState, location);
+      },
+    );
+  }
+
+  private enqueueEpochPadding(provingState: EpochProvingState) {
+    if (!provingState.verifyState()) {
+      this.logger.debug('Not running epoch padding. State no longer valid.');
+      return;
+    }
+
+    if (!provingState.tryStartProvingPaddingCheckpoint()) {
+      this.logger.debug('Padding checkpoint already started.');
+      return;
+    }
+
+    this.logger.debug('Padding epoch proof with a padding block root proof.');
+
+    const inputs = provingState.getPaddingCheckpointInputs();
+
+    this.deferredProving(
+      provingState,
+      wrapCallbackInSpan(
+        this.tracer,
+        'ProvingOrchestrator.prover.getCheckpointPaddingRollupProof',
+        {
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'rollup-checkpoint-padding' satisfies CircuitName,
+        },
+        signal => this.prover.getCheckpointPaddingRollupProof(inputs, signal, provingState.epochNumber),
+      ),
+      result => {
+        this.logger.debug('Completed proof for padding checkpoint.');
+        provingState.setCheckpointPaddingProof(result);
         this.checkAndEnqueueRootRollup(provingState);
       },
     );
@@ -818,13 +1143,13 @@ export class ProvingOrchestrator implements EpochProver {
   // Executes the root rollup circuit
   private enqueueRootRollup(provingState: EpochProvingState) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running root rollup, state no longer valid');
+      this.logger.debug('Not running root rollup, state no longer valid');
       return;
     }
 
-    logger.debug(`Preparing root rollup`);
+    this.logger.debug(`Preparing root rollup`);
 
-    const inputs = provingState.getRootRollupInputs(this.proverId);
+    const inputs = provingState.getRootRollupInputs();
 
     this.deferredProving(
       provingState,
@@ -832,59 +1157,63 @@ export class ProvingOrchestrator implements EpochProver {
         this.tracer,
         'ProvingOrchestrator.prover.getRootRollupProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
-          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'root-rollup' satisfies CircuitName,
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'rollup-root' satisfies CircuitName,
         },
         signal => this.prover.getRootRollupProof(inputs, signal, provingState.epochNumber),
       ),
       result => {
-        logger.verbose(`Orchestrator completed root rollup for epoch ${provingState.epochNumber}`);
+        this.logger.verbose(`Orchestrator completed root rollup for epoch ${provingState.epochNumber}`);
         provingState.setRootRollupProof(result);
         provingState.resolve({ status: 'success' });
       },
     );
   }
 
-  private async checkAndEnqueueNextMergeRollup(provingState: BlockProvingState, currentLocation: TreeNodeLocation) {
+  private checkAndEnqueueNextMergeRollup(provingState: BlockProvingState, currentLocation: TreeNodeLocation) {
     if (!provingState.isReadyForMergeRollup(currentLocation)) {
       return;
     }
 
     const parentLocation = provingState.getParentLocation(currentLocation);
     if (parentLocation.level === 0) {
-      await this.checkAndEnqueueBlockRootRollup(provingState);
+      this.checkAndEnqueueBlockRootRollup(provingState);
     } else {
       this.enqueueMergeRollup(provingState, parentLocation);
     }
   }
 
-  private async checkAndEnqueueBlockRootRollup(provingState: BlockProvingState) {
+  private checkAndEnqueueBlockRootRollup(provingState: BlockProvingState) {
     if (!provingState.isReadyForBlockRootRollup()) {
-      logger.debug('Not ready for root rollup');
+      this.logger.debug('Not ready for block root rollup');
       return;
     }
-    if (provingState.blockRootRollupStarted) {
-      logger.debug('Block root rollup already started');
+
+    this.enqueueBlockRootRollup(provingState);
+  }
+
+  private checkAndEnqueueNextBlockMergeRollup(provingState: CheckpointProvingState, currentLocation: TreeNodeLocation) {
+    if (!provingState.isReadyForBlockMerge(currentLocation)) {
       return;
     }
-    const blockNumber = provingState.blockNumber;
 
-    // TODO(palla/prover): This closes the fork only on the happy path. If this epoch orchestrator
-    // is aborted and never reaches this point, it will leak the fork. We need to add a global cleanup,
-    // but have to make sure it only runs once all operations are completed, otherwise some function here
-    // will attempt to access the fork after it was closed.
-    logger.debug(`Cleaning up world state fork for ${blockNumber}`);
-    void this.dbs
-      .get(blockNumber)
-      ?.close()
-      .then(() => this.dbs.delete(blockNumber))
-      .catch(err => logger.error(`Error closing db for block ${blockNumber}`, err));
+    const parentLocation = provingState.getParentLocation(currentLocation);
+    if (parentLocation.level === 0) {
+      this.checkAndEnqueueCheckpointRootRollup(provingState);
+    } else {
+      this.enqueueBlockMergeRollup(provingState, parentLocation);
+    }
+  }
+
+  private checkAndEnqueueCheckpointRootRollup(provingState: CheckpointProvingState) {
+    if (!provingState.isReadyForCheckpointRoot()) {
+      return;
+    }
 
-    await this.enqueueBlockRootRollup(provingState);
+    this.enqueueCheckpointRootRollup(provingState);
   }
 
-  private checkAndEnqueueNextBlockMergeRollup(provingState: EpochProvingState, currentLocation: TreeNodeLocation) {
-    if (!provingState.isReadyForBlockMerge(currentLocation)) {
+  private checkAndEnqueueNextCheckpointMergeRollup(provingState: EpochProvingState, currentLocation: TreeNodeLocation) {
+    if (!provingState.isReadyForCheckpointMerge(currentLocation)) {
       return;
     }
 
@@ -892,13 +1221,13 @@ export class ProvingOrchestrator implements EpochProver {
     if (parentLocation.level === 0) {
       this.checkAndEnqueueRootRollup(provingState);
     } else {
-      this.enqueueBlockMergeRollup(provingState, parentLocation);
+      this.enqueueCheckpointMergeRollup(provingState, parentLocation);
     }
   }
 
   private checkAndEnqueueRootRollup(provingState: EpochProvingState) {
     if (!provingState.isReadyForRootRollup()) {
-      logger.debug('Not ready for root rollup');
+      this.logger.debug('Not ready for root rollup');
       return;
     }
 
@@ -913,14 +1242,12 @@ export class ProvingOrchestrator implements EpochProver {
    */
   private enqueueVM(provingState: BlockProvingState, txIndex: number) {
     if (!provingState.verifyState()) {
-      logger.debug(`Not running VM circuit as state is no longer valid`);
+      this.logger.debug(`Not running VM circuit as state is no longer valid`);
       return;
     }
 
     const txProvingState = provingState.getTxProvingState(txIndex);
 
-    // This function tries to do AVM proving. If there is a failure, it fakes the proof unless AVM_PROVING_STRICT is defined.
-    // Nothing downstream depends on the AVM proof yet. So having this mode lets us incrementally build the AVM circuit.
     const doAvmProving = wrapCallbackInSpan(
       this.tracer,
       'ProvingOrchestrator.prover.getAvmProof',
@@ -929,42 +1256,25 @@ export class ProvingOrchestrator implements EpochProver {
       },
       async (signal: AbortSignal) => {
         const inputs = txProvingState.getAvmInputs();
-        try {
-          return await this.prover.getAvmProof(inputs, signal, provingState.epochNumber);
-        } catch (err) {
-          if (process.env.AVM_PROVING_STRICT) {
-            logger.error(`Error thrown when proving AVM circuit with AVM_PROVING_STRICT on`, err);
-            throw err;
-          } else {
-            logger.warn(
-              `Error thrown when proving AVM circuit but AVM_PROVING_STRICT is off. Faking AVM proof and carrying on. ${inspect(
-                err,
-              )}.`,
-            );
-            return {
-              proof: makeEmptyRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS),
-              verificationKey: VerificationKeyData.makeFake(AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS),
-            };
-          }
-        }
+        return await this.prover.getAvmProof(inputs, signal, provingState.epochNumber);
       },
     );
 
-    this.deferredProving(provingState, doAvmProving, proofAndVk => {
-      logger.debug(`Proven VM for tx index: ${txIndex}`);
-      txProvingState.setAvmProof(proofAndVk);
-      this.checkAndEnqueueNextTxCircuit(provingState, txIndex);
+    this.deferredProving(provingState, doAvmProving, proof => {
+      this.logger.debug(`Proven VM for tx index: ${txIndex}`);
+      txProvingState.setAvmProof(proof);
+      this.checkAndEnqueueBaseRollup(provingState, txIndex);
     });
   }
 
-  private checkAndEnqueueNextTxCircuit(provingState: BlockProvingState, txIndex: number) {
+  private checkAndEnqueueBaseRollup(provingState: BlockProvingState, txIndex: number) {
     const txProvingState = provingState.getTxProvingState(txIndex);
     if (!txProvingState.ready()) {
       return;
     }
 
-    // We must have completed all proving (tube proof and (if required) vm proof are generated), we now move to the base rollup.
-    logger.debug(`Public functions completed for tx ${txIndex} enqueueing base rollup`);
+    // We must have completed all proving (chonk verifier proof and (if required) vm proof are generated), we now move to the base rollup.
+    this.logger.debug(`Public functions completed for tx ${txIndex} enqueueing base rollup`);
 
     this.enqueueBaseRollup(provingState, txIndex);
   }