@aztec/prover-client 0.55.1 → 0.57.0

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

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

@@ -0,0 +1,147 @@
+import { NUM_BASE_PARITY_PER_ROOT_PARITY, } from '@aztec/circuits.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 {
+    constructor(index, totalNumTxs, globalVariables, newL1ToL2Messages, messageTreeSnapshot, messageTreeRootSiblingPath, messageTreeSnapshotAfterInsertion, archiveTreeSnapshot, archiveTreeRootSiblingPath, previousBlockHash, parentEpoch) {
+        this.index = index;
+        this.totalNumTxs = totalNumTxs;
+        this.globalVariables = globalVariables;
+        this.newL1ToL2Messages = newL1ToL2Messages;
+        this.messageTreeSnapshot = messageTreeSnapshot;
+        this.messageTreeRootSiblingPath = messageTreeRootSiblingPath;
+        this.messageTreeSnapshotAfterInsertion = messageTreeSnapshotAfterInsertion;
+        this.archiveTreeSnapshot = archiveTreeSnapshot;
+        this.archiveTreeRootSiblingPath = archiveTreeRootSiblingPath;
+        this.previousBlockHash = previousBlockHash;
+        this.parentEpoch = parentEpoch;
+        this.mergeRollupInputs = [];
+        this.rootParityInputs = [];
+        this.blockRootRollupStarted = false;
+        this.txs = [];
+        this.rootParityInputs = Array.from({ length: NUM_BASE_PARITY_PER_ROOT_PARITY }).map(_ => undefined);
+    }
+    get blockNumber() {
+        return this.globalVariables.blockNumber.toNumber();
+    }
+    // Returns the number of levels of merge rollups
+    get numMergeLevels() {
+        return BigInt(Math.ceil(Math.log2(this.totalNumTxs)) - 1);
+    }
+    // Calculates the index and level of the parent rollup circuit
+    // Based on tree implementation in unbalanced_tree.ts -> batchInsert()
+    findMergeLevel(currentLevel, currentIndex) {
+        const moveUpMergeLevel = (levelSize, index, nodeToShift) => {
+            levelSize /= 2;
+            if (levelSize & 1) {
+                [levelSize, nodeToShift] = nodeToShift ? [levelSize + 1, false] : [levelSize - 1, true];
+            }
+            index >>= 1n;
+            return { thisLevelSize: levelSize, thisIndex: index, shiftUp: nodeToShift };
+        };
+        let [thisLevelSize, shiftUp] = this.totalNumTxs & 1 ? [this.totalNumTxs - 1, true] : [this.totalNumTxs, false];
+        const maxLevel = this.numMergeLevels + 1n;
+        let placeholder = currentIndex;
+        for (let i = 0; i < maxLevel - currentLevel; i++) {
+            ({ thisLevelSize, thisIndex: placeholder, shiftUp } = moveUpMergeLevel(thisLevelSize, placeholder, shiftUp));
+        }
+        let thisIndex = currentIndex;
+        let mergeLevel = currentLevel;
+        while (thisIndex >= thisLevelSize && mergeLevel != 0n) {
+            mergeLevel -= 1n;
+            ({ thisLevelSize, thisIndex, shiftUp } = moveUpMergeLevel(thisLevelSize, thisIndex, shiftUp));
+        }
+        return [mergeLevel - 1n, thisIndex >> 1n, thisIndex & 1n];
+    }
+    // Adds a transaction to the proving state, returns it's index
+    addNewTx(tx) {
+        this.txs.push(tx);
+        return this.txs.length - 1;
+    }
+    // Returns the number of received transactions
+    get transactionsReceived() {
+        return this.txs.length;
+    }
+    // Returns the final set of root parity inputs
+    get finalRootParityInput() {
+        return this.finalRootParityInputs;
+    }
+    // Sets the final set of root parity inputs
+    set finalRootParityInput(input) {
+        this.finalRootParityInputs = input;
+    }
+    // Returns the set of root parity inputs
+    get rootParityInput() {
+        return this.rootParityInputs;
+    }
+    // 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.globalVariables.blockNumber.toNumber();
+    }
+    /**
+     * Stores the inputs to a merge circuit and determines if the circuit is ready to be executed
+     * @param mergeInputs - The inputs to store
+     * @param indexWithinMerge - The index in the set of inputs to this merge circuit
+     * @param indexOfMerge - The global index of this merge circuit
+     * @returns True if the merge circuit is ready to be executed, false otherwise
+     */
+    storeMergeInputs(mergeInputs, indexWithinMerge, indexOfMerge) {
+        if (!this.mergeRollupInputs[indexOfMerge]) {
+            const mergeInputData = {
+                inputs: [undefined, undefined],
+                proofs: [undefined, undefined],
+                verificationKeys: [undefined, undefined],
+            };
+            mergeInputData.inputs[indexWithinMerge] = mergeInputs[0];
+            mergeInputData.proofs[indexWithinMerge] = mergeInputs[1];
+            mergeInputData.verificationKeys[indexWithinMerge] = mergeInputs[2];
+            this.mergeRollupInputs[indexOfMerge] = mergeInputData;
+            return false;
+        }
+        const mergeInputData = this.mergeRollupInputs[indexOfMerge];
+        mergeInputData.inputs[indexWithinMerge] = mergeInputs[0];
+        mergeInputData.proofs[indexWithinMerge] = mergeInputs[1];
+        mergeInputData.verificationKeys[indexWithinMerge] = mergeInputs[2];
+        return true;
+    }
+    // Returns a specific transaction proving state
+    getTxProvingState(txIndex) {
+        return this.txs[txIndex];
+    }
+    // Returns a set of merge rollup inputs
+    getMergeInputs(indexOfMerge) {
+        return this.mergeRollupInputs[indexOfMerge];
+    }
+    // Returns true if we have sufficient inputs to execute the block root rollup
+    isReadyForBlockRootRollup() {
+        return !(this.block === undefined ||
+            this.mergeRollupInputs[0] === undefined ||
+            this.finalRootParityInput === undefined ||
+            this.mergeRollupInputs[0].inputs.findIndex(p => !p) !== -1);
+    }
+    // Stores a set of root parity inputs at the given index
+    setRootParityInputs(inputs, index) {
+        this.rootParityInputs[index] = inputs;
+    }
+    // Returns true if we have sufficient root parity inputs to execute the root parity circuit
+    areRootParityInputsReady() {
+        return this.rootParityInputs.findIndex(p => !p) === -1;
+    }
+    // Returns true if we are still able to accept transactions, false otherwise
+    isAcceptingTransactions() {
+        return this.totalNumTxs > this.txs.length;
+    }
+    // Returns whether the proving state is still valid
+    verifyState() {
+        return this.parentEpoch.verifyState();
+    }
+    reject(reason) {
+        this.parentEpoch.reject(reason);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvY2stcHJvdmluZy1zdGF0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9vcmNoZXN0cmF0b3IvYmxvY2stcHJvdmluZy1zdGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBVUwsK0JBQStCLEdBTWhDLE1BQU0sb0JBQW9CLENBQUM7QUFpQjVCOzs7R0FHRztBQUNILE1BQU0sT0FBTyxpQkFBaUI7SUFVNUIsWUFDa0IsS0FBYSxFQUNiLFdBQW1CLEVBQ25CLGVBQWdDLEVBQ2hDLGlCQUF3RSxFQUN4RSxtQkFBMkMsRUFDM0MsMEJBQXNGLEVBQ3RGLGlDQUF5RCxFQUN6RCxtQkFBMkMsRUFDM0MsMEJBQTRELEVBQzVELGlCQUFxQixFQUNwQixXQUE4QjtRQVYvQixVQUFLLEdBQUwsS0FBSyxDQUFRO1FBQ2IsZ0JBQVcsR0FBWCxXQUFXLENBQVE7UUFDbkIsb0JBQWUsR0FBZixlQUFlLENBQWlCO1FBQ2hDLHNCQUFpQixHQUFqQixpQkFBaUIsQ0FBdUQ7UUFDeEUsd0JBQW1CLEdBQW5CLG1CQUFtQixDQUF3QjtRQUMzQywrQkFBMEIsR0FBMUIsMEJBQTBCLENBQTREO1FBQ3RGLHNDQUFpQyxHQUFqQyxpQ0FBaUMsQ0FBd0I7UUFDekQsd0JBQW1CLEdBQW5CLG1CQUFtQixDQUF3QjtRQUMzQywrQkFBMEIsR0FBMUIsMEJBQTBCLENBQWtDO1FBQzVELHNCQUFpQixHQUFqQixpQkFBaUIsQ0FBSTtRQUNwQixnQkFBVyxHQUFYLFdBQVcsQ0FBbUI7UUFwQnpDLHNCQUFpQixHQUEyQixFQUFFLENBQUM7UUFDL0MscUJBQWdCLEdBQXNFLEVBQUUsQ0FBQztRQUcxRiwyQkFBc0IsR0FBWSxLQUFLLENBQUM7UUFHdkMsUUFBRyxHQUFxQixFQUFFLENBQUM7UUFlakMsSUFBSSxDQUFDLGdCQUFnQixHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUMsRUFBRSxNQUFNLEVBQUUsK0JBQStCLEVBQUUsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ3RHLENBQUM7SUFFRCxJQUFXLFdBQVc7UUFDcEIsT0FBTyxJQUFJLENBQUMsZUFBZSxDQUFDLFdBQVcsQ0FBQyxRQUFRLEVBQUUsQ0FBQztJQUNyRCxDQUFDO0lBRUQsZ0RBQWdEO0lBQ2hELElBQVcsY0FBYztRQUN2QixPQUFPLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFDNUQsQ0FBQztJQUVELDhEQUE4RDtJQUM5RCxzRUFBc0U7SUFDL0QsY0FBYyxDQUFDLFlBQW9CLEVBQUUsWUFBb0I7UUFDOUQsTUFBTSxnQkFBZ0IsR0FBRyxDQUFDLFNBQWlCLEVBQUUsS0FBYSxFQUFFLFdBQW9CLEVBQUUsRUFBRTtZQUNsRixTQUFTLElBQUksQ0FBQyxDQUFDO1lBQ2YsSUFBSSxTQUFTLEdBQUcsQ0FBQyxFQUFFLENBQUM7Z0JBQ2xCLENBQUMsU0FBUyxFQUFFLFdBQVcsQ0FBQyxHQUFHLFdBQVcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxTQUFTLEdBQUcsQ0FBQyxFQUFFLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLFNBQVMsR0FBRyxDQUFDLEVBQUUsSUFBSSxDQUFDLENBQUM7WUFDMUYsQ0FBQztZQUNELEtBQUssS0FBSyxFQUFFLENBQUM7WUFDYixPQUFPLEVBQUUsYUFBYSxFQUFFLFNBQVMsRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE9BQU8sRUFBRSxXQUFXLEVBQUUsQ0FBQztRQUM5RSxDQUFDLENBQUM7UUFDRixJQUFJLENBQUMsYUFBYSxFQUFFLE9BQU8sQ0FBQyxHQUFHLElBQUksQ0FBQyxXQUFXLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxXQUFXLEdBQUcsQ0FBQyxFQUFFLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFDL0csTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLGNBQWMsR0FBRyxFQUFFLENBQUM7UUFDMUMsSUFBSSxXQUFXLEdBQUcsWUFBWSxDQUFDO1FBQy9CLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxRQUFRLEdBQUcsWUFBWSxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUM7WUFDakQsQ0FBQyxFQUFFLGFBQWEsRUFBRSxTQUFTLEVBQUUsV0FBVyxFQUFFLE9BQU8sRUFBRSxHQUFHLGdCQUFnQixDQUFDLGFBQWEsRUFBRSxXQUFXLEVBQUUsT0FBTyxDQUFDLENBQUMsQ0FBQztRQUMvRyxDQUFDO1FBQ0QsSUFBSSxTQUFTLEdBQUcsWUFBWSxDQUFDO1FBQzdCLElBQUksVUFBVSxHQUFHLFlBQVksQ0FBQztRQUM5QixPQUFPLFNBQVMsSUFBSSxhQUFhLElBQUksVUFBVSxJQUFJLEVBQUUsRUFBRSxDQUFDO1lBQ3RELFVBQVUsSUFBSSxFQUFFLENBQUM7WUFDakIsQ0FBQyxFQUFFLGFBQWEsRUFBRSxTQUFTLEVBQUUsT0FBTyxFQUFFLEdBQUcsZ0JBQWdCLENBQUMsYUFBYSxFQUFFLFNBQVMsRUFBRSxPQUFPLENBQUMsQ0FBQyxDQUFDO1FBQ2hHLENBQUM7UUFDRCxPQUFPLENBQUMsVUFBVSxHQUFHLEVBQUUsRUFBRSxTQUFTLElBQUksRUFBRSxFQUFFLFNBQVMsR0FBRyxFQUFFLENBQUMsQ0FBQztJQUM1RCxDQUFDO0lBRUQsOERBQThEO0lBQ3ZELFFBQVEsQ0FBQyxFQUFrQjtRQUNoQyxJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUNsQixPQUFPLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQztJQUM3QixDQUFDO0lBRUQsOENBQThDO0lBQzlDLElBQVcsb0JBQW9CO1FBQzdCLE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUM7SUFDekIsQ0FBQztJQUVELDhDQUE4QztJQUM5QyxJQUFXLG9CQUFvQjtRQUM3QixPQUFPLElBQUksQ0FBQyxxQkFBcUIsQ0FBQztJQUNwQyxDQUFDO0lBRUQsMkNBQTJDO0lBQzNDLElBQVcsb0JBQW9CLENBQUMsS0FBd0U7UUFDdEcsSUFBSSxDQUFDLHFCQUFxQixHQUFHLEtBQUssQ0FBQztJQUNyQyxDQUFDO0lBRUQsd0NBQXdDO0lBQ3hDLElBQVcsZUFBZTtRQUN4QixPQUFPLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQztJQUMvQixDQUFDO0lBRUQsZ0VBQWdFO0lBQ2hFLElBQVcsTUFBTTtRQUNmLE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQztJQUNsQixDQUFDO0lBRUQseUZBQXlGO0lBQ3pGLElBQVcsV0FBVztRQUNwQixPQUFPLElBQUksQ0FBQyxlQUFlLENBQUMsV0FBVyxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQ3JELENBQUM7SUFFRDs7Ozs7O09BTUc7SUFDSSxnQkFBZ0IsQ0FDckIsV0FJQyxFQUNELGdCQUF3QixFQUN4QixZQUFvQjtRQUVwQixJQUFJLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLFlBQVksQ0FBQyxFQUFFLENBQUM7WUFDMUMsTUFBTSxjQUFjLEdBQXlCO2dCQUMzQyxNQUFNLEVBQUUsQ0FBQyxTQUFTLEVBQUUsU0FBUyxDQUFDO2dCQUM5QixNQUFNLEVBQUUsQ0FBQyxTQUFTLEVBQUUsU0FBUyxDQUFDO2dCQUM5QixnQkFBZ0IsRUFBRSxDQUFDLFNBQVMsRUFBRSxTQUFTLENBQUM7YUFDekMsQ0FBQztZQUNGLGNBQWMsQ0FBQyxNQUFNLENBQUMsZ0JBQWdCLENBQUMsR0FBRyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDekQsY0FBYyxDQUFDLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxHQUFHLFdBQVcsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUN6RCxjQUFjLENBQUMsZ0JBQWdCLENBQUMsZ0JBQWdCLENBQUMsR0FBRyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDbkUsSUFBSSxDQUFDLGlCQUFpQixDQUFDLFlBQVksQ0FBQyxHQUFHLGNBQWMsQ0FBQztZQUN0RCxPQUFPLEtBQUssQ0FBQztRQUNmLENBQUM7UUFDRCxNQUFNLGNBQWMsR0FBRyxJQUFJLENBQUMsaUJBQWlCLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDNUQsY0FBYyxDQUFDLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxHQUFHLFdBQVcsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUN6RCxjQUFjLENBQUMsTUFBTSxDQUFDLGdCQUFnQixDQUFDLEdBQUcsV0FBVyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ3pELGNBQWMsQ0FBQyxnQkFBZ0IsQ0FBQyxnQkFBZ0IsQ0FBQyxHQUFHLFdBQVcsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNuRSxPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7SUFFRCwrQ0FBK0M7SUFDeEMsaUJBQWlCLENBQUMsT0FBZTtRQUN0QyxPQUFPLElBQUksQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDM0IsQ0FBQztJQUVELHVDQUF1QztJQUNoQyxjQUFjLENBQUMsWUFBb0I7UUFDeEMsT0FBTyxJQUFJLENBQUMsaUJBQWlCLENBQUMsWUFBWSxDQUFDLENBQUM7SUFDOUMsQ0FBQztJQUVELDZFQUE2RTtJQUN0RSx5QkFBeUI7UUFDOUIsT0FBTyxDQUFDLENBQ04sSUFBSSxDQUFDLEtBQUssS0FBSyxTQUFTO1lBQ3hCLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsS0FBSyxTQUFTO1lBQ3ZDLElBQUksQ0FBQyxvQkFBb0IsS0FBSyxTQUFTO1lBQ3ZDLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FDM0QsQ0FBQztJQUNKLENBQUM7SUFFRCx3REFBd0Q7SUFDakQsbUJBQW1CLENBQUMsTUFBc0QsRUFBRSxLQUFhO1FBQzlGLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxLQUFLLENBQUMsR0FBRyxNQUFNLENBQUM7SUFDeEMsQ0FBQztJQUVELDJGQUEyRjtJQUNwRix3QkFBd0I7UUFDN0IsT0FBTyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztJQUN6RCxDQUFDO0lBRUQsNEVBQTRFO0lBQ3JFLHVCQUF1QjtRQUM1QixPQUFPLElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUM7SUFDNUMsQ0FBQztJQUVELG1EQUFtRDtJQUM1QyxXQUFXO1FBQ2hCLE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQyxXQUFXLEVBQUUsQ0FBQztJQUN4QyxDQUFDO0lBRU0sTUFBTSxDQUFDLE1BQWM7UUFDMUIsSUFBSSxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDbEMsQ0FBQztDQUNGIn0=

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

@@ -0,0 +1,63 @@
+import { type MerkleTreeId } from '@aztec/circuit-types';
+import { type ARCHIVE_HEIGHT, type AppendOnlyTreeSnapshot, type BlockRootOrBlockMergePublicInputs, Fr, type GlobalVariables, type L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, type NESTED_RECURSIVE_PROOF_LENGTH, type Proof, type RecursiveProof, type RootRollupPublicInputs, type VerificationKeyAsFields } from '@aztec/circuits.js';
+import { type Tuple } from '@aztec/foundation/serialize';
+import { BlockProvingState } from './block-proving-state.js';
+export type TreeSnapshots = Map<MerkleTreeId, AppendOnlyTreeSnapshot>;
+export type BlockMergeRollupInputData = {
+    inputs: [BlockRootOrBlockMergePublicInputs | undefined, BlockRootOrBlockMergePublicInputs | undefined];
+    proofs: [
+        RecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH> | undefined,
+        RecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH> | undefined
+    ];
+    verificationKeys: [VerificationKeyAsFields | undefined, VerificationKeyAsFields | undefined];
+};
+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 {
+    readonly epochNumber: number;
+    readonly totalNumBlocks: number;
+    private completionCallback;
+    private rejectionCallback;
+    private provingStateLifecycle;
+    private mergeRollupInputs;
+    rootRollupPublicInputs: RootRollupPublicInputs | undefined;
+    finalProof: Proof | undefined;
+    blocks: BlockProvingState[];
+    constructor(epochNumber: number, totalNumBlocks: number, completionCallback: (result: ProvingResult) => void, rejectionCallback: (reason: string) => void);
+    /** Returns the current block proving state */
+    get currentBlock(): BlockProvingState | undefined;
+    get numMergeLevels(): bigint;
+    findMergeLevel(currentLevel: bigint, currentIndex: bigint): bigint[];
+    startNewBlock(numTxs: number, globalVariables: GlobalVariables, l1ToL2Messages: Fr[], messageTreeSnapshot: AppendOnlyTreeSnapshot, messageTreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>, messageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot, archiveTreeSnapshot: AppendOnlyTreeSnapshot, archiveTreeRootSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, previousBlockHash: Fr): number;
+    verifyState(): boolean;
+    isAcceptingBlocks(): boolean;
+    /**
+     * Stores the inputs to a merge circuit and determines if the circuit is ready to be executed
+     * @param mergeInputs - The inputs to store
+     * @param indexWithinMerge - The index in the set of inputs to this merge circuit
+     * @param indexOfMerge - The global index of this merge circuit
+     * @returns True if the merge circuit is ready to be executed, false otherwise
+     */
+    storeMergeInputs(mergeInputs: [
+        BlockRootOrBlockMergePublicInputs,
+        RecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>,
+        VerificationKeyAsFields
+    ], indexWithinMerge: number, indexOfMerge: number): boolean;
+    getBlockProvingState(index: number): BlockProvingState;
+    getMergeInputs(indexOfMerge: number): BlockMergeRollupInputData;
+    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":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,iCAAiC,EACtC,EAAE,EACF,KAAK,eAAe,EACpB,KAAK,wCAAwC,EAC7C,KAAK,6BAA6B,EAElC,KAAK,KAAK,EACV,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAC7B,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAEzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,YAAY,EAAE,sBAAsB,CAAC,CAAC;AAStE,MAAM,MAAM,yBAAyB,GAAG;IACtC,MAAM,EAAE,CAAC,iCAAiC,GAAG,SAAS,EAAE,iCAAiC,GAAG,SAAS,CAAC,CAAC;IACvG,MAAM,EAAE;QACN,cAAc,CAAC,OAAO,6BAA6B,CAAC,GAAG,SAAS;QAChE,cAAc,CAAC,OAAO,6BAA6B,CAAC,GAAG,SAAS;KACjE,CAAC;IACF,gBAAgB,EAAE,CAAC,uBAAuB,GAAG,SAAS,EAAE,uBAAuB,GAAG,SAAS,CAAC,CAAC;CAC9F,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1F;;;;;GAKG;AACH,qBAAa,iBAAiB;aASV,WAAW,EAAE,MAAM;aACnB,cAAc,EAAE,MAAM;IACtC,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,iBAAiB;IAX3B,OAAO,CAAC,qBAAqB,CAAiD;IAE9E,OAAO,CAAC,iBAAiB,CAAmC;IACrD,sBAAsB,EAAE,sBAAsB,GAAG,SAAS,CAAC;IAC3D,UAAU,EAAE,KAAK,GAAG,SAAS,CAAC;IAC9B,MAAM,EAAE,iBAAiB,EAAE,CAAM;gBAGtB,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,EAC9B,kBAAkB,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,EACnD,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI;IAGrD,8CAA8C;IAC9C,IAAW,YAAY,IAAI,iBAAiB,GAAG,SAAS,CAEvD;IAGD,IAAW,cAAc,WAGxB;IAKM,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;IA2BzD,aAAa,CAClB,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,eAAe,EAChC,cAAc,EAAE,EAAE,EAAE,EACpB,mBAAmB,EAAE,sBAAsB,EAC3C,0BAA0B,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,wCAAwC,CAAC,EACtF,iCAAiC,EAAE,sBAAsB,EACzD,mBAAmB,EAAE,sBAAsB,EAC3C,0BAA0B,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,cAAc,CAAC,EAC5D,iBAAiB,EAAE,EAAE;IAuBhB,WAAW;IAQX,iBAAiB;IAIxB;;;;;;OAMG;IACI,gBAAgB,CACrB,WAAW,EAAE;QACX,iCAAiC;QACjC,cAAc,CAAC,OAAO,6BAA6B,CAAC;QACpD,uBAAuB;KACxB,EACD,gBAAgB,EAAE,MAAM,EACxB,YAAY,EAAE,MAAM;IAsBf,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAKlC,cAAc,CAAC,YAAY,EAAE,MAAM;IAKnC,oBAAoB;IAKpB,MAAM;IAMN,MAAM,CAAC,MAAM,EAAE,MAAM;IAUrB,OAAO,CAAC,MAAM,EAAE,aAAa;CAOrC"}

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

@@ -0,0 +1,143 @@
+import { Fr, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, } from '@aztec/circuits.js';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { BlockProvingState } from './block-proving-state.js';
+var PROVING_STATE_LIFECYCLE;
+(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";
+})(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 {
+    constructor(epochNumber, totalNumBlocks, completionCallback, rejectionCallback) {
+        this.epochNumber = epochNumber;
+        this.totalNumBlocks = totalNumBlocks;
+        this.completionCallback = completionCallback;
+        this.rejectionCallback = rejectionCallback;
+        this.provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED;
+        this.mergeRollupInputs = [];
+        this.blocks = [];
+    }
+    /** Returns the current block proving state */
+    get currentBlock() {
+        return this.blocks.at(-1);
+    }
+    // Returns the number of levels of merge rollups
+    get numMergeLevels() {
+        const totalLeaves = Math.max(2, this.totalNumBlocks);
+        return BigInt(Math.ceil(Math.log2(totalLeaves)) - 1);
+    }
+    // Calculates the index and level of the parent rollup circuit
+    // Based on tree implementation in unbalanced_tree.ts -> batchInsert()
+    // REFACTOR: This is repeated from the block orchestrator
+    findMergeLevel(currentLevel, currentIndex) {
+        const totalLeaves = Math.max(2, this.totalNumBlocks);
+        const moveUpMergeLevel = (levelSize, index, nodeToShift) => {
+            levelSize /= 2;
+            if (levelSize & 1) {
+                [levelSize, nodeToShift] = nodeToShift ? [levelSize + 1, false] : [levelSize - 1, true];
+            }
+            index >>= 1n;
+            return { thisLevelSize: levelSize, thisIndex: index, shiftUp: nodeToShift };
+        };
+        let [thisLevelSize, shiftUp] = totalLeaves & 1 ? [totalLeaves - 1, true] : [totalLeaves, false];
+        const maxLevel = this.numMergeLevels + 1n;
+        let placeholder = currentIndex;
+        for (let i = 0; i < maxLevel - currentLevel; i++) {
+            ({ thisLevelSize, thisIndex: placeholder, shiftUp } = moveUpMergeLevel(thisLevelSize, placeholder, shiftUp));
+        }
+        let thisIndex = currentIndex;
+        let mergeLevel = currentLevel;
+        while (thisIndex >= thisLevelSize && mergeLevel != 0n) {
+            mergeLevel -= 1n;
+            ({ thisLevelSize, thisIndex, shiftUp } = moveUpMergeLevel(thisLevelSize, thisIndex, shiftUp));
+        }
+        return [mergeLevel - 1n, thisIndex >> 1n, thisIndex & 1n];
+    }
+    // Adds a block to the proving state, returns its index
+    // Will update the proving life cycle if this is the last block
+    startNewBlock(numTxs, globalVariables, l1ToL2Messages, messageTreeSnapshot, messageTreeRootSiblingPath, messageTreeSnapshotAfterInsertion, archiveTreeSnapshot, archiveTreeRootSiblingPath, previousBlockHash) {
+        const block = new BlockProvingState(this.blocks.length, numTxs, globalVariables, padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP), messageTreeSnapshot, messageTreeRootSiblingPath, messageTreeSnapshotAfterInsertion, archiveTreeSnapshot, archiveTreeRootSiblingPath, previousBlockHash, this);
+        this.blocks.push(block);
+        if (this.blocks.length === this.totalNumBlocks) {
+            this.provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_FULL;
+        }
+        return this.blocks.length - 1;
+    }
+    // Returns true if this proving state is still valid, false otherwise
+    verifyState() {
+        return (this.provingStateLifecycle === PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED ||
+            this.provingStateLifecycle === PROVING_STATE_LIFECYCLE.PROVING_STATE_FULL);
+    }
+    // Returns true if we are still able to accept blocks, false otherwise
+    isAcceptingBlocks() {
+        return this.provingStateLifecycle === PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED;
+    }
+    /**
+     * Stores the inputs to a merge circuit and determines if the circuit is ready to be executed
+     * @param mergeInputs - The inputs to store
+     * @param indexWithinMerge - The index in the set of inputs to this merge circuit
+     * @param indexOfMerge - The global index of this merge circuit
+     * @returns True if the merge circuit is ready to be executed, false otherwise
+     */
+    storeMergeInputs(mergeInputs, indexWithinMerge, indexOfMerge) {
+        if (!this.mergeRollupInputs[indexOfMerge]) {
+            const mergeInputData = {
+                inputs: [undefined, undefined],
+                proofs: [undefined, undefined],
+                verificationKeys: [undefined, undefined],
+            };
+            mergeInputData.inputs[indexWithinMerge] = mergeInputs[0];
+            mergeInputData.proofs[indexWithinMerge] = mergeInputs[1];
+            mergeInputData.verificationKeys[indexWithinMerge] = mergeInputs[2];
+            this.mergeRollupInputs[indexOfMerge] = mergeInputData;
+            return false;
+        }
+        const mergeInputData = this.mergeRollupInputs[indexOfMerge];
+        mergeInputData.inputs[indexWithinMerge] = mergeInputs[0];
+        mergeInputData.proofs[indexWithinMerge] = mergeInputs[1];
+        mergeInputData.verificationKeys[indexWithinMerge] = mergeInputs[2];
+        return true;
+    }
+    // Returns a specific transaction proving state
+    getBlockProvingState(index) {
+        return this.blocks[index];
+    }
+    // Returns a set of merge rollup inputs
+    getMergeInputs(indexOfMerge) {
+        return this.mergeRollupInputs[indexOfMerge];
+    }
+    // Returns true if we have sufficient inputs to execute the block root rollup
+    isReadyForRootRollup() {
+        return !(this.mergeRollupInputs[0] === undefined || this.mergeRollupInputs[0].inputs.findIndex(p => !p) !== -1);
+    }
+    // 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 = PROVING_STATE_LIFECYCLE.PROVING_STATE_REJECTED;
+        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 = PROVING_STATE_LIFECYCLE.PROVING_STATE_RESOLVED;
+        this.completionCallback(result);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/orchestrator/orchestrator.d.ts

@@ -1,6 +1,6 @@
-import { type ProcessedTx } from '@aztec/circuit-types';
-import { type BlockProver, type ProvingBlockResult, type ProvingTicket, type ServerCircuitProver } from '@aztec/circuit-types/interfaces';
-import { Fr, type GlobalVariables } from '@aztec/circuits.js';
+import { L2Block, type ProcessedTx, type ServerCircuitProver } from '@aztec/circuit-types';
+import { type EpochProver } from '@aztec/circuit-types/interfaces';
+import { Fr, type GlobalVariables, type Proof } from '@aztec/circuits.js';
 import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
 import { type MerkleTreeOperations } from '@aztec/world-state';
 /**
@@ -16,13 +16,14 @@ import { type MerkleTreeOperations } from '@aztec/world-state';
 /**
  * The orchestrator, managing the flow of recursive proving operations required to build the rollup proof tree.
  */
-export declare class ProvingOrchestrator implements BlockProver {
+export declare class ProvingOrchestrator implements EpochProver {
     private db;
     private prover;
     private readonly proverId;
     private provingState;
     private pendingProvingJobs;
     private paddingTx;
+    private provingPromise;
     private metrics;
     constructor(db: MerkleTreeOperations, prover: ServerCircuitProver, telemetryClient: TelemetryClient, proverId?: Fr);
     get tracer(): Tracer;
@@ -31,15 +32,16 @@ export declare class ProvingOrchestrator implements BlockProver {
      * Resets the orchestrator's cached padding tx.
      */
     reset(): void;
+    startNewEpoch(epochNumber: number, totalNumBlocks: number): void;
     /**
      * Starts off a new block
-     * @param numTxs - The total number of transactions in the block. Must be a power of 2
+     * @param numTxs - The total number of transactions in the block.
      * @param globalVariables - The global variables for the block
      * @param l1ToL2Messages - The l1 to l2 messages for the block
      * @param verificationKeys - The private kernel verification keys
      * @returns A proving ticket, containing a promise notifying of proving completion
      */
-    startNewBlock(numTxs: number, globalVariables: GlobalVariables, l1ToL2Messages: Fr[]): Promise<ProvingTicket>;
+    startNewBlock(numTxs: number, globalVariables: GlobalVariables, l1ToL2Messages: Fr[]): Promise<void>;
     /**
      * The interface to add a simulated transaction to the scheduler
      * @param tx - The transaction to be proven
@@ -47,8 +49,13 @@ export declare class ProvingOrchestrator implements BlockProver {
     addNewTx(tx: ProcessedTx): Promise<void>;
     /**
      * Marks the block as full and pads it if required, no more transactions will be accepted.
+     * Computes the block header and updates the archive tree.
      */
-    setBlockCompleted(): Promise<void>;
+    setBlockCompleted(): Promise<L2Block>;
+    /** Returns the block as built for a given index. */
+    getBlock(index: number): L2Block;
+    private padEpoch;
+    private buildBlock;
     private enqueuePaddingTxs;
     /**
      * Prepares the cached sets of base rollup inputs for padding transactions and proves them
@@ -58,20 +65,21 @@ export declare class ProvingOrchestrator implements BlockProver {
      */
     private provePaddingTransactions;
     /**
-     * Cancel any further proving of the block
+     * Cancel any further proving
      */
-    cancelBlock(): void;
+    cancel(): void;
     /**
      * Extract the block header from public inputs.
-     * TODO(#7346): Refactor this once new batch rollup circuits are integrated
      * @returns The header of this proving state's block.
      */
-    private extractBlockHeader;
+    private extractBlockHeaderFromPublicInputs;
     /**
-     * Performs the final tree update for the block and returns the fully proven block.
-     * @returns The fully proven block and proof.
+     * Returns the proof for the current epoch.
      */
-    finaliseBlock(): Promise<ProvingBlockResult>;
+    finaliseEpoch(): Promise<{
+        proof: Proof;
+        publicInputs: import("@aztec/circuits.js").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
@@ -87,14 +95,16 @@ export declare class ProvingOrchestrator implements BlockProver {
      */
     private deferredProving;
     private prepareBaseRollupInputs;
-    private storeMergeInputs;
     private enqueueBaseRollup;
     private enqueueTube;
     private enqueueMergeRollup;
     private enqueueBlockRootRollup;
     private enqueueBaseParityCircuit;
     private enqueueRootParityCircuit;
+    private enqueueBlockMergeRollup;
+    private enqueueRootRollup;
     private checkAndEnqueueBlockRootRollup;
+    private checkAndEnqueueRootRollup;
     /**
      * Stores the inputs to a merge/root circuit and enqueues the circuit if ready
      * @param provingState - The proving state being operated on
@@ -103,6 +113,14 @@ export declare class ProvingOrchestrator implements BlockProver {
      * @param mergeInputData - The inputs to be stored
      */
     private storeAndExecuteNextMergeLevel;
+    /**
+     * Stores the inputs to a block merge/root circuit and enqueues the circuit if ready
+     * @param provingState - The proving state being operated on
+     * @param currentLevel - The level of the merge/root circuit
+     * @param currentIndex - The index of the merge/root circuit
+     * @param mergeInputData - The inputs to be stored
+     */
+    private storeAndExecuteNextBlockMergeLevel;
     /**
      * Executes the VM circuit for a public function, will enqueue the corresponding kernel if the
      * previous kernel is ready

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

@@ -1 +1 @@
-{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../src/orchestrator/orchestrator.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,WAAW,EASjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAEL,KAAK,WAAW,EAEhB,KAAK,kBAAkB,EAEvB,KAAK,aAAa,EAElB,KAAK,mBAAmB,EACzB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAML,EAAE,EACF,KAAK,eAAe,EAsBrB,MAAM,oBAAoB,CAAC;AAW5B,OAAO,EAAc,KAAK,eAAe,EAAE,KAAK,MAAM,EAAiC,MAAM,yBAAyB,CAAC;AACvH,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAoB/D;;;;;;;;;GASG;AAEH;;GAEG;AACH,qBAAa,mBAAoB,YAAW,WAAW;IAQnD,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,MAAM;IAEd,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAV3B,OAAO,CAAC,YAAY,CAAuC;IAC3D,OAAO,CAAC,kBAAkB,CAAyB;IACnD,OAAO,CAAC,SAAS,CAA6C;IAE9D,OAAO,CAAC,OAAO,CAA6B;gBAGlC,EAAE,EAAE,oBAAoB,EACxB,MAAM,EAAE,mBAAmB,EACnC,eAAe,EAAE,eAAe,EACf,QAAQ,GAAE,EAAY;IAKzC,IAAI,MAAM,IAAI,MAAM,CAEnB;IAEM,WAAW,IAAI,EAAE;IAIxB;;OAEG;IACI,KAAK;IAIZ;;;;;;;OAOG;IAKU,aAAa,CACxB,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,eAAe,EAChC,cAAc,EAAE,EAAE,EAAE,GACnB,OAAO,CAAC,aAAa,CAAC;IAiFzB;;;OAGG;IAIU,QAAQ,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBrD;;OAEG;IAYU,iBAAiB;IA2C9B,OAAO,CAAC,iBAAiB;IA4CzB;;;;;OAKG;IACH,OAAO,CAAC,wBAAwB;IAmBhC;;OAEG;IACI,WAAW;IAQlB;;;;OAIG;YACW,kBAAkB;IAyChC;;;OAGG;IAQU,aAAa;IAkE1B;;;;OAIG;YACW,kBAAkB;IAShC,OAAO,CAAC,kBAAkB;IAkB1B;;;;;OAKG;IACH,OAAO,CAAC,eAAe;YA4DT,uBAAuB;IAwCrC,OAAO,CAAC,gBAAgB;IA0BxB,OAAO,CAAC,iBAAiB;IAgFzB,OAAO,CAAC,WAAW;IA2CnB,OAAO,CAAC,kBAAkB;YAiCZ,sBAAsB;IAgDpC,OAAO,CAAC,wBAAwB;IA6BhC,OAAO,CAAC,wBAAwB;YAmBlB,8BAA8B;IAQ5C;;;;;;OAMG;IACH,OAAO,CAAC,6BAA6B;IA0BrC;;;;;;OAMG;IACH,OAAO,CAAC,SAAS;IAmDjB,OAAO,CAAC,sCAAsC;IAqB9C,OAAO,CAAC,4BAA4B;IAsCpC;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;CA+C5B"}
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../src/orchestrator/orchestrator.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,OAAO,EAGP,KAAK,WAAW,EAGhB,KAAK,mBAAmB,EAOzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAEnE,OAAO,EAQL,EAAE,EACF,KAAK,eAAe,EAQpB,KAAK,KAAK,EAaX,MAAM,oBAAoB,CAAC;AAU5B,OAAO,EAAc,KAAK,eAAe,EAAE,KAAK,MAAM,EAAiC,MAAM,yBAAyB,CAAC;AACvH,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AA8B/D;;;;;;;;;GASG;AAEH;;GAEG;AACH,qBAAa,mBAAoB,YAAW,WAAW;IASnD,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,MAAM;IAEd,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAX3B,OAAO,CAAC,YAAY,CAA4C;IAChE,OAAO,CAAC,kBAAkB,CAAyB;IACnD,OAAO,CAAC,SAAS,CAA6C;IAE9D,OAAO,CAAC,cAAc,CAAiD;IACvE,OAAO,CAAC,OAAO,CAA6B;gBAGlC,EAAE,EAAE,oBAAoB,EACxB,MAAM,EAAE,mBAAmB,EACnC,eAAe,EAAE,eAAe,EACf,QAAQ,GAAE,EAAY;IAKzC,IAAI,MAAM,IAAI,MAAM,CAEnB;IAEM,WAAW,IAAI,EAAE;IAIxB;;OAEG;IACI,KAAK;IAIL,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM;IAWhE;;;;;;;OAOG;IAKU,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,EAAE,EAAE;IAwFjG;;;OAGG;IAIU,QAAQ,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IA+BrD;;;OAGG;IAYU,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC;IAkDlD,oDAAoD;IAC7C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAiBvC,OAAO,CAAC,QAAQ;YAkDF,UAAU;IAsCxB,OAAO,CAAC,iBAAiB;IA4CzB;;;;;OAKG;IACH,OAAO,CAAC,wBAAwB;IAmBhC;;OAEG;IACI,MAAM;IAQb;;;OAGG;IACH,OAAO,CAAC,kCAAkC;IAmB1C;;OAEG;IACU,aAAa;;;;IAwB1B;;;;OAIG;YACW,kBAAkB;IAShC,OAAO,CAAC,kBAAkB;IAkB1B;;;;;OAKG;IACH,OAAO,CAAC,eAAe;YA4DT,uBAAuB;IAyCrC,OAAO,CAAC,iBAAiB;IAgFzB,OAAO,CAAC,WAAW;IAoCnB,OAAO,CAAC,kBAAkB;IAiC1B,OAAO,CAAC,sBAAsB;IA4E9B,OAAO,CAAC,wBAAwB;IA6BhC,OAAO,CAAC,wBAAwB;IAqBhC,OAAO,CAAC,uBAAuB;IAiC/B,OAAO,CAAC,iBAAiB;IAuCzB,OAAO,CAAC,8BAA8B;IAYtC,OAAO,CAAC,yBAAyB;IAQjC;;;;;;OAMG;IACH,OAAO,CAAC,6BAA6B;IA+BrC;;;;;;OAMG;IACH,OAAO,CAAC,kCAAkC;IAqC1C;;;;;;OAMG;IACH,OAAO,CAAC,SAAS;IAiDjB,OAAO,CAAC,sCAAsC;IAqB9C,OAAO,CAAC,4BAA4B;IAqCpC;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;CAsD5B"}