@aztec/prover-client 3.0.0-nightly.20250917 → 3.0.0-nightly.20250918

package/src/mocks/fixtures.ts

@@ -5,10 +5,13 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import type { Logger } from '@aztec/foundation/log';
 import { fileURLToPath } from '@aztec/foundation/url';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
 import { type CircuitSimulator, NativeACVMSimulator, WASMSimulatorWithBlobs } from '@aztec/simulator/server';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { GasFees } from '@aztec/stdlib/gas';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { CheckpointConstantData } from '@aztec/stdlib/rollup';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import type { ProcessedTx } from '@aztec/stdlib/tx';
 import { GlobalVariables } from '@aztec/stdlib/tx';
@@ -103,15 +106,30 @@ export const updateExpectedTreesFromTxs = async (db: MerkleTreeWriteOperations,
   }
 };
 
-export const makeGlobals = (blockNumber: number) => {
+export const makeGlobals = (blockNumber: number, slotNumber = blockNumber) => {
+  const checkpointConstants = makeCheckpointConstants(slotNumber);
   return new GlobalVariables(
-    Fr.ZERO,
-    Fr.ZERO,
+    checkpointConstants.chainId,
+    checkpointConstants.version,
     blockNumber /** block number */,
-    new Fr(blockNumber) /** slot number */,
+    new Fr(slotNumber) /** slot number */,
     BigInt(blockNumber) /** block number as pseudo-timestamp for testing */,
-    EthAddress.ZERO,
-    AztecAddress.ZERO,
-    GasFees.empty(),
+    checkpointConstants.coinbase,
+    checkpointConstants.feeRecipient,
+    checkpointConstants.gasFees,
   );
 };
+
+export const makeCheckpointConstants = (slotNumber: number) => {
+  return CheckpointConstantData.from({
+    chainId: Fr.ZERO,
+    version: Fr.ZERO,
+    vkTreeRoot: getVKTreeRoot(),
+    protocolContractTreeRoot,
+    proverId: Fr.ZERO,
+    slotNumber: new Fr(slotNumber),
+    coinbase: EthAddress.ZERO,
+    feeRecipient: AztecAddress.ZERO,
+    gasFees: GasFees.empty(),
+  });
+};

package/src/mocks/test_context.ts

@@ -1,4 +1,5 @@
 import type { BBProverConfig } from '@aztec/bb-prover';
+import { SpongeBlob } from '@aztec/blob-lib';
 import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
 import { padArrayEnd, times, timesParallel } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
@@ -11,10 +12,11 @@ import { SimpleContractDataSource } from '@aztec/simulator/public/fixtures';
 import { PublicProcessorFactory } from '@aztec/simulator/server';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { EthAddress, type L2Block } from '@aztec/stdlib/block';
+import { EthAddress, getBlockBlobFields } from '@aztec/stdlib/block';
 import type { ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
+import type { CheckpointConstantData } from '@aztec/stdlib/rollup';
 import { makeBloatedProcessedTx } from '@aztec/stdlib/testing';
-import { type AppendOnlyTreeSnapshot, MerkleTreeId, PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import { MerkleTreeId, PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 import { type BlockHeader, type GlobalVariables, type ProcessedTx, TreeSnapshots, type Tx } from '@aztec/stdlib/tx';
 import type { MerkleTreeAdminDatabase } from '@aztec/world-state';
 import { NativeWorldStateService } from '@aztec/world-state/native';
@@ -26,10 +28,17 @@ import { promises as fs } from 'fs';
 import { TestCircuitProver } from '../../../bb-prover/src/test/test_circuit_prover.js';
 import { buildBlockWithCleanDB } from '../block-factory/light.js';
 import { getTreeSnapshot } from '../orchestrator/block-building-helpers.js';
+import type { BlockProvingState } from '../orchestrator/block-proving-state.js';
 import { ProvingOrchestrator } from '../orchestrator/index.js';
 import { BrokerCircuitProverFacade } from '../proving_broker/broker_prover_facade.js';
 import { TestBroker } from '../test/mock_prover.js';
-import { getEnvironmentConfig, getSimulator, makeGlobals, updateExpectedTreesFromTxs } from './fixtures.js';
+import {
+  getEnvironmentConfig,
+  getSimulator,
+  makeCheckpointConstants,
+  makeGlobals,
+  updateExpectedTreesFromTxs,
+} from './fixtures.js';
 
 export class TestContext {
   private headers: Map<number, BlockHeader> = new Map();
@@ -37,6 +46,7 @@ export class TestContext {
 
   constructor(
     public worldState: MerkleTreeAdminDatabase,
+    public firstCheckpointNumber: Fr,
     public globalVariables: GlobalVariables,
     public prover: ServerCircuitProver,
     public broker: TestBroker,
@@ -55,20 +65,27 @@ export class TestContext {
     return this.orchestrator;
   }
 
+  public getCheckpointConstants(checkpointIndex = 0): CheckpointConstantData {
+    return makeCheckpointConstants(this.firstCheckpointNumber.toNumber() + checkpointIndex);
+  }
+
   static async new(
     logger: Logger,
     {
       proverCount = 4,
       createProver = async (bbConfig: BBProverConfig) => new TestCircuitProver(await getSimulator(bbConfig, logger)),
+      slotNumber = 1,
       blockNumber = 1,
     }: {
       proverCount?: number;
       createProver?: (bbConfig: BBProverConfig) => Promise<ServerCircuitProver>;
+      slotNumber?: number;
       blockNumber?: number;
     } = {},
   ) {
     const directoriesToCleanup: string[] = [];
-    const globalVariables = makeGlobals(blockNumber);
+    const firstCheckpointNumber = new Fr(slotNumber);
+    const globalVariables = makeGlobals(blockNumber, slotNumber);
 
     const feePayer = AztecAddress.fromNumber(42222);
     const initialFeePayerBalance = new Fr(10n ** 20n);
@@ -112,6 +129,7 @@ export class TestContext {
 
     return new this(
       ws,
+      firstCheckpointNumber,
       globalVariables,
       localProver,
       broker,
@@ -131,14 +149,10 @@ export class TestContext {
 
   public getBlockHeader(blockNumber: 0): BlockHeader;
   public getBlockHeader(blockNumber: number): BlockHeader | undefined;
-  public getBlockHeader(blockNumber = 0) {
+  public getBlockHeader(blockNumber = 0): BlockHeader | undefined {
     return blockNumber === 0 ? this.worldState.getCommitted().getInitialHeader() : this.headers.get(blockNumber);
   }
 
-  public setBlockHeader(header: BlockHeader, blockNumber: number) {
-    this.headers.set(blockNumber, header);
-  }
-
   public getPreviousBlockHeader(currentBlockNumber = this.blockNumber): BlockHeader {
     return this.getBlockHeader(currentBlockNumber - 1)!;
   }
@@ -155,9 +169,9 @@ export class TestContext {
     }
   }
 
-  private async makeProcessedTx(opts?: Parameters<typeof makeBloatedProcessedTx>[0]): Promise<ProcessedTx> {
+  async makeProcessedTx(opts?: Parameters<typeof makeBloatedProcessedTx>[0]): Promise<ProcessedTx> {
     const blockNum = (opts?.globalVariables ?? this.globalVariables).blockNumber;
-    const header = this.getBlockHeader(blockNum - 1);
+    const header = opts?.header ?? this.getBlockHeader(blockNum - 1);
     const tx = await makeBloatedProcessedTx({
       header,
       vkTreeRoot: getVKTreeRoot(),
@@ -177,11 +191,20 @@ export class TestContext {
   /** Creates a block with the given number of txs and adds it to world-state */
   public async makePendingBlock(
     numTxs: number,
-    numL1ToL2Messages: number = 0,
-    blockNumOrGlobals: GlobalVariables | number = this.globalVariables,
-    makeProcessedTxOpts: (index: number) => Partial<Parameters<typeof makeBloatedProcessedTx>[0]> = () => ({}),
+    {
+      checkpointIndex = 0,
+      numL1ToL2Messages = 0,
+      blockNumber = this.blockNumber,
+      makeProcessedTxOpts = () => ({}),
+    }: {
+      checkpointIndex?: number;
+      numL1ToL2Messages?: number;
+      blockNumber?: number;
+      makeProcessedTxOpts?: (index: number) => Partial<Parameters<typeof makeBloatedProcessedTx>[0]>;
+    } = {},
   ) {
-    const globalVariables = typeof blockNumOrGlobals === 'number' ? makeGlobals(blockNumOrGlobals) : blockNumOrGlobals;
+    const slotNumber = this.firstCheckpointNumber.toNumber() + checkpointIndex;
+    const globalVariables = makeGlobals(blockNumber, slotNumber);
     const blockNum = globalVariables.blockNumber;
     const db = await this.worldState.fork();
     const l1ToL2Messages = times(numL1ToL2Messages, i => new Fr(blockNum * 100 + i));
@@ -202,11 +225,83 @@ export class TestContext {
     await this.setTreeRoots(txs);
 
     const block = await buildBlockWithCleanDB(txs, globalVariables, l1ToL2Messages, db);
-    this.headers.set(blockNum, block.header);
+    this.headers.set(blockNum, block.getBlockHeader());
     await this.worldState.handleL2BlockAndMessages(block, l1ToL2Messages);
     return { block, txs, l1ToL2Messages };
   }
 
+  public async makePendingBlocksInCheckpoint(
+    numBlocks: number,
+    {
+      checkpointIndex = 0,
+      numTxsPerBlock = 1,
+      numL1ToL2Messages = 0,
+      firstBlockNumber = this.blockNumber + checkpointIndex * numBlocks,
+      makeProcessedTxOpts = () => ({}),
+    }: {
+      checkpointIndex?: number;
+      numTxsPerBlock?: number | number[];
+      numL1ToL2Messages?: number;
+      firstBlockNumber?: number;
+      makeProcessedTxOpts?: (index: number) => Partial<Parameters<typeof makeBloatedProcessedTx>[0]>;
+    } = {},
+  ) {
+    const slotNumber = this.firstCheckpointNumber.toNumber() + checkpointIndex;
+    const l1ToL2Messages = times(numL1ToL2Messages, i => new Fr(slotNumber * 100 + i));
+    const merkleTrees = await this.worldState.fork();
+    await merkleTrees.appendLeaves(
+      MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
+      padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP),
+    );
+    const newL1ToL2Snapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, merkleTrees);
+
+    const blockGlobalVariables = times(numBlocks, i => makeGlobals(firstBlockNumber + i, slotNumber));
+    let totalTxs = 0;
+    const blockTxs = await timesParallel(numBlocks, blockIndex => {
+      const txIndexOffset = totalTxs;
+      const numTxs = typeof numTxsPerBlock === 'number' ? numTxsPerBlock : numTxsPerBlock[blockIndex];
+      totalTxs += numTxs;
+      return timesParallel(numTxs, txIndex =>
+        this.makeProcessedTx({
+          seed: (txIndexOffset + txIndex + 1) * 321 + (checkpointIndex + 1) * 123456,
+          globalVariables: blockGlobalVariables[blockIndex],
+          header: this.getBlockHeader(firstBlockNumber - 1),
+          newL1ToL2Snapshot,
+          ...makeProcessedTxOpts(txIndexOffset + txIndex),
+        }),
+      );
+    });
+
+    const blockBlobFields = blockTxs.map(txs => getBlockBlobFields(txs.map(tx => tx.txEffect)));
+    const totalNumBlobFields = blockBlobFields.reduce((acc, curr) => acc + curr.length, 0);
+    const spongeBlobState = SpongeBlob.init(totalNumBlobFields);
+
+    const blocks: { header: BlockHeader; txs: ProcessedTx[] }[] = [];
+    for (let i = 0; i < numBlocks; i++) {
+      const isFirstBlock = i === 0;
+      const blockNumber = firstBlockNumber + i;
+      const globalVariables = blockGlobalVariables[i];
+      const txs = blockTxs[i];
+
+      await this.setTreeRoots(txs);
+
+      const fork = await this.worldState.fork();
+      const blockMsgs = isFirstBlock ? l1ToL2Messages : [];
+      const block = await buildBlockWithCleanDB(txs, globalVariables, blockMsgs, fork, spongeBlobState, isFirstBlock);
+
+      const header = block.getBlockHeader();
+      this.headers.set(blockNumber, header);
+
+      await this.worldState.handleL2BlockAndMessages(block, blockMsgs, isFirstBlock);
+
+      await spongeBlobState.absorb(blockBlobFields[i]);
+
+      blocks.push({ header, txs });
+    }
+
+    return { blocks, l1ToL2Messages, blobFields: blockBlobFields.flat() };
+  }
+
   public async processPublicFunctions(
     txs: Tx[],
     {
@@ -265,12 +360,9 @@ class TestProvingOrchestrator extends ProvingOrchestrator {
 
   // Disable this check by default, since it requires seeding world state with the block being built
   // This is only enabled in some tests with multiple blocks that populate the pending chain via makePendingBlock
-  protected override verifyBuiltBlockAgainstSyncedState(
-    l2Block: L2Block,
-    newArchive: AppendOnlyTreeSnapshot,
-  ): Promise<void> {
+  protected override verifyBuiltBlockAgainstSyncedState(provingState: BlockProvingState): Promise<void> {
     if (this.isVerifyBuiltBlockAgainstSyncedStateEnabled) {
-      return super.verifyBuiltBlockAgainstSyncedState(l2Block, newArchive);
+      return super.verifyBuiltBlockAgainstSyncedState(provingState);
     }
     return Promise.resolve();
   }

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

@@ -1,4 +1,4 @@
-import { BatchedBlobAccumulator, Blob, type SpongeBlob } from '@aztec/blob-lib';
+import { BatchedBlob, BatchedBlobAccumulator, Blob, SpongeBlob } from '@aztec/blob-lib';
 import {
   ARCHIVE_HEIGHT,
   CIVC_PROOF_LENGTH,
@@ -20,19 +20,16 @@ import { BLS12Point, Fr } from '@aztec/foundation/fields';
 import { type Bufferable, type Tuple, assertLength, toFriendlyJSON } from '@aztec/foundation/serialize';
 import { MembershipWitness, MerkleTreeCalculator, computeUnbalancedMerkleTreeRoot } from '@aztec/foundation/trees';
 import { getVkData } from '@aztec/noir-protocol-circuits-types/server/vks';
-import { getVKIndex, getVKSiblingPath, getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { computeFeePayerBalanceLeafSlot } from '@aztec/protocol-contracts/fee-juice';
 import { PublicDataHint } from '@aztec/stdlib/avm';
-import { Body } from '@aztec/stdlib/block';
+import { Body, L2BlockHeader, getBlockBlobFields } from '@aztec/stdlib/block';
 import type { MerkleTreeWriteOperations, PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
 import { ContractClassLogFields } from '@aztec/stdlib/logs';
-import type { ParityPublicInputs } from '@aztec/stdlib/parity';
 import { Proof, ProofData, RecursiveProof } from '@aztec/stdlib/proofs';
 import {
-  type BaseOrMergeRollupPublicInputs,
   BlockConstantData,
-  type BlockRootOrBlockMergePublicInputs,
+  BlockRollupPublicInputs,
   PrivateBaseRollupHints,
   PrivateBaseStateDiffHints,
   PublicBaseRollupHints,
@@ -49,12 +46,11 @@ import {
 import {
   BlockHeader,
   ContentCommitment,
-  type GlobalVariables,
+  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';
@@ -76,14 +72,14 @@ export const insertSideEffectsAndBuildBaseRollupHints = runInSpan(
   async (
     span: Span,
     tx: ProcessedTx,
-    globalVariables: GlobalVariables,
+    lastArchive: AppendOnlyTreeSnapshot,
     newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot,
-    db: MerkleTreeWriteOperations,
     startSpongeBlob: SpongeBlob,
+    proverId: Fr,
+    db: MerkleTreeWriteOperations,
   ) => {
     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),
@@ -141,17 +137,13 @@ export const insertSideEffectsAndBuildBaseRollupHints = runInSpan(
       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,
       i => tx.txEffect.contractClassLogs[i]?.fields || ContractClassLogFields.empty(),
     );
 
     if (tx.avmProvingRequest) {
-      const blockHash = await tx.data.constants.historicalHeader.hash();
+      const blockHash = await tx.data.constants.anchorBlockHeader.hash();
       const archiveRootMembershipWitness = await getMembershipWitnessFor(
         blockHash,
         MerkleTreeId.ARCHIVE,
@@ -160,10 +152,11 @@ export const insertSideEffectsAndBuildBaseRollupHints = runInSpan(
       );
 
       return PublicBaseRollupHints.from({
-        startSpongeBlob: inputSpongeBlob,
+        startSpongeBlob,
         lastArchive,
         archiveRootMembershipWitness,
         contractClassLogsFields,
+        proverId,
       });
     } else {
       if (
@@ -203,7 +196,7 @@ export const insertSideEffectsAndBuildBaseRollupHints = runInSpan(
         feeWriteSiblingPath,
       });
 
-      const blockHash = await tx.data.constants.historicalHeader.hash();
+      const blockHash = await tx.data.constants.anchorBlockHeader.hash();
       const archiveRootMembershipWitness = await getMembershipWitnessFor(
         blockHash,
         MerkleTreeId.ARCHIVE,
@@ -213,15 +206,16 @@ export const insertSideEffectsAndBuildBaseRollupHints = runInSpan(
 
       const constants = BlockConstantData.from({
         lastArchive,
-        newL1ToL2: newL1ToL2MessageTreeSnapshot,
-        vkTreeRoot: getVKTreeRoot(),
-        protocolContractTreeRoot,
-        globalVariables,
+        l1ToL2TreeSnapshot: newL1ToL2MessageTreeSnapshot,
+        vkTreeRoot: tx.data.constants.vkTreeRoot,
+        protocolContractTreeRoot: tx.data.constants.protocolContractTreeRoot,
+        globalVariables: tx.globalVariables,
+        proverId,
       });
 
       return PrivateBaseRollupHints.from({
         start,
-        startSpongeBlob: inputSpongeBlob,
+        startSpongeBlob,
         stateDiffHints,
         feePayerFeeJuiceBalanceReadHint,
         archiveRootMembershipWitness,
@@ -269,11 +263,13 @@ export function getPublicTubePrivateInputsFromTx(tx: Tx | ProcessedTx) {
   return new PublicTubePrivateInputs(proofData);
 }
 
+// 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 blob fields.
 export const buildBlobHints = runInSpan(
   'BlockBuilderHelpers',
   'buildBlobHints',
-  async (_span: Span, txEffects: TxEffect[]) => {
-    const blobFields = txEffects.flatMap(tx => tx.toBlobFields());
+  async (_span: Span, blobFields: Fr[]) => {
     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.
@@ -282,15 +278,26 @@ export const buildBlobHints = runInSpan(
     // 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 };
+    return { blobCommitments, blobs, blobsHash };
   },
 );
 
+// Build the data required to prove the txs in an epoch. Currently only used in tests.
+export const buildBlobDataFromTxs = async (txsPerCheckpoint: ProcessedTx[][]) => {
+  const blobFields = txsPerCheckpoint.map(txs => getBlockBlobFields(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 = await Promise.all(blobFieldsPerCheckpoint.map(blobFields => Blob.getBlobsPerBlock(blobFields)));
+  return await BatchedBlob.precomputeBatchedBlobChallenges(blobs.flat());
+};
+
 export const accumulateBlobs = runInSpan(
   'BlockBuilderHelpers',
   'accumulateBlobs',
-  async (_span: Span, txs: ProcessedTx[], startBlobAccumulator: BatchedBlobAccumulator) => {
-    const blobFields = txs.flatMap(tx => tx.txEffect.toBlobFields());
+  async (_span: Span, blobFields: Fr[], startBlobAccumulator: BatchedBlobAccumulator) => {
     const blobs = await Blob.getBlobsPerBlock(blobFields);
     const endBlobAccumulator = startBlobAccumulator.accumulateBlobs(blobs);
     return endBlobAccumulator;
@@ -300,36 +307,28 @@ export const accumulateBlobs = runInSpan(
 export const buildHeaderFromCircuitOutputs = runInSpan(
   'BlockBuilderHelpers',
   'buildHeaderFromCircuitOutputs',
-  (
-    _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);
+  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,
+    });
 
-    const accumulatedFees = previousRollupData.reduce((sum, d) => sum.add(d.accumulatedFees), Fr.ZERO);
-    const accumulatedManaUsed = previousRollupData.reduce((sum, d) => sum.add(d.accumulatedManaUsed), Fr.ZERO);
+    const spongeBlobHash = await blockRootRollupOutput.endSpongeBlob.clone().squeeze();
 
     return new BlockHeader(
-      rootRollupOutputs.previousArchive,
-      contentCommitment,
-      endState,
-      rootRollupOutputs.endGlobalVariables,
-      accumulatedFees,
-      accumulatedManaUsed,
+      blockRootRollupOutput.previousArchive,
+      blockRootRollupOutput.endState,
+      spongeBlobHash,
+      globalVariables,
+      blockRootRollupOutput.accumulatedFees,
+      blockRootRollupOutput.accumulatedManaUsed,
     );
   },
 );
@@ -343,6 +342,7 @@ export const buildHeaderAndBodyFromTxs = runInSpan(
     globalVariables: GlobalVariables,
     l1ToL2Messages: Fr[],
     db: MerkleTreeReadOperations,
+    startSpongeBlob?: SpongeBlob,
   ) => {
     span.setAttribute(Attributes.BLOCK_NUMBER, globalVariables.blockNumber);
     const stateReference = new StateReference(
@@ -363,19 +363,67 @@ export const buildHeaderAndBodyFromTxs = runInSpan(
     const outHash = txOutHashes.length === 0 ? Fr.ZERO : new Fr(computeUnbalancedMerkleTreeRoot(txOutHashes));
 
     const parityShaRoot = await computeInHashFromL1ToL2Messages(l1ToL2Messages);
-    const blobsHash = getBlobsHashFromBlobs(await Blob.getBlobsPerBlock(body.toBlobFields()));
+    const blobFields = body.toBlobFields();
+    const blobsHash = getBlobsHashFromBlobs(await Blob.getBlobsPerBlock(blobFields));
 
     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 header = new BlockHeader(previousArchive, contentCommitment, stateReference, globalVariables, fees, manaUsed);
+    const endSpongeBlob = startSpongeBlob?.clone() ?? SpongeBlob.init(blobFields.length);
+    await endSpongeBlob.absorb(blobFields);
+    const spongeBlobHash = await endSpongeBlob.squeeze();
+
+    const header = new L2BlockHeader(
+      previousArchive,
+      contentCommitment,
+      stateReference,
+      globalVariables,
+      fees,
+      manaUsed,
+      spongeBlobHash,
+    );
 
     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(unpaddedL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
@@ -398,40 +446,6 @@ export async function getEmptyBlockBlobsHash(): Promise<Fr> {
   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);
@@ -564,7 +578,7 @@ function validateSimulatedTree(
 }
 
 export function validateTx(tx: ProcessedTx) {
-  const txHeader = tx.data.constants.historicalHeader;
+  const txHeader = tx.data.constants.anchorBlockHeader;
   if (txHeader.state.l1ToL2MessageTree.isEmpty()) {
     throw new Error(`Empty L1 to L2 messages tree in tx: ${toFriendlyJSON(tx)}`);
   }