@aztec-labs/prover-client 6.0.0-nightly.20260829

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

@@ -0,0 +1,274 @@
+import { BatchedBlobAccumulator, computeBlobsHashFromBlobs, encodeBlockBlobData, getBlobCommitmentsFromBlobs, getBlobsPerL1Block } from '@aztec-labs/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-labs/constants';
+import { makeTuple } from '@aztec-labs/foundation/array';
+import { BlockNumber } from '@aztec-labs/foundation/branded-types';
+import { padArrayEnd } from '@aztec-labs/foundation/collection';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { assertLength, toFriendlyJSON } from '@aztec-labs/foundation/serialize';
+import { MembershipWitness } from '@aztec-labs/foundation/trees';
+import { getVkData } from '@aztec-labs/noir-protocol-circuits-types/server/vks';
+import { getVKIndex, getVKSiblingPath } from '@aztec-labs/noir-protocol-circuits-types/vk-tree';
+import { computeFeePayerBalanceLeafSlot } from '@aztec-labs/protocol-contracts/fee-juice';
+import { Body } from '@aztec-labs/stdlib/block';
+import { ContractClassLogFields } from '@aztec-labs/stdlib/logs';
+import { Proof, ProofData, RecursiveProof } from '@aztec-labs/stdlib/proofs';
+import { BlockConstantData, PrivateBaseRollupHints, PublicBaseRollupHints, PublicChonkVerifierPrivateInputs, TreeSnapshotDiffHints } from '@aztec-labs/stdlib/rollup';
+import { AppendOnlyTreeSnapshot, MerkleTreeId, NullifierLeafPreimage, getTreeHeight } from '@aztec-labs/stdlib/trees';
+import { BlockHeader, GlobalVariables, PartialStateReference } from '@aztec-labs/stdlib/tx';
+import { VkData } from '@aztec-labs/stdlib/vks';
+import { Attributes, runInSpan } from '@aztec-labs/telemetry-client';
+// Builds the hints for base rollup. Updating the contract, nullifier, and data trees in the process.
+export const insertSideEffectsAndBuildBaseRollupHints = runInSpan('BlockBuilderHelpers', 'buildBaseRollupHints', async (span, tx, lastArchive, newL1ToL2MessageTreeSnapshot, startSpongeBlob, proverId, db)=>{
+    span.setAttribute(Attributes.TX_HASH, tx.hash.toString());
+    // Get trees info before any changes hit
+    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);
+    const { nullifierInsertionResult, publicDataInsertionResult } = await insertSideEffects(tx, db);
+    const blockHash = await tx.data.constants.anchorBlockHeader.hash();
+    const anchorBlockArchiveSiblingPath = (await getMembershipWitnessFor(blockHash.toFr(), 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) {
+        return PublicBaseRollupHints.from({
+            startSpongeBlob,
+            lastArchive,
+            anchorBlockArchiveSiblingPath,
+            contractClassLogsFields
+        });
+    } else {
+        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 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 (!leafSlot.equals(feePayerBalanceLeafPreimage.leaf.slot)) {
+            throw new Error(`Cannot find the public data tree leaf for the fee payer's balance`);
+        }
+        // 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,
+            nullifierPredecessorMembershipWitnesses,
+            sortedNullifiers,
+            sortedNullifierIndexes,
+            nullifierSubtreeRootSiblingPath,
+            feePayerBalanceMembershipWitness
+        });
+        const constants = BlockConstantData.from({
+            lastArchive,
+            l1ToL2TreeSnapshot: newL1ToL2MessageTreeSnapshot,
+            vkTreeRoot: tx.data.constants.vkTreeRoot,
+            protocolContractsHash: tx.data.constants.protocolContractsHash,
+            globalVariables: tx.globalVariables,
+            proverId
+        });
+        return PrivateBaseRollupHints.from({
+            start,
+            startSpongeBlob,
+            treeSnapshotDiffHints,
+            feePayerBalanceLeafPreimage,
+            anchorBlockArchiveSiblingPath,
+            contractClassLogsFields,
+            constants
+        });
+    }
+});
+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);
+    return new RecursiveProof(tx.chonkProof.fields, binaryProof, true, CHONK_PROOF_LENGTH);
+}
+export function getPublicChonkVerifierPrivateInputsFromTx(tx, proverId) {
+    const proofData = new ProofData(tx.data.toPrivateToPublicKernelCircuitPublicInputs(), getChonkProofFromTx(tx), getVkData('HidingKernelToPublic'));
+    return new PublicChonkVerifierPrivateInputs(proofData, proverId);
+}
+// 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 = async (blobFields)=>{
+    const blobs = await getBlobsPerL1Block(blobFields);
+    const blobCommitments = getBlobCommitmentsFromBlobs(blobs);
+    const blobsHash = computeBlobsHashFromBlobs(blobs);
+    return {
+        blobCommitments,
+        blobs,
+        blobsHash
+    };
+};
+export const buildFinalBlobChallenges = async (blobFieldsPerCheckpoint)=>{
+    return await BatchedBlobAccumulator.precomputeBatchedBlobChallenges(blobFieldsPerCheckpoint);
+};
+export const accumulateBlobs = runInSpan('BlockBuilderHelpers', 'accumulateBlobs', async (_span, blobFields, startBlobAccumulator)=>{
+    const endBlobAccumulator = await startBlobAccumulator.accumulateFields(blobFields);
+    return endBlobAccumulator;
+});
+export const buildHeaderFromCircuitOutputs = runInSpan('BlockBuilderHelpers', 'buildHeaderFromCircuitOutputs', async (_span, blockRootRollupOutput)=>{
+    const constants = blockRootRollupOutput.constants;
+    const globalVariables = GlobalVariables.from({
+        chainId: constants.chainId,
+        version: constants.version,
+        blockNumber: BlockNumber(blockRootRollupOutput.previousArchive.nextAvailableLeafIndex),
+        timestamp: blockRootRollupOutput.timestamp,
+        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, lastArchive, endState, globalVariables, startSpongeBlob)=>{
+    span.setAttribute(Attributes.BLOCK_NUMBER, globalVariables.blockNumber);
+    const txEffects = txs.map((tx)=>tx.txEffect);
+    const body = new Body(txEffects);
+    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,
+        // Every block carries its own post-bundle l1-to-l2 message tree root.
+        l1ToL2MessageRoot: l1ToL2MessageTree.root,
+        txs: body.toTxBlobData()
+    });
+    const endSpongeBlob = startSpongeBlob.clone();
+    await endSpongeBlob.absorb(blockBlobFields);
+    const spongeBlobHash = await endSpongeBlob.squeeze();
+    const header = BlockHeader.from({
+        lastArchive,
+        state: endState,
+        spongeBlobHash,
+        globalVariables,
+        totalFees,
+        totalManaUsed
+    });
+    return {
+        header,
+        body,
+        blockBlobFields
+    };
+});
+export async function getLastSiblingPath(treeId, db) {
+    const { size } = await db.getTreeInfo(treeId);
+    const path = await db.getSiblingPath(treeId, size - 1n);
+    return padArrayEnd(path.toFields(), Fr.ZERO, getTreeHeight(treeId));
+}
+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 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));
+}
+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();
+}
+/**
+ * Returns the full-height frontier (left-sibling path) at a tree's next-available leaf index — the hint the append
+ * circuits re-hash against the snapshot root when appending leaves at a compact (unaligned) index.
+ */ export async function getFrontierSiblingPath(treeId, db) {
+    const nextAvailableLeafIndex = await db.getTreeInfo(treeId).then((t)=>t.size);
+    return (await db.getSiblingPath(treeId, nextAvailableLeafIndex)).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.data.constants.anchorBlockHeader;
+    if (txHeader.state.l1ToL2MessageTree.isEmpty()) {
+        throw new Error(`Empty L1 to L2 messages tree in tx: ${toFriendlyJSON(tx)}`);
+    }
+    if (txHeader.state.partial.noteHashTree.isEmpty()) {
+        throw new Error(`Empty note hash tree in tx: ${toFriendlyJSON(tx)}`);
+    }
+    if (txHeader.state.partial.nullifierTree.isEmpty()) {
+        throw new Error(`Empty nullifier tree in tx: ${toFriendlyJSON(tx)}`);
+    }
+    if (txHeader.state.partial.publicDataTree.isEmpty()) {
+        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

@@ -0,0 +1,107 @@
+import { type BlockBlobData, type BlockEndBlobData, type SpongeBlob } from '@aztec-labs/blob-lib';
+import type { ARCHIVE_HEIGHT, L1_TO_L2_MSG_TREE_HEIGHT, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec-labs/constants';
+import { BlockNumber } from '@aztec-labs/foundation/branded-types';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { Tuple } from '@aztec-labs/foundation/serialize';
+import { type TreeNodeLocation } from '@aztec-labs/foundation/trees';
+import type { PublicInputsAndRecursiveProof } from '@aztec-labs/stdlib/interfaces/server';
+import { type L1ToL2MessageSponge } from '@aztec-labs/stdlib/messaging';
+import { BlockRollupPublicInputs, BlockRootNoTxsRollupPrivateInputs, BlockRootRollupPrivateInputs, BlockRootSingleTxRollupPrivateInputs, CheckpointConstantData, TxMergeRollupPrivateInputs, type TxRollupPublicInputs } from '@aztec-labs/stdlib/rollup';
+import { AppendOnlyTreeSnapshot } from '@aztec-labs/stdlib/trees';
+import { BlockHeader, StateReference } from '@aztec-labs/stdlib/tx';
+import type { UInt64 } from '@aztec-labs/stdlib/types';
+import type { CheckpointProvingState } from './checkpoint-proving-state.js';
+import type { TxProvingState } from './tx-proving-state.js';
+export type ProofState<T, PROOF_LENGTH extends number> = {
+    provingOutput?: PublicInputsAndRecursiveProof<T, PROOF_LENGTH>;
+    isProving?: boolean;
+};
+/**
+ * The block-root rollup flavor a block proves with and its private inputs, discriminated by circuit name so callers
+ * can dispatch to the matching prover entrypoint with the correctly-typed inputs.
+ */
+export type BlockRootRollupTypeAndInputs = {
+    rollupType: 'rollup-block-root-no-txs';
+    inputs: BlockRootNoTxsRollupPrivateInputs;
+} | {
+    rollupType: 'rollup-block-root-single-tx';
+    inputs: BlockRootSingleTxRollupPrivateInputs;
+} | {
+    rollupType: 'rollup-block-root';
+    inputs: BlockRootRollupPrivateInputs;
+};
+/**
+ * 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 blockNumber: BlockNumber;
+    readonly totalNumTxs: number;
+    private readonly constants;
+    private readonly timestamp;
+    readonly lastArchiveTreeSnapshot: AppendOnlyTreeSnapshot;
+    private readonly lastArchiveSiblingPath;
+    private readonly previousState;
+    private readonly startL1ToL2MessageTreeSnapshot;
+    readonly newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot;
+    private readonly l1ToL2MessageFrontierHint;
+    private readonly l1ToL2Messages;
+    private readonly startMsgSponge;
+    private readonly endMsgSponge;
+    private readonly startSpongeBlob;
+    parentCheckpoint: CheckpointProvingState;
+    private baseOrMergeProofs;
+    private blockRootProof;
+    private builtBlockHeader;
+    private builtArchive;
+    private endState;
+    private endSpongeBlob;
+    private txs;
+    private error;
+    constructor(index: number, blockNumber: BlockNumber, totalNumTxs: number, constants: CheckpointConstantData, timestamp: UInt64, lastArchiveTreeSnapshot: AppendOnlyTreeSnapshot, lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, previousState: StateReference, startL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, l1ToL2MessageFrontierHint: Tuple<Fr, typeof L1_TO_L2_MSG_TREE_HEIGHT>, l1ToL2Messages: Fr[], startMsgSponge: L1ToL2MessageSponge, endMsgSponge: L1ToL2MessageSponge, startSpongeBlob: SpongeBlob, parentCheckpoint: CheckpointProvingState);
+    /** The message sponge after absorbing this block's slice; inherited by the next block as its start sponge. */
+    getEndMsgSponge(): L1ToL2MessageSponge;
+    get epochNumber(): number;
+    addNewTx(tx: TxProvingState): number;
+    isAcceptingTxs(): boolean;
+    getProcessedTxs(): import("@aztec-labs/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;
+    tryStartProvingBlockRoot(): boolean;
+    setBlockRootRollupProof(provingOutput: PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): TreeNodeLocation;
+    getBlockRootRollupOutput(): BlockRollupPublicInputs | undefined;
+    buildBlockHeader(): Promise<BlockHeader>;
+    getBuiltBlockHeader(): BlockHeader | undefined;
+    setBuiltArchive(archive: AppendOnlyTreeSnapshot): void;
+    getBuiltArchive(): AppendOnlyTreeSnapshot | undefined;
+    getStartSpongeBlob(): SpongeBlob;
+    setEndSpongeBlob(endSpongeBlob: SpongeBlob): void;
+    getEndSpongeBlob(): SpongeBlob | undefined;
+    setEndState(endState: StateReference): void;
+    hasEndState(): boolean;
+    getBlockEndBlobFields(): Fr[];
+    getBlockEndBlobData(): BlockEndBlobData;
+    getBlockBlobData(): BlockBlobData;
+    getTxEffects(): import("@aztec-labs/stdlib/tx").TxEffect[];
+    getParentLocation(location: TreeNodeLocation): TreeNodeLocation;
+    getMergeRollupInputs(mergeLocation: TreeNodeLocation): TxMergeRollupPrivateInputs;
+    /**
+     * The block root variant is selected by transaction count alone. Whether this is the checkpoint's first block is
+     * expressed through the start sponge values it feeds the circuit, which the checkpoint root pins to their initial
+     * values for the leftmost block and the block merge pins to the previous block's end values otherwise.
+     */
+    getBlockRootRollupTypeAndInputs(): BlockRootRollupTypeAndInputs;
+    getTxProvingState(txIndex: number): TxProvingState;
+    buildHeaderFromProvingOutputs(): Promise<BlockHeader>;
+    isReadyForMergeRollup(location: TreeNodeLocation): boolean;
+    isReadyForBlockRootRollup(): boolean;
+    isComplete(): boolean;
+    verifyState(): boolean;
+    getError(): string | undefined;
+    reject(reason: string): void;
+}
+//# sourceMappingURL=data:application/json;base64,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

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