@aztec/prover-client 0.0.0-test.0

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

@@ -0,0 +1,55 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Blob, type SpongeBlob } from '@aztec/blob-lib';
+import { Fr } from '@aztec/foundation/fields';
+import type { Logger } from '@aztec/foundation/log';
+import { type Tuple } from '@aztec/foundation/serialize';
+import { MembershipWitness } from '@aztec/foundation/trees';
+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, ConstantRollupData, PrivateBaseRollupHints, PublicBaseRollupHints } from '@aztec/stdlib/rollup';
+import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+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.
+ */
+type BaseTreeNames = 'NoteHashTree' | 'ContractTree' | 'NullifierTree' | 'PublicDataTree';
+/**
+ * Type representing the names of the trees.
+ */
+export type TreeNames = BaseTreeNames | 'L1ToL2MessageTree' | 'Archive';
+export declare const buildBaseRollupHints: (tx: ProcessedTx, globalVariables: GlobalVariables, 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: [Fr, Fr][];
+    blobs: Blob[];
+    blobsHash: Fr;
+}>;
+export declare const buildHeaderFromCircuitOutputs: (previousRollupData: BaseOrMergeRollupPublicInputs[], parityPublicInputs: ParityPublicInputs, rootRollupOutputs: BlockRootOrBlockMergePublicInputs, endState: StateReference, logger?: Logger | undefined) => Promise<BlockHeader>;
+export declare const buildHeaderAndBodyFromTxs: (txs: ProcessedTx[], globalVariables: GlobalVariables, l1ToL2Messages: Fr[], db: MerkleTreeReadOperations) => Promise<{
+    header: BlockHeader;
+    body: Body;
+}>;
+export declare function getBlobsHashFromBlobs(inputs: Blob[]): Buffer;
+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 getRootTreeSiblingPath<TID extends MerkleTreeId>(treeId: TID, db: MerkleTreeReadOperations): Promise<Tuple<Fr, {
+    readonly 1: 40;
+    readonly 4: 29;
+    readonly 3: 39;
+    readonly 0: 40;
+    readonly 2: 40;
+}[TID]>>;
+export declare const getConstantRollupData: (globalVariables: GlobalVariables, db: MerkleTreeReadOperations) => Promise<ConstantRollupData>;
+export declare function getTreeSnapshot(id: MerkleTreeId, db: MerkleTreeReadOperations): Promise<AppendOnlyTreeSnapshot>;
+export declare function makeEmptyMembershipWitness<N extends number>(height: N): MembershipWitness<N>;
+export declare function getSubtreeSiblingPath(treeId: MerkleTreeId, subtreeHeight: number, db: MerkleTreeReadOperations): Promise<Fr[]>;
+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 {};
+//# sourceMappingURL=block-building-helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"block-building-helpers.d.ts","sourceRoot":"","sources":["../../src/orchestrator/block-building-helpers.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAiBxD,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,KAAK,KAAK,EAAmD,MAAM,6BAA6B,CAAC;AAC1G,OAAO,EAAE,iBAAiB,EAAqD,MAAM,yBAAyB,CAAC;AAI/G,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAC3C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAEjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,EACL,KAAK,6BAA6B,EAClC,KAAK,iCAAiC,EACtC,kBAAkB,EAClB,sBAAsB,EAEtB,qBAAqB,EACtB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,sBAAsB,EACtB,YAAY,EAKb,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,WAAW,EAEX,KAAK,eAAe,EACpB,qBAAqB,EACrB,KAAK,WAAW,EAChB,cAAc,EACd,QAAQ,EACT,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAInE;;GAEG;AACH,KAAK,aAAa,GAAG,cAAc,GAAG,cAAc,GAAG,eAAe,GAAG,gBAAgB,CAAC;AAC1F;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG,mBAAmB,GAAG,SAAS,CAAC;AAGxE,eAAO,MAAM,oBAAoB,4KAuJhC,CAAC;AAEF,wBAAsB,iBAAiB,CAAC,EAAE,EAAE,yBAAyB,EAAE,QAAQ,EAAE,MAAM,2BAkBtF;AAED,eAAO,MAAM,cAAc;;;;;EAU1B,CAAC;AAEF,eAAO,MAAM,6BAA6B,oOAoDzC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;EAoDrC,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,CAG5D;AAGD,wBAAsB,uBAAuB,CAC3C,eAAe,EAAE,iCAAiC,EAClD,WAAW,EAAE,WAAW,EACxB,EAAE,EAAE,wBAAwB,iBAM7B;AAED,eAAO,MAAM,aAAa,wEAmBzB,CAAC;AAEF,wBAAsB,sBAAsB,CAAC,GAAG,SAAS,YAAY,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,wBAAwB;;;;;;SAI/G;AAED,eAAO,MAAM,qBAAqB,iGAWjC,CAAC;AAEF,wBAAsB,eAAe,CAAC,EAAE,EAAE,YAAY,EAAE,EAAE,EAAE,wBAAwB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAGrH;AAED,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,wBAMrE;AA4CD,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,YAAY,EACpB,aAAa,EAAE,MAAM,EACrB,EAAE,EAAE,wBAAwB,GAC3B,OAAO,CAAC,EAAE,EAAE,CAAC,CAMf;AAGD,wBAAsB,uBAAuB,CAAC,CAAC,SAAS,MAAM,EAC5D,KAAK,EAAE,EAAE,EACT,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,CAAC,EACT,EAAE,EAAE,wBAAwB,GAC3B,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAY/B;AAED,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,qBAAqB,EACnC,aAAa,EAAE,GAAG,CAAC,YAAY,EAAE,sBAAsB,CAAC,QASzD;AAqBD,wBAAgB,UAAU,CAAC,EAAE,EAAE,WAAW,QAczC"}

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

@@ -0,0 +1,285 @@
+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 { assertLength, serializeToBuffer, toFriendlyJSON } from '@aztec/foundation/serialize';
+import { MembershipWitness, MerkleTreeCalculator, computeUnbalancedMerkleRoot } 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 { PublicDataHint } from '@aztec/stdlib/avm';
+import { Body } from '@aztec/stdlib/block';
+import { ContractClassLog } from '@aztec/stdlib/logs';
+import { ConstantRollupData, PrivateBaseRollupHints, PrivateBaseStateDiffHints, PublicBaseRollupHints } from '@aztec/stdlib/rollup';
+import { AppendOnlyTreeSnapshot, MerkleTreeId, NullifierLeafPreimage, PublicDataTreeLeaf, PublicDataTreeLeafPreimage, getTreeHeight } from '@aztec/stdlib/trees';
+import { BlockHeader, ContentCommitment, PartialStateReference, StateReference, TxEffect } from '@aztec/stdlib/tx';
+import { Attributes, runInSpan } from '@aztec/telemetry-client';
+import { inspect } from 'util';
+// Builds the hints for base rollup. Updating the contract, nullifier, and data trees in the process.
+export const buildBaseRollupHints = runInSpan('BlockBuilderHelpers', 'buildBaseRollupHints', async (span, tx, globalVariables, db, startSpongeBlob)=>{
+    span.setAttribute(Attributes.TX_HASH, tx.hash.toString());
+    // Get trees info before any changes hit
+    const constants = await getConstantRollupData(globalVariables, 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);
+    // 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);
+    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 contractClassLogsPreimages = makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, (i)=>tx.txEffect.contractClassLogs[i]?.toUnsiloed() || ContractClassLog.empty());
+    if (tx.avmProvingRequest) {
+        const blockHash = await tx.constants.historicalHeader.hash();
+        const archiveRootMembershipWitness = await getMembershipWitnessFor(blockHash, MerkleTreeId.ARCHIVE, ARCHIVE_HEIGHT, db);
+        return PublicBaseRollupHints.from({
+            startSpongeBlob: inputSpongeBlob,
+            archiveRootMembershipWitness,
+            contractClassLogsPreimages,
+            constants
+        });
+    } 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()),
+            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
+        });
+        const blockHash = await tx.constants.historicalHeader.hash();
+        const archiveRootMembershipWitness = await getMembershipWitnessFor(blockHash, MerkleTreeId.ARCHIVE, ARCHIVE_HEIGHT, db);
+        return PrivateBaseRollupHints.from({
+            start,
+            startSpongeBlob: inputSpongeBlob,
+            stateDiffHints,
+            feePayerFeeJuiceBalanceReadHint,
+            archiveRootMembershipWitness,
+            contractClassLogsPreimages,
+            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.slot.toBigInt() === leafSlot;
+    const value = exists ? leafPreimage.value : Fr.ZERO;
+    return new PublicDataHint(new Fr(leafSlot), value, membershipWitness, leafPreimage);
+}
+export const buildBlobHints = runInSpan('BlockBuilderHelpers', 'buildBlobHints', async (_span, txEffects)=>{
+    const blobFields = txEffects.flatMap((tx)=>tx.toBlobFields());
+    const blobs = await Blob.getBlobs(blobFields);
+    const blobCommitments = blobs.map((b)=>b.commitmentToFields());
+    const blobsHash = new Fr(getBlobsHashFromBlobs(blobs));
+    return {
+        blobFields,
+        blobCommitments,
+        blobs,
+        blobsHash
+    };
+});
+export const buildHeaderFromCircuitOutputs = runInSpan('BlockBuilderHelpers', 'buildHeaderFromCircuitOutputs', async (_span, previousRollupData, parityPublicInputs, rootRollupOutputs, endState, logger)=>{
+    if (previousRollupData.length > 2) {
+        throw new Error(`There can't be more than 2 previous rollups. Received ${previousRollupData.length}.`);
+    }
+    const blobsHash = rootRollupOutputs.blobPublicInputs[0].getBlobsHash();
+    const numTxs = previousRollupData.reduce((sum, d)=>sum + d.numTxs, 0);
+    const outHash = previousRollupData.length === 0 ? Fr.ZERO.toBuffer() : previousRollupData.length === 1 ? previousRollupData[0].outHash.toBuffer() : sha256Trunc(Buffer.concat([
+        previousRollupData[0].outHash.toBuffer(),
+        previousRollupData[1].outHash.toBuffer()
+    ]));
+    const contentCommitment = new ContentCommitment(new Fr(numTxs), blobsHash, parityPublicInputs.shaRoot.toBuffer(), 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);
+    const header = new BlockHeader(rootRollupOutputs.previousArchive, contentCommitment, endState, rootRollupOutputs.endGlobalVariables, accumulatedFees, accumulatedManaUsed);
+    if (!(await header.hash()).equals(rootRollupOutputs.endBlockHash)) {
+        logger?.error(`Block header mismatch when building header from circuit outputs.` + `\n\nHeader: ${inspect(header)}` + `\n\nCircuit: ${toFriendlyJSON(rootRollupOutputs)}`);
+        throw new Error(`Block header mismatch when building from circuit outputs`);
+    }
+    return header;
+});
+export const buildHeaderAndBodyFromTxs = runInSpan('BlockBuilderHelpers', 'buildHeaderAndBodyFromTxs', async (span, txs, globalVariables, l1ToL2Messages, db)=>{
+    span.setAttribute(Attributes.BLOCK_NUMBER, globalVariables.blockNumber.toNumber());
+    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 numTxs = body.txEffects.length;
+    const outHash = numTxs === 0 ? Fr.ZERO.toBuffer() : numTxs === 1 ? body.txEffects[0].txOutHash() : computeUnbalancedMerkleRoot(body.txEffects.map((tx)=>tx.txOutHash()), TxEffect.empty().txOutHash());
+    l1ToL2Messages = padArrayEnd(l1ToL2Messages, 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);
+    const parityShaRoot = await parityCalculator.computeTreeRoot(l1ToL2Messages.map((msg)=>msg.toBuffer()));
+    const blobsHash = getBlobsHashFromBlobs(await Blob.getBlobs(body.toBlobFields()));
+    const contentCommitment = new ContentCommitment(new Fr(numTxs), blobsHash, parityShaRoot, outHash);
+    const fees = body.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);
+    return {
+        header,
+        body
+    };
+});
+export function getBlobsHashFromBlobs(inputs) {
+    const blobHashes = serializeToBuffer(inputs.map((b)=>b.getEthVersionedBlobHash()));
+    return sha256Trunc(serializeToBuffer(blobHashes));
+}
+// Validate that the roots of all local trees match the output of the root circuit simulation
+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 getRootTreeSiblingPath(treeId, db) {
+    const { size } = await db.getTreeInfo(treeId);
+    const path = await db.getSiblingPath(treeId, size);
+    return padArrayEnd(path.toFields(), Fr.ZERO, getTreeHeight(treeId));
+}
+export const getConstantRollupData = runInSpan('BlockBuilderHelpers', 'getConstantRollupData', async (_span, globalVariables, db)=>{
+    return ConstantRollupData.from({
+        vkTreeRoot: getVKTreeRoot(),
+        protocolContractTreeRoot,
+        lastArchive: await getTreeSnapshot(MerkleTreeId.ARCHIVE, db),
+        globalVariables
+    });
+});
+export async function getTreeSnapshot(id, db) {
+    const treeInfo = await db.getTreeInfo(id);
+    return new AppendOnlyTreeSnapshot(Fr.fromBuffer(treeInfo.root), Number(treeInfo.size));
+}
+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);
+    // Drop the first subtreeHeight items since we only care about the path to the subtree root
+    return fullSiblingPath.getSubtreeSiblingPath(subtreeHeight).toFields();
+}
+// Scan a tree searching for a specific value and return a membership witness proof for it
+export async function getMembershipWitnessFor(value, treeId, height, db) {
+    // If this is an empty tx, then just return zeroes
+    if (value.isZero()) {
+        return makeEmptyMembershipWitness(height);
+    }
+    const index = (await db.findLeafIndices(treeId, [
+        value.toBuffer()
+    ]))[0];
+    if (index === undefined) {
+        throw new Error(`Leaf with value ${value} not found in tree ${MerkleTreeId[treeId]}`);
+    }
+    const path = await db.getSiblingPath(treeId, index);
+    return new MembershipWitness(height, index, assertLength(path.toFields(), height));
+}
+export function validatePartialState(partialState, treeSnapshots) {
+    validateSimulatedTree(treeSnapshots.get(MerkleTreeId.NOTE_HASH_TREE), partialState.noteHashTree, 'NoteHashTree');
+    validateSimulatedTree(treeSnapshots.get(MerkleTreeId.NULLIFIER_TREE), partialState.nullifierTree, 'NullifierTree');
+    validateSimulatedTree(treeSnapshots.get(MerkleTreeId.PUBLIC_DATA_TREE), partialState.publicDataTree, 'PublicDataTree');
+}
+// Helper for comparing two trees snapshots
+function validateSimulatedTree(localTree, simulatedTree, name, label) {
+    if (!simulatedTree.root.toBuffer().equals(localTree.root.toBuffer())) {
+        throw new Error(`${label ?? name} tree root mismatch (local ${localTree.root}, simulated ${simulatedTree.root})`);
+    }
+    if (simulatedTree.nextAvailableLeafIndex !== localTree.nextAvailableLeafIndex) {
+        throw new Error(`${label ?? name} tree next available leaf index mismatch (local ${localTree.nextAvailableLeafIndex}, simulated ${simulatedTree.nextAvailableLeafIndex})`);
+    }
+}
+export function validateTx(tx) {
+    const txHeader = tx.constants.historicalHeader;
+    if (txHeader.state.l1ToL2MessageTree.isZero()) {
+        throw new Error(`Empty L1 to L2 messages tree in tx: ${toFriendlyJSON(tx)}`);
+    }
+    if (txHeader.state.partial.noteHashTree.isZero()) {
+        throw new Error(`Empty note hash tree in tx: ${toFriendlyJSON(tx)}`);
+    }
+    if (txHeader.state.partial.nullifierTree.isZero()) {
+        throw new Error(`Empty nullifier tree in tx: ${toFriendlyJSON(tx)}`);
+    }
+    if (txHeader.state.partial.publicDataTree.isZero()) {
+        throw new Error(`Empty public data tree in tx: ${toFriendlyJSON(tx)}`);
+    }
+}

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

@@ -0,0 +1,76 @@
+import { 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 { Fr } from '@aztec/foundation/fields';
+import type { Logger } from '@aztec/foundation/log';
+import type { Tuple } from '@aztec/foundation/serialize';
+import { type TreeNodeLocation } from '@aztec/foundation/trees';
+import type { 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, SingleTxBlockRootRollupInputs } from '@aztec/stdlib/rollup';
+import type { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+import { type BlockHeader, type GlobalVariables } from '@aztec/stdlib/tx';
+import type { EpochProvingState } from './epoch-proving-state.js';
+import type { TxProvingState } from './tx-proving-state.js';
+export type TreeSnapshots = Map<MerkleTreeId, AppendOnlyTreeSnapshot>;
+/**
+ * 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.
+ */
+export declare class BlockProvingState {
+    #private;
+    readonly index: number;
+    readonly globalVariables: GlobalVariables;
+    readonly newL1ToL2Messages: Fr[];
+    private readonly l1ToL2MessageSubtreeSiblingPath;
+    private readonly l1ToL2MessageTreeSnapshotAfterInsertion;
+    private readonly lastArchiveSnapshot;
+    private readonly newArchiveSiblingPath;
+    private readonly previousBlockHeader;
+    private readonly parentEpoch;
+    private baseOrMergeProvingOutputs;
+    private baseParityProvingOutputs;
+    private rootParityProvingOutput;
+    private blockRootProvingOutput;
+    blockRootRollupStarted: boolean;
+    block: L2Block | undefined;
+    spongeBlobState: SpongeBlob | undefined;
+    totalNumTxs: number;
+    private txs;
+    error: string | undefined;
+    constructor(index: number, globalVariables: GlobalVariables, newL1ToL2Messages: Fr[], l1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>, l1ToL2MessageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot, lastArchiveSnapshot: AppendOnlyTreeSnapshot, newArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, previousBlockHeader: BlockHeader, parentEpoch: EpochProvingState);
+    get blockNumber(): number;
+    startNewBlock(numTxs: number, numBlobFields: number): void;
+    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;
+    setBaseParityProof(index: number, provingOutput: PublicInputsAndRecursiveProof<ParityPublicInputs>): void;
+    setRootParityProof(provingOutput: PublicInputsAndRecursiveProof<ParityPublicInputs>): void;
+    setBlockRootRollupProof(provingOutput: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
+    get allTxs(): TxProvingState[];
+    /** Returns the block number as an epoch number. Used for prioritizing proof requests. */
+    get epochNumber(): number;
+    getParentLocation(location: TreeNodeLocation): TreeNodeLocation;
+    getMergeRollupInputs(mergeLocation: TreeNodeLocation): MergeRollupInputs;
+    getBlockRootRollupTypeAndInputs(proverId: Fr): Promise<{
+        rollupType: string;
+        inputs: EmptyBlockRootRollupInputs;
+    } | {
+        rollupType: string;
+        inputs: SingleTxBlockRootRollupInputs;
+    } | {
+        rollupType: string;
+        inputs: BlockRootRollupInputs;
+    }>;
+    getPaddingBlockRootInputs(proverId: Fr): Promise<EmptyBlockRootRollupInputs>;
+    getRootParityInputs(): RootParityInputs;
+    getTxProvingState(txIndex: number): TxProvingState;
+    buildHeaderFromProvingOutputs(logger?: Logger): Promise<BlockHeader>;
+    isReadyForMergeRollup(location: TreeNodeLocation): boolean;
+    isReadyForBlockRootRollup(): boolean;
+    isReadyForRootParity(): boolean;
+    isComplete(): boolean;
+    verifyState(): boolean;
+    reject(reason: string): void;
+}
+//# sourceMappingURL=block-proving-state.d.ts.map

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

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