@aztec/prover-client 3.0.0-nightly.20251113 → 3.0.0-nightly.20251115

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

@@ -1,21 +1,19 @@
-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 { BatchedBlob, computeBlobsHashFromBlobs, encodeBlockBlobData, 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, 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 { assertLength, toFriendlyJSON } from '@aztec/foundation/serialize';
-import { MembershipWitness, MerkleTreeCalculator, computeCompressedUnbalancedMerkleTreeRoot } from '@aztec/foundation/trees';
+import { MembershipWitness } 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 { Body, L2BlockHeader, getBlockBlobFields } from '@aztec/stdlib/block';
-import { getCheckpointBlobFields } from '@aztec/stdlib/checkpoint';
+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 { AppendOnlyTreeSnapshot, MerkleTreeId, NullifierLeafPreimage, getTreeHeight } from '@aztec/stdlib/trees';
+import { BlockHeader, GlobalVariables, PartialStateReference } 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.
@@ -25,18 +23,7 @@ export const insertSideEffectsAndBuildBaseRollupHints = runInSpan('BlockBuilderH
     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);
-    // 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);
-    // 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);
-    if (nullifierWitnessLeaves === undefined) {
-        throw new Error(`Could not craft nullifier batch insertion proofs`);
-    }
+    const { nullifierInsertionResult, publicDataInsertionResult } = await insertSideEffects(tx, db);
     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());
@@ -48,25 +35,31 @@ export const insertSideEffectsAndBuildBaseRollupHints = runInSpan('BlockBuilderH
             contractClassLogsFields
         });
     } else {
-        if (txPublicDataUpdateRequestInfo.lowPublicDataWritesMembershipWitnesses.length > 1 || txPublicDataUpdateRequestInfo.lowPublicDataWritesPreimages.length > 1 || txPublicDataUpdateRequestInfo.publicDataWritesSiblingPaths.length > 1) {
+        if (tx.txEffect.publicDataWrites.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 feePayerBalanceLeafWitnessData = publicDataInsertionResult.lowLeavesWitnessData[0];
+        const feePayerBalanceMembershipWitness = MembershipWitness.fromBufferArray(feePayerBalanceLeafWitnessData.index, assertLength(feePayerBalanceLeafWitnessData.siblingPath.toBufferArray(), PUBLIC_DATA_TREE_HEIGHT));
+        const feePayerBalanceLeafPreimage = feePayerBalanceLeafWitnessData.leafPreimage;
         const leafSlot = await computeFeePayerBalanceLeafSlot(tx.data.feePayer);
-        if (!feePayerBalanceMembershipWitness || !leafSlot.equals(feePayerBalanceLeafPreimage?.leaf.slot)) {
+        if (!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)));
+        // Get hints for inserting the nullifiers.
+        const nullifierLowLeavesWitnessData = nullifierInsertionResult.lowLeavesWitnessData;
+        const nullifierPredecessorPreimages = padArrayEnd(nullifierLowLeavesWitnessData.map((l)=>l.leafPreimage), NullifierLeafPreimage.empty(), MAX_NULLIFIERS_PER_TX);
+        const nullifierPredecessorMembershipWitnesses = padArrayEnd(nullifierLowLeavesWitnessData.map((l)=>MembershipWitness.fromBufferArray(l.index, assertLength(l.siblingPath.toBufferArray(), NULLIFIER_TREE_HEIGHT))), makeEmptyMembershipWitness(NULLIFIER_TREE_HEIGHT), MAX_NULLIFIERS_PER_TX);
+        const sortedNullifiers = assertLength(nullifierInsertionResult.sortedNewLeaves.map((n)=>Fr.fromBuffer(n)), MAX_NULLIFIERS_PER_TX);
+        const sortedNullifierIndexes = assertLength(nullifierInsertionResult.sortedNewLeavesIndexes, MAX_NULLIFIERS_PER_TX);
+        const nullifierSubtreeRootSiblingPath = assertLength(nullifierInsertionResult.newSubtreeSiblingPath.toFields(), NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH);
         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: 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),
+            nullifierPredecessorPreimages,
+            nullifierPredecessorMembershipWitnesses,
+            sortedNullifiers,
+            sortedNullifierIndexes,
+            nullifierSubtreeRootSiblingPath,
             feePayerBalanceMembershipWitness
         });
         const constants = BlockConstantData.from({
@@ -88,6 +81,28 @@ export const insertSideEffectsAndBuildBaseRollupHints = runInSpan('BlockBuilderH
         });
     }
 });
+export const insertSideEffects = runInSpan('BlockBuilderHelpers', 'buildBaseRollupHints', async (span, tx, db)=>{
+    span.setAttribute(Attributes.TX_HASH, tx.hash.toString());
+    // Insert the note hashes. Padded with zeros to the max number of note hashes per tx.
+    const noteHashes = padArrayEnd(tx.txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX);
+    await db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, noteHashes);
+    // Insert the nullifiers. Padded with zeros to the max number of nullifiers per tx.
+    // Capturing the low nullifier info for each individual operation.
+    const nullifierInsertionResult = await db.batchInsert(MerkleTreeId.NULLIFIER_TREE, padArrayEnd(tx.txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map((n)=>n.toBuffer()), NULLIFIER_SUBTREE_HEIGHT);
+    if (nullifierInsertionResult.lowLeavesWitnessData === undefined) {
+        throw new Error(`Failed to batch insert nullifiers.`);
+    }
+    if (tx.txEffect.publicDataWrites.some((write)=>write.isEmpty())) {
+        throw new Error(`Empty public data write in tx: ${toFriendlyJSON(tx)}.`);
+    }
+    // Insert the public data writes sequentially. No need to pad them to the max array size.
+    // Capturing the low leaf info for each individual operation.
+    const publicDataInsertionResult = await db.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, tx.txEffect.publicDataWrites.map((write)=>write.toBuffer()));
+    return {
+        nullifierInsertionResult,
+        publicDataInsertionResult
+    };
+});
 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);
@@ -110,17 +125,6 @@ export const buildBlobHints = (blobFields)=>{
         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);
@@ -145,56 +149,50 @@ export const buildHeaderFromCircuitOutputs = runInSpan('BlockBuilderHelpers', 'b
     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, startSpongeBlob)=>{
+export const buildHeaderAndBodyFromTxs = runInSpan('BlockBuilderHelpers', 'buildHeaderAndBodyFromTxs', async (span, txs, lastArchive, endState, globalVariables, startSpongeBlob, isFirstBlock)=>{
     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 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 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);
+    const totalFees = txEffects.reduce((acc, tx)=>acc.add(tx.transactionFee), Fr.ZERO);
+    const totalManaUsed = txs.reduce((acc, tx)=>acc.add(new Fr(tx.gasUsed.billedGas.l2Gas)), Fr.ZERO);
+    const { l1ToL2MessageTree, partial } = endState;
+    const blockBlobFields = encodeBlockBlobData({
+        blockEndMarker: {
+            timestamp: globalVariables.timestamp,
+            blockNumber: globalVariables.blockNumber,
+            numTxs: txs.length
+        },
+        blockEndStateField: {
+            l1ToL2MessageNextAvailableLeafIndex: l1ToL2MessageTree.nextAvailableLeafIndex,
+            noteHashNextAvailableLeafIndex: partial.noteHashTree.nextAvailableLeafIndex,
+            nullifierNextAvailableLeafIndex: partial.nullifierTree.nextAvailableLeafIndex,
+            publicDataNextAvailableLeafIndex: partial.publicDataTree.nextAvailableLeafIndex,
+            totalManaUsed: totalManaUsed.toBigInt()
+        },
+        lastArchiveRoot: lastArchive.root,
+        noteHashRoot: partial.noteHashTree.root,
+        nullifierRoot: partial.nullifierTree.root,
+        publicDataRoot: partial.publicDataTree.root,
+        l1ToL2MessageRoot: isFirstBlock ? l1ToL2MessageTree.root : undefined,
+        txs: body.toTxBlobData()
+    });
+    const endSpongeBlob = startSpongeBlob.clone();
     await endSpongeBlob.absorb(blockBlobFields);
     const spongeBlobHash = await endSpongeBlob.squeeze();
-    const header = new L2BlockHeader(previousArchive, contentCommitment, stateReference, globalVariables, fees, manaUsed, spongeBlobHash);
+    const header = BlockHeader.from({
+        lastArchive,
+        state: endState,
+        spongeBlobHash,
+        globalVariables,
+        totalFees,
+        totalManaUsed
+    });
     return {
         header,
-        body
+        body,
+        blockBlobFields
     };
 });
-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([
-            left,
-            right
-        ])));
-    const parityHeight = Math.ceil(Math.log2(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP));
-    const parityCalculator = await MerkleTreeCalculator.create(parityHeight, Fr.ZERO.toBuffer(), hasher);
-    return new Fr(await parityCalculator.computeTreeRoot(l1ToL2Messages.map((msg)=>msg.toBuffer())));
-}
 export async function getLastSiblingPath(treeId, db) {
     const { size } = await db.getTreeInfo(treeId);
     const path = await db.getSiblingPath(treeId, size - 1n);
@@ -212,28 +210,6 @@ export async function getTreeSnapshot(id, db) {
 export function makeEmptyMembershipWitness(height) {
     return new MembershipWitness(height, 0n, makeTuple(height, ()=>Fr.ZERO));
 }
-const processPublicDataUpdateRequests = runInSpan('BlockBuilderHelpers', 'processPublicDataUpdateRequests', async (span, tx, db)=>{
-    span.setAttribute(Attributes.TX_HASH, tx.hash.toString());
-    const allPublicDataWrites = tx.txEffect.publicDataWrites.map(({ leafSlot, value })=>new PublicDataTreeLeaf(leafSlot, value));
-    const { lowLeavesWitnessData, insertionWitnessData } = await db.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, allPublicDataWrites.map((write)=>{
-        if (write.isEmpty()) {
-            throw new Error(`Empty public data write in tx: ${toFriendlyJSON(tx)}`);
-        }
-        return write.toBuffer();
-    }));
-    const lowPublicDataWritesPreimages = lowLeavesWitnessData.map((lowLeafWitness)=>lowLeafWitness.leafPreimage);
-    const lowPublicDataWritesMembershipWitnesses = lowLeavesWitnessData.map((lowLeafWitness)=>MembershipWitness.fromBufferArray(lowLeafWitness.index, assertLength(lowLeafWitness.siblingPath.toBufferArray(), PUBLIC_DATA_TREE_HEIGHT)));
-    const publicDataWritesSiblingPaths = insertionWitnessData.map((w)=>{
-        const insertionSiblingPath = w.siblingPath.toFields();
-        assertLength(insertionSiblingPath, PUBLIC_DATA_TREE_HEIGHT);
-        return insertionSiblingPath;
-    });
-    return {
-        lowPublicDataWritesPreimages,
-        lowPublicDataWritesMembershipWitnesses,
-        publicDataWritesSiblingPaths
-    };
-});
 export async function getSubtreeSiblingPath(treeId, subtreeHeight, db) {
     const nextAvailableLeafIndex = await db.getTreeInfo(treeId).then((t)=>t.size);
     const fullSiblingPath = await db.getSiblingPath(treeId, nextAvailableLeafIndex);

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

@@ -1,4 +1,4 @@
-import type { SpongeBlob } from '@aztec/blob-lib';
+import { type BlockBlobData, type BlockEndBlobData, 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';
@@ -7,7 +7,7 @@ import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/ser
 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 { BlockHeader, StateReference } 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';
@@ -39,6 +39,7 @@ export declare class BlockProvingState {
     private rootParityProof;
     private blockRootProof;
     private builtBlockHeader;
+    private endState;
     private endSpongeBlob;
     private txs;
     private isFirstBlock;
@@ -59,12 +60,16 @@ export declare class BlockProvingState {
     tryStartProvingBlockRoot(): boolean;
     setBlockRootRollupProof(provingOutput: PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): TreeNodeLocation;
     getBlockRootRollupOutput(): BlockRollupPublicInputs | undefined;
-    setBuiltBlockHeader(blockHeader: BlockHeader): void;
+    buildBlockHeader(): Promise<BlockHeader>;
     getBuiltBlockHeader(): BlockHeader | undefined;
-    getGlobalVariables(): GlobalVariables;
     getStartSpongeBlob(): SpongeBlob;
     setEndSpongeBlob(endSpongeBlob: SpongeBlob): void;
     getEndSpongeBlob(): SpongeBlob | undefined;
+    setEndState(endState: StateReference): void;
+    hasEndState(): boolean;
+    getBlockEndBlobFields(): Fr[];
+    getBlockEndBlobData(): BlockEndBlobData;
+    getBlockBlobData(): BlockBlobData;
     getTxEffects(): import("@aztec/stdlib/tx").TxEffect[];
     getParentLocation(location: TreeNodeLocation): TreeNodeLocation;
     getMergeRollupInputs(mergeLocation: TreeNodeLocation): TxMergeRollupPrivateInputs;

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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"}

package/dest/orchestrator/block-proving-state.js

@@ -1,9 +1,11 @@
+import { encodeBlockEndBlobData } from '@aztec/blob-lib';
 import { NUM_BASE_PARITY_PER_ROOT_PARITY } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
 import { assertLength } from '@aztec/foundation/serialize';
 import { UnbalancedTreeStore } from '@aztec/foundation/trees';
 import { ParityRootPrivateInputs } from '@aztec/stdlib/parity';
 import { BlockRootEmptyTxFirstRollupPrivateInputs, BlockRootFirstRollupPrivateInputs, BlockRootRollupPrivateInputs, BlockRootSingleTxFirstRollupPrivateInputs, BlockRootSingleTxRollupPrivateInputs, TxMergeRollupPrivateInputs } from '@aztec/stdlib/rollup';
-import { GlobalVariables } from '@aztec/stdlib/tx';
+import { BlockHeader, GlobalVariables } from '@aztec/stdlib/tx';
 import { buildHeaderFromCircuitOutputs, toProofData } from './block-building-helpers.js';
 /**
  * The current state of the proving schedule for a given block. Managed by ProvingState.
@@ -27,6 +29,7 @@ import { buildHeaderFromCircuitOutputs, toProofData } from './block-building-hel
     rootParityProof;
     blockRootProof;
     builtBlockHeader;
+    endState;
     endSpongeBlob;
     txs;
     isFirstBlock;
@@ -157,28 +160,24 @@ import { buildHeaderFromCircuitOutputs, toProofData } from './block-building-hel
     getBlockRootRollupOutput() {
         return this.blockRootProof?.provingOutput?.inputs;
     }
-    setBuiltBlockHeader(blockHeader) {
-        this.builtBlockHeader = blockHeader;
+    async buildBlockHeader() {
+        if (this.isAcceptingTxs()) {
+            throw new Error('All txs must be added to the block before building the header.');
+        }
+        if (!this.endState) {
+            throw new Error('Call `setEndState` first.');
+        }
+        if (!this.endSpongeBlob) {
+            throw new Error('Call `setEndSpongeBlob` first.');
+        }
+        const endSpongeBlob = this.endSpongeBlob.clone();
+        const endSpongeBlobHash = await endSpongeBlob.squeeze();
+        this.builtBlockHeader = new BlockHeader(this.lastArchiveTreeSnapshot, this.endState, endSpongeBlobHash, this.#getGlobalVariables(), this.#getTotalFees(), new Fr(this.#getTotalManaUsed()));
+        return this.builtBlockHeader;
     }
     getBuiltBlockHeader() {
         return this.builtBlockHeader;
     }
-    getGlobalVariables() {
-        if (this.txs.length) {
-            return this.txs[0].processedTx.globalVariables;
-        }
-        const constants = this.constants;
-        return GlobalVariables.from({
-            chainId: constants.chainId,
-            version: constants.version,
-            blockNumber: this.blockNumber,
-            slotNumber: constants.slotNumber,
-            timestamp: this.timestamp,
-            coinbase: constants.coinbase,
-            feeRecipient: constants.feeRecipient,
-            gasFees: constants.gasFees
-        });
-    }
     getStartSpongeBlob() {
         return this.startSpongeBlob;
     }
@@ -188,6 +187,46 @@ import { buildHeaderFromCircuitOutputs, toProofData } from './block-building-hel
     getEndSpongeBlob() {
         return this.endSpongeBlob;
     }
+    setEndState(endState) {
+        this.endState = endState;
+    }
+    hasEndState() {
+        return !!this.endState;
+    }
+    getBlockEndBlobFields() {
+        return encodeBlockEndBlobData(this.getBlockEndBlobData());
+    }
+    getBlockEndBlobData() {
+        if (!this.endState) {
+            throw new Error('Call `setEndState` first.');
+        }
+        const partial = this.endState.partial;
+        return {
+            blockEndMarker: {
+                numTxs: this.totalNumTxs,
+                timestamp: this.timestamp,
+                blockNumber: this.blockNumber
+            },
+            blockEndStateField: {
+                l1ToL2MessageNextAvailableLeafIndex: this.newL1ToL2MessageTreeSnapshot.nextAvailableLeafIndex,
+                noteHashNextAvailableLeafIndex: partial.noteHashTree.nextAvailableLeafIndex,
+                nullifierNextAvailableLeafIndex: partial.nullifierTree.nextAvailableLeafIndex,
+                publicDataNextAvailableLeafIndex: partial.publicDataTree.nextAvailableLeafIndex,
+                totalManaUsed: this.#getTotalManaUsed()
+            },
+            lastArchiveRoot: this.lastArchiveTreeSnapshot.root,
+            noteHashRoot: partial.noteHashTree.root,
+            nullifierRoot: partial.nullifierTree.root,
+            publicDataRoot: partial.publicDataTree.root,
+            l1ToL2MessageRoot: this.isFirstBlock ? this.newL1ToL2MessageTreeSnapshot.root : undefined
+        };
+    }
+    getBlockBlobData() {
+        return {
+            ...this.getBlockEndBlobData(),
+            txs: this.getTxEffects().map((t)=>t.toTxBlobData())
+        };
+    }
     getTxEffects() {
         return this.txs.map((t)=>t.processedTx.txEffect);
     }
@@ -310,4 +349,26 @@ import { buildHeaderFromCircuitOutputs, toProofData } from './block-building-hel
             this.baseOrMergeProofs.getNode(rootLocation)?.provingOutput
         ] : this.baseOrMergeProofs.getChildren(rootLocation).map((c)=>c?.provingOutput);
     }
+    #getGlobalVariables() {
+        if (this.txs.length) {
+            return this.txs[0].processedTx.globalVariables;
+        }
+        const constants = this.constants;
+        return GlobalVariables.from({
+            chainId: constants.chainId,
+            version: constants.version,
+            blockNumber: this.blockNumber,
+            slotNumber: constants.slotNumber,
+            timestamp: this.timestamp,
+            coinbase: constants.coinbase,
+            feeRecipient: constants.feeRecipient,
+            gasFees: constants.gasFees
+        });
+    }
+    #getTotalFees() {
+        return this.txs.reduce((acc, tx)=>acc.add(tx.processedTx.txEffect.transactionFee), Fr.ZERO);
+    }
+    #getTotalManaUsed() {
+        return this.txs.reduce((acc, tx)=>acc + BigInt(tx.processedTx.gasUsed.billedGas.l2Gas), 0n);
+    }
 }

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

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

package/dest/orchestrator/checkpoint-proving-state.js

@@ -1,9 +1,8 @@
-import { SpongeBlob } from '@aztec/blob-lib';
+import { SpongeBlob, encodeCheckpointBlobData } from '@aztec/blob-lib';
 import { BLOBS_PER_BLOCK, FIELDS_PER_BLOB, NUM_MSGS_PER_BASE_PARITY } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { BLS12Point, Fr } from '@aztec/foundation/fields';
 import { UnbalancedTreeStore } from '@aztec/foundation/trees';
-import { getCheckpointBlobFields } from '@aztec/stdlib/checkpoint';
 import { ParityBasePrivateInputs } from '@aztec/stdlib/parity';
 import { BlockMergeRollupPrivateInputs, CheckpointRootRollupHints, CheckpointRootRollupPrivateInputs, CheckpointRootSingleBlockRollupPrivateInputs } from '@aztec/stdlib/rollup';
 import { accumulateBlobs, buildBlobHints, toProofData } from './block-building-helpers.js';
@@ -118,10 +117,13 @@ export class CheckpointProvingState {
         return new ParityBasePrivateInputs(messages, this.constants.vkTreeRoot);
     }
     async accumulateBlobs(startBlobAccumulator) {
-        if (this.isAcceptingBlocks() || this.blocks.some((b)=>b.isAcceptingTxs())) {
+        if (this.isAcceptingBlocks() || this.blocks.some((b)=>!b?.hasEndState())) {
             return;
         }
-        this.blobFields = getCheckpointBlobFields(this.blocks.map((b)=>b.getTxEffects()));
+        this.blobFields = encodeCheckpointBlobData({
+            totalNumBlobFields: this.totalNumBlobFields,
+            blocks: this.blocks.map((b)=>b.getBlockBlobData())
+        });
         this.endBlobAccumulator = await accumulateBlobs(this.blobFields, startBlobAccumulator);
         this.startBlobAccumulator = startBlobAccumulator;
         this.onBlobAccumulatorSet(this);

package/dest/orchestrator/orchestrator.d.ts

@@ -59,7 +59,6 @@ export declare class ProvingOrchestrator implements EpochProver {
      * Computes the block header and updates the archive tree.
      */
     setBlockCompleted(blockNumber: number, expectedHeader?: BlockHeader): Promise<BlockHeader>;
-    private buildL2BlockHeader;
     protected verifyBuiltBlockAgainstSyncedState(provingState: BlockProvingState): Promise<void>;
     /**
      * Cancel any further proving

package/dest/orchestrator/orchestrator.d.ts.map

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

package/dest/orchestrator/orchestrator.js

@@ -14,12 +14,11 @@ import { assertLength } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
 import { elapsed } from '@aztec/foundation/timer';
 import { readAvmMinimalPublicTxInputsFromFile } from '@aztec/simulator/public/fixtures';
-import { createBlockEndMarker } from '@aztec/stdlib/block';
 import { BlockRootEmptyTxFirstRollupPrivateInputs, BlockRootFirstRollupPrivateInputs, BlockRootSingleTxFirstRollupPrivateInputs, BlockRootSingleTxRollupPrivateInputs, CheckpointRootSingleBlockRollupPrivateInputs, PrivateTxBaseRollupPrivateInputs } from '@aztec/stdlib/rollup';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { Attributes, getTelemetryClient, trackSpan, wrapCallbackInSpan } from '@aztec/telemetry-client';
 import { inspect } from 'util';
-import { buildBlockHeaderFromTxs, buildHeaderFromCircuitOutputs, getLastSiblingPath, getPublicChonkVerifierPrivateInputsFromTx, getRootTreeSiblingPath, getSubtreeSiblingPath, getTreeSnapshot, insertSideEffectsAndBuildBaseRollupHints, validatePartialState, validateTx } from './block-building-helpers.js';
+import { buildHeaderFromCircuitOutputs, getLastSiblingPath, getPublicChonkVerifierPrivateInputsFromTx, getRootTreeSiblingPath, getSubtreeSiblingPath, getTreeSnapshot, insertSideEffectsAndBuildBaseRollupHints, validatePartialState, validateTx } from './block-building-helpers.js';
 import { EpochProvingState } from './epoch-proving-state.js';
 import { ProvingOrchestratorMetrics } from './orchestrator_metrics.js';
 import { TxProvingState } from './tx-proving-state.js';
@@ -134,10 +133,11 @@ const logger = createLogger('prover-client:orchestrator');
         // Because `addTxs` won't be called for a block without txs, and that's where the sponge blob state is computed.
         // We need to set its end sponge blob here, which will become the start sponge blob for the next block.
         if (totalNumTxs === 0) {
+            const endState = await db.getStateReference();
+            blockProvingState.setEndState(endState);
             const endSpongeBlob = blockProvingState.getStartSpongeBlob().clone();
-            await endSpongeBlob.absorb([
-                createBlockEndMarker(0)
-            ]);
+            const blockEndBlobFields = blockProvingState.getBlockEndBlobFields();
+            await endSpongeBlob.absorb(blockEndBlobFields);
             blockProvingState.setEndSpongeBlob(endSpongeBlob);
             // And also try to accumulate the blobs as far as we can:
             await this.provingState.setBlobAccumulators();
@@ -201,9 +201,10 @@ const logger = createLogger('prover-client:orchestrator');
                 });
             }
         }
-        await spongeBlobState.absorb([
-            createBlockEndMarker(txs.length)
-        ]);
+        const endState = await db.getStateReference();
+        provingState.setEndState(endState);
+        const blockEndBlobFields = provingState.getBlockEndBlobFields();
+        await spongeBlobState.absorb(blockEndBlobFields);
         provingState.setEndSpongeBlob(spongeBlobState);
         // Txs have been added to the block. Now try to accumulate the blobs as far as we can:
         await this.provingState.setBlobAccumulators();
@@ -248,28 +249,19 @@ const logger = createLogger('prover-client:orchestrator');
         if (provingState.isAcceptingTxs()) {
             throw new Error(`Block ${blockNumber} is still accepting txs. Call setBlockCompleted after all txs have been added.`);
         }
-        // And build the block header
+        // Given we've applied every change from this block, now assemble the block header:
         logger.verbose(`Block ${blockNumber} completed. Assembling header.`);
-        const header = await this.buildL2BlockHeader(provingState, expectedHeader);
-        await this.verifyBuiltBlockAgainstSyncedState(provingState);
-        return header;
-    }
-    async buildL2BlockHeader(provingState, expectedHeader) {
-        // Collect all txs in this block to build the header. The function calling this has made sure that all txs have been added.
-        const txs = provingState.getProcessedTxs();
-        const startSpongeBlob = provingState.getStartSpongeBlob();
-        // Get db for this block
-        const db = this.dbs.get(provingState.blockNumber);
-        // Given we've applied every change from this block, now assemble the block header
-        // and update the archive tree, so we're ready to start processing the next block
-        const header = await buildBlockHeaderFromTxs(txs, provingState.getGlobalVariables(), startSpongeBlob, db);
+        const header = await provingState.buildBlockHeader();
         if (expectedHeader && !header.equals(expectedHeader)) {
             logger.error(`Block header mismatch: header=${header} expectedHeader=${expectedHeader}`);
             throw new Error('Block header mismatch');
         }
+        // Get db for this block
+        const db = this.dbs.get(provingState.blockNumber);
+        // Update the archive tree, so we're ready to start processing the next block:
         logger.verbose(`Updating archive tree with block ${provingState.blockNumber} header ${(await header.hash()).toString()}`);
         await db.updateArchive(header);
-        provingState.setBuiltBlockHeader(header);
+        await this.verifyBuiltBlockAgainstSyncedState(provingState);
         return header;
     }
     // Flagged as protected to disable in certain unit tests