@aztec/prover-client 0.55.1 → 0.56.0

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

@@ -0,0 +1,170 @@
+import { NUM_BASE_PARITY_PER_ROOT_PARITY, } from '@aztec/circuits.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_RESOLVED"] = 1] = "PROVING_STATE_RESOLVED";
+    PROVING_STATE_LIFECYCLE[PROVING_STATE_LIFECYCLE["PROVING_STATE_REJECTED"] = 2] = "PROVING_STATE_REJECTED";
+})(PROVING_STATE_LIFECYCLE || (PROVING_STATE_LIFECYCLE = {}));
+/**
+ * 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, completionCallback, rejectionCallback) {
+        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.completionCallback = completionCallback;
+        this.rejectionCallback = rejectionCallback;
+        this.mergeRollupInputs = [];
+        this.rootParityInputs = [];
+        this.txs = [];
+        this.provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED;
+        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.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.provingStateLifecycle === PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED && this.totalNumTxs > this.txs.length);
+    }
+    // Returns true if this proving state is still valid, false otherwise
+    verifyState() {
+        return this.provingStateLifecycle === PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED;
+    }
+    // Attempts to reject the proving state promise with the given reason
+    reject(reason) {
+        if (!this.verifyState()) {
+            return;
+        }
+        this.provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_REJECTED;
+        if (this.rejectionCallback) {
+            this.rejectionCallback(reason);
+        }
+    }
+    // Attempts to resolve the proving state promise with the given result
+    resolve(result) {
+        if (!this.verifyState()) {
+            return;
+        }
+        this.provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_RESOLVED;
+        if (this.completionCallback) {
+            this.completionCallback(result);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,57 @@
+import { type MerkleTreeId, type ProvingResult } 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];
+};
+/**
+ * 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, completionCallback?: (result: ProvingResult) => void, rejectionCallback?: (reason: string) => void): 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,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC7E,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;;;;;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,WAExB;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,EACrB,kBAAkB,CAAC,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,EACpD,iBAAiB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI;IA+BvC,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;IAcrB,OAAO,CAAC,MAAM,EAAE,aAAa;CAOrC"}

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

@@ -0,0 +1,151 @@
+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[this.blocks.length - 1];
+    }
+    // Returns the number of levels of merge rollups
+    get numMergeLevels() {
+        return BigInt(Math.ceil(Math.log2(this.totalNumBlocks)) - 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 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.totalNumBlocks & 1 ? [this.totalNumBlocks - 1, true] : [this.totalNumBlocks, 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, completionCallback, rejectionCallback) {
+        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, completionCallback, reason => {
+            // Reject the block
+            if (rejectionCallback) {
+                rejectionCallback(reason);
+            }
+            // An error on any block rejects this whole epoch
+            this.reject(reason);
+        });
+        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);
+        for (const block of this.blocks) {
+            block.reject('Proving cancelled');
+        }
+    }
+    // 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 { type ProcessedTx, type ProvingBlockResult, type ProvingTicket, 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,7 +16,7 @@ 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;
@@ -31,6 +31,7 @@ export declare class ProvingOrchestrator implements BlockProver {
      * Resets the orchestrator's cached padding tx.
      */
     reset(): void;
+    startNewEpoch(epochNumber: number, totalNumBlocks: number): ProvingTicket;
     /**
      * Starts off a new block
      * @param numTxs - The total number of transactions in the block. Must be a power of 2
@@ -47,8 +48,10 @@ 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>;
+    private buildBlockHeader;
     private enqueuePaddingTxs;
     /**
      * Prepares the cached sets of base rollup inputs for padding transactions and proves them
@@ -58,20 +61,28 @@ 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. Requires proving to have been completed.
+     * @param index - The index of the block to finalise. Defaults to the last block.
      * @returns The fully proven block and proof.
      */
-    finaliseBlock(): Promise<ProvingBlockResult>;
+    finaliseBlock(index?: number): Promise<ProvingBlockResult>;
+    /**
+     * Returns the proof for the current epoch.
+     * Requires proving to have been completed.
+     */
+    finaliseEpoch(): {
+        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 +98,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 +116,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,EASL,KAAK,WAAW,EAChB,KAAK,kBAAkB,EAGvB,KAAK,aAAa,EAElB,KAAK,mBAAmB,EAQzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAEnE,OAAO,EAOL,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;AAyB/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,CAA4C;IAChE,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;IAQL,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,aAAa;IAahF;;;;;;;OAOG;IAKU,aAAa,CACxB,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,eAAe,EAChC,cAAc,EAAE,EAAE,EAAE,GACnB,OAAO,CAAC,aAAa,CAAC;IA4FzB;;;OAGG;IAIU,QAAQ,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IA8BrD;;;OAGG;IAYU,iBAAiB;YA8ChB,gBAAgB;IAsC9B,OAAO,CAAC,iBAAiB;IA4CzB;;;;;OAKG;IACH,OAAO,CAAC,wBAAwB;IAmBhC;;OAEG;IACI,MAAM;IAQb;;;OAGG;IACH,OAAO,CAAC,kCAAkC;IAmB1C;;;;OAIG;IACI,aAAa,CAAC,KAAK,CAAC,EAAE,MAAM;IAiCnC;;;OAGG;IACI,aAAa;;;;IAQpB;;;;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;IAkF9B,OAAO,CAAC,wBAAwB;IA6BhC,OAAO,CAAC,wBAAwB;IAqBhC,OAAO,CAAC,uBAAuB;IAiC/B,OAAO,CAAC,iBAAiB;IAsCzB,OAAO,CAAC,8BAA8B;IAQtC,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"}