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

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

@@ -1,157 +1,140 @@
-import type { SpongeBlob } from '@aztec/blob-lib';
+import { BatchedBlobAccumulator, BlobAccumulatorPublicInputs, SpongeBlob } from '@aztec/blob-lib';
 import {
   type ARCHIVE_HEIGHT,
-  type L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
-  NESTED_RECURSIVE_PROOF_LENGTH,
+  BLOBS_PER_BLOCK,
+  FIELDS_PER_BLOB,
+  type L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
   type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   NUM_BASE_PARITY_PER_ROOT_PARITY,
+  type RECURSIVE_PROOF_LENGTH,
 } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import { type Tuple, assertLength } from '@aztec/foundation/serialize';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { BLS12Point, Fr } from '@aztec/foundation/fields';
+import type { Tuple } 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, ParityRootPrivateInputs } from '@aztec/stdlib/parity';
-import type { RollupHonkProofData } from '@aztec/stdlib/proofs';
+import { type ParityPublicInputs, RootParityInput, RootParityInputs } from '@aztec/stdlib/parity';
 import {
-  BlockRollupPublicInputs,
-  BlockRootEmptyTxFirstRollupPrivateInputs,
-  BlockRootFirstRollupPrivateInputs,
-  BlockRootRollupPrivateInputs,
-  BlockRootSingleTxFirstRollupPrivateInputs,
-  BlockRootSingleTxRollupPrivateInputs,
-  CheckpointConstantData,
-  TxMergeRollupPrivateInputs,
-  type TxRollupPublicInputs,
+  type BaseOrMergeRollupPublicInputs,
+  BlockConstantData,
+  type BlockRootOrBlockMergePublicInputs,
+  BlockRootRollupBlobData,
+  BlockRootRollupData,
+  BlockRootRollupInputs,
+  EmptyBlockRootRollupInputs,
+  EpochConstantData,
+  MergeRollupInputs,
+  PaddingBlockRootRollupInputs,
+  PreviousRollupData,
+  SingleTxBlockRootRollupInputs,
 } from '@aztec/stdlib/rollup';
 import type { CircuitName } from '@aztec/stdlib/stats';
-import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
-import { type BlockHeader, GlobalVariables } from '@aztec/stdlib/tx';
-import type { UInt64 } from '@aztec/stdlib/types';
+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 { buildHeaderFromCircuitOutputs, toProofData } from './block-building-helpers.js';
-import type { CheckpointProvingState } from './checkpoint-proving-state.js';
+import {
+  accumulateBlobs,
+  buildBlobHints,
+  buildHeaderFromCircuitOutputs,
+  getEmptyBlockBlobsHash,
+} from './block-building-helpers.js';
+import type { EpochProvingState } from './epoch-proving-state.js';
 import type { TxProvingState } from './tx-proving-state.js';
 
-export type ProofState<T, PROOF_LENGTH extends number> = {
-  provingOutput?: PublicInputsAndRecursiveProof<T, PROOF_LENGTH>;
-  isProving?: boolean;
-};
+export type TreeSnapshots = Map<MerkleTreeId, AppendOnlyTreeSnapshot>;
 
 /**
  * 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 baseOrMergeProofs: UnbalancedTreeStore<
-    ProofState<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  private baseOrMergeProvingOutputs: UnbalancedTreeStore<
+    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   > = new UnbalancedTreeStore(0);
-  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>
+  private baseParityProvingOutputs: (PublicInputsAndRecursiveProof<ParityPublicInputs> | undefined)[];
+  private rootParityProvingOutput: PublicInputsAndRecursiveProof<ParityPublicInputs> | undefined;
+  private blockRootProvingOutput:
+    | PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
     | undefined;
-  private builtBlockHeader: BlockHeader | undefined;
-  private endSpongeBlob: SpongeBlob | 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 txs: TxProvingState[] = [];
-  private isFirstBlock: boolean;
-  private error: string | undefined;
+  public error: string | undefined;
 
   constructor(
     public readonly index: number,
-    public readonly blockNumber: number,
-    public readonly totalNumTxs: number,
-    private readonly constants: CheckpointConstantData,
-    private readonly timestamp: UInt64,
-    public readonly lastArchiveTreeSnapshot: AppendOnlyTreeSnapshot,
+    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,
     private readonly lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
-    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,
+    private readonly newArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
+    private readonly previousBlockHeader: BlockHeader,
+    private readonly proverId: EthAddress,
+    private readonly parentEpoch: EpochProvingState,
   ) {
-    this.isFirstBlock = index === 0;
-    if (!totalNumTxs && !this.isFirstBlock) {
-      throw new Error(`Cannot create a block with 0 txs, unless it's the first block.`);
+    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.baseOrMergeProofs = new UnbalancedTreeStore(totalNumTxs);
+  public get blockNumber() {
+    return this.globalVariables.blockNumber;
   }
 
-  public get epochNumber(): number {
-    return this.parentCheckpoint.epochNumber;
+  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;
   }
 
   // Adds a transaction to the proving state, returns it's index
   public addNewTx(tx: TxProvingState) {
-    if (!this.isAcceptingTxs()) {
-      throw new Error(`Cannot add more txs to block ${this.blockNumber}.`);
+    if (!this.spongeBlobState) {
+      throw new Error(`Invalid block proving state, call startNewBlock before adding transactions.`);
     }
     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<
-      TxRollupPublicInputs,
+      BaseOrMergeRollupPublicInputs,
       typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
     >,
   ): TreeNodeLocation {
-    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;
-    }
+    return this.baseOrMergeProvingOutputs.setLeaf(txIndex, provingOutput);
   }
 
   public setMergeRollupProof(
     location: TreeNodeLocation,
     provingOutput: PublicInputsAndRecursiveProof<
-      TxRollupPublicInputs,
+      BaseOrMergeRollupPublicInputs,
       typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
     >,
   ) {
-    this.baseOrMergeProofs.setNode(location, { provingOutput });
-  }
-
-  public tryStartProvingBaseParity(index: number) {
-    if (this.baseParityProofs[index]?.isProving) {
-      return false;
-    } else {
-      this.baseParityProofs[index] = { isProving: true };
-      return true;
-    }
+    this.baseOrMergeProvingOutputs.setNode(location, provingOutput);
   }
 
   // Stores a set of root parity inputs at the given index
@@ -161,179 +144,144 @@ export class BlockProvingState {
         `Unable to set a base parity proofs at index ${index}. Expected at most ${NUM_BASE_PARITY_PER_ROOT_PARITY} proofs.`,
       );
     }
-    this.baseParityProofs[index] = { provingOutput };
-  }
-
-  public tryStartProvingRootParity() {
-    if (this.rootParityProof?.isProving) {
-      return false;
-    } else {
-      this.rootParityProof = { isProving: true };
-      return true;
-    }
+    this.baseParityProvingOutputs[index] = provingOutput;
   }
 
   public setRootParityProof(provingOutput: PublicInputsAndRecursiveProof<ParityPublicInputs>) {
-    this.rootParityProof = { provingOutput };
-  }
-
-  public tryStartProvingBlockRoot() {
-    if (this.blockRootProof?.isProving) {
-      return false;
-    } else {
-      this.blockRootProof = { isProving: true };
-      return true;
-    }
+    this.rootParityProvingOutput = provingOutput;
   }
 
   public setBlockRootRollupProof(
     provingOutput: PublicInputsAndRecursiveProof<
-      BlockRollupPublicInputs,
+      BlockRootOrBlockMergePublicInputs,
       typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
     >,
-  ): TreeNodeLocation {
-    this.blockRootProof = { provingOutput };
-    return this.parentCheckpoint.setBlockRootRollupProof(this.index, provingOutput);
+  ) {
+    this.blockRootProvingOutput = provingOutput;
   }
 
-  public getBlockRootRollupOutput() {
-    return this.blockRootProof?.provingOutput?.inputs;
+  public setBlock(block: L2Block) {
+    this.block = block;
   }
 
-  public setBuiltBlockHeader(blockHeader: BlockHeader) {
-    this.builtBlockHeader = blockHeader;
+  public setStartBlobAccumulator(accumulator: BatchedBlobAccumulator) {
+    this.startBlobAccumulator = accumulator;
   }
 
-  public getBuiltBlockHeader() {
-    return this.builtBlockHeader;
+  public setEndBlobAccumulator(accumulator: BatchedBlobAccumulator) {
+    this.endBlobAccumulator = accumulator;
   }
 
-  public getGlobalVariables() {
-    if (this.txs.length) {
-      return this.txs[0].processedTx.globalVariables;
+  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;
     }
-
-    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,
-    });
-  }
-
-  public getStartSpongeBlob() {
-    return this.startSpongeBlob;
-  }
-
-  public setEndSpongeBlob(endSpongeBlob: SpongeBlob) {
-    this.endSpongeBlob = endSpongeBlob;
+    const endBlobAccumulator = await accumulateBlobs(
+      this.allTxs.map(t => t.processedTx),
+      this.startBlobAccumulator,
+    );
+    this.setEndBlobAccumulator(endBlobAccumulator);
   }
 
-  public getEndSpongeBlob() {
-    return this.endSpongeBlob;
+  // Returns the complete set of transaction proving state objects
+  public get allTxs() {
+    return this.txs;
   }
 
-  public getTxEffects() {
-    return this.txs.map(t => t.processedTx.txEffect);
+  /** Returns the block number as an epoch number. Used for prioritizing proof requests. */
+  public get epochNumber(): number {
+    return this.parentEpoch.epochNumber;
   }
 
   public getParentLocation(location: TreeNodeLocation) {
-    return this.baseOrMergeProofs.getParentLocation(location);
+    return this.baseOrMergeProvingOutputs.getParentLocation(location);
   }
 
   public getMergeRollupInputs(mergeLocation: TreeNodeLocation) {
-    const [left, right] = this.baseOrMergeProofs.getChildren(mergeLocation).map(c => c?.provingOutput);
+    const [left, right] = this.baseOrMergeProvingOutputs.getChildren(mergeLocation);
     if (!left || !right) {
-      throw new Error('At least one child is not ready for the merge rollup.');
+      throw new Error('At lease one child is not ready.');
     }
 
-    return new TxMergeRollupPrivateInputs([toProofData(left), toProofData(right)]);
+    return new MergeRollupInputs([this.#getPreviousRollupData(left), this.#getPreviousRollupData(right)]);
   }
 
-  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.');
+  public async getBlockRootRollupTypeAndInputs() {
+    if (!this.rootParityProvingOutput) {
+      throw new Error('Root parity is not ready.');
     }
 
-    const previousRollups = provingOutputs.map(p => toProofData(p));
-
-    if (this.isFirstBlock) {
-      return this.#getFirstBlockRootRollupTypeAndInputs(previousRollups);
+    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.');
     }
 
-    const [leftRollup, rightRollup] = previousRollups;
-    if (!rightRollup) {
-      return {
-        rollupType: 'rollup-block-root-single-tx' satisfies CircuitName,
-        inputs: new BlockRootSingleTxRollupPrivateInputs(leftRollup, this.lastArchiveSiblingPath),
-      };
-    } else {
+    const data = this.#getBlockRootRollupData();
+
+    if (this.totalNumTxs === 0) {
+      const constants = BlockConstantData.from({
+        lastArchive: this.lastArchiveSnapshot,
+        newL1ToL2: this.l1ToL2MessageTreeSnapshotAfterInsertion,
+        globalVariables: this.globalVariables,
+        vkTreeRoot: getVKTreeRoot(),
+        protocolContractTreeRoot,
+      });
+
+      this.blobsHash = await getEmptyBlockBlobsHash();
+
       return {
-        rollupType: 'rollup-block-root' satisfies CircuitName,
-        inputs: new BlockRootRollupPrivateInputs([leftRollup, rightRollup], this.lastArchiveSiblingPath),
+        rollupType: 'empty-block-root-rollup' satisfies CircuitName,
+        inputs: EmptyBlockRootRollupInputs.from({
+          data,
+          constants,
+        }),
       };
     }
-  }
 
-  #getFirstBlockRootRollupTypeAndInputs([leftRollup, rightRollup]: RollupHonkProofData<TxRollupPublicInputs>[]) {
-    if (!this.rootParityProof?.provingOutput) {
-      throw new Error('Root parity is not ready.');
-    }
-    const l1ToL2Roots = toProofData(this.rootParityProof.provingOutput);
+    const previousRollupData = await Promise.all(nonEmptyProofs.map(p => this.#getPreviousRollupData(p!)));
+    const blobData = await this.#getBlockRootRollupBlobData();
+    this.blobsHash = blobData.blobsHash;
 
-    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) {
+    if (previousRollupData.length === 1) {
       return {
-        rollupType: 'rollup-block-root-first-single-tx' satisfies CircuitName,
-        inputs: new BlockRootSingleTxFirstRollupPrivateInputs(
-          l1ToL2Roots,
-          leftRollup,
-          this.lastL1ToL2MessageTreeSnapshot,
-          this.lastL1ToL2MessageSubtreeRootSiblingPath,
-          this.lastArchiveSiblingPath,
-        ),
+        rollupType: 'single-tx-block-root-rollup' satisfies CircuitName,
+        inputs: new SingleTxBlockRootRollupInputs(previousRollupData as [PreviousRollupData], data, blobData),
       };
     } else {
       return {
-        rollupType: 'rollup-block-root-first' satisfies CircuitName,
-        inputs: new BlockRootFirstRollupPrivateInputs(
-          l1ToL2Roots,
-          [leftRollup, rightRollup],
-          this.lastL1ToL2MessageTreeSnapshot,
-          this.lastL1ToL2MessageSubtreeRootSiblingPath,
-          this.lastArchiveSiblingPath,
+        rollupType: 'block-root-rollup' satisfies CircuitName,
+        inputs: new BlockRootRollupInputs(
+          previousRollupData as [PreviousRollupData, PreviousRollupData],
+          data,
+          blobData,
         ),
       };
     }
   }
 
-  public getParityRootInputs() {
-    const baseParityProvingOutputs = this.baseParityProofs.filter(p => !!p?.provingOutput).map(p => p!.provingOutput!);
-    if (baseParityProvingOutputs.length !== this.baseParityProofs.length) {
+  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)) {
       throw new Error('At lease one base parity is not ready.');
     }
 
-    const children = baseParityProvingOutputs.map(p => toProofData(p));
-    return new ParityRootPrivateInputs(assertLength(children, NUM_BASE_PARITY_PER_ROOT_PARITY));
+    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>,
+    );
   }
 
   // Returns a specific transaction proving state
@@ -342,46 +290,89 @@ export class BlockProvingState {
   }
 
   public async buildHeaderFromProvingOutputs() {
-    if (!this.blockRootProof?.provingOutput) {
-      throw new Error('Block root rollup is not ready.');
+    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;
     }
+    const endState = new StateReference(this.l1ToL2MessageTreeSnapshotAfterInsertion, endPartialState);
 
-    return await buildHeaderFromCircuitOutputs(this.blockRootProof.provingOutput.inputs);
+    return buildHeaderFromCircuitOutputs(
+      previousRollupData.map(d => d.baseOrMergeRollupPublicInputs),
+      this.rootParityProvingOutput!.inputs,
+      this.blockRootProvingOutput!.inputs,
+      this.blobsHash!,
+      endState,
+    );
   }
 
   public isReadyForMergeRollup(location: TreeNodeLocation) {
-    return !!this.baseOrMergeProofs.getSibling(location)?.provingOutput;
+    return this.baseOrMergeProvingOutputs.getSibling(location) !== undefined;
   }
 
   // Returns true if we have sufficient inputs to execute the block root rollup
   public isReadyForBlockRootRollup() {
-    const childProofs = this.#getChildProvingOutputsForBlockRoot();
-    return (!this.isFirstBlock || !!this.rootParityProof?.provingOutput) && childProofs.every(p => !!p);
+    const childProofs = this.#getChildProofsForBlockRoot();
+    return (
+      this.block !== undefined &&
+      this.rootParityProvingOutput !== undefined &&
+      this.endBlobAccumulator !== undefined &&
+      childProofs.every(p => !!p)
+    );
   }
 
   // Returns true if we have sufficient root parity inputs to execute the root parity circuit
   public isReadyForRootParity() {
-    return this.baseParityProofs.every(p => !!p?.provingOutput);
+    return this.baseParityProvingOutputs.every(p => !!p);
   }
 
   public isComplete() {
-    return !!this.blockRootProof;
+    return !!this.blockRootProvingOutput;
   }
 
+  // Returns whether the proving state is still valid
   public verifyState() {
-    return this.parentCheckpoint.verifyState();
-  }
-
-  public getError() {
-    return this.error;
+    return this.parentEpoch.verifyState();
   }
 
   public reject(reason: string) {
     this.error = reason;
-    this.parentCheckpoint.reject(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(),
+    });
+  }
+
+  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,
+    });
   }
 
-  #getChildProvingOutputsForBlockRoot() {
+  #getChildProofsForBlockRoot() {
     if (this.totalNumTxs === 0) {
       return [];
     }
@@ -389,7 +380,26 @@ 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.baseOrMergeProofs.getNode(rootLocation)?.provingOutput]
-      : this.baseOrMergeProofs.getChildren(rootLocation).map(c => c?.provingOutput);
+      ? [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,
+    );
   }
 }