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

package/src/orchestrator/block-building-helpers.ts

@@ -1,50 +1,38 @@
-import {
-  BatchedBlob,
-  BatchedBlobAccumulator,
-  SpongeBlob,
-  computeBlobsHashFromBlobs,
-  getBlobCommitmentsFromBlobs,
-  getBlobsPerL1Block,
-} from '@aztec/blob-lib';
+import { BatchedBlobAccumulator, Blob, type SpongeBlob } from '@aztec/blob-lib';
 import {
   ARCHIVE_HEIGHT,
-  CHONK_PROOF_LENGTH,
   MAX_CONTRACT_CLASS_LOGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
   NOTE_HASH_SUBTREE_HEIGHT,
-  NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
+  NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH,
   NULLIFIER_SUBTREE_HEIGHT,
-  NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
+  NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH,
   NULLIFIER_TREE_HEIGHT,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   PUBLIC_DATA_TREE_HEIGHT,
 } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { sha256Trunc } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
-import { type Bufferable, type Tuple, assertLength, toFriendlyJSON } from '@aztec/foundation/serialize';
-import {
-  MembershipWitness,
-  MerkleTreeCalculator,
-  computeCompressedUnbalancedMerkleTreeRoot,
-} from '@aztec/foundation/trees';
-import { getVkData } from '@aztec/noir-protocol-circuits-types/server/vks';
-import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { sha256ToField, sha256Trunc } from '@aztec/foundation/crypto';
+import { BLS12Point, Fr } from '@aztec/foundation/fields';
+import { type Tuple, assertLength, toFriendlyJSON } from '@aztec/foundation/serialize';
+import { MembershipWitness, MerkleTreeCalculator, computeUnbalancedMerkleTreeRoot } from '@aztec/foundation/trees';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
 import { computeFeePayerBalanceLeafSlot } from '@aztec/protocol-contracts/fee-juice';
-import { Body, L2BlockHeader, getBlockBlobFields } from '@aztec/stdlib/block';
-import { getCheckpointBlobFields } from '@aztec/stdlib/checkpoint';
-import type { MerkleTreeWriteOperations, PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
+import { PublicDataHint } from '@aztec/stdlib/avm';
+import { Body } from '@aztec/stdlib/block';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
 import { ContractClassLogFields } from '@aztec/stdlib/logs';
-import { Proof, ProofData, RecursiveProof } from '@aztec/stdlib/proofs';
+import type { ParityPublicInputs } from '@aztec/stdlib/parity';
 import {
+  type BaseOrMergeRollupPublicInputs,
   BlockConstantData,
-  BlockRollupPublicInputs,
+  type BlockRootOrBlockMergePublicInputs,
   PrivateBaseRollupHints,
+  PrivateBaseStateDiffHints,
   PublicBaseRollupHints,
-  PublicChonkVerifierPrivateInputs,
-  TreeSnapshotDiffHints,
 } from '@aztec/stdlib/rollup';
 import {
   AppendOnlyTreeSnapshot,
@@ -57,13 +45,12 @@ import {
 import {
   BlockHeader,
   ContentCommitment,
-  GlobalVariables,
+  type GlobalVariables,
   PartialStateReference,
   type ProcessedTx,
   StateReference,
-  Tx,
+  TxEffect,
 } from '@aztec/stdlib/tx';
-import { VkData } from '@aztec/stdlib/vks';
 import { Attributes, type Span, runInSpan } from '@aztec/telemetry-client';
 import type { MerkleTreeReadOperations } from '@aztec/world-state';
 
@@ -83,24 +70,28 @@ export const insertSideEffectsAndBuildBaseRollupHints = runInSpan(
   async (
     span: Span,
     tx: ProcessedTx,
-    lastArchive: AppendOnlyTreeSnapshot,
+    globalVariables: GlobalVariables,
     newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot,
-    startSpongeBlob: SpongeBlob,
-    proverId: Fr,
     db: MerkleTreeWriteOperations,
+    startSpongeBlob: SpongeBlob,
   ) => {
     span.setAttribute(Attributes.TX_HASH, tx.hash.toString());
     // Get trees info before any changes hit
+    const lastArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
     const start = new PartialStateReference(
       await getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE, db),
       await getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE, db),
       await getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE, db),
     );
+    // Get the subtree sibling paths for the circuit
+    const noteHashSubtreeSiblingPathArray = await getSubtreeSiblingPath(
+      MerkleTreeId.NOTE_HASH_TREE,
+      NOTE_HASH_SUBTREE_HEIGHT,
+      db,
+    );
 
-    // Get the note hash subtree root sibling path for insertion.
-    const noteHashSubtreeRootSiblingPath = assertLength(
-      await getSubtreeSiblingPath(MerkleTreeId.NOTE_HASH_TREE, NOTE_HASH_SUBTREE_HEIGHT, db),
-      NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
+    const noteHashSubtreeSiblingPath = makeTuple(NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH, i =>
+      i < noteHashSubtreeSiblingPathArray.length ? noteHashSubtreeSiblingPathArray[i] : Fr.ZERO,
     );
 
     // Update the note hash trees with the new items being inserted to get the new roots
@@ -108,6 +99,10 @@ export const insertSideEffectsAndBuildBaseRollupHints = runInSpan(
     const noteHashes = padArrayEnd(tx.txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX);
     await db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, noteHashes);
 
+    // Create data hint for reading fee payer initial balance in Fee Juice
+    const leafSlot = await computeFeePayerBalanceLeafSlot(tx.data.feePayer);
+    const feePayerFeeJuiceBalanceReadHint = await getPublicDataHint(db, leafSlot.toBigInt());
+
     // The read witnesses for a given TX should be generated before the writes of the same TX are applied.
     // All reads that refer to writes in the same tx are transient and can be simplified out.
     const txPublicDataUpdateRequestInfo = await processPublicDataUpdateRequests(tx, db);
@@ -115,8 +110,8 @@ export const insertSideEffectsAndBuildBaseRollupHints = runInSpan(
     // Update the nullifier tree, capturing the low nullifier info for each individual operation
     const {
       lowLeavesWitnessData: nullifierWitnessLeaves,
-      newSubtreeSiblingPath: nullifiersSubtreeRootSiblingPath,
-      sortedNewLeaves: sortedNullifiers,
+      newSubtreeSiblingPath: nullifiersSubtreeSiblingPath,
+      sortedNewLeaves: sortednullifiers,
       sortedNewLeavesIndexes,
     } = await db.batchInsert(
       MerkleTreeId.NULLIFIER_TREE,
@@ -128,10 +123,21 @@ export const insertSideEffectsAndBuildBaseRollupHints = runInSpan(
       throw new Error(`Could not craft nullifier batch insertion proofs`);
     }
 
-    const blockHash = await tx.data.constants.anchorBlockHeader.hash();
-    const anchorBlockArchiveSiblingPath = (
-      await getMembershipWitnessFor(blockHash, MerkleTreeId.ARCHIVE, ARCHIVE_HEIGHT, db)
-    ).siblingPath;
+    // Extract witness objects from returned data
+    const nullifierPredecessorMembershipWitnessesWithoutPadding: MembershipWitness<typeof NULLIFIER_TREE_HEIGHT>[] =
+      nullifierWitnessLeaves.map(l =>
+        MembershipWitness.fromBufferArray(l.index, assertLength(l.siblingPath.toBufferArray(), NULLIFIER_TREE_HEIGHT)),
+      );
+
+    const nullifierSubtreeSiblingPathArray = nullifiersSubtreeSiblingPath.toFields();
+
+    const nullifierSubtreeSiblingPath = makeTuple(NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH, i =>
+      i < nullifierSubtreeSiblingPathArray.length ? nullifierSubtreeSiblingPathArray[i] : Fr.ZERO,
+    );
+
+    // Append new data to startSpongeBlob
+    const inputSpongeBlob = startSpongeBlob.clone();
+    await startSpongeBlob.absorb(tx.txEffect.toBlobFields());
 
     const contractClassLogsFields = makeTuple(
       MAX_CONTRACT_CLASS_LOGS_PER_TX,
@@ -139,10 +145,18 @@ export const insertSideEffectsAndBuildBaseRollupHints = runInSpan(
     );
 
     if (tx.avmProvingRequest) {
+      const blockHash = await tx.data.constants.historicalHeader.hash();
+      const archiveRootMembershipWitness = await getMembershipWitnessFor(
+        blockHash,
+        MerkleTreeId.ARCHIVE,
+        ARCHIVE_HEIGHT,
+        db,
+      );
+
       return PublicBaseRollupHints.from({
-        startSpongeBlob,
+        startSpongeBlob: inputSpongeBlob,
         lastArchive,
-        anchorBlockArchiveSiblingPath,
+        archiveRootMembershipWitness,
         contractClassLogsFields,
       });
     } else {
@@ -154,62 +168,57 @@ export const insertSideEffectsAndBuildBaseRollupHints = runInSpan(
         throw new Error(`More than one public data write in a private only tx`);
       }
 
-      // Get hints for reading fee payer's balance in the public data tree.
-      const feePayerBalanceMembershipWitness = txPublicDataUpdateRequestInfo.lowPublicDataWritesMembershipWitnesses[0];
-      const feePayerBalanceLeafPreimage = txPublicDataUpdateRequestInfo.lowPublicDataWritesPreimages[0];
-      const leafSlot = await computeFeePayerBalanceLeafSlot(tx.data.feePayer);
-      if (!feePayerBalanceMembershipWitness || !leafSlot.equals(feePayerBalanceLeafPreimage?.leaf.slot)) {
-        throw new Error(`Cannot find the public data tree leaf for the fee payer's balance`);
-      }
-
-      // Extract witness objects from returned data
-      const nullifierPredecessorMembershipWitnessesWithoutPadding: MembershipWitness<typeof NULLIFIER_TREE_HEIGHT>[] =
-        nullifierWitnessLeaves.map(l =>
-          MembershipWitness.fromBufferArray(
-            l.index,
-            assertLength(l.siblingPath.toBufferArray(), NULLIFIER_TREE_HEIGHT),
-          ),
-        );
-
-      const treeSnapshotDiffHints = TreeSnapshotDiffHints.from({
-        noteHashSubtreeRootSiblingPath,
-        nullifierPredecessorPreimages: padArrayEnd(
-          nullifierWitnessLeaves.map(l => l.leafPreimage as NullifierLeafPreimage),
-          NullifierLeafPreimage.empty(),
-          MAX_NULLIFIERS_PER_TX,
+      const feeWriteLowLeafPreimage =
+        txPublicDataUpdateRequestInfo.lowPublicDataWritesPreimages[0] || PublicDataTreeLeafPreimage.empty();
+      const feeWriteLowLeafMembershipWitness =
+        txPublicDataUpdateRequestInfo.lowPublicDataWritesMembershipWitnesses[0] ||
+        MembershipWitness.empty<typeof PUBLIC_DATA_TREE_HEIGHT>(PUBLIC_DATA_TREE_HEIGHT);
+      const feeWriteSiblingPath =
+        txPublicDataUpdateRequestInfo.publicDataWritesSiblingPaths[0] ||
+        makeTuple(PUBLIC_DATA_TREE_HEIGHT, () => Fr.ZERO);
+
+      const stateDiffHints = PrivateBaseStateDiffHints.from({
+        nullifierPredecessorPreimages: makeTuple(MAX_NULLIFIERS_PER_TX, i =>
+          i < nullifierWitnessLeaves.length
+            ? (nullifierWitnessLeaves[i].leafPreimage as NullifierLeafPreimage)
+            : NullifierLeafPreimage.empty(),
         ),
         nullifierPredecessorMembershipWitnesses: makeTuple(MAX_NULLIFIERS_PER_TX, i =>
           i < nullifierPredecessorMembershipWitnessesWithoutPadding.length
             ? nullifierPredecessorMembershipWitnessesWithoutPadding[i]
             : makeEmptyMembershipWitness(NULLIFIER_TREE_HEIGHT),
         ),
-        sortedNullifiers: assertLength(
-          sortedNullifiers.map(n => Fr.fromBuffer(n)),
-          MAX_NULLIFIERS_PER_TX,
-        ),
-        sortedNullifierIndexes: assertLength(sortedNewLeavesIndexes, MAX_NULLIFIERS_PER_TX),
-        nullifierSubtreeRootSiblingPath: assertLength(
-          nullifiersSubtreeRootSiblingPath.toFields(),
-          NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
-        ),
-        feePayerBalanceMembershipWitness,
+        sortedNullifiers: makeTuple(MAX_NULLIFIERS_PER_TX, i => Fr.fromBuffer(sortednullifiers[i])),
+        sortedNullifierIndexes: makeTuple(MAX_NULLIFIERS_PER_TX, i => sortedNewLeavesIndexes[i]),
+        noteHashSubtreeSiblingPath,
+        nullifierSubtreeSiblingPath,
+        feeWriteLowLeafPreimage,
+        feeWriteLowLeafMembershipWitness,
+        feeWriteSiblingPath,
       });
 
+      const blockHash = await tx.data.constants.historicalHeader.hash();
+      const archiveRootMembershipWitness = await getMembershipWitnessFor(
+        blockHash,
+        MerkleTreeId.ARCHIVE,
+        ARCHIVE_HEIGHT,
+        db,
+      );
+
       const constants = BlockConstantData.from({
         lastArchive,
-        l1ToL2TreeSnapshot: newL1ToL2MessageTreeSnapshot,
-        vkTreeRoot: tx.data.constants.vkTreeRoot,
-        protocolContractsHash: tx.data.constants.protocolContractsHash,
-        globalVariables: tx.globalVariables,
-        proverId,
+        newL1ToL2: newL1ToL2MessageTreeSnapshot,
+        vkTreeRoot: getVKTreeRoot(),
+        protocolContractTreeRoot,
+        globalVariables,
       });
 
       return PrivateBaseRollupHints.from({
         start,
-        startSpongeBlob,
-        treeSnapshotDiffHints,
-        feePayerBalanceLeafPreimage,
-        anchorBlockArchiveSiblingPath,
+        startSpongeBlob: inputSpongeBlob,
+        stateDiffHints,
+        feePayerFeeJuiceBalanceReadHint,
+        archiveRootMembershipWitness,
         contractClassLogsFields,
         constants,
       });
@@ -217,53 +226,50 @@ export const insertSideEffectsAndBuildBaseRollupHints = runInSpan(
   },
 );
 
-export function getChonkProofFromTx(tx: Tx | ProcessedTx) {
-  const publicInputs = tx.data.publicInputs().toFields();
+export async function getPublicDataHint(db: MerkleTreeWriteOperations, leafSlot: bigint) {
+  const { index } = (await db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot)) ?? {};
+  if (index === undefined) {
+    throw new Error(`Cannot find the previous value index for public data ${leafSlot}.`);
+  }
 
-  const binaryProof = new Proof(
-    Buffer.concat(tx.chonkProof.attachPublicInputs(publicInputs).fieldsWithPublicInputs.map(field => field.toBuffer())),
-    publicInputs.length,
-  );
-  return new RecursiveProof(tx.chonkProof.fields, binaryProof, true, CHONK_PROOF_LENGTH);
-}
+  const siblingPath = await db.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, index);
+  const membershipWitness = new MembershipWitness(PUBLIC_DATA_TREE_HEIGHT, index, siblingPath.toTuple());
 
-export function getPublicChonkVerifierPrivateInputsFromTx(tx: Tx | ProcessedTx, proverId: Fr) {
-  const proofData = new ProofData(
-    tx.data.toPrivateToPublicKernelCircuitPublicInputs(),
-    getChonkProofFromTx(tx),
-    getVkData('HidingKernelToPublic'),
-  );
-  return new PublicChonkVerifierPrivateInputs(proofData, proverId);
+  const leafPreimage = (await db.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, index)) as PublicDataTreeLeafPreimage;
+  if (!leafPreimage) {
+    throw new Error(`Cannot find the leaf preimage for public data tree at index ${index}.`);
+  }
+
+  const exists = leafPreimage.leaf.slot.toBigInt() === leafSlot;
+  const value = exists ? leafPreimage.leaf.value : Fr.ZERO;
+
+  return new PublicDataHint(new Fr(leafSlot), value, membershipWitness, leafPreimage);
 }
 
-// Build "hints" as the private inputs for the checkpoint root rollup circuit.
-// The `blobCommitments` will be accumulated and checked in the root rollup against the `finalBlobChallenges`.
-// The `blobsHash` will be validated on L1 against the submitted blob data.
-export const buildBlobHints = (blobFields: Fr[]) => {
-  const blobs = getBlobsPerL1Block(blobFields);
-  const blobCommitments = getBlobCommitmentsFromBlobs(blobs);
-  const blobsHash = computeBlobsHashFromBlobs(blobs);
-  return { blobCommitments, blobs, blobsHash };
-};
-
-// Build the data required to prove the txs in an epoch. Currently only used in tests. It assumes 1 block per checkpoint.
-export const buildBlobDataFromTxs = async (txsPerCheckpoint: ProcessedTx[][]) => {
-  const blobFields = txsPerCheckpoint.map(txs => getCheckpointBlobFields([txs.map(tx => tx.txEffect)]));
-  const finalBlobChallenges = await buildFinalBlobChallenges(blobFields);
-  return { blobFieldsLengths: blobFields.map(fields => fields.length), finalBlobChallenges };
-};
-
-export const buildFinalBlobChallenges = async (blobFieldsPerCheckpoint: Fr[][]) => {
-  const blobs = blobFieldsPerCheckpoint.map(blobFields => getBlobsPerL1Block(blobFields));
-  return await BatchedBlob.precomputeBatchedBlobChallenges(blobs);
-};
+export const buildBlobHints = runInSpan(
+  'BlockBuilderHelpers',
+  'buildBlobHints',
+  async (_span: Span, txEffects: TxEffect[]) => {
+    const blobFields = txEffects.flatMap(tx => tx.toBlobFields());
+    const blobs = await Blob.getBlobsPerBlock(blobFields);
+    // TODO(#13430): The blobsHash is confusingly similar to blobCommitmentsHash, calculated from below blobCommitments:
+    // - blobsHash := sha256([blobhash_0, ..., blobhash_m]) = a hash of all blob hashes in a block with m+1 blobs inserted into the header, exists so a user can cross check blobs.
+    // - blobCommitmentsHash := sha256( ...sha256(sha256(C_0), C_1) ... C_n) = iteratively calculated hash of all blob commitments in an epoch with n+1 blobs (see calculateBlobCommitmentsHash()),
+    //   exists so we can validate injected commitments to the rollup circuits correspond to the correct real blobs.
+    // We may be able to combine these values e.g. blobCommitmentsHash := sha256( ...sha256(sha256(blobshash_0), blobshash_1) ... blobshash_l) for an epoch with l+1 blocks.
+    const blobCommitments = blobs.map(b => BLS12Point.decompress(b.commitment));
+    const blobsHash = new Fr(getBlobsHashFromBlobs(blobs));
+    return { blobFields, blobCommitments, blobs, blobsHash };
+  },
+);
 
 export const accumulateBlobs = runInSpan(
   'BlockBuilderHelpers',
   'accumulateBlobs',
-  async (_span: Span, blobFields: Fr[], startBlobAccumulator: BatchedBlobAccumulator) => {
-    const blobs = getBlobsPerL1Block(blobFields);
-    const endBlobAccumulator = await startBlobAccumulator.accumulateBlobs(blobs);
+  async (_span: Span, txs: ProcessedTx[], startBlobAccumulator: BatchedBlobAccumulator) => {
+    const blobFields = txs.flatMap(tx => tx.txEffect.toBlobFields());
+    const blobs = await Blob.getBlobsPerBlock(blobFields);
+    const endBlobAccumulator = startBlobAccumulator.accumulateBlobs(blobs);
     return endBlobAccumulator;
   },
 );
@@ -271,28 +277,36 @@ export const accumulateBlobs = runInSpan(
 export const buildHeaderFromCircuitOutputs = runInSpan(
   'BlockBuilderHelpers',
   'buildHeaderFromCircuitOutputs',
-  async (_span, blockRootRollupOutput: BlockRollupPublicInputs) => {
-    const constants = blockRootRollupOutput.constants;
-    const globalVariables = GlobalVariables.from({
-      chainId: constants.chainId,
-      version: constants.version,
-      blockNumber: blockRootRollupOutput.previousArchive.nextAvailableLeafIndex,
-      timestamp: blockRootRollupOutput.endTimestamp,
-      slotNumber: constants.slotNumber,
-      coinbase: constants.coinbase,
-      feeRecipient: constants.feeRecipient,
-      gasFees: constants.gasFees,
-    });
+  (
+    _span,
+    previousRollupData: BaseOrMergeRollupPublicInputs[],
+    parityPublicInputs: ParityPublicInputs,
+    rootRollupOutputs: BlockRootOrBlockMergePublicInputs,
+    blobsHash: Fr,
+    endState: StateReference,
+  ) => {
+    if (previousRollupData.length > 2) {
+      throw new Error(`There can't be more than 2 previous rollups. Received ${previousRollupData.length}.`);
+    }
+
+    const outHash =
+      previousRollupData.length === 0
+        ? Fr.ZERO
+        : previousRollupData.length === 1
+          ? previousRollupData[0].outHash
+          : sha256ToField([previousRollupData[0].outHash, previousRollupData[1].outHash]);
+    const contentCommitment = new ContentCommitment(blobsHash, parityPublicInputs.shaRoot, outHash);
 
-    const spongeBlobHash = await blockRootRollupOutput.endSpongeBlob.clone().squeeze();
+    const accumulatedFees = previousRollupData.reduce((sum, d) => sum.add(d.accumulatedFees), Fr.ZERO);
+    const accumulatedManaUsed = previousRollupData.reduce((sum, d) => sum.add(d.accumulatedManaUsed), Fr.ZERO);
 
     return new BlockHeader(
-      blockRootRollupOutput.previousArchive,
-      blockRootRollupOutput.endState,
-      spongeBlobHash,
-      globalVariables,
-      blockRootRollupOutput.accumulatedFees,
-      blockRootRollupOutput.accumulatedManaUsed,
+      rootRollupOutputs.previousArchive,
+      contentCommitment,
+      endState,
+      rootRollupOutputs.endGlobalVariables,
+      accumulatedFees,
+      accumulatedManaUsed,
     );
   },
 );
@@ -306,7 +320,6 @@ export const buildHeaderAndBodyFromTxs = runInSpan(
     globalVariables: GlobalVariables,
     l1ToL2Messages: Fr[],
     db: MerkleTreeReadOperations,
-    startSpongeBlob?: SpongeBlob,
   ) => {
     span.setAttribute(Attributes.BLOCK_NUMBER, globalVariables.blockNumber);
     const stateReference = new StateReference(
@@ -324,75 +337,25 @@ export const buildHeaderAndBodyFromTxs = runInSpan(
     const body = new Body(txEffects);
 
     const txOutHashes = txEffects.map(tx => tx.txOutHash());
-    const outHash = txOutHashes.length === 0 ? Fr.ZERO : new Fr(computeCompressedUnbalancedMerkleTreeRoot(txOutHashes));
+    const outHash = txOutHashes.length === 0 ? Fr.ZERO : new Fr(computeUnbalancedMerkleTreeRoot(txOutHashes));
 
     const parityShaRoot = await computeInHashFromL1ToL2Messages(l1ToL2Messages);
-    const blockBlobFields = body.toBlobFields();
-    // TODO(#17027): This only works when there's one block per checkpoint.
-    const blobFields = [new Fr(blockBlobFields.length + 1)].concat(blockBlobFields);
-    const blobsHash = computeBlobsHashFromBlobs(getBlobsPerL1Block(blobFields));
+    const blobsHash = getBlobsHashFromBlobs(await Blob.getBlobsPerBlock(body.toBlobFields()));
 
     const contentCommitment = new ContentCommitment(blobsHash, parityShaRoot, outHash);
 
     const fees = txEffects.reduce((acc, tx) => acc.add(tx.transactionFee), Fr.ZERO);
     const manaUsed = txs.reduce((acc, tx) => acc.add(new Fr(tx.gasUsed.billedGas.l2Gas)), Fr.ZERO);
 
-    const endSpongeBlob = startSpongeBlob?.clone() ?? (await SpongeBlob.init(blobFields.length));
-    await endSpongeBlob.absorb(blockBlobFields);
-    const spongeBlobHash = await endSpongeBlob.squeeze();
-
-    const header = new L2BlockHeader(
-      previousArchive,
-      contentCommitment,
-      stateReference,
-      globalVariables,
-      fees,
-      manaUsed,
-      spongeBlobHash,
-    );
+    const header = new BlockHeader(previousArchive, contentCommitment, stateReference, globalVariables, fees, manaUsed);
 
     return { header, body };
   },
 );
 
-export const buildBlockHeaderFromTxs = runInSpan(
-  'BlockBuilderHelpers',
-  'buildBlockHeaderFromTxs',
-  async (
-    span,
-    txs: ProcessedTx[],
-    globalVariables: GlobalVariables,
-    startSpongeBlob: SpongeBlob,
-    db: MerkleTreeReadOperations,
-  ) => {
-    span.setAttribute(Attributes.BLOCK_NUMBER, globalVariables.blockNumber);
-    const stateReference = new StateReference(
-      await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db),
-      new PartialStateReference(
-        await getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE, db),
-        await getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE, db),
-        await getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE, db),
-      ),
-    );
-
-    const previousArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
-
-    const blobFields = getBlockBlobFields(txs.map(tx => tx.txEffect));
-    const endSpongeBlob = startSpongeBlob.clone();
-    await endSpongeBlob.absorb(blobFields);
-    const spongeBlobHash = await endSpongeBlob.squeeze();
-
-    const txEffects = txs.map(tx => tx.txEffect);
-    const fees = txEffects.reduce((acc, tx) => acc.add(tx.transactionFee), Fr.ZERO);
-    const manaUsed = txs.reduce((acc, tx) => acc.add(new Fr(tx.gasUsed.billedGas.l2Gas)), Fr.ZERO);
-
-    return new BlockHeader(previousArchive, stateReference, spongeBlobHash, globalVariables, fees, manaUsed);
-  },
-);
-
 /** Computes the inHash for a block's ContentCommitment given its l1 to l2 messages. */
 export async function computeInHashFromL1ToL2Messages(unpaddedL1ToL2Messages: Fr[]): Promise<Fr> {
-  const l1ToL2Messages = padArrayEnd<Fr, number>(unpaddedL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+  const l1ToL2Messages = padArrayEnd(unpaddedL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
   const hasher = (left: Buffer, right: Buffer) =>
     Promise.resolve(sha256Trunc(Buffer.concat([left, right])) as Buffer<ArrayBuffer>);
   const parityHeight = Math.ceil(Math.log2(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
@@ -400,6 +363,52 @@ export async function computeInHashFromL1ToL2Messages(unpaddedL1ToL2Messages: Fr
   return new Fr(await parityCalculator.computeTreeRoot(l1ToL2Messages.map(msg => msg.toBuffer())));
 }
 
+export function getBlobsHashFromBlobs(inputs: Blob[]): Fr {
+  return sha256ToField(inputs.map(b => b.getEthVersionedBlobHash()));
+}
+
+// Note: tested against the constant values in block_root/empty_block_root_rollup_inputs.nr, set by block_building_helpers.test.ts.
+// Having this separate fn hopefully makes it clear how we treat empty blocks and their blobs, and won't break if we decide to change how
+// getBlobsPerBlock() works on empty input.
+export async function getEmptyBlockBlobsHash(): Promise<Fr> {
+  const blobHash = (await Blob.getBlobsPerBlock([])).map(b => b.getEthVersionedBlobHash());
+  return sha256ToField(blobHash);
+}
+
+// Validate that the roots of all local trees match the output of the root circuit simulation
+// TODO: does this get called?
+export async function validateBlockRootOutput(
+  blockRootOutput: BlockRootOrBlockMergePublicInputs,
+  blockHeader: BlockHeader,
+  db: MerkleTreeReadOperations,
+) {
+  await Promise.all([
+    validateState(blockHeader.state, db),
+    validateSimulatedTree(await getTreeSnapshot(MerkleTreeId.ARCHIVE, db), blockRootOutput.newArchive, 'Archive'),
+  ]);
+}
+
+export const validateState = runInSpan(
+  'BlockBuilderHelpers',
+  'validateState',
+  async (_span, state: StateReference, db: MerkleTreeReadOperations) => {
+    const promises = [MerkleTreeId.NOTE_HASH_TREE, MerkleTreeId.NULLIFIER_TREE, MerkleTreeId.PUBLIC_DATA_TREE].map(
+      async (id: MerkleTreeId) => {
+        return { key: id, value: await getTreeSnapshot(id, db) };
+      },
+    );
+    const snapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot> = new Map(
+      (await Promise.all(promises)).map(obj => [obj.key, obj.value]),
+    );
+    validatePartialState(state.partial, snapshots);
+    validateSimulatedTree(
+      await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db),
+      state.l1ToL2MessageTree,
+      'L1ToL2MessageTree',
+    );
+  },
+);
+
 export async function getLastSiblingPath<TID extends MerkleTreeId>(treeId: TID, db: MerkleTreeReadOperations) {
   const { size } = await db.getTreeInfo(treeId);
   const path = await db.getSiblingPath(treeId, size - 1n);
@@ -532,7 +541,7 @@ function validateSimulatedTree(
 }
 
 export function validateTx(tx: ProcessedTx) {
-  const txHeader = tx.data.constants.anchorBlockHeader;
+  const txHeader = tx.data.constants.historicalHeader;
   if (txHeader.state.l1ToL2MessageTree.isEmpty()) {
     throw new Error(`Empty L1 to L2 messages tree in tx: ${toFriendlyJSON(tx)}`);
   }
@@ -546,12 +555,3 @@ export function validateTx(tx: ProcessedTx) {
     throw new Error(`Empty public data tree in tx: ${toFriendlyJSON(tx)}`);
   }
 }
-
-export function toProofData<T extends Bufferable, PROOF_LENGTH extends number>(
-  { inputs, proof, verificationKey }: PublicInputsAndRecursiveProof<T, PROOF_LENGTH>,
-  vkIndex?: number,
-) {
-  const leafIndex = vkIndex || getVKIndex(verificationKey.keyAsFields);
-  const vkData = new VkData(verificationKey, leafIndex, getVKSiblingPath(leafIndex));
-  return new ProofData(inputs, proof, vkData);
-}