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

package/dest/orchestrator/block-building-helpers.d.ts

@@ -1,13 +1,14 @@
-import { BatchedBlobAccumulator, SpongeBlob } from '@aztec/blob-lib';
-import { Fr } from '@aztec/foundation/fields';
-import { type Bufferable, type Tuple } from '@aztec/foundation/serialize';
+import { BatchedBlobAccumulator, Blob, type SpongeBlob } from '@aztec/blob-lib';
+import { BLS12Point, Fr } from '@aztec/foundation/fields';
+import { type Tuple } from '@aztec/foundation/serialize';
 import { MembershipWitness } from '@aztec/foundation/trees';
-import { Body, L2BlockHeader } from '@aztec/stdlib/block';
-import type { MerkleTreeWriteOperations, PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
-import { ProofData, RecursiveProof } from '@aztec/stdlib/proofs';
-import { BlockRollupPublicInputs, PrivateBaseRollupHints, PublicBaseRollupHints, PublicChonkVerifierPrivateInputs } from '@aztec/stdlib/rollup';
+import { PublicDataHint } from '@aztec/stdlib/avm';
+import { Body } from '@aztec/stdlib/block';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import type { ParityPublicInputs } from '@aztec/stdlib/parity';
+import { type BaseOrMergeRollupPublicInputs, type BlockRootOrBlockMergePublicInputs, PrivateBaseRollupHints, PublicBaseRollupHints } from '@aztec/stdlib/rollup';
 import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
-import { BlockHeader, GlobalVariables, PartialStateReference, type ProcessedTx, Tx } from '@aztec/stdlib/tx';
+import { BlockHeader, type GlobalVariables, PartialStateReference, type ProcessedTx, StateReference, TxEffect } from '@aztec/stdlib/tx';
 import type { MerkleTreeReadOperations } from '@aztec/world-state';
 /**
  * Type representing the names of the trees for the base rollup.
@@ -17,40 +18,38 @@ type BaseTreeNames = 'NoteHashTree' | 'ContractTree' | 'NullifierTree' | 'Public
  * Type representing the names of the trees.
  */
 export type TreeNames = BaseTreeNames | 'L1ToL2MessageTree' | 'Archive';
-export declare const insertSideEffectsAndBuildBaseRollupHints: (tx: ProcessedTx, lastArchive: AppendOnlyTreeSnapshot, newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, startSpongeBlob: SpongeBlob, proverId: Fr, db: MerkleTreeWriteOperations) => Promise<PublicBaseRollupHints | PrivateBaseRollupHints>;
-export declare function getChonkProofFromTx(tx: Tx | ProcessedTx): RecursiveProof<2084>;
-export declare function getPublicChonkVerifierPrivateInputsFromTx(tx: Tx | ProcessedTx, proverId: Fr): PublicChonkVerifierPrivateInputs;
-export declare const buildBlobHints: (blobFields: Fr[]) => {
-    blobCommitments: import("@aztec/foundation/fields").BLS12Point[];
-    blobs: import("@aztec/blob-lib").Blob[];
+export declare const insertSideEffectsAndBuildBaseRollupHints: (tx: ProcessedTx, globalVariables: GlobalVariables, newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, db: MerkleTreeWriteOperations, startSpongeBlob: SpongeBlob) => Promise<PublicBaseRollupHints | PrivateBaseRollupHints>;
+export declare function getPublicDataHint(db: MerkleTreeWriteOperations, leafSlot: bigint): Promise<PublicDataHint>;
+export declare const buildBlobHints: (txEffects: TxEffect[]) => Promise<{
+    blobFields: Fr[];
+    blobCommitments: BLS12Point[];
+    blobs: Blob[];
     blobsHash: Fr;
-};
-export declare const buildBlobDataFromTxs: (txsPerCheckpoint: ProcessedTx[][]) => Promise<{
-    blobFieldsLengths: number[];
-    finalBlobChallenges: import("@aztec/blob-lib").FinalBlobBatchingChallenges;
 }>;
-export declare const buildFinalBlobChallenges: (blobFieldsPerCheckpoint: Fr[][]) => Promise<import("@aztec/blob-lib").FinalBlobBatchingChallenges>;
-export declare const accumulateBlobs: (blobFields: Fr[], startBlobAccumulator: BatchedBlobAccumulator) => Promise<BatchedBlobAccumulator>;
-export declare const buildHeaderFromCircuitOutputs: (blockRootRollupOutput: BlockRollupPublicInputs) => Promise<BlockHeader>;
-export declare const buildHeaderAndBodyFromTxs: (txs: ProcessedTx[], globalVariables: GlobalVariables, l1ToL2Messages: Fr[], db: MerkleTreeReadOperations, startSpongeBlob?: SpongeBlob | undefined) => Promise<{
-    header: L2BlockHeader;
+export declare const accumulateBlobs: (txs: ProcessedTx[], startBlobAccumulator: BatchedBlobAccumulator) => Promise<BatchedBlobAccumulator>;
+export declare const buildHeaderFromCircuitOutputs: (previousRollupData: BaseOrMergeRollupPublicInputs[], parityPublicInputs: ParityPublicInputs, rootRollupOutputs: BlockRootOrBlockMergePublicInputs, blobsHash: Fr, endState: StateReference) => BlockHeader;
+export declare const buildHeaderAndBodyFromTxs: (txs: ProcessedTx[], globalVariables: GlobalVariables, l1ToL2Messages: Fr[], db: MerkleTreeReadOperations) => Promise<{
+    header: BlockHeader;
     body: Body;
 }>;
-export declare const buildBlockHeaderFromTxs: (txs: ProcessedTx[], globalVariables: GlobalVariables, startSpongeBlob: SpongeBlob, db: MerkleTreeReadOperations) => Promise<BlockHeader>;
 /** Computes the inHash for a block's ContentCommitment given its l1 to l2 messages. */
 export declare function computeInHashFromL1ToL2Messages(unpaddedL1ToL2Messages: Fr[]): Promise<Fr>;
+export declare function getBlobsHashFromBlobs(inputs: Blob[]): Fr;
+export declare function getEmptyBlockBlobsHash(): Promise<Fr>;
+export declare function validateBlockRootOutput(blockRootOutput: BlockRootOrBlockMergePublicInputs, blockHeader: BlockHeader, db: MerkleTreeReadOperations): Promise<void>;
+export declare const validateState: (state: StateReference, db: MerkleTreeReadOperations) => Promise<void>;
 export declare function getLastSiblingPath<TID extends MerkleTreeId>(treeId: TID, db: MerkleTreeReadOperations): Promise<Tuple<Fr, {
-    readonly 1: 42;
-    readonly 4: 30;
-    readonly 3: 36;
-    readonly 0: 42;
+    readonly 1: 40;
+    readonly 4: 29;
+    readonly 3: 39;
+    readonly 0: 40;
     readonly 2: 40;
 }[TID]>>;
 export declare function getRootTreeSiblingPath<TID extends MerkleTreeId>(treeId: TID, db: MerkleTreeReadOperations): Promise<Tuple<Fr, {
-    readonly 1: 42;
-    readonly 4: 30;
-    readonly 3: 36;
-    readonly 0: 42;
+    readonly 1: 40;
+    readonly 4: 29;
+    readonly 3: 39;
+    readonly 0: 40;
     readonly 2: 40;
 }[TID]>>;
 export declare function getTreeSnapshot(id: MerkleTreeId, db: MerkleTreeReadOperations): Promise<AppendOnlyTreeSnapshot>;
@@ -59,6 +58,5 @@ export declare function getSubtreeSiblingPath(treeId: MerkleTreeId, subtreeHeigh
 export declare function getMembershipWitnessFor<N extends number>(value: Fr, treeId: MerkleTreeId, height: N, db: MerkleTreeReadOperations): Promise<MembershipWitness<N>>;
 export declare function validatePartialState(partialState: PartialStateReference, treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>): void;
 export declare function validateTx(tx: ProcessedTx): void;
-export declare function toProofData<T extends Bufferable, PROOF_LENGTH extends number>({ inputs, proof, verificationKey }: PublicInputsAndRecursiveProof<T, PROOF_LENGTH>, vkIndex?: number): ProofData<T, PROOF_LENGTH>;
 export {};
 //# sourceMappingURL=block-building-helpers.d.ts.map

package/dest/orchestrator/block-building-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block-building-helpers.d.ts","sourceRoot":"","sources":["../../src/orchestrator/block-building-helpers.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"block-building-helpers.d.ts","sourceRoot":"","sources":["../../src/orchestrator/block-building-helpers.ts"],"names":[],"mappings":"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"}

package/dest/orchestrator/block-building-helpers.js

@@ -1,190 +1,170 @@
-import { BatchedBlob, SpongeBlob, computeBlobsHashFromBlobs, getBlobCommitmentsFromBlobs, getBlobsPerL1Block } 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, NULLIFIER_SUBTREE_HEIGHT, NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH, NULLIFIER_TREE_HEIGHT, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, PUBLIC_DATA_TREE_HEIGHT } from '@aztec/constants';
+import { Blob } from '@aztec/blob-lib';
+import { ARCHIVE_HEIGHT, MAX_CONTRACT_CLASS_LOGS_PER_TX, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NOTE_HASH_SUBTREE_HEIGHT, NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH, NULLIFIER_SUBTREE_HEIGHT, 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 { sha256ToField, sha256Trunc } from '@aztec/foundation/crypto';
+import { BLS12Point, Fr } from '@aztec/foundation/fields';
 import { 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 { 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 { PublicDataHint } from '@aztec/stdlib/avm';
+import { Body } from '@aztec/stdlib/block';
 import { ContractClassLogFields } from '@aztec/stdlib/logs';
-import { Proof, ProofData, RecursiveProof } from '@aztec/stdlib/proofs';
-import { BlockConstantData, PrivateBaseRollupHints, PublicBaseRollupHints, PublicChonkVerifierPrivateInputs, TreeSnapshotDiffHints } from '@aztec/stdlib/rollup';
-import { AppendOnlyTreeSnapshot, MerkleTreeId, NullifierLeafPreimage, PublicDataTreeLeaf, getTreeHeight } from '@aztec/stdlib/trees';
-import { BlockHeader, ContentCommitment, GlobalVariables, PartialStateReference, StateReference } from '@aztec/stdlib/tx';
-import { VkData } from '@aztec/stdlib/vks';
+import { BlockConstantData, PrivateBaseRollupHints, PrivateBaseStateDiffHints, PublicBaseRollupHints } from '@aztec/stdlib/rollup';
+import { AppendOnlyTreeSnapshot, MerkleTreeId, NullifierLeafPreimage, PublicDataTreeLeaf, PublicDataTreeLeafPreimage, getTreeHeight } from '@aztec/stdlib/trees';
+import { BlockHeader, ContentCommitment, PartialStateReference, StateReference } from '@aztec/stdlib/tx';
 import { Attributes, runInSpan } from '@aztec/telemetry-client';
 // Builds the hints for base rollup. Updating the contract, nullifier, and data trees in the process.
-export const insertSideEffectsAndBuildBaseRollupHints = runInSpan('BlockBuilderHelpers', 'buildBaseRollupHints', async (span, tx, lastArchive, newL1ToL2MessageTreeSnapshot, startSpongeBlob, proverId, db)=>{
+export const insertSideEffectsAndBuildBaseRollupHints = runInSpan('BlockBuilderHelpers', 'buildBaseRollupHints', async (span, tx, globalVariables, newL1ToL2MessageTreeSnapshot, db, startSpongeBlob)=>{
     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 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);
+    // Get the subtree sibling paths for the circuit
+    const noteHashSubtreeSiblingPathArray = await getSubtreeSiblingPath(MerkleTreeId.NOTE_HASH_TREE, NOTE_HASH_SUBTREE_HEIGHT, db);
+    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
     // that will be used by the next iteration of the base rollup circuit, skipping the empty ones
     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);
     // Update the nullifier tree, capturing the low nullifier info for each individual operation
-    const { lowLeavesWitnessData: nullifierWitnessLeaves, newSubtreeSiblingPath: nullifiersSubtreeRootSiblingPath, sortedNewLeaves: sortedNullifiers, sortedNewLeavesIndexes } = await db.batchInsert(MerkleTreeId.NULLIFIER_TREE, padArrayEnd(tx.txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map((n)=>n.toBuffer()), NULLIFIER_SUBTREE_HEIGHT);
+    const { lowLeavesWitnessData: nullifierWitnessLeaves, newSubtreeSiblingPath: nullifiersSubtreeSiblingPath, sortedNewLeaves: sortednullifiers, sortedNewLeavesIndexes } = await db.batchInsert(MerkleTreeId.NULLIFIER_TREE, padArrayEnd(tx.txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map((n)=>n.toBuffer()), NULLIFIER_SUBTREE_HEIGHT);
     if (nullifierWitnessLeaves === undefined) {
         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 = 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, (i)=>tx.txEffect.contractClassLogs[i]?.fields || ContractClassLogFields.empty());
     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 {
         if (txPublicDataUpdateRequestInfo.lowPublicDataWritesMembershipWitnesses.length > 1 || txPublicDataUpdateRequestInfo.lowPublicDataWritesPreimages.length > 1 || txPublicDataUpdateRequestInfo.publicDataWritesSiblingPaths.length > 1) {
             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 = 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), NullifierLeafPreimage.empty(), MAX_NULLIFIERS_PER_TX),
+        const feeWriteLowLeafPreimage = txPublicDataUpdateRequestInfo.lowPublicDataWritesPreimages[0] || PublicDataTreeLeafPreimage.empty();
+        const feeWriteLowLeafMembershipWitness = txPublicDataUpdateRequestInfo.lowPublicDataWritesMembershipWitnesses[0] || MembershipWitness.empty(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 : 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
         });
     }
 });
-export function getChonkProofFromTx(tx) {
-    const publicInputs = tx.data.publicInputs().toFields();
-    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);
-}
-export function getPublicChonkVerifierPrivateInputsFromTx(tx, proverId) {
-    const proofData = new ProofData(tx.data.toPrivateToPublicKernelCircuitPublicInputs(), getChonkProofFromTx(tx), getVkData('HidingKernelToPublic'));
-    return new PublicChonkVerifierPrivateInputs(proofData, proverId);
+export async function getPublicDataHint(db, leafSlot) {
+    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 siblingPath = await db.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, index);
+    const membershipWitness = new MembershipWitness(PUBLIC_DATA_TREE_HEIGHT, index, siblingPath.toTuple());
+    const leafPreimage = await db.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, index);
+    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)=>{
-    const blobs = getBlobsPerL1Block(blobFields);
-    const blobCommitments = getBlobCommitmentsFromBlobs(blobs);
-    const blobsHash = computeBlobsHashFromBlobs(blobs);
+export const buildBlobHints = runInSpan('BlockBuilderHelpers', 'buildBlobHints', async (_span, txEffects)=>{
+    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
     };
-};
-// 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)=>{
-    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)=>{
-    const blobs = blobFieldsPerCheckpoint.map((blobFields)=>getBlobsPerL1Block(blobFields));
-    return await BatchedBlob.precomputeBatchedBlobChallenges(blobs);
-};
-export const accumulateBlobs = runInSpan('BlockBuilderHelpers', 'accumulateBlobs', async (_span, blobFields, startBlobAccumulator)=>{
-    const blobs = getBlobsPerL1Block(blobFields);
-    const endBlobAccumulator = await startBlobAccumulator.accumulateBlobs(blobs);
+});
+export const accumulateBlobs = runInSpan('BlockBuilderHelpers', 'accumulateBlobs', async (_span, txs, startBlobAccumulator)=>{
+    const blobFields = txs.flatMap((tx)=>tx.txEffect.toBlobFields());
+    const blobs = await Blob.getBlobsPerBlock(blobFields);
+    const endBlobAccumulator = startBlobAccumulator.accumulateBlobs(blobs);
     return endBlobAccumulator;
 });
-export const buildHeaderFromCircuitOutputs = runInSpan('BlockBuilderHelpers', 'buildHeaderFromCircuitOutputs', async (_span, blockRootRollupOutput)=>{
-    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 spongeBlobHash = await blockRootRollupOutput.endSpongeBlob.clone().squeeze();
-    return new BlockHeader(blockRootRollupOutput.previousArchive, blockRootRollupOutput.endState, spongeBlobHash, globalVariables, blockRootRollupOutput.accumulatedFees, blockRootRollupOutput.accumulatedManaUsed);
+export const buildHeaderFromCircuitOutputs = runInSpan('BlockBuilderHelpers', 'buildHeaderFromCircuitOutputs', (_span, previousRollupData, parityPublicInputs, rootRollupOutputs, blobsHash, endState)=>{
+    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 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(rootRollupOutputs.previousArchive, contentCommitment, endState, rootRollupOutputs.endGlobalVariables, accumulatedFees, accumulatedManaUsed);
 });
-export const buildHeaderAndBodyFromTxs = runInSpan('BlockBuilderHelpers', 'buildHeaderAndBodyFromTxs', async (span, txs, globalVariables, l1ToL2Messages, db, startSpongeBlob)=>{
+export const buildHeaderAndBodyFromTxs = runInSpan('BlockBuilderHelpers', 'buildHeaderAndBodyFromTxs', async (span, txs, globalVariables, l1ToL2Messages, db)=>{
     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 txEffects = txs.map((tx)=>tx.txEffect);
     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, globalVariables, startSpongeBlob, db)=>{
-    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) {
     const l1ToL2Messages = padArrayEnd(unpaddedL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
     const hasher = (left, right)=>Promise.resolve(sha256Trunc(Buffer.concat([
@@ -195,6 +175,42 @@ export const buildBlockHeaderFromTxs = runInSpan('BlockBuilderHelpers', 'buildBl
     const parityCalculator = await MerkleTreeCalculator.create(parityHeight, Fr.ZERO.toBuffer(), hasher);
     return new Fr(await parityCalculator.computeTreeRoot(l1ToL2Messages.map((msg)=>msg.toBuffer())));
 }
+export function getBlobsHashFromBlobs(inputs) {
+    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() {
+    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, blockHeader, db) {
+    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, db)=>{
+    const promises = [
+        MerkleTreeId.NOTE_HASH_TREE,
+        MerkleTreeId.NULLIFIER_TREE,
+        MerkleTreeId.PUBLIC_DATA_TREE
+    ].map(async (id)=>{
+        return {
+            key: id,
+            value: await getTreeSnapshot(id, db)
+        };
+    });
+    const snapshots = 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(treeId, db) {
     const { size } = await db.getTreeInfo(treeId);
     const path = await db.getSiblingPath(treeId, size - 1n);
@@ -270,7 +286,7 @@ function validateSimulatedTree(localTree, simulatedTree, name, label) {
     }
 }
 export function validateTx(tx) {
-    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)}`);
     }
@@ -284,8 +300,3 @@ export function validateTx(tx) {
         throw new Error(`Empty public data tree in tx: ${toFriendlyJSON(tx)}`);
     }
 }
-export function toProofData({ inputs, proof, verificationKey }, vkIndex) {
-    const leafIndex = vkIndex || getVKIndex(verificationKey.keyAsFields);
-    const vkData = new VkData(verificationKey, leafIndex, getVKSiblingPath(leafIndex));
-    return new ProofData(inputs, proof, vkData);
-}