@aztec/prover-client 0.0.0-test.0

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

@@ -0,0 +1,269 @@
+import { SpongeBlob } from '@aztec/blob-lib';
+import { BLOBS_PER_BLOCK, FIELDS_PER_BLOB, NUM_BASE_PARITY_PER_ROOT_PARITY, VK_TREE_HEIGHT } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import { MembershipWitness, UnbalancedTreeStore } from '@aztec/foundation/trees';
+import { getVKIndex, getVKSiblingPath, getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { RootParityInput, RootParityInputs } from '@aztec/stdlib/parity';
+import { BlockRootRollupBlobData, BlockRootRollupData, BlockRootRollupInputs, ConstantRollupData, EmptyBlockRootRollupInputs, MergeRollupInputs, PreviousRollupData, SingleTxBlockRootRollupInputs } from '@aztec/stdlib/rollup';
+import { StateReference } from '@aztec/stdlib/tx';
+import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-helpers.js';
+/**
+ * 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 class BlockProvingState {
+    index;
+    globalVariables;
+    newL1ToL2Messages;
+    l1ToL2MessageSubtreeSiblingPath;
+    l1ToL2MessageTreeSnapshotAfterInsertion;
+    lastArchiveSnapshot;
+    newArchiveSiblingPath;
+    previousBlockHeader;
+    parentEpoch;
+    baseOrMergeProvingOutputs;
+    baseParityProvingOutputs;
+    rootParityProvingOutput;
+    blockRootProvingOutput;
+    blockRootRollupStarted;
+    block;
+    spongeBlobState;
+    totalNumTxs;
+    txs;
+    error;
+    constructor(index, globalVariables, newL1ToL2Messages, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchiveSnapshot, newArchiveSiblingPath, previousBlockHeader, parentEpoch){
+        this.index = index;
+        this.globalVariables = globalVariables;
+        this.newL1ToL2Messages = newL1ToL2Messages;
+        this.l1ToL2MessageSubtreeSiblingPath = l1ToL2MessageSubtreeSiblingPath;
+        this.l1ToL2MessageTreeSnapshotAfterInsertion = l1ToL2MessageTreeSnapshotAfterInsertion;
+        this.lastArchiveSnapshot = lastArchiveSnapshot;
+        this.newArchiveSiblingPath = newArchiveSiblingPath;
+        this.previousBlockHeader = previousBlockHeader;
+        this.parentEpoch = parentEpoch;
+        this.baseOrMergeProvingOutputs = new UnbalancedTreeStore(0);
+        this.blockRootRollupStarted = false;
+        this.txs = [];
+        this.baseParityProvingOutputs = Array.from({
+            length: NUM_BASE_PARITY_PER_ROOT_PARITY
+        }).map((_)=>undefined);
+        this.totalNumTxs = 0;
+    }
+    get blockNumber() {
+        return this.globalVariables.blockNumber.toNumber();
+    }
+    startNewBlock(numTxs, numBlobFields) {
+        if (this.spongeBlobState) {
+            throw new Error(`Block ${this.blockNumber} already initalised.`);
+        }
+        this.baseOrMergeProvingOutputs = new UnbalancedTreeStore(numTxs);
+        // Initialise the sponge which will eventually absorb all tx effects to be added to the blob.
+        // Like l1 to l2 messages, we need to know beforehand how many effects will be absorbed.
+        this.spongeBlobState = SpongeBlob.init(numBlobFields);
+        this.totalNumTxs = numTxs;
+    }
+    // Adds a transaction to the proving state, returns it's index
+    addNewTx(tx) {
+        if (!this.spongeBlobState) {
+            throw new Error(`Invalid block proving state, call startNewBlock before adding transactions.`);
+        }
+        const txIndex = this.txs.length;
+        this.txs[txIndex] = tx;
+        return txIndex;
+    }
+    setBaseRollupProof(txIndex, provingOutput) {
+        return this.baseOrMergeProvingOutputs.setLeaf(txIndex, provingOutput);
+    }
+    setMergeRollupProof(location, provingOutput) {
+        this.baseOrMergeProvingOutputs.setNode(location, provingOutput);
+    }
+    // Stores a set of root parity inputs at the given index
+    setBaseParityProof(index, provingOutput) {
+        if (index >= NUM_BASE_PARITY_PER_ROOT_PARITY) {
+            throw new Error(`Unable to set a base parity proofs at index ${index}. Expected at most ${NUM_BASE_PARITY_PER_ROOT_PARITY} proofs.`);
+        }
+        this.baseParityProvingOutputs[index] = provingOutput;
+    }
+    setRootParityProof(provingOutput) {
+        this.rootParityProvingOutput = provingOutput;
+    }
+    setBlockRootRollupProof(provingOutput) {
+        this.blockRootProvingOutput = provingOutput;
+    }
+    // Returns the complete set of transaction proving state objects
+    get allTxs() {
+        return this.txs;
+    }
+    /** Returns the block number as an epoch number. Used for prioritizing proof requests. */ get epochNumber() {
+        return this.parentEpoch.epochNumber;
+    }
+    getParentLocation(location) {
+        return this.baseOrMergeProvingOutputs.getParentLocation(location);
+    }
+    getMergeRollupInputs(mergeLocation) {
+        const [left, right] = this.baseOrMergeProvingOutputs.getChildren(mergeLocation);
+        if (!left || !right) {
+            throw new Error('At lease one child is not ready.');
+        }
+        return new MergeRollupInputs([
+            this.#getPreviousRollupData(left),
+            this.#getPreviousRollupData(right)
+        ]);
+    }
+    async getBlockRootRollupTypeAndInputs(proverId) {
+        if (!this.rootParityProvingOutput) {
+            throw new Error('Root parity is not ready.');
+        }
+        const proofs = this.#getChildProofsForBlockRoot();
+        const nonEmptyProofs = proofs.filter((p)=>!!p);
+        if (proofs.length !== nonEmptyProofs.length) {
+            throw new Error('At lease one child is not ready for the block root.');
+        }
+        const data = this.#getBlockRootRollupData(proverId);
+        if (this.totalNumTxs === 0) {
+            const constants = ConstantRollupData.from({
+                lastArchive: this.lastArchiveSnapshot,
+                globalVariables: this.globalVariables,
+                vkTreeRoot: getVKTreeRoot(),
+                protocolContractTreeRoot
+            });
+            return {
+                rollupType: 'empty-block-root-rollup',
+                inputs: EmptyBlockRootRollupInputs.from({
+                    data,
+                    constants,
+                    isPadding: false
+                })
+            };
+        }
+        const previousRollupData = await Promise.all(nonEmptyProofs.map((p)=>this.#getPreviousRollupData(p)));
+        const blobData = await this.#getBlockRootRollupBlobData();
+        if (previousRollupData.length === 1) {
+            return {
+                rollupType: 'single-tx-block-root-rollup',
+                inputs: new SingleTxBlockRootRollupInputs(previousRollupData, data, blobData)
+            };
+        } else {
+            return {
+                rollupType: 'block-root-rollup',
+                inputs: new BlockRootRollupInputs(previousRollupData, data, blobData)
+            };
+        }
+    }
+    async getPaddingBlockRootInputs(proverId) {
+        if (!this.rootParityProvingOutput) {
+            throw new Error('Root parity is not ready.');
+        }
+        // Use the new block header and archive of the current block as the previous header and archiver of the next padding block.
+        const newBlockHeader = await this.buildHeaderFromProvingOutputs();
+        const newArchive = this.blockRootProvingOutput.inputs.newArchive;
+        const data = BlockRootRollupData.from({
+            l1ToL2Roots: this.#getRootParityData(this.rootParityProvingOutput),
+            l1ToL2MessageSubtreeSiblingPath: this.l1ToL2MessageSubtreeSiblingPath,
+            newArchiveSiblingPath: this.newArchiveSiblingPath,
+            previousBlockHeader: newBlockHeader,
+            proverId
+        });
+        const constants = ConstantRollupData.from({
+            lastArchive: newArchive,
+            globalVariables: this.globalVariables,
+            vkTreeRoot: getVKTreeRoot(),
+            protocolContractTreeRoot
+        });
+        return EmptyBlockRootRollupInputs.from({
+            data,
+            constants,
+            isPadding: true
+        });
+    }
+    getRootParityInputs() {
+        if (!this.baseParityProvingOutputs.every((p)=>!!p)) {
+            throw new Error('At lease one base parity is not ready.');
+        }
+        const children = this.baseParityProvingOutputs.map((p)=>this.#getRootParityData(p));
+        return new RootParityInputs(children);
+    }
+    // Returns a specific transaction proving state
+    getTxProvingState(txIndex) {
+        return this.txs[txIndex];
+    }
+    async buildHeaderFromProvingOutputs(logger) {
+        const previousRollupData = this.totalNumTxs === 0 ? [] : await Promise.all(this.#getChildProofsForBlockRoot().map((p)=>this.#getPreviousRollupData(p)));
+        let endPartialState = this.previousBlockHeader.state.partial;
+        if (this.totalNumTxs !== 0) {
+            const previousRollupData = this.#getChildProofsForBlockRoot();
+            const lastRollup = previousRollupData[previousRollupData.length - 1];
+            if (!lastRollup) {
+                throw new Error('End state of the block is not available. Last rollup is not ready yet.');
+            }
+            endPartialState = lastRollup.inputs.end;
+        }
+        const endState = new StateReference(this.l1ToL2MessageTreeSnapshotAfterInsertion, endPartialState);
+        return buildHeaderFromCircuitOutputs(previousRollupData.map((d)=>d.baseOrMergeRollupPublicInputs), this.rootParityProvingOutput.inputs, this.blockRootProvingOutput.inputs, endState, logger);
+    }
+    isReadyForMergeRollup(location) {
+        return this.baseOrMergeProvingOutputs.getSibling(location) !== undefined;
+    }
+    // Returns true if we have sufficient inputs to execute the block root rollup
+    isReadyForBlockRootRollup() {
+        const childProofs = this.#getChildProofsForBlockRoot();
+        return this.block !== undefined && this.rootParityProvingOutput !== undefined && childProofs.every((p)=>!!p);
+    }
+    // Returns true if we have sufficient root parity inputs to execute the root parity circuit
+    isReadyForRootParity() {
+        return this.baseParityProvingOutputs.every((p)=>!!p);
+    }
+    isComplete() {
+        return !!this.blockRootProvingOutput;
+    }
+    // Returns whether the proving state is still valid
+    verifyState() {
+        return this.parentEpoch.verifyState();
+    }
+    reject(reason) {
+        this.error = reason;
+        this.parentEpoch.reject(reason);
+    }
+    #getBlockRootRollupData(proverId) {
+        return BlockRootRollupData.from({
+            l1ToL2Roots: this.#getRootParityData(this.rootParityProvingOutput),
+            l1ToL2MessageSubtreeSiblingPath: this.l1ToL2MessageSubtreeSiblingPath,
+            newArchiveSiblingPath: this.newArchiveSiblingPath,
+            previousBlockHeader: this.previousBlockHeader,
+            proverId
+        });
+    }
+    async #getBlockRootRollupBlobData() {
+        const txEffects = this.txs.map((txProvingState)=>txProvingState.processedTx.txEffect);
+        const { blobFields, blobCommitments, blobsHash } = await buildBlobHints(txEffects);
+        return BlockRootRollupBlobData.from({
+            blobFields: padArrayEnd(blobFields, Fr.ZERO, FIELDS_PER_BLOB * BLOBS_PER_BLOCK),
+            blobCommitments: padArrayEnd(blobCommitments, [
+                Fr.ZERO,
+                Fr.ZERO
+            ], BLOBS_PER_BLOCK),
+            blobsHash
+        });
+    }
+    #getChildProofsForBlockRoot() {
+        if (this.totalNumTxs === 0) {
+            return [];
+        }
+        const rootLocation = {
+            level: 0,
+            index: 0
+        };
+        // If there's only 1 tx, its base rollup proof will be stored at the root.
+        return this.totalNumTxs === 1 ? [
+            this.baseOrMergeProvingOutputs.getNode(rootLocation)
+        ] : this.baseOrMergeProvingOutputs.getChildren(rootLocation);
+    }
+    #getPreviousRollupData({ inputs, proof, verificationKey }) {
+        const leafIndex = getVKIndex(verificationKey.keyAsFields);
+        return new PreviousRollupData(inputs, proof, verificationKey.keyAsFields, new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), getVKSiblingPath(leafIndex)));
+    }
+    #getRootParityData({ inputs, proof, verificationKey }) {
+        return new RootParityInput(proof, verificationKey.keyAsFields, getVKSiblingPath(getVKIndex(verificationKey)), inputs);
+    }
+}

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

@@ -0,0 +1,60 @@
+import { type ARCHIVE_HEIGHT, type L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import type { Fr } from '@aztec/foundation/fields';
+import type { Tuple } from '@aztec/foundation/serialize';
+import { type TreeNodeLocation } from '@aztec/foundation/trees';
+import type { ProofAndVerificationKey, PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
+import type { Proof } from '@aztec/stdlib/proofs';
+import { BlockMergeRollupInputs, type BlockRootOrBlockMergePublicInputs, RootRollupInputs, type RootRollupPublicInputs } from '@aztec/stdlib/rollup';
+import type { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+import type { BlockHeader, GlobalVariables } from '@aztec/stdlib/tx';
+import { BlockProvingState } from './block-proving-state.js';
+export type TreeSnapshots = Map<MerkleTreeId, AppendOnlyTreeSnapshot>;
+export type ProvingResult = {
+    status: 'success';
+} | {
+    status: 'failure';
+    reason: string;
+};
+/**
+ * The current state of the proving schedule for an epoch.
+ * Contains the raw inputs and intermediate state to generate every constituent proof in the tree.
+ * Carries an identifier so we can identify if the proving state is discarded and a new one started.
+ * Captures resolve and reject callbacks to provide a promise base interface to the consumer of our proving.
+ */
+export declare class EpochProvingState {
+    #private;
+    readonly epochNumber: number;
+    readonly firstBlockNumber: number;
+    readonly totalNumBlocks: number;
+    private completionCallback;
+    private rejectionCallback;
+    private blockRootOrMergeProvingOutputs;
+    private paddingBlockRootProvingOutput;
+    private rootRollupProvingOutput;
+    private provingStateLifecycle;
+    readonly cachedTubeProofs: Map<string, Promise<ProofAndVerificationKey<538>>>;
+    blocks: (BlockProvingState | undefined)[];
+    constructor(epochNumber: number, firstBlockNumber: number, totalNumBlocks: number, completionCallback: (result: ProvingResult) => void, rejectionCallback: (reason: string) => void);
+    startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: 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): BlockProvingState;
+    verifyState(): boolean;
+    isAcceptingBlocks(): boolean;
+    setBlockRootRollupProof(blockIndex: number, proof: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): TreeNodeLocation;
+    setBlockMergeRollupProof(location: TreeNodeLocation, proof: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
+    setRootRollupProof(proof: PublicInputsAndRecursiveProof<RootRollupPublicInputs>): void;
+    setPaddingBlockRootProof(proof: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
+    getParentLocation(location: TreeNodeLocation): TreeNodeLocation;
+    getBlockMergeRollupInputs(mergeLocation: TreeNodeLocation): BlockMergeRollupInputs;
+    getRootRollupInputs(proverId: Fr): RootRollupInputs;
+    getPaddingBlockRootInputs(proverId: Fr): Promise<import("@aztec/stdlib/rollup").EmptyBlockRootRollupInputs>;
+    getBlockProvingStateByBlockNumber(blockNumber: number): BlockProvingState | undefined;
+    getEpochProofResult(): {
+        proof: Proof;
+        publicInputs: RootRollupPublicInputs;
+    };
+    isReadyForBlockMerge(location: TreeNodeLocation): boolean;
+    isReadyForRootRollup(): boolean;
+    cancel(): void;
+    reject(reason: string): void;
+    resolve(result: ProvingResult): void;
+}
+//# sourceMappingURL=epoch-proving-state.d.ts.map

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

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

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

@@ -0,0 +1,163 @@
+import { VK_TREE_HEIGHT } from '@aztec/constants';
+import { MembershipWitness, UnbalancedTreeStore } from '@aztec/foundation/trees';
+import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { BlockMergeRollupInputs, PreviousRollupBlockData, RootRollupInputs } from '@aztec/stdlib/rollup';
+import { BlockProvingState } from './block-proving-state.js';
+var PROVING_STATE_LIFECYCLE = /*#__PURE__*/ function(PROVING_STATE_LIFECYCLE) {
+    PROVING_STATE_LIFECYCLE[PROVING_STATE_LIFECYCLE["PROVING_STATE_CREATED"] = 0] = "PROVING_STATE_CREATED";
+    PROVING_STATE_LIFECYCLE[PROVING_STATE_LIFECYCLE["PROVING_STATE_FULL"] = 1] = "PROVING_STATE_FULL";
+    PROVING_STATE_LIFECYCLE[PROVING_STATE_LIFECYCLE["PROVING_STATE_RESOLVED"] = 2] = "PROVING_STATE_RESOLVED";
+    PROVING_STATE_LIFECYCLE[PROVING_STATE_LIFECYCLE["PROVING_STATE_REJECTED"] = 3] = "PROVING_STATE_REJECTED";
+    return PROVING_STATE_LIFECYCLE;
+}(PROVING_STATE_LIFECYCLE || {});
+/**
+ * The current state of the proving schedule for an epoch.
+ * Contains the raw inputs and intermediate state to generate every constituent proof in the tree.
+ * Carries an identifier so we can identify if the proving state is discarded and a new one started.
+ * Captures resolve and reject callbacks to provide a promise base interface to the consumer of our proving.
+ */ export class EpochProvingState {
+    epochNumber;
+    firstBlockNumber;
+    totalNumBlocks;
+    completionCallback;
+    rejectionCallback;
+    blockRootOrMergeProvingOutputs;
+    paddingBlockRootProvingOutput;
+    rootRollupProvingOutput;
+    provingStateLifecycle;
+    // Map from tx hash to tube proof promise. Used when kickstarting tube proofs before tx processing.
+    cachedTubeProofs;
+    blocks;
+    constructor(epochNumber, firstBlockNumber, totalNumBlocks, completionCallback, rejectionCallback){
+        this.epochNumber = epochNumber;
+        this.firstBlockNumber = firstBlockNumber;
+        this.totalNumBlocks = totalNumBlocks;
+        this.completionCallback = completionCallback;
+        this.rejectionCallback = rejectionCallback;
+        this.provingStateLifecycle = 0;
+        this.cachedTubeProofs = new Map();
+        this.blocks = [];
+        this.blockRootOrMergeProvingOutputs = new UnbalancedTreeStore(totalNumBlocks);
+    }
+    // Adds a block to the proving state, returns its index
+    // Will update the proving life cycle if this is the last block
+    startNewBlock(globalVariables, l1ToL2Messages, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchiveSnapshot, newArchiveSiblingPath, previousBlockHeader) {
+        const index = globalVariables.blockNumber.toNumber() - this.firstBlockNumber;
+        const block = new BlockProvingState(index, globalVariables, l1ToL2Messages, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchiveSnapshot, newArchiveSiblingPath, previousBlockHeader, this);
+        this.blocks[index] = block;
+        if (this.blocks.filter((b)=>!!b).length === this.totalNumBlocks) {
+            this.provingStateLifecycle = 1;
+        }
+        return block;
+    }
+    // Returns true if this proving state is still valid, false otherwise
+    verifyState() {
+        return this.provingStateLifecycle === 0 || this.provingStateLifecycle === 1;
+    }
+    // Returns true if we are still able to accept blocks, false otherwise
+    isAcceptingBlocks() {
+        return this.provingStateLifecycle === 0;
+    }
+    setBlockRootRollupProof(blockIndex, proof) {
+        return this.blockRootOrMergeProvingOutputs.setLeaf(blockIndex, proof);
+    }
+    setBlockMergeRollupProof(location, proof) {
+        this.blockRootOrMergeProvingOutputs.setNode(location, proof);
+    }
+    setRootRollupProof(proof) {
+        this.rootRollupProvingOutput = proof;
+    }
+    setPaddingBlockRootProof(proof) {
+        this.paddingBlockRootProvingOutput = proof;
+    }
+    getParentLocation(location) {
+        return this.blockRootOrMergeProvingOutputs.getParentLocation(location);
+    }
+    getBlockMergeRollupInputs(mergeLocation) {
+        const [left, right] = this.blockRootOrMergeProvingOutputs.getChildren(mergeLocation);
+        if (!left || !right) {
+            throw new Error('At lease one child is not ready.');
+        }
+        return new BlockMergeRollupInputs([
+            this.#getPreviousRollupData(left),
+            this.#getPreviousRollupData(right)
+        ]);
+    }
+    getRootRollupInputs(proverId) {
+        const [left, right] = this.#getChildProofsForRoot();
+        if (!left || !right) {
+            throw new Error('At lease one child is not ready.');
+        }
+        return RootRollupInputs.from({
+            previousRollupData: [
+                this.#getPreviousRollupData(left),
+                this.#getPreviousRollupData(right)
+            ],
+            proverId
+        });
+    }
+    getPaddingBlockRootInputs(proverId) {
+        if (!this.blocks[0]?.isComplete()) {
+            throw new Error('Epoch needs one completed block in order to be padded.');
+        }
+        return this.blocks[0].getPaddingBlockRootInputs(proverId);
+    }
+    // Returns a specific transaction proving state
+    getBlockProvingStateByBlockNumber(blockNumber) {
+        return this.blocks.find((block)=>block?.blockNumber === blockNumber);
+    }
+    getEpochProofResult() {
+        if (!this.rootRollupProvingOutput) {
+            throw new Error('Unable to get epoch proof result. Root rollup is not ready.');
+        }
+        return {
+            proof: this.rootRollupProvingOutput.proof.binaryProof,
+            publicInputs: this.rootRollupProvingOutput.inputs
+        };
+    }
+    isReadyForBlockMerge(location) {
+        return this.blockRootOrMergeProvingOutputs.getSibling(location) !== undefined;
+    }
+    // Returns true if we have sufficient inputs to execute the block root rollup
+    isReadyForRootRollup() {
+        const childProofs = this.#getChildProofsForRoot();
+        return childProofs.every((p)=>!!p);
+    }
+    // Attempts to reject the proving state promise with a reason of 'cancelled'
+    cancel() {
+        this.reject('Proving cancelled');
+    }
+    // Attempts to reject the proving state promise with the given reason
+    // Does nothing if not in a valid state
+    reject(reason) {
+        if (!this.verifyState()) {
+            return;
+        }
+        this.provingStateLifecycle = 3;
+        this.rejectionCallback(reason);
+    }
+    // Attempts to resolve the proving state promise with the given result
+    // Does nothing if not in a valid state
+    resolve(result) {
+        if (!this.verifyState()) {
+            return;
+        }
+        this.provingStateLifecycle = 2;
+        this.completionCallback(result);
+    }
+    #getChildProofsForRoot() {
+        const rootLocation = {
+            level: 0,
+            index: 0
+        };
+        // If there's only 1 block, its block root proof will be stored at the root.
+        return this.totalNumBlocks === 1 ? [
+            this.blockRootOrMergeProvingOutputs.getNode(rootLocation),
+            this.paddingBlockRootProvingOutput
+        ] : this.blockRootOrMergeProvingOutputs.getChildren(rootLocation);
+    }
+    #getPreviousRollupData({ inputs, proof, verificationKey }) {
+        const leafIndex = getVKIndex(verificationKey.keyAsFields);
+        return new PreviousRollupBlockData(inputs, proof, verificationKey.keyAsFields, new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), getVKSiblingPath(leafIndex)));
+    }
+}

package/dest/orchestrator/index.d.ts

@@ -0,0 +1,2 @@
+export { ProvingOrchestrator } from './orchestrator.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/orchestrator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC"}

package/dest/orchestrator/index.js

@@ -0,0 +1 @@
+export { ProvingOrchestrator } from './orchestrator.js';

package/dest/orchestrator/orchestrator.d.ts

@@ -0,0 +1,110 @@
+import { Fr } from '@aztec/foundation/fields';
+import { L2Block } from '@aztec/stdlib/block';
+import type { EpochProver, ForkMerkleTreeOperations, ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
+import { type AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
+import { type BlockHeader, type GlobalVariables, type ProcessedTx, type Tx } from '@aztec/stdlib/tx';
+import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
+/**
+ * Implements an event driven proving scheduler to build the recursive proof tree. The idea being:
+ * 1. Transactions are provided to the scheduler post simulation.
+ * 2. Tree insertions are performed as required to generate transaction specific proofs
+ * 3. Those transaction specific proofs are generated in the necessary order accounting for dependencies
+ * 4. Once a transaction is proven, it will be incorporated into a merge proof
+ * 5. Merge proofs are produced at each level of the tree until the root proof is produced
+ *
+ * The proving implementation is determined by the provided prover. This could be for example a local prover or a remote prover pool.
+ */
+/**
+ * The orchestrator, managing the flow of recursive proving operations required to build the rollup proof tree.
+ */
+export declare class ProvingOrchestrator implements EpochProver {
+    private dbProvider;
+    private prover;
+    private readonly proverId;
+    private provingState;
+    private pendingProvingJobs;
+    private provingPromise;
+    private metrics;
+    private dbs;
+    constructor(dbProvider: ForkMerkleTreeOperations, prover: ServerCircuitProver, proverId?: Fr, telemetryClient?: TelemetryClient);
+    get tracer(): Tracer;
+    getProverId(): Fr;
+    stop(): Promise<void>;
+    startNewEpoch(epochNumber: number, firstBlockNumber: number, totalNumBlocks: number): void;
+    /**
+     * Starts off a new block
+     * @param globalVariables - The global variables for the block
+     * @param l1ToL2Messages - The l1 to l2 messages for the block
+     * @returns A proving ticket, containing a promise notifying of proving completion
+     */
+    startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[], previousBlockHeader: BlockHeader): Promise<void>;
+    /**
+     * The interface to add simulated transactions to the scheduler. This can only be called once per block.
+     * @param txs - The transactions to be proven
+     */
+    addTxs(txs: ProcessedTx[]): Promise<void>;
+    /**
+     * Kickstarts tube circuits for the specified txs. These will be used during epoch proving.
+     * Note that if the tube circuits are not started this way, they will be started nontheless after processing.
+     */
+    startTubeCircuits(txs: Tx[]): Promise<void>;
+    /**
+     * Marks the block as completed.
+     * Computes the block header and updates the archive tree.
+     */
+    setBlockCompleted(blockNumber: number, expectedHeader?: BlockHeader): Promise<L2Block>;
+    /** Returns the block as built for a given index. */
+    getBlock(index: number): L2Block;
+    private buildBlock;
+    protected verifyBuiltBlockAgainstSyncedState(l2Block: L2Block, newArchive: AppendOnlyTreeSnapshot): Promise<void>;
+    /**
+     * Cancel any further proving
+     */
+    cancel(): void;
+    /**
+     * Returns the proof for the current epoch.
+     */
+    finaliseEpoch(): Promise<{
+        proof: import("@aztec/stdlib/proofs").Proof;
+        publicInputs: import("@aztec/stdlib/rollup").RootRollupPublicInputs;
+    }>;
+    /**
+     * Starts the proving process for the given transaction and adds it to our state
+     * @param tx - The transaction whose proving we wish to commence
+     * @param provingState - The proving state being worked on
+     */
+    private prepareTransaction;
+    /**
+     * Enqueue a job to be scheduled
+     * @param provingState - The proving state object being operated on
+     * @param jobType - The type of job to be queued
+     * @param job - The actual job, returns a promise notifying of the job's completion
+     */
+    private deferredProving;
+    private prepareBaseParityInputs;
+    private prepareBaseRollupInputs;
+    private enqueueBaseRollup;
+    private getOrEnqueueTube;
+    private doEnqueueTube;
+    private enqueueMergeRollup;
+    private enqueueBlockRootRollup;
+    private enqueueBaseParityCircuit;
+    private checkAndEnqueueRootParityCircuit;
+    private enqueueRootParityCircuit;
+    private enqueueBlockMergeRollup;
+    private enqueueEpochPadding;
+    private enqueueRootRollup;
+    private checkAndEnqueueNextMergeRollup;
+    private checkAndEnqueueBlockRootRollup;
+    private checkAndEnqueueNextBlockMergeRollup;
+    private checkAndEnqueueRootRollup;
+    /**
+     * Executes the VM circuit for a public function, will enqueue the corresponding kernel if the
+     * previous kernel is ready
+     * @param provingState - The proving state being operated on
+     * @param txIndex - The index of the transaction being proven
+     */
+    private enqueueVM;
+    private checkAndEnqueueNextTxCircuit;
+}
+//# sourceMappingURL=orchestrator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../src/orchestrator/orchestrator.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAQ9C,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,KAAK,EACV,WAAW,EACX,wBAAwB,EAGxB,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AAWzC,OAAO,EAAE,KAAK,sBAAsB,EAAgB,MAAM,qBAAqB,CAAC;AAChF,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,EAAE,EAAmB,MAAM,kBAAkB,CAAC;AAEtH,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,MAAM,EAIZ,MAAM,yBAAyB,CAAC;AAoBjC;;;;;;;;;GASG;AAEH;;GAEG;AACH,qBAAa,mBAAoB,YAAW,WAAW;IASnD,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAV3B,OAAO,CAAC,YAAY,CAA4C;IAChE,OAAO,CAAC,kBAAkB,CAAyB;IAEnD,OAAO,CAAC,cAAc,CAAiD;IACvE,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,GAAG,CAAqD;gBAGtD,UAAU,EAAE,wBAAwB,EACpC,MAAM,EAAE,mBAAmB,EAClB,QAAQ,GAAE,EAAY,EACvC,eAAe,GAAE,eAAsC;IAKzD,IAAI,MAAM,IAAI,MAAM,CAEnB;IAEM,WAAW,IAAI,EAAE;IAIjB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAKrB,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM;IAW1F;;;;;OAKG;IAIU,aAAa,CAAC,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,EAAE,EAAE,EAAE,mBAAmB,EAAE,WAAW;IAyCnH;;;OAGG;IAIU,MAAM,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAiDtD;;;OAGG;IAEU,iBAAiB,CAAC,GAAG,EAAE,EAAE,EAAE;IAcxC;;;OAGG;IAIU,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAyBnG,oDAAoD;IAC7C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;YAQzB,UAAU;cAqCR,kCAAkC,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,sBAAsB;IAWvG;;OAEG;IACI,MAAM;IAQb;;OAEG;IACU,aAAa;;;;IAoB1B;;;;OAIG;YACW,kBAAkB;IAShC;;;;;OAKG;IACH,OAAO,CAAC,eAAe;YAwDT,uBAAuB;YA+BvB,uBAAuB;IAmCrC,OAAO,CAAC,iBAAiB;IA+CzB,OAAO,CAAC,gBAAgB;IA0BxB,OAAO,CAAC,aAAa;IA6BrB,OAAO,CAAC,kBAAkB;YA2BZ,sBAAsB;IA2DpC,OAAO,CAAC,wBAAwB;IAwBhC,OAAO,CAAC,gCAAgC;IAUxC,OAAO,CAAC,wBAAwB;IA4BhC,OAAO,CAAC,uBAAuB;YA0BjB,mBAAmB;IA8BjC,OAAO,CAAC,iBAAiB;YA6BX,8BAA8B;YAa9B,8BAA8B;IAyB5C,OAAO,CAAC,mCAAmC;IAa3C,OAAO,CAAC,yBAAyB;IASjC;;;;;OAKG;IACH,OAAO,CAAC,SAAS;IA8CjB,OAAO,CAAC,4BAA4B;CAWrC"}