@aztec/prover-client 3.0.0-canary.a9708bd → 3.0.0-manual.20251030

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

@@ -1,170 +1,190 @@
-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 { 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 { makeTuple } from '@aztec/foundation/array';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { sha256ToField, sha256Trunc } from '@aztec/foundation/crypto';
-import { BLS12Point, Fr } from '@aztec/foundation/fields';
+import { sha256Trunc } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
 import { 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 { 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 { 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 { getCheckpointBlobFields } from '@aztec/stdlib/checkpoint';
 import { ContractClassLogFields } from '@aztec/stdlib/logs';
-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 { 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 { 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, globalVariables, newL1ToL2MessageTreeSnapshot, db, startSpongeBlob)=>{
+export const insertSideEffectsAndBuildBaseRollupHints = runInSpan('BlockBuilderHelpers', 'buildBaseRollupHints', async (span, tx, lastArchive, newL1ToL2MessageTreeSnapshot, startSpongeBlob, proverId, db)=>{
     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);
-    const noteHashSubtreeSiblingPath = makeTuple(NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH, (i)=>i < noteHashSubtreeSiblingPathArray.length ? noteHashSubtreeSiblingPathArray[i] : Fr.ZERO);
+    // 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);
     // 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: 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);
+    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);
     if (nullifierWitnessLeaves === undefined) {
         throw new Error(`Could not craft nullifier batch insertion proofs`);
     }
-    // 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 blockHash = await tx.data.constants.anchorBlockHeader.hash();
+    const anchorBlockArchiveSiblingPath = (await getMembershipWitnessFor(blockHash, MerkleTreeId.ARCHIVE, ARCHIVE_HEIGHT, db)).siblingPath;
     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: inputSpongeBlob,
+            startSpongeBlob,
             lastArchive,
-            archiveRootMembershipWitness,
+            anchorBlockArchiveSiblingPath,
             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`);
         }
-        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()),
+        // 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),
             nullifierPredecessorMembershipWitnesses: makeTuple(MAX_NULLIFIERS_PER_TX, (i)=>i < nullifierPredecessorMembershipWitnessesWithoutPadding.length ? nullifierPredecessorMembershipWitnessesWithoutPadding[i] : makeEmptyMembershipWitness(NULLIFIER_TREE_HEIGHT)),
-            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
+            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
         });
-        const blockHash = await tx.data.constants.historicalHeader.hash();
-        const archiveRootMembershipWitness = await getMembershipWitnessFor(blockHash, MerkleTreeId.ARCHIVE, ARCHIVE_HEIGHT, db);
         const constants = BlockConstantData.from({
             lastArchive,
-            newL1ToL2: newL1ToL2MessageTreeSnapshot,
-            vkTreeRoot: getVKTreeRoot(),
-            protocolContractTreeRoot,
-            globalVariables
+            l1ToL2TreeSnapshot: newL1ToL2MessageTreeSnapshot,
+            vkTreeRoot: tx.data.constants.vkTreeRoot,
+            protocolContractsHash: tx.data.constants.protocolContractsHash,
+            globalVariables: tx.globalVariables,
+            proverId
         });
         return PrivateBaseRollupHints.from({
             start,
-            startSpongeBlob: inputSpongeBlob,
-            stateDiffHints,
-            feePayerFeeJuiceBalanceReadHint,
-            archiveRootMembershipWitness,
+            startSpongeBlob,
+            treeSnapshotDiffHints,
+            feePayerBalanceLeafPreimage,
+            anchorBlockArchiveSiblingPath,
             contractClassLogsFields,
             constants
         });
     }
 });
-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);
+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 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));
+export function getPublicChonkVerifierPrivateInputsFromTx(tx, proverId) {
+    const proofData = new ProofData(tx.data.toPrivateToPublicKernelCircuitPublicInputs(), getChonkProofFromTx(tx), getVkData('HidingKernelToPublic'));
+    return new PublicChonkVerifierPrivateInputs(proofData, proverId);
+}
+// 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);
     return {
-        blobFields,
         blobCommitments,
         blobs,
         blobsHash
     };
-});
-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);
+};
+// 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);
     return endBlobAccumulator;
 });
-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 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 buildHeaderAndBodyFromTxs = runInSpan('BlockBuilderHelpers', 'buildHeaderAndBodyFromTxs', async (span, txs, globalVariables, l1ToL2Messages, db)=>{
+export const buildHeaderAndBodyFromTxs = runInSpan('BlockBuilderHelpers', 'buildHeaderAndBodyFromTxs', async (span, txs, globalVariables, l1ToL2Messages, db, startSpongeBlob)=>{
     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(computeUnbalancedMerkleTreeRoot(txOutHashes));
+    const outHash = txOutHashes.length === 0 ? Fr.ZERO : new Fr(computeCompressedUnbalancedMerkleTreeRoot(txOutHashes));
     const parityShaRoot = await computeInHashFromL1ToL2Messages(l1ToL2Messages);
-    const blobsHash = getBlobsHashFromBlobs(await Blob.getBlobsPerBlock(body.toBlobFields()));
+    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 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() ?? 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);
     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([
@@ -175,42 +195,6 @@ export const buildHeaderAndBodyFromTxs = runInSpan('BlockBuilderHelpers', 'build
     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);
@@ -286,7 +270,7 @@ function validateSimulatedTree(localTree, simulatedTree, name, label) {
     }
 }
 export function validateTx(tx) {
-    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)}`);
     }
@@ -300,3 +284,8 @@ 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);
+}

package/dest/orchestrator/block-proving-state.d.ts

@@ -1,17 +1,20 @@
-import { BatchedBlobAccumulator, SpongeBlob } from '@aztec/blob-lib';
-import { type ARCHIVE_HEIGHT, type L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import type { SpongeBlob } from '@aztec/blob-lib';
+import { type ARCHIVE_HEIGHT, type L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
-import type { Tuple } from '@aztec/foundation/serialize';
+import { type Tuple } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation } from '@aztec/foundation/trees';
-import type { EthAddress, L2Block } from '@aztec/stdlib/block';
 import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
-import { type ParityPublicInputs, RootParityInputs } from '@aztec/stdlib/parity';
-import { type BaseOrMergeRollupPublicInputs, type BlockRootOrBlockMergePublicInputs, BlockRootRollupInputs, EmptyBlockRootRollupInputs, MergeRollupInputs, PaddingBlockRootRollupInputs, SingleTxBlockRootRollupInputs } from '@aztec/stdlib/rollup';
-import { AppendOnlyTreeSnapshot, type MerkleTreeId } from '@aztec/stdlib/trees';
-import { type BlockHeader, type GlobalVariables } from '@aztec/stdlib/tx';
-import type { EpochProvingState } from './epoch-proving-state.js';
+import { type ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity';
+import { BlockRollupPublicInputs, BlockRootEmptyTxFirstRollupPrivateInputs, BlockRootRollupPrivateInputs, BlockRootSingleTxRollupPrivateInputs, CheckpointConstantData, TxMergeRollupPrivateInputs, type TxRollupPublicInputs } from '@aztec/stdlib/rollup';
+import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
+import { type BlockHeader, GlobalVariables } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+import type { CheckpointProvingState } from './checkpoint-proving-state.js';
 import type { TxProvingState } from './tx-proving-state.js';
-export type TreeSnapshots = Map<MerkleTreeId, AppendOnlyTreeSnapshot>;
+export type ProofState<T, PROOF_LENGTH extends number> = {
+    provingOutput?: PublicInputsAndRecursiveProof<T, PROOF_LENGTH>;
+    isProving?: boolean;
+};
 /**
  * The current state of the proving schedule for a given block. Managed by ProvingState.
  * Contains the raw inputs and intermediate state to generate every constituent proof in the tree.
@@ -19,60 +22,63 @@ export type TreeSnapshots = Map<MerkleTreeId, AppendOnlyTreeSnapshot>;
 export declare class BlockProvingState {
     #private;
     readonly index: number;
-    readonly globalVariables: GlobalVariables;
-    readonly newL1ToL2Messages: Fr[];
-    readonly l1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot;
-    private readonly l1ToL2MessageSubtreeSiblingPath;
-    readonly l1ToL2MessageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot;
-    private readonly lastArchiveSnapshot;
+    readonly blockNumber: number;
+    readonly totalNumTxs: number;
+    private readonly constants;
+    private readonly timestamp;
+    readonly lastArchiveTreeSnapshot: AppendOnlyTreeSnapshot;
     private readonly lastArchiveSiblingPath;
-    private readonly newArchiveSiblingPath;
-    private readonly previousBlockHeader;
-    private readonly proverId;
-    private readonly parentEpoch;
-    private baseOrMergeProvingOutputs;
-    private baseParityProvingOutputs;
-    private rootParityProvingOutput;
-    private blockRootProvingOutput;
-    blockRootRollupStarted: boolean;
-    block: L2Block | undefined;
-    spongeBlobState: SpongeBlob | undefined;
-    startBlobAccumulator: BatchedBlobAccumulator | undefined;
-    endBlobAccumulator: BatchedBlobAccumulator | undefined;
-    blobsHash: Fr | undefined;
-    totalNumTxs: number;
+    private readonly lastL1ToL2MessageTreeSnapshot;
+    private readonly lastL1ToL2MessageSubtreeRootSiblingPath;
+    readonly newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot;
+    private readonly headerOfLastBlockInPreviousCheckpoint;
+    private readonly startSpongeBlob;
+    parentCheckpoint: CheckpointProvingState;
+    private baseOrMergeProofs;
+    private baseParityProofs;
+    private rootParityProof;
+    private blockRootProof;
+    private builtBlockHeader;
+    private endSpongeBlob;
     private txs;
-    error: string | undefined;
-    constructor(index: number, globalVariables: GlobalVariables, newL1ToL2Messages: Fr[], l1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, l1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>, l1ToL2MessageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot, lastArchiveSnapshot: AppendOnlyTreeSnapshot, lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, newArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, previousBlockHeader: BlockHeader, proverId: EthAddress, parentEpoch: EpochProvingState);
-    get blockNumber(): number;
-    startNewBlock(numTxs: number, numBlobFields: number): void;
+    private isFirstBlock;
+    private error;
+    constructor(index: number, blockNumber: number, totalNumTxs: number, constants: CheckpointConstantData, timestamp: UInt64, lastArchiveTreeSnapshot: AppendOnlyTreeSnapshot, lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, lastL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, lastL1ToL2MessageSubtreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH>, newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, headerOfLastBlockInPreviousCheckpoint: BlockHeader, startSpongeBlob: SpongeBlob, parentCheckpoint: CheckpointProvingState);
+    get epochNumber(): number;
     addNewTx(tx: TxProvingState): number;
-    setBaseRollupProof(txIndex: number, provingOutput: PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): TreeNodeLocation;
-    setMergeRollupProof(location: TreeNodeLocation, provingOutput: PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
+    isAcceptingTxs(): boolean;
+    getProcessedTxs(): import("@aztec/stdlib/tx").ProcessedTx[];
+    tryStartProvingBase(txIndex: number): boolean;
+    setBaseRollupProof(txIndex: number, provingOutput: PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): TreeNodeLocation;
+    tryStartProvingMerge(location: TreeNodeLocation): boolean;
+    setMergeRollupProof(location: TreeNodeLocation, provingOutput: PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
+    tryStartProvingBaseParity(index: number): boolean;
     setBaseParityProof(index: number, provingOutput: PublicInputsAndRecursiveProof<ParityPublicInputs>): void;
+    tryStartProvingRootParity(): boolean;
     setRootParityProof(provingOutput: PublicInputsAndRecursiveProof<ParityPublicInputs>): void;
-    setBlockRootRollupProof(provingOutput: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
-    setBlock(block: L2Block): void;
-    setStartBlobAccumulator(accumulator: BatchedBlobAccumulator): void;
-    setEndBlobAccumulator(accumulator: BatchedBlobAccumulator): void;
-    accumulateBlobs(): Promise<void>;
-    get allTxs(): TxProvingState[];
-    /** Returns the block number as an epoch number. Used for prioritizing proof requests. */
-    get epochNumber(): number;
+    tryStartProvingBlockRoot(): boolean;
+    setBlockRootRollupProof(provingOutput: PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): TreeNodeLocation;
+    getBlockRootRollupOutput(): BlockRollupPublicInputs | undefined;
+    setBuiltBlockHeader(blockHeader: BlockHeader): void;
+    getBuiltBlockHeader(): BlockHeader | undefined;
+    getGlobalVariables(): GlobalVariables;
+    getStartSpongeBlob(): SpongeBlob;
+    setEndSpongeBlob(endSpongeBlob: SpongeBlob): void;
+    getEndSpongeBlob(): SpongeBlob | undefined;
+    getTxEffects(): import("@aztec/stdlib/tx").TxEffect[];
     getParentLocation(location: TreeNodeLocation): TreeNodeLocation;
-    getMergeRollupInputs(mergeLocation: TreeNodeLocation): MergeRollupInputs;
-    getBlockRootRollupTypeAndInputs(): Promise<{
+    getMergeRollupInputs(mergeLocation: TreeNodeLocation): TxMergeRollupPrivateInputs;
+    getBlockRootRollupTypeAndInputs(): {
         rollupType: string;
-        inputs: EmptyBlockRootRollupInputs;
+        inputs: BlockRootEmptyTxFirstRollupPrivateInputs;
     } | {
         rollupType: string;
-        inputs: SingleTxBlockRootRollupInputs;
+        inputs: BlockRootSingleTxRollupPrivateInputs;
     } | {
         rollupType: string;
-        inputs: BlockRootRollupInputs;
-    }>;
-    getPaddingBlockRootInputs(): PaddingBlockRootRollupInputs;
-    getRootParityInputs(): RootParityInputs;
+        inputs: BlockRootRollupPrivateInputs;
+    };
+    getParityRootInputs(): ParityRootPrivateInputs;
     getTxProvingState(txIndex: number): TxProvingState;
     buildHeaderFromProvingOutputs(): Promise<BlockHeader>;
     isReadyForMergeRollup(location: TreeNodeLocation): boolean;
@@ -80,6 +86,7 @@ export declare class BlockProvingState {
     isReadyForRootParity(): boolean;
     isComplete(): boolean;
     verifyState(): boolean;
+    getError(): string | undefined;
     reject(reason: string): void;
 }
 //# sourceMappingURL=block-proving-state.d.ts.map

package/dest/orchestrator/block-proving-state.d.ts.map

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