@aztec/prover-client 3.0.0-canary.a9708bd → 3.0.0-devnet.3

package/src/orchestrator/block-proving-state.ts

@@ -1,140 +1,157 @@
-import { BatchedBlobAccumulator, BlobAccumulatorPublicInputs, SpongeBlob } from '@aztec/blob-lib';
+import type { SpongeBlob } from '@aztec/blob-lib';
 import {
   type ARCHIVE_HEIGHT,
-  BLOBS_PER_BLOCK,
-  FIELDS_PER_BLOB,
-  type L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
+  type L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
+  NESTED_RECURSIVE_PROOF_LENGTH,
   type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   NUM_BASE_PARITY_PER_ROOT_PARITY,
-  type RECURSIVE_PROOF_LENGTH,
 } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { BLS12Point, Fr } from '@aztec/foundation/fields';
-import type { Tuple } from '@aztec/foundation/serialize';
+import { Fr } from '@aztec/foundation/fields';
+import { type Tuple, assertLength } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
-import { getVKIndex, getVKSiblingPath, getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
-import type { EthAddress, L2Block } from '@aztec/stdlib/block';
 import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
-import { type ParityPublicInputs, RootParityInput, RootParityInputs } from '@aztec/stdlib/parity';
+import { type ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity';
+import type { RollupHonkProofData } from '@aztec/stdlib/proofs';
 import {
-  type BaseOrMergeRollupPublicInputs,
-  BlockConstantData,
-  type BlockRootOrBlockMergePublicInputs,
-  BlockRootRollupBlobData,
-  BlockRootRollupData,
-  BlockRootRollupInputs,
-  EmptyBlockRootRollupInputs,
-  EpochConstantData,
-  MergeRollupInputs,
-  PaddingBlockRootRollupInputs,
-  PreviousRollupData,
-  SingleTxBlockRootRollupInputs,
+  BlockRollupPublicInputs,
+  BlockRootEmptyTxFirstRollupPrivateInputs,
+  BlockRootFirstRollupPrivateInputs,
+  BlockRootRollupPrivateInputs,
+  BlockRootSingleTxFirstRollupPrivateInputs,
+  BlockRootSingleTxRollupPrivateInputs,
+  CheckpointConstantData,
+  TxMergeRollupPrivateInputs,
+  type TxRollupPublicInputs,
 } from '@aztec/stdlib/rollup';
 import type { CircuitName } from '@aztec/stdlib/stats';
-import { AppendOnlyTreeSnapshot, type MerkleTreeId } from '@aztec/stdlib/trees';
-import { type BlockHeader, type GlobalVariables, StateReference } from '@aztec/stdlib/tx';
-import { VkData } from '@aztec/stdlib/vks';
+import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
+import { type BlockHeader, GlobalVariables } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
 
-import {
-  accumulateBlobs,
-  buildBlobHints,
-  buildHeaderFromCircuitOutputs,
-  getEmptyBlockBlobsHash,
-} from './block-building-helpers.js';
-import type { EpochProvingState } from './epoch-proving-state.js';
+import { buildHeaderFromCircuitOutputs, toProofData } from './block-building-helpers.js';
+import type { CheckpointProvingState } from './checkpoint-proving-state.js';
 import type { TxProvingState } from './tx-proving-state.js';
 
-export type TreeSnapshots = Map<MerkleTreeId, AppendOnlyTreeSnapshot>;
+export type ProofState<T, PROOF_LENGTH extends number> = {
+  provingOutput?: PublicInputsAndRecursiveProof<T, PROOF_LENGTH>;
+  isProving?: boolean;
+};
 
 /**
  * The current state of the proving schedule for a given block. Managed by ProvingState.
  * Contains the raw inputs and intermediate state to generate every constituent proof in the tree.
  */
 export class BlockProvingState {
-  private baseOrMergeProvingOutputs: UnbalancedTreeStore<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  private baseOrMergeProofs: UnbalancedTreeStore<
+    ProofState<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > = new UnbalancedTreeStore(0);
-  private baseParityProvingOutputs: (PublicInputsAndRecursiveProof<ParityPublicInputs> | undefined)[];
-  private rootParityProvingOutput: PublicInputsAndRecursiveProof<ParityPublicInputs> | undefined;
-  private blockRootProvingOutput:
-    | PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  private baseParityProofs: (ProofState<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH> | undefined)[] =
+    Array.from({
+      length: NUM_BASE_PARITY_PER_ROOT_PARITY,
+    }).map(_ => undefined);
+  private rootParityProof: ProofState<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH> | undefined;
+  private blockRootProof:
+    | ProofState<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
     | undefined;
-  public blockRootRollupStarted: boolean = false;
-  public block: L2Block | undefined;
-  public spongeBlobState: SpongeBlob | undefined;
-  public startBlobAccumulator: BatchedBlobAccumulator | undefined;
-  public endBlobAccumulator: BatchedBlobAccumulator | undefined;
-  public blobsHash: Fr | undefined;
-  public totalNumTxs: number;
+  private builtBlockHeader: BlockHeader | undefined;
+  private endSpongeBlob: SpongeBlob | undefined;
   private txs: TxProvingState[] = [];
-  public error: string | undefined;
+  private isFirstBlock: boolean;
+  private error: string | undefined;
 
   constructor(
     public readonly index: number,
-    public readonly globalVariables: GlobalVariables,
-    public readonly newL1ToL2Messages: Fr[],
-    public readonly l1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot,
-    private readonly l1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>,
-    public readonly l1ToL2MessageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot,
-    private readonly lastArchiveSnapshot: AppendOnlyTreeSnapshot,
+    public readonly blockNumber: number,
+    public readonly totalNumTxs: number,
+    private readonly constants: CheckpointConstantData,
+    private readonly timestamp: UInt64,
+    public readonly lastArchiveTreeSnapshot: AppendOnlyTreeSnapshot,
     private readonly lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
-    private readonly newArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
-    private readonly previousBlockHeader: BlockHeader,
-    private readonly proverId: EthAddress,
-    private readonly parentEpoch: EpochProvingState,
+    private readonly lastL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot,
+    private readonly lastL1ToL2MessageSubtreeRootSiblingPath: Tuple<
+      Fr,
+      typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH
+    >,
+    public readonly newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot,
+    private readonly headerOfLastBlockInPreviousCheckpoint: BlockHeader,
+    private readonly startSpongeBlob: SpongeBlob,
+    public parentCheckpoint: CheckpointProvingState,
   ) {
-    this.baseParityProvingOutputs = Array.from({ length: NUM_BASE_PARITY_PER_ROOT_PARITY }).map(_ => undefined);
-    this.totalNumTxs = 0;
-    if (this.blockNumber == parentEpoch.firstBlockNumber) {
-      this.startBlobAccumulator = BatchedBlobAccumulator.newWithChallenges(parentEpoch.finalBlobBatchingChallenges);
+    this.isFirstBlock = index === 0;
+    if (!totalNumTxs && !this.isFirstBlock) {
+      throw new Error(`Cannot create a block with 0 txs, unless it's the first block.`);
     }
-  }
 
-  public get blockNumber() {
-    return this.globalVariables.blockNumber;
+    this.baseOrMergeProofs = new UnbalancedTreeStore(totalNumTxs);
   }
 
-  public startNewBlock(numTxs: number, numBlobFields: number) {
-    if (this.spongeBlobState) {
-      throw new Error(`Block ${this.blockNumber} already initalised.`);
-    }
-
-    this.baseOrMergeProvingOutputs = new UnbalancedTreeStore(numTxs);
-    // Initialize the sponge which will eventually absorb all tx effects to be added to the blob.
-    // Like l1 to l2 messages, we need to know beforehand how many effects will be absorbed.
-    this.spongeBlobState = SpongeBlob.init(numBlobFields);
-    this.totalNumTxs = numTxs;
+  public get epochNumber(): number {
+    return this.parentCheckpoint.epochNumber;
   }
 
   // Adds a transaction to the proving state, returns it's index
   public addNewTx(tx: TxProvingState) {
-    if (!this.spongeBlobState) {
-      throw new Error(`Invalid block proving state, call startNewBlock before adding transactions.`);
+    if (!this.isAcceptingTxs()) {
+      throw new Error(`Cannot add more txs to block ${this.blockNumber}.`);
     }
     const txIndex = this.txs.length;
     this.txs[txIndex] = tx;
     return txIndex;
   }
 
+  public isAcceptingTxs() {
+    return this.txs.length < this.totalNumTxs;
+  }
+
+  public getProcessedTxs() {
+    return this.txs.map(t => t.processedTx);
+  }
+
+  public tryStartProvingBase(txIndex: number) {
+    if (this.baseOrMergeProofs.getLeaf(txIndex)?.isProving) {
+      return false;
+    } else {
+      this.baseOrMergeProofs.setLeaf(txIndex, { isProving: true });
+      return true;
+    }
+  }
+
   public setBaseRollupProof(
     txIndex: number,
     provingOutput: PublicInputsAndRecursiveProof<
-      BaseOrMergeRollupPublicInputs,
+      TxRollupPublicInputs,
       typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
     >,
   ): TreeNodeLocation {
-    return this.baseOrMergeProvingOutputs.setLeaf(txIndex, provingOutput);
+    return this.baseOrMergeProofs.setLeaf(txIndex, { provingOutput });
+  }
+
+  public tryStartProvingMerge(location: TreeNodeLocation) {
+    if (this.baseOrMergeProofs.getNode(location)?.isProving) {
+      return false;
+    } else {
+      this.baseOrMergeProofs.setNode(location, { isProving: true });
+      return true;
+    }
   }
 
   public setMergeRollupProof(
     location: TreeNodeLocation,
     provingOutput: PublicInputsAndRecursiveProof<
-      BaseOrMergeRollupPublicInputs,
+      TxRollupPublicInputs,
       typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
     >,
   ) {
-    this.baseOrMergeProvingOutputs.setNode(location, provingOutput);
+    this.baseOrMergeProofs.setNode(location, { provingOutput });
+  }
+
+  public tryStartProvingBaseParity(index: number) {
+    if (this.baseParityProofs[index]?.isProving) {
+      return false;
+    } else {
+      this.baseParityProofs[index] = { isProving: true };
+      return true;
+    }
   }
 
   // Stores a set of root parity inputs at the given index
@@ -144,144 +161,179 @@ export class BlockProvingState {
         `Unable to set a base parity proofs at index ${index}. Expected at most ${NUM_BASE_PARITY_PER_ROOT_PARITY} proofs.`,
       );
     }
-    this.baseParityProvingOutputs[index] = provingOutput;
+    this.baseParityProofs[index] = { provingOutput };
+  }
+
+  public tryStartProvingRootParity() {
+    if (this.rootParityProof?.isProving) {
+      return false;
+    } else {
+      this.rootParityProof = { isProving: true };
+      return true;
+    }
   }
 
   public setRootParityProof(provingOutput: PublicInputsAndRecursiveProof<ParityPublicInputs>) {
-    this.rootParityProvingOutput = provingOutput;
+    this.rootParityProof = { provingOutput };
+  }
+
+  public tryStartProvingBlockRoot() {
+    if (this.blockRootProof?.isProving) {
+      return false;
+    } else {
+      this.blockRootProof = { isProving: true };
+      return true;
+    }
   }
 
   public setBlockRootRollupProof(
     provingOutput: PublicInputsAndRecursiveProof<
-      BlockRootOrBlockMergePublicInputs,
+      BlockRollupPublicInputs,
       typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
     >,
-  ) {
-    this.blockRootProvingOutput = provingOutput;
+  ): TreeNodeLocation {
+    this.blockRootProof = { provingOutput };
+    return this.parentCheckpoint.setBlockRootRollupProof(this.index, provingOutput);
   }
 
-  public setBlock(block: L2Block) {
-    this.block = block;
+  public getBlockRootRollupOutput() {
+    return this.blockRootProof?.provingOutput?.inputs;
   }
 
-  public setStartBlobAccumulator(accumulator: BatchedBlobAccumulator) {
-    this.startBlobAccumulator = accumulator;
+  public setBuiltBlockHeader(blockHeader: BlockHeader) {
+    this.builtBlockHeader = blockHeader;
   }
 
-  public setEndBlobAccumulator(accumulator: BatchedBlobAccumulator) {
-    this.endBlobAccumulator = accumulator;
+  public getBuiltBlockHeader() {
+    return this.builtBlockHeader;
   }
 
-  public async accumulateBlobs() {
-    if (!this.block || !this.startBlobAccumulator) {
-      // We only want to accumulate once we have all txs, so we wait until the block is set.
-      return;
+  public getGlobalVariables() {
+    if (this.txs.length) {
+      return this.txs[0].processedTx.globalVariables;
     }
-    const endBlobAccumulator = await accumulateBlobs(
-      this.allTxs.map(t => t.processedTx),
-      this.startBlobAccumulator,
-    );
-    this.setEndBlobAccumulator(endBlobAccumulator);
+
+    const constants = this.constants;
+    return GlobalVariables.from({
+      chainId: constants.chainId,
+      version: constants.version,
+      blockNumber: this.blockNumber,
+      slotNumber: constants.slotNumber,
+      timestamp: this.timestamp,
+      coinbase: constants.coinbase,
+      feeRecipient: constants.feeRecipient,
+      gasFees: constants.gasFees,
+    });
   }
 
-  // Returns the complete set of transaction proving state objects
-  public get allTxs() {
-    return this.txs;
+  public getStartSpongeBlob() {
+    return this.startSpongeBlob;
   }
 
-  /** Returns the block number as an epoch number. Used for prioritizing proof requests. */
-  public get epochNumber(): number {
-    return this.parentEpoch.epochNumber;
+  public setEndSpongeBlob(endSpongeBlob: SpongeBlob) {
+    this.endSpongeBlob = endSpongeBlob;
+  }
+
+  public getEndSpongeBlob() {
+    return this.endSpongeBlob;
+  }
+
+  public getTxEffects() {
+    return this.txs.map(t => t.processedTx.txEffect);
   }
 
   public getParentLocation(location: TreeNodeLocation) {
-    return this.baseOrMergeProvingOutputs.getParentLocation(location);
+    return this.baseOrMergeProofs.getParentLocation(location);
   }
 
   public getMergeRollupInputs(mergeLocation: TreeNodeLocation) {
-    const [left, right] = this.baseOrMergeProvingOutputs.getChildren(mergeLocation);
+    const [left, right] = this.baseOrMergeProofs.getChildren(mergeLocation).map(c => c?.provingOutput);
     if (!left || !right) {
-      throw new Error('At lease one child is not ready.');
+      throw new Error('At least one child is not ready for the merge rollup.');
     }
 
-    return new MergeRollupInputs([this.#getPreviousRollupData(left), this.#getPreviousRollupData(right)]);
+    return new TxMergeRollupPrivateInputs([toProofData(left), toProofData(right)]);
   }
 
-  public async getBlockRootRollupTypeAndInputs() {
-    if (!this.rootParityProvingOutput) {
-      throw new Error('Root parity is not ready.');
-    }
-
-    const proofs = this.#getChildProofsForBlockRoot();
-    const nonEmptyProofs = proofs.filter(p => !!p);
-    if (proofs.length !== nonEmptyProofs.length) {
-      throw new Error('At lease one child is not ready for the block root.');
+  public getBlockRootRollupTypeAndInputs() {
+    const provingOutputs = this.#getChildProvingOutputsForBlockRoot();
+    if (!provingOutputs.every(p => !!p)) {
+      throw new Error('At least one child is not ready for the block root rollup.');
     }
 
-    const data = this.#getBlockRootRollupData();
+    const previousRollups = provingOutputs.map(p => toProofData(p));
 
-    if (this.totalNumTxs === 0) {
-      const constants = BlockConstantData.from({
-        lastArchive: this.lastArchiveSnapshot,
-        newL1ToL2: this.l1ToL2MessageTreeSnapshotAfterInsertion,
-        globalVariables: this.globalVariables,
-        vkTreeRoot: getVKTreeRoot(),
-        protocolContractTreeRoot,
-      });
-
-      this.blobsHash = await getEmptyBlockBlobsHash();
+    if (this.isFirstBlock) {
+      return this.#getFirstBlockRootRollupTypeAndInputs(previousRollups);
+    }
 
+    const [leftRollup, rightRollup] = previousRollups;
+    if (!rightRollup) {
+      return {
+        rollupType: 'rollup-block-root-single-tx' satisfies CircuitName,
+        inputs: new BlockRootSingleTxRollupPrivateInputs(leftRollup, this.lastArchiveSiblingPath),
+      };
+    } else {
       return {
-        rollupType: 'empty-block-root-rollup' satisfies CircuitName,
-        inputs: EmptyBlockRootRollupInputs.from({
-          data,
-          constants,
-        }),
+        rollupType: 'rollup-block-root' satisfies CircuitName,
+        inputs: new BlockRootRollupPrivateInputs([leftRollup, rightRollup], this.lastArchiveSiblingPath),
       };
     }
+  }
 
-    const previousRollupData = await Promise.all(nonEmptyProofs.map(p => this.#getPreviousRollupData(p!)));
-    const blobData = await this.#getBlockRootRollupBlobData();
-    this.blobsHash = blobData.blobsHash;
+  #getFirstBlockRootRollupTypeAndInputs([leftRollup, rightRollup]: RollupHonkProofData<TxRollupPublicInputs>[]) {
+    if (!this.rootParityProof?.provingOutput) {
+      throw new Error('Root parity is not ready.');
+    }
+    const l1ToL2Roots = toProofData(this.rootParityProof.provingOutput);
 
-    if (previousRollupData.length === 1) {
+    if (!leftRollup) {
+      return {
+        rollupType: 'rollup-block-root-first-empty-tx' satisfies CircuitName,
+        inputs: new BlockRootEmptyTxFirstRollupPrivateInputs(
+          l1ToL2Roots,
+          this.lastArchiveTreeSnapshot,
+          this.headerOfLastBlockInPreviousCheckpoint.state,
+          this.constants,
+          this.startSpongeBlob,
+          this.timestamp,
+          this.lastL1ToL2MessageSubtreeRootSiblingPath,
+          this.lastArchiveSiblingPath,
+        ),
+      };
+    } else if (!rightRollup) {
       return {
-        rollupType: 'single-tx-block-root-rollup' satisfies CircuitName,
-        inputs: new SingleTxBlockRootRollupInputs(previousRollupData as [PreviousRollupData], data, blobData),
+        rollupType: 'rollup-block-root-first-single-tx' satisfies CircuitName,
+        inputs: new BlockRootSingleTxFirstRollupPrivateInputs(
+          l1ToL2Roots,
+          leftRollup,
+          this.lastL1ToL2MessageTreeSnapshot,
+          this.lastL1ToL2MessageSubtreeRootSiblingPath,
+          this.lastArchiveSiblingPath,
+        ),
       };
     } else {
       return {
-        rollupType: 'block-root-rollup' satisfies CircuitName,
-        inputs: new BlockRootRollupInputs(
-          previousRollupData as [PreviousRollupData, PreviousRollupData],
-          data,
-          blobData,
+        rollupType: 'rollup-block-root-first' satisfies CircuitName,
+        inputs: new BlockRootFirstRollupPrivateInputs(
+          l1ToL2Roots,
+          [leftRollup, rightRollup],
+          this.lastL1ToL2MessageTreeSnapshot,
+          this.lastL1ToL2MessageSubtreeRootSiblingPath,
+          this.lastArchiveSiblingPath,
         ),
       };
     }
   }
 
-  public getPaddingBlockRootInputs() {
-    const constants = EpochConstantData.from({
-      vkTreeRoot: getVKTreeRoot(),
-      protocolContractTreeRoot,
-      proverId: this.proverId.toField(),
-    });
-
-    return PaddingBlockRootRollupInputs.from({
-      constants,
-    });
-  }
-
-  public getRootParityInputs() {
-    if (!this.baseParityProvingOutputs.every(p => !!p)) {
+  public getParityRootInputs() {
+    const baseParityProvingOutputs = this.baseParityProofs.filter(p => !!p?.provingOutput).map(p => p!.provingOutput!);
+    if (baseParityProvingOutputs.length !== this.baseParityProofs.length) {
       throw new Error('At lease one base parity is not ready.');
     }
 
-    const children = this.baseParityProvingOutputs.map(p => this.#getRootParityData(p!));
-    return new RootParityInputs(
-      children as Tuple<RootParityInput<typeof RECURSIVE_PROOF_LENGTH>, typeof NUM_BASE_PARITY_PER_ROOT_PARITY>,
-    );
+    const children = baseParityProvingOutputs.map(p => toProofData(p));
+    return new ParityRootPrivateInputs(assertLength(children, NUM_BASE_PARITY_PER_ROOT_PARITY));
   }
 
   // Returns a specific transaction proving state
@@ -290,89 +342,46 @@ export class BlockProvingState {
   }
 
   public async buildHeaderFromProvingOutputs() {
-    const previousRollupData =
-      this.totalNumTxs === 0
-        ? []
-        : await Promise.all(this.#getChildProofsForBlockRoot().map(p => this.#getPreviousRollupData(p!)));
-
-    let endPartialState = this.previousBlockHeader.state.partial;
-    if (this.totalNumTxs !== 0) {
-      const previousRollupData = this.#getChildProofsForBlockRoot();
-      const lastRollup = previousRollupData[previousRollupData.length - 1];
-      if (!lastRollup) {
-        throw new Error('End state of the block is not available. Last rollup is not ready yet.');
-      }
-      endPartialState = lastRollup.inputs.end;
+    if (!this.blockRootProof?.provingOutput) {
+      throw new Error('Block root rollup is not ready.');
     }
-    const endState = new StateReference(this.l1ToL2MessageTreeSnapshotAfterInsertion, endPartialState);
 
-    return buildHeaderFromCircuitOutputs(
-      previousRollupData.map(d => d.baseOrMergeRollupPublicInputs),
-      this.rootParityProvingOutput!.inputs,
-      this.blockRootProvingOutput!.inputs,
-      this.blobsHash!,
-      endState,
-    );
+    return await buildHeaderFromCircuitOutputs(this.blockRootProof.provingOutput.inputs);
   }
 
   public isReadyForMergeRollup(location: TreeNodeLocation) {
-    return this.baseOrMergeProvingOutputs.getSibling(location) !== undefined;
+    return !!this.baseOrMergeProofs.getSibling(location)?.provingOutput;
   }
 
   // Returns true if we have sufficient inputs to execute the block root rollup
   public isReadyForBlockRootRollup() {
-    const childProofs = this.#getChildProofsForBlockRoot();
-    return (
-      this.block !== undefined &&
-      this.rootParityProvingOutput !== undefined &&
-      this.endBlobAccumulator !== undefined &&
-      childProofs.every(p => !!p)
-    );
+    const childProofs = this.#getChildProvingOutputsForBlockRoot();
+    return (!this.isFirstBlock || !!this.rootParityProof?.provingOutput) && childProofs.every(p => !!p);
   }
 
   // Returns true if we have sufficient root parity inputs to execute the root parity circuit
   public isReadyForRootParity() {
-    return this.baseParityProvingOutputs.every(p => !!p);
+    return this.baseParityProofs.every(p => !!p?.provingOutput);
   }
 
   public isComplete() {
-    return !!this.blockRootProvingOutput;
+    return !!this.blockRootProof;
   }
 
-  // Returns whether the proving state is still valid
   public verifyState() {
-    return this.parentEpoch.verifyState();
+    return this.parentCheckpoint.verifyState();
   }
 
-  public reject(reason: string) {
-    this.error = reason;
-    this.parentEpoch.reject(reason);
-  }
-
-  #getBlockRootRollupData() {
-    return BlockRootRollupData.from({
-      l1ToL2Roots: this.#getRootParityData(this.rootParityProvingOutput!),
-      l1ToL2MessageSubtreeSiblingPath: this.l1ToL2MessageSubtreeSiblingPath,
-      previousArchiveSiblingPath: this.lastArchiveSiblingPath,
-      newArchiveSiblingPath: this.newArchiveSiblingPath,
-      previousBlockHeader: this.previousBlockHeader,
-      startBlobAccumulator: BlobAccumulatorPublicInputs.fromBatchedBlobAccumulator(this.startBlobAccumulator!),
-      finalBlobChallenges: this.startBlobAccumulator!.finalBlobChallenges,
-      proverId: this.proverId.toField(),
-    });
+  public getError() {
+    return this.error;
   }
 
-  async #getBlockRootRollupBlobData() {
-    const txEffects = this.txs.map(txProvingState => txProvingState.processedTx.txEffect);
-    const { blobFields, blobCommitments, blobsHash } = await buildBlobHints(txEffects);
-    return BlockRootRollupBlobData.from({
-      blobFields: padArrayEnd(blobFields, Fr.ZERO, FIELDS_PER_BLOB * BLOBS_PER_BLOCK),
-      blobCommitments: padArrayEnd(blobCommitments, BLS12Point.ZERO, BLOBS_PER_BLOCK),
-      blobsHash,
-    });
+  public reject(reason: string) {
+    this.error = reason;
+    this.parentCheckpoint.reject(reason);
   }
 
-  #getChildProofsForBlockRoot() {
+  #getChildProvingOutputsForBlockRoot() {
     if (this.totalNumTxs === 0) {
       return [];
     }
@@ -380,26 +389,7 @@ export class BlockProvingState {
     const rootLocation = { level: 0, index: 0 };
     // If there's only 1 tx, its base rollup proof will be stored at the root.
     return this.totalNumTxs === 1
-      ? [this.baseOrMergeProvingOutputs.getNode(rootLocation)]
-      : this.baseOrMergeProvingOutputs.getChildren(rootLocation);
-  }
-
-  #getPreviousRollupData({
-    inputs,
-    proof,
-    verificationKey,
-  }: PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>) {
-    const leafIndex = getVKIndex(verificationKey.keyAsFields);
-    const vkData = new VkData(verificationKey, leafIndex, getVKSiblingPath(leafIndex));
-    return new PreviousRollupData(inputs, proof, vkData);
-  }
-
-  #getRootParityData({ inputs, proof, verificationKey }: PublicInputsAndRecursiveProof<ParityPublicInputs>) {
-    return new RootParityInput(
-      proof,
-      verificationKey.keyAsFields,
-      getVKSiblingPath(getVKIndex(verificationKey)),
-      inputs,
-    );
+      ? [this.baseOrMergeProofs.getNode(rootLocation)?.provingOutput]
+      : this.baseOrMergeProofs.getChildren(rootLocation).map(c => c?.provingOutput);
   }
 }