@aztec/prover-client 0.43.0 → 0.45.0

package/dest/orchestrator/orchestrator.js

@@ -1,4 +1,5 @@
-import { Body, L2Block, MerkleTreeId, PublicKernelType, Tx, makeEmptyProcessedTx, makePaddingProcessedTx, toTxEffect, } from '@aztec/circuit-types';
+import { __esDecorate, __runInitializers } from "tslib";
+import { Body, L2Block, MerkleTreeId, PublicKernelType, Tx, makeEmptyProcessedTx, makePaddingProcessedTx, mapPublicKernelToCircuitName, toTxEffect, } from '@aztec/circuit-types';
 import { BlockProofError, PROVING_STATUS, } from '@aztec/circuit-types/interfaces';
 import { AGGREGATION_OBJECT_LENGTH, AvmCircuitInputs, BaseParityInputs, Fr, L1_TO_L2_MSG_SUBTREE_HEIGHT, L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, NUM_BASE_PARITY_PER_ROOT_PARITY, RootParityInputs, VerificationKeyData, makeEmptyProof, } from '@aztec/circuits.js';
 import { makeTuple } from '@aztec/foundation/array';
@@ -8,6 +9,7 @@ import { createDebugLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { BufferReader } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
+import { Attributes, trackSpan, wrapCallbackInSpan } from '@aztec/telemetry-client';
 import { inspect } from 'util';
 import { buildBaseRollupInput, createMergeRollupInputs, getRootRollupInput, getSubtreeSiblingPath, getTreeSnapshot, validatePartialState, validateRootOutput, validateTx, } from './block-building-helpers.js';
 import { ProvingState } from './proving-state.js';
@@ -26,549 +28,638 @@ const logger = createDebugLogger('aztec:prover:proving-orchestrator');
 /**
  * The orchestrator, managing the flow of recursive proving operations required to build the rollup proof tree.
  */
-export class ProvingOrchestrator {
-    constructor(db, prover, initialHeader) {
-        this.db = db;
-        this.prover = prover;
-        this.initialHeader = initialHeader;
-        this.provingState = undefined;
-        this.pendingProvingJobs = [];
-        this.paddingTx = undefined;
-    }
-    /**
-     * Resets the orchestrator's cached padding tx.
-     */
-    reset() {
-        this.paddingTx = undefined;
-    }
-    /**
-     * Starts off a new block
-     * @param numTxs - The total number of transactions in the block. Must be a power of 2
-     * @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
-     */
-    async startNewBlock(numTxs, globalVariables, l1ToL2Messages, verificationKeys) {
-        // Create initial header if not done so yet
-        if (!this.initialHeader) {
-            this.initialHeader = await this.db.buildInitialHeader();
-        }
-        // Check that the length of the array of txs is a power of two
-        // See https://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2
-        if (!Number.isInteger(numTxs) || numTxs < 2 || (numTxs & (numTxs - 1)) !== 0) {
-            throw new Error(`Length of txs for the block should be a power of two and at least two (got ${numTxs})`);
-        }
-        // Cancel any currently proving block before starting a new one
-        this.cancelBlock();
-        logger.info(`Starting new block with ${numTxs} transactions`);
-        // we start the block by enqueueing all of the base parity circuits
-        let baseParityInputs = [];
-        let l1ToL2MessagesPadded;
-        try {
-            l1ToL2MessagesPadded = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-        }
-        catch (err) {
-            throw new Error('Too many L1 to L2 messages');
-        }
-        baseParityInputs = Array.from({ length: NUM_BASE_PARITY_PER_ROOT_PARITY }, (_, i) => BaseParityInputs.fromSlice(l1ToL2MessagesPadded, i));
-        const messageTreeSnapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, this.db);
-        const newL1ToL2MessageTreeRootSiblingPathArray = await getSubtreeSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, L1_TO_L2_MSG_SUBTREE_HEIGHT, this.db);
-        const newL1ToL2MessageTreeRootSiblingPath = makeTuple(L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, i => i < newL1ToL2MessageTreeRootSiblingPathArray.length ? newL1ToL2MessageTreeRootSiblingPathArray[i] : Fr.ZERO, 0);
-        // Update the local trees to include the new l1 to l2 messages
-        await this.db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
-        const { promise: _promise, resolve, reject } = promiseWithResolvers();
-        const promise = _promise.catch((reason) => ({
-            status: PROVING_STATUS.FAILURE,
-            reason,
-        }));
-        const provingState = new ProvingState(numTxs, resolve, reject, globalVariables, l1ToL2MessagesPadded, baseParityInputs.length, messageTreeSnapshot, newL1ToL2MessageTreeRootSiblingPath, verificationKeys);
-        for (let i = 0; i < baseParityInputs.length; i++) {
-            this.enqueueBaseParityCircuit(provingState, baseParityInputs[i], i);
-        }
-        this.provingState = provingState;
-        const ticket = {
-            provingPromise: promise,
-        };
-        return ticket;
-    }
-    /**
-     * The interface to add a simulated transaction to the scheduler
-     * @param tx - The transaction to be proven
-     */
-    async addNewTx(tx) {
-        if (!this.provingState) {
-            throw new Error(`Invalid proving state, call startNewBlock before adding transactions`);
-        }
-        if (!this.provingState.isAcceptingTransactions()) {
-            throw new Error(`Rollup not accepting further transactions`);
-        }
-        validateTx(tx);
-        logger.info(`Received transaction: ${tx.hash}`);
-        const [inputs, treeSnapshots] = await this.prepareTransaction(tx, this.provingState);
-        this.enqueueFirstProof(inputs, treeSnapshots, tx, this.provingState);
-    }
-    /**
-     * Marks the block as full and pads it to the full power of 2 block size, no more transactions will be accepted.
-     */
-    async setBlockCompleted() {
-        if (!this.provingState) {
-            throw new Error(`Invalid proving state, call startNewBlock before adding transactions or completing the block`);
-        }
-        // we may need to pad the rollup with empty transactions
-        const paddingTxCount = this.provingState.totalNumTxs - this.provingState.transactionsReceived;
-        if (paddingTxCount === 0) {
-            return;
-        }
-        logger.debug(`Padding rollup with ${paddingTxCount} empty transactions`);
-        // Make an empty padding transaction
-        // Insert it into the tree the required number of times to get all of the
-        // base rollup inputs
-        // Then enqueue the proving of all the transactions
-        const unprovenPaddingTx = makeEmptyProcessedTx(this.initialHeader ?? (await this.db.buildInitialHeader()), this.provingState.globalVariables.chainId, this.provingState.globalVariables.version);
-        const txInputs = [];
-        for (let i = 0; i < paddingTxCount; i++) {
-            const [inputs, snapshot] = await this.prepareTransaction(unprovenPaddingTx, this.provingState);
-            const txInput = {
-                inputs,
-                snapshot,
-            };
-            txInputs.push(txInput);
-        }
-        // Now enqueue the proving
-        this.enqueuePaddingTxs(this.provingState, txInputs, unprovenPaddingTx);
-    }
-    // Enqueues the proving of the required padding transactions
-    // If the fully proven padding transaction is not available, this will first be proven
-    enqueuePaddingTxs(provingState, txInputs, unprovenPaddingTx) {
-        if (this.paddingTx) {
-            // We already have the padding transaction
-            logger.debug(`Enqueuing ${txInputs.length} padding transactions using existing padding tx`);
-            this.provePaddingTransactions(txInputs, this.paddingTx, provingState);
-            return;
-        }
-        logger.debug(`Enqueuing deferred proving for padding txs to enqueue ${txInputs.length} paddings`);
-        this.deferredProving(provingState, signal => this.prover.getEmptyPrivateKernelProof({
-            // Chain id and version should not change even if the proving state does, so it's safe to use them for the padding tx
-            // which gets cached across multiple runs of the orchestrator with different proving states. If they were to change,
-            // we'd have to clear out the paddingTx here and regenerate it when they do.
-            chainId: unprovenPaddingTx.data.constants.txContext.chainId,
-            version: unprovenPaddingTx.data.constants.txContext.version,
-            header: unprovenPaddingTx.data.constants.historicalHeader,
-        }, signal), result => {
-            logger.debug(`Completed proof for padding tx, now enqueuing ${txInputs.length} padding txs`);
-            this.paddingTx = makePaddingProcessedTx(result);
-            this.provePaddingTransactions(txInputs, this.paddingTx, provingState);
-        });
-    }
-    /**
-     * Prepares the cached sets of base rollup inputs for padding transactions and proves them
-     * @param txInputs - The base rollup inputs, start and end hash paths etc
-     * @param paddingTx - The padding tx, contains the header, proof, vk, public inputs used in the proof
-     * @param provingState - The block proving state
-     */
-    provePaddingTransactions(txInputs, paddingTx, provingState) {
-        // The padding tx contains the proof and vk, generated separately from the base inputs
-        // Copy these into the base rollup inputs
-        for (let i = 0; i < txInputs.length; i++) {
-            txInputs[i].inputs.kernelData.vk = paddingTx.verificationKey;
-            txInputs[i].inputs.kernelData.proof = paddingTx.recursiveProof;
-            this.enqueueFirstProof(txInputs[i].inputs, txInputs[i].snapshot, paddingTx, provingState);
-        }
-    }
-    /**
-     * Cancel any further proving of the block
-     */
-    cancelBlock() {
-        for (const controller of this.pendingProvingJobs) {
-            controller.abort();
-        }
-        this.provingState?.cancel();
-    }
-    /**
-     * Performs the final tree update for the block and returns the fully proven block.
-     * @returns The fully proven block and proof.
-     */
-    async finaliseBlock() {
-        try {
-            if (!this.provingState ||
-                !this.provingState.rootRollupPublicInputs ||
-                !this.provingState.finalProof ||
-                !this.provingState.finalAggregationObject) {
-                throw new Error(`Invalid proving state, a block must be proven before it can be finalised`);
+let ProvingOrchestrator = (() => {
+    var _a;
+    let _instanceExtraInitializers = [];
+    let _startNewBlock_decorators;
+    let _addNewTx_decorators;
+    let _setBlockCompleted_decorators;
+    let _finaliseBlock_decorators;
+    let _prepareBaseRollupInputs_decorators;
+    return _a = class ProvingOrchestrator {
+            constructor(db, prover, telemetryClient, initialHeader) {
+                this.db = (__runInitializers(this, _instanceExtraInitializers), db);
+                this.prover = prover;
+                this.initialHeader = initialHeader;
+                this.provingState = undefined;
+                this.pendingProvingJobs = [];
+                this.paddingTx = undefined;
+                this.tracer = telemetryClient.getTracer('ProvingOrchestrator');
             }
-            if (this.provingState.block) {
-                throw new Error('Block already finalised');
+            /**
+             * Resets the orchestrator's cached padding tx.
+             */
+            reset() {
+                this.paddingTx = undefined;
             }
-            const rootRollupOutputs = this.provingState.rootRollupPublicInputs;
-            logger?.debug(`Updating and validating root trees`);
-            await this.db.updateArchive(rootRollupOutputs.header);
-            await validateRootOutput(rootRollupOutputs, this.db);
-            // Collect all new nullifiers, commitments, and contracts from all txs in this block
-            const gasFees = this.provingState.globalVariables.gasFees;
-            const nonEmptyTxEffects = this.provingState.allTxs.map(txProvingState => toTxEffect(txProvingState.processedTx, gasFees)).filter(txEffect => !txEffect.isEmpty());
-            const blockBody = new Body(nonEmptyTxEffects);
-            const l2Block = L2Block.fromFields({
-                archive: rootRollupOutputs.archive,
-                header: rootRollupOutputs.header,
-                body: blockBody,
-            });
-            if (!l2Block.body.getTxsEffectsHash().equals(rootRollupOutputs.header.contentCommitment.txsEffectsHash)) {
-                logger.debug(inspect(blockBody));
-                throw new Error(`Txs effects hash mismatch, ${l2Block.body
-                    .getTxsEffectsHash()
-                    .toString('hex')} == ${rootRollupOutputs.header.contentCommitment.txsEffectsHash.toString('hex')} `);
+            /**
+             * Starts off a new block
+             * @param numTxs - The total number of transactions in the block. Must be a power of 2
+             * @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
+             */
+            async startNewBlock(numTxs, globalVariables, l1ToL2Messages, verificationKeys) {
+                // Create initial header if not done so yet
+                if (!this.initialHeader) {
+                    this.initialHeader = await this.db.buildInitialHeader();
+                }
+                if (!Number.isInteger(numTxs) || numTxs < 2) {
+                    throw new Error(`Length of txs for the block should be at least two (got ${numTxs})`);
+                }
+                // Cancel any currently proving block before starting a new one
+                this.cancelBlock();
+                logger.info(`Starting new block with ${numTxs} transactions`);
+                // we start the block by enqueueing all of the base parity circuits
+                let baseParityInputs = [];
+                let l1ToL2MessagesPadded;
+                try {
+                    l1ToL2MessagesPadded = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+                }
+                catch (err) {
+                    throw new Error('Too many L1 to L2 messages');
+                }
+                baseParityInputs = Array.from({ length: NUM_BASE_PARITY_PER_ROOT_PARITY }, (_, i) => BaseParityInputs.fromSlice(l1ToL2MessagesPadded, i));
+                const messageTreeSnapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, this.db);
+                const newL1ToL2MessageTreeRootSiblingPathArray = await getSubtreeSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, L1_TO_L2_MSG_SUBTREE_HEIGHT, this.db);
+                const newL1ToL2MessageTreeRootSiblingPath = makeTuple(L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, i => i < newL1ToL2MessageTreeRootSiblingPathArray.length ? newL1ToL2MessageTreeRootSiblingPathArray[i] : Fr.ZERO, 0);
+                // Update the local trees to include the new l1 to l2 messages
+                await this.db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
+                const { promise: _promise, resolve, reject } = promiseWithResolvers();
+                const promise = _promise.catch((reason) => ({
+                    status: PROVING_STATUS.FAILURE,
+                    reason,
+                }));
+                const provingState = new ProvingState(numTxs, resolve, reject, globalVariables, l1ToL2MessagesPadded, baseParityInputs.length, messageTreeSnapshot, newL1ToL2MessageTreeRootSiblingPath, verificationKeys);
+                for (let i = 0; i < baseParityInputs.length; i++) {
+                    this.enqueueBaseParityCircuit(provingState, baseParityInputs[i], i);
+                }
+                this.provingState = provingState;
+                const ticket = {
+                    provingPromise: promise,
+                };
+                return ticket;
             }
-            logger.info(`Successfully proven block ${l2Block.number}!`);
-            this.provingState.block = l2Block;
-            const blockResult = {
-                proof: this.provingState.finalProof,
-                aggregationObject: this.provingState.finalAggregationObject,
-                block: l2Block,
-            };
-            pushTestData('blockResults', {
-                block: l2Block.toString(),
-                proof: this.provingState.finalProof.toString(),
-                aggregationObject: blockResult.aggregationObject.map(x => x.toString()),
-            });
-            return blockResult;
-        }
-        catch (err) {
-            throw new BlockProofError(err && typeof err === 'object' && 'message' in err ? String(err.message) : String(err), this.provingState?.allTxs.map(x => Tx.getHash(x.processedTx)) ?? []);
-        }
-    }
-    /**
-     * 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
-     */
-    async prepareTransaction(tx, provingState) {
-        // Pass the private kernel tail vk here as the previous one.
-        // If there are public functions then this key will be overwritten once the public tail has been proven
-        const previousKernelVerificationKey = provingState.privateKernelVerificationKeys.privateKernelCircuit;
-        const txInputs = await this.prepareBaseRollupInputs(provingState, tx, previousKernelVerificationKey);
-        if (!txInputs) {
-            // This should not be possible
-            throw new Error(`Unable to add padding transaction, preparing base inputs failed`);
-        }
-        return txInputs;
-    }
-    enqueueFirstProof(inputs, treeSnapshots, tx, provingState) {
-        const txProvingState = new TxProvingState(tx, inputs, treeSnapshots, provingState.privateKernelVerificationKeys.privateKernelToPublicCircuit);
-        const txIndex = provingState.addNewTx(txProvingState);
-        const numPublicKernels = txProvingState.getNumPublicKernels();
-        if (!numPublicKernels) {
-            // no public functions, go straight to the base rollup
-            logger.debug(`Enqueueing base rollup for tx ${txIndex}`);
-            this.enqueueBaseRollup(provingState, BigInt(txIndex), txProvingState);
-            return;
-        }
-        // Enqueue all of the VM/kernel proving requests
-        // Rather than handle the Kernel Tail as a special case here, we will just handle it inside enqueueVM
-        for (let i = 0; i < numPublicKernels; i++) {
-            logger.debug(`Enqueueing public VM ${i} for tx ${txIndex}`);
-            this.enqueueVM(provingState, txIndex, i);
-        }
-    }
-    /**
-     * 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
-     */
-    deferredProving(provingState, request, callback) {
-        if (!provingState?.verifyState()) {
-            logger.debug(`Not enqueuing job, state no longer valid`);
-            return;
-        }
-        const controller = new AbortController();
-        this.pendingProvingJobs.push(controller);
-        // We use a 'safeJob'. We don't want promise rejections in the proving pool, we want to capture the error here
-        // and reject the proving job whilst keeping the event loop free of rejections
-        const safeJob = async () => {
-            try {
-                // there's a delay between enqueueing this job and it actually running
-                if (controller.signal.aborted) {
-                    return;
+            /**
+             * The interface to add a simulated transaction to the scheduler
+             * @param tx - The transaction to be proven
+             */
+            async addNewTx(tx) {
+                if (!this.provingState) {
+                    throw new Error(`Invalid proving state, call startNewBlock before adding transactions`);
                 }
-                const result = await request(controller.signal);
-                if (!provingState?.verifyState()) {
-                    logger.debug(`State no longer valid, discarding result`);
+                if (!this.provingState.isAcceptingTransactions()) {
+                    throw new Error(`Rollup not accepting further transactions`);
+                }
+                validateTx(tx);
+                logger.info(`Received transaction: ${tx.hash}`);
+                if (tx.isEmpty) {
+                    logger.warn(`Ignoring empty transaction ${tx.hash} - it will not be added to this block`);
                     return;
                 }
-                // we could have been cancelled whilst waiting for the result
-                // and the prover ignored the signal. Drop the result in that case
-                if (controller.signal.aborted) {
+                const [inputs, treeSnapshots] = await this.prepareTransaction(tx, this.provingState);
+                this.enqueueFirstProof(inputs, treeSnapshots, tx, this.provingState);
+            }
+            /**
+             * Marks the block as full and pads it if required, no more transactions will be accepted.
+             */
+            async setBlockCompleted() {
+                if (!this.provingState) {
+                    throw new Error(`Invalid proving state, call startNewBlock before adding transactions or completing the block`);
+                }
+                // we may need to pad the rollup with empty transactions
+                const paddingTxCount = this.provingState.totalNumTxs - this.provingState.transactionsReceived;
+                if (paddingTxCount === 0) {
                     return;
                 }
-                await callback(result);
+                else if (this.provingState.totalNumTxs > 2) {
+                    throw new Error(`Block not ready for completion: expecting ${paddingTxCount} more transactions.`);
+                }
+                logger.debug(`Padding rollup with ${paddingTxCount} empty transactions`);
+                // Make an empty padding transaction
+                // Required for:
+                // 0 (when we want an empty block, largely for testing), or
+                // 1 (we need to pad with one tx as all rollup circuits require a pair of inputs) txs
+                // Insert it into the tree the required number of times to get all of the
+                // base rollup inputs
+                // Then enqueue the proving of all the transactions
+                const unprovenPaddingTx = makeEmptyProcessedTx(this.initialHeader ?? (await this.db.buildInitialHeader()), this.provingState.globalVariables.chainId, this.provingState.globalVariables.version);
+                const txInputs = [];
+                for (let i = 0; i < paddingTxCount; i++) {
+                    const [inputs, snapshot] = await this.prepareTransaction(unprovenPaddingTx, this.provingState);
+                    const txInput = {
+                        inputs,
+                        snapshot,
+                    };
+                    txInputs.push(txInput);
+                }
+                // Now enqueue the proving
+                this.enqueuePaddingTxs(this.provingState, txInputs, unprovenPaddingTx);
             }
-            catch (err) {
-                if (err instanceof AbortError) {
-                    // operation was cancelled, probably because the block was cancelled
-                    // drop this result
+            // Enqueues the proving of the required padding transactions
+            // If the fully proven padding transaction is not available, this will first be proven
+            enqueuePaddingTxs(provingState, txInputs, unprovenPaddingTx) {
+                if (this.paddingTx) {
+                    // We already have the padding transaction
+                    logger.debug(`Enqueuing ${txInputs.length} padding transactions using existing padding tx`);
+                    this.provePaddingTransactions(txInputs, this.paddingTx, provingState);
                     return;
                 }
-                logger.error(`Error thrown when proving job`);
-                provingState.reject(`${err}`);
+                logger.debug(`Enqueuing deferred proving for padding txs to enqueue ${txInputs.length} paddings`);
+                this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getEmptyPrivateKernelProof', {
+                    [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+                    [Attributes.PROTOCOL_CIRCUIT_NAME]: 'private-kernel-empty',
+                }, signal => this.prover.getEmptyPrivateKernelProof({
+                    // Chain id and version should not change even if the proving state does, so it's safe to use them for the padding tx
+                    // which gets cached across multiple runs of the orchestrator with different proving states. If they were to change,
+                    // we'd have to clear out the paddingTx here and regenerate it when they do.
+                    chainId: unprovenPaddingTx.data.constants.txContext.chainId,
+                    version: unprovenPaddingTx.data.constants.txContext.version,
+                    header: unprovenPaddingTx.data.constants.historicalHeader,
+                }, signal)), result => {
+                    logger.debug(`Completed proof for padding tx, now enqueuing ${txInputs.length} padding txs`);
+                    this.paddingTx = makePaddingProcessedTx(result);
+                    this.provePaddingTransactions(txInputs, this.paddingTx, provingState);
+                });
             }
-            finally {
-                const index = this.pendingProvingJobs.indexOf(controller);
-                if (index > -1) {
-                    this.pendingProvingJobs.splice(index, 1);
+            /**
+             * Prepares the cached sets of base rollup inputs for padding transactions and proves them
+             * @param txInputs - The base rollup inputs, start and end hash paths etc
+             * @param paddingTx - The padding tx, contains the header, proof, vk, public inputs used in the proof
+             * @param provingState - The block proving state
+             */
+            provePaddingTransactions(txInputs, paddingTx, provingState) {
+                // The padding tx contains the proof and vk, generated separately from the base inputs
+                // Copy these into the base rollup inputs
+                for (let i = 0; i < txInputs.length; i++) {
+                    txInputs[i].inputs.kernelData.vk = paddingTx.verificationKey;
+                    txInputs[i].inputs.kernelData.proof = paddingTx.recursiveProof;
+                    this.enqueueFirstProof(txInputs[i].inputs, txInputs[i].snapshot, paddingTx, provingState);
                 }
             }
-        };
-        // let the callstack unwind before adding the job to the queue
-        setImmediate(safeJob);
-    }
-    // Updates the merkle trees for a transaction. The first enqueued job for a transaction
-    async prepareBaseRollupInputs(provingState, tx, kernelVk) {
-        if (!provingState?.verifyState()) {
-            logger.debug('Not preparing base rollup inputs, state invalid');
-            return;
-        }
-        const inputs = await buildBaseRollupInput(tx, provingState.globalVariables, this.db, kernelVk);
-        const promises = [MerkleTreeId.NOTE_HASH_TREE, MerkleTreeId.NULLIFIER_TREE, MerkleTreeId.PUBLIC_DATA_TREE].map(async (id) => {
-            return { key: id, value: await getTreeSnapshot(id, this.db) };
-        });
-        const treeSnapshots = new Map((await Promise.all(promises)).map(obj => [obj.key, obj.value]));
-        if (!provingState?.verifyState()) {
-            logger.debug(`Discarding proving job, state no longer valid`);
-            return;
-        }
-        return [inputs, treeSnapshots];
-    }
-    // Stores the intermediate inputs prepared for a merge proof
-    storeMergeInputs(provingState, currentLevel, currentIndex, mergeInputs) {
-        const mergeLevel = currentLevel - 1n;
-        const indexWithinMergeLevel = currentIndex >> 1n;
-        const mergeIndex = 2n ** mergeLevel - 1n + indexWithinMergeLevel;
-        const subscript = Number(mergeIndex);
-        const indexWithinMerge = Number(currentIndex & 1n);
-        const ready = provingState.storeMergeInputs(mergeInputs, indexWithinMerge, subscript);
-        return { ready, indexWithinMergeLevel, mergeLevel, mergeInputData: provingState.getMergeInputs(subscript) };
-    }
-    // Executes the base rollup circuit and stored the output as intermediate state for the parent merge/root circuit
-    // Executes the next level of merge if all inputs are available
-    enqueueBaseRollup(provingState, index, tx) {
-        if (!provingState?.verifyState()) {
-            logger.debug('Not running base rollup, state invalid');
-            return;
-        }
-        if (!tx.baseRollupInputs.kernelData.publicInputs.end.noteEncryptedLogsHash
-            .toBuffer()
-            .equals(tx.processedTx.noteEncryptedLogs.hash())) {
-            provingState.reject(`Note encrypted logs hash mismatch: ${tx.baseRollupInputs.kernelData.publicInputs.end.noteEncryptedLogsHash} === ${Fr.fromBuffer(tx.processedTx.noteEncryptedLogs.hash())}`);
-            return;
-        }
-        if (!tx.baseRollupInputs.kernelData.publicInputs.end.encryptedLogsHash
-            .toBuffer()
-            .equals(tx.processedTx.encryptedLogs.hash())) {
-            // @todo This rejection messages is never seen. Never making it out to the logs
-            provingState.reject(`Encrypted logs hash mismatch: ${tx.baseRollupInputs.kernelData.publicInputs.end.encryptedLogsHash} === ${Fr.fromBuffer(tx.processedTx.encryptedLogs.hash())}`);
-            return;
-        }
-        if (!tx.baseRollupInputs.kernelData.publicInputs.end.unencryptedLogsHash
-            .toBuffer()
-            .equals(tx.processedTx.unencryptedLogs.hash())) {
-            provingState.reject(`Unencrypted logs hash mismatch: ${tx.baseRollupInputs.kernelData.publicInputs.end.unencryptedLogsHash} === ${Fr.fromBuffer(tx.processedTx.unencryptedLogs.hash())}`);
-            return;
-        }
-        logger.debug(`Enqueuing deferred proving base rollup${tx.processedTx.isEmpty ? ' with padding tx' : ''} for ${tx.processedTx.hash.toString()}`);
-        this.deferredProving(provingState, signal => this.prover.getBaseRollupProof(tx.baseRollupInputs, signal), result => {
-            logger.debug(`Completed proof for base rollup for tx ${tx.processedTx.hash.toString()}`);
-            validatePartialState(result.inputs.end, tx.treeSnapshots);
-            const currentLevel = provingState.numMergeLevels + 1n;
-            this.storeAndExecuteNextMergeLevel(provingState, currentLevel, index, [
-                result.inputs,
-                result.proof,
-                result.verificationKey.keyAsFields,
-            ]);
-        });
-    }
-    // Executes the merge rollup circuit and stored the output as intermediate state for the parent merge/root circuit
-    // Enqueues the next level of merge if all inputs are available
-    enqueueMergeRollup(provingState, level, index, mergeInputData) {
-        const inputs = createMergeRollupInputs([mergeInputData.inputs[0], mergeInputData.proofs[0], mergeInputData.verificationKeys[0]], [mergeInputData.inputs[1], mergeInputData.proofs[1], mergeInputData.verificationKeys[1]]);
-        this.deferredProving(provingState, signal => this.prover.getMergeRollupProof(inputs, signal), result => {
-            this.storeAndExecuteNextMergeLevel(provingState, level, index, [
-                result.inputs,
-                result.proof,
-                result.verificationKey.keyAsFields,
-            ]);
-        });
-    }
-    // Executes the root rollup circuit
-    async enqueueRootRollup(provingState) {
-        if (!provingState?.verifyState()) {
-            logger.debug('Not running root rollup, state no longer valid');
-            return;
-        }
-        const mergeInputData = provingState.getMergeInputs(0);
-        const rootParityInput = provingState.finalRootParityInput;
-        const inputs = await getRootRollupInput(mergeInputData.inputs[0], mergeInputData.proofs[0], mergeInputData.verificationKeys[0], mergeInputData.inputs[1], mergeInputData.proofs[1], mergeInputData.verificationKeys[1], rootParityInput, provingState.newL1ToL2Messages, provingState.messageTreeSnapshot, provingState.messageTreeRootSiblingPath, this.db);
-        this.deferredProving(provingState, signal => this.prover.getRootRollupProof(inputs, signal), result => {
-            provingState.rootRollupPublicInputs = result.inputs;
-            provingState.finalAggregationObject = extractAggregationObject(result.proof.binaryProof, result.verificationKey.numPublicInputs);
-            provingState.finalProof = result.proof.binaryProof;
-            const provingResult = {
-                status: PROVING_STATUS.SUCCESS,
-            };
-            provingState.resolve(provingResult);
-        });
-    }
-    // Executes the base parity circuit and stores the intermediate state for the root parity circuit
-    // Enqueues the root parity circuit if all inputs are available
-    enqueueBaseParityCircuit(provingState, inputs, index) {
-        this.deferredProving(provingState, signal => this.prover.getBaseParityProof(inputs, signal), rootInput => {
-            provingState.setRootParityInputs(rootInput, index);
-            if (provingState.areRootParityInputsReady()) {
-                const rootParityInputs = new RootParityInputs(provingState.rootParityInput);
-                this.enqueueRootParityCircuit(provingState, rootParityInputs);
+            /**
+             * Cancel any further proving of the block
+             */
+            cancelBlock() {
+                for (const controller of this.pendingProvingJobs) {
+                    controller.abort();
+                }
+                this.provingState?.cancel();
             }
-        });
-    }
-    // Runs the root parity circuit ans stored the outputs
-    // Enqueues the root rollup proof if all inputs are available
-    enqueueRootParityCircuit(provingState, inputs) {
-        this.deferredProving(provingState, signal => this.prover.getRootParityProof(inputs, signal), async (rootInput) => {
-            provingState.finalRootParityInput = rootInput;
-            await this.checkAndEnqueueRootRollup(provingState);
-        });
-    }
-    async checkAndEnqueueRootRollup(provingState) {
-        if (!provingState?.isReadyForRootRollup()) {
-            logger.debug('Not ready for root rollup');
-            return;
-        }
-        await this.enqueueRootRollup(provingState);
-    }
-    /**
-     * Stores the inputs to a 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
-     */
-    storeAndExecuteNextMergeLevel(provingState, currentLevel, currentIndex, mergeInputData) {
-        const result = this.storeMergeInputs(provingState, currentLevel, currentIndex, mergeInputData);
-        // Are we ready to execute the next circuit?
-        if (!result.ready) {
-            return;
-        }
-        if (result.mergeLevel === 0n) {
-            // TODO (alexg) remove this `void`
-            void this.checkAndEnqueueRootRollup(provingState);
-        }
-        else {
-            // onto the next merge level
-            this.enqueueMergeRollup(provingState, result.mergeLevel, result.indexWithinMergeLevel, result.mergeInputData);
-        }
-    }
-    /**
-     * 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
-     * @param functionIndex - The index of the function/kernel being proven
-     */
-    enqueueVM(provingState, txIndex, functionIndex) {
-        if (!provingState?.verifyState()) {
-            logger.debug(`Not running VM circuit as state is no longer valid`);
-            return;
-        }
-        const txProvingState = provingState.getTxProvingState(txIndex);
-        const publicFunction = txProvingState.getPublicFunctionState(functionIndex);
-        // If there is a VM request, we need to prove it. Otherwise, continue with the kernel.
-        if (publicFunction.vmRequest) {
-            // This function tries to do AVM proving. If there is a failure, it fakes the proof unless AVM_PROVING_STRICT is defined.
-            // Nothing downstream depends on the AVM proof yet. So having this mode lets us incrementally build the AVM circuit.
-            const doAvmProving = async (signal) => {
-                const inputs = new AvmCircuitInputs(publicFunction.vmRequest.bytecode, publicFunction.vmRequest.calldata, publicFunction.vmRequest.kernelRequest.inputs.publicCall.callStackItem.publicInputs, publicFunction.vmRequest.avmHints);
+            /**
+             * Performs the final tree update for the block and returns the fully proven block.
+             * @returns The fully proven block and proof.
+             */
+            async finaliseBlock() {
                 try {
-                    return await this.prover.getAvmProof(inputs, signal);
+                    if (!this.provingState ||
+                        !this.provingState.rootRollupPublicInputs ||
+                        !this.provingState.finalProof ||
+                        !this.provingState.finalAggregationObject) {
+                        throw new Error(`Invalid proving state, a block must be proven before it can be finalised`);
+                    }
+                    if (this.provingState.block) {
+                        throw new Error('Block already finalised');
+                    }
+                    const rootRollupOutputs = this.provingState.rootRollupPublicInputs;
+                    logger?.debug(`Updating and validating root trees`);
+                    await this.db.updateArchive(rootRollupOutputs.header);
+                    await validateRootOutput(rootRollupOutputs, this.db);
+                    // Collect all new nullifiers, commitments, and contracts from all txs in this block
+                    const gasFees = this.provingState.globalVariables.gasFees;
+                    const nonEmptyTxEffects = this.provingState.allTxs.map(txProvingState => toTxEffect(txProvingState.processedTx, gasFees)).filter(txEffect => !txEffect.isEmpty());
+                    const blockBody = new Body(nonEmptyTxEffects);
+                    const l2Block = L2Block.fromFields({
+                        archive: rootRollupOutputs.archive,
+                        header: rootRollupOutputs.header,
+                        body: blockBody,
+                    });
+                    if (!l2Block.body.getTxsEffectsHash().equals(rootRollupOutputs.header.contentCommitment.txsEffectsHash)) {
+                        logger.debug(inspect(blockBody));
+                        throw new Error(`Txs effects hash mismatch, ${l2Block.body
+                            .getTxsEffectsHash()
+                            .toString('hex')} == ${rootRollupOutputs.header.contentCommitment.txsEffectsHash.toString('hex')} `);
+                    }
+                    logger.info(`Successfully proven block ${l2Block.number}!`);
+                    this.provingState.block = l2Block;
+                    const blockResult = {
+                        proof: this.provingState.finalProof,
+                        aggregationObject: this.provingState.finalAggregationObject,
+                        block: l2Block,
+                    };
+                    pushTestData('blockResults', {
+                        block: l2Block.toString(),
+                        proof: this.provingState.finalProof.toString(),
+                        aggregationObject: blockResult.aggregationObject.map(x => x.toString()),
+                    });
+                    return blockResult;
                 }
                 catch (err) {
-                    if (process.env.AVM_PROVING_STRICT) {
-                        throw err;
+                    throw new BlockProofError(err && typeof err === 'object' && 'message' in err ? String(err.message) : String(err), this.provingState?.allTxs.map(x => Tx.getHash(x.processedTx)) ?? []);
+                }
+            }
+            /**
+             * 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
+             */
+            async prepareTransaction(tx, provingState) {
+                // Pass the private kernel tail vk here as the previous one.
+                // If there are public functions then this key will be overwritten once the public tail has been proven
+                const previousKernelVerificationKey = provingState.privateKernelVerificationKeys.privateKernelCircuit;
+                const txInputs = await this.prepareBaseRollupInputs(provingState, tx, previousKernelVerificationKey);
+                if (!txInputs) {
+                    // This should not be possible
+                    throw new Error(`Unable to add padding transaction, preparing base inputs failed`);
+                }
+                return txInputs;
+            }
+            enqueueFirstProof(inputs, treeSnapshots, tx, provingState) {
+                const txProvingState = new TxProvingState(tx, inputs, treeSnapshots, provingState.privateKernelVerificationKeys.privateKernelToPublicCircuit);
+                const txIndex = provingState.addNewTx(txProvingState);
+                const numPublicKernels = txProvingState.getNumPublicKernels();
+                if (!numPublicKernels) {
+                    // no public functions, go straight to the base rollup
+                    logger.debug(`Enqueueing base rollup for tx ${txIndex}`);
+                    this.enqueueBaseRollup(provingState, BigInt(txIndex), txProvingState);
+                    return;
+                }
+                // Enqueue all of the VM/kernel proving requests
+                // Rather than handle the Kernel Tail as a special case here, we will just handle it inside enqueueVM
+                for (let i = 0; i < numPublicKernels; i++) {
+                    logger.debug(`Enqueueing public VM ${i} for tx ${txIndex}`);
+                    this.enqueueVM(provingState, txIndex, i);
+                }
+            }
+            /**
+             * 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
+             */
+            deferredProving(provingState, request, callback) {
+                if (!provingState?.verifyState()) {
+                    logger.debug(`Not enqueuing job, state no longer valid`);
+                    return;
+                }
+                const controller = new AbortController();
+                this.pendingProvingJobs.push(controller);
+                // We use a 'safeJob'. We don't want promise rejections in the proving pool, we want to capture the error here
+                // and reject the proving job whilst keeping the event loop free of rejections
+                const safeJob = async () => {
+                    try {
+                        // there's a delay between enqueueing this job and it actually running
+                        if (controller.signal.aborted) {
+                            return;
+                        }
+                        const result = await request(controller.signal);
+                        if (!provingState?.verifyState()) {
+                            logger.debug(`State no longer valid, discarding result`);
+                            return;
+                        }
+                        // we could have been cancelled whilst waiting for the result
+                        // and the prover ignored the signal. Drop the result in that case
+                        if (controller.signal.aborted) {
+                            return;
+                        }
+                        await callback(result);
                     }
-                    else {
-                        logger.warn(`Error thrown when proving AVM circuit: ${err}`);
-                        logger.warn(`AVM_PROVING_STRICT is off, faking AVM proof and carrying on...`);
-                        return { proof: makeEmptyProof(), verificationKey: VerificationKeyData.makeFake() };
+                    catch (err) {
+                        if (err instanceof AbortError) {
+                            // operation was cancelled, probably because the block was cancelled
+                            // drop this result
+                            return;
+                        }
+                        logger.error(`Error thrown when proving job`);
+                        provingState.reject(`${err}`);
+                    }
+                    finally {
+                        const index = this.pendingProvingJobs.indexOf(controller);
+                        if (index > -1) {
+                            this.pendingProvingJobs.splice(index, 1);
+                        }
                     }
+                };
+                // let the callstack unwind before adding the job to the queue
+                setImmediate(safeJob);
+            }
+            // Updates the merkle trees for a transaction. The first enqueued job for a transaction
+            async prepareBaseRollupInputs(provingState, tx, kernelVk) {
+                if (!provingState?.verifyState()) {
+                    logger.debug('Not preparing base rollup inputs, state invalid');
+                    return;
                 }
-            };
-            this.deferredProving(provingState, doAvmProving, proofAndVk => {
-                logger.debug(`Proven VM for function index ${functionIndex} of tx index ${txIndex}`);
-                this.checkAndEnqueuePublicKernel(provingState, txIndex, functionIndex, proofAndVk.proof);
-            });
-        }
-        else {
-            this.checkAndEnqueuePublicKernel(provingState, txIndex, functionIndex, /*vmProof=*/ makeEmptyProof());
-        }
-    }
-    checkAndEnqueuePublicKernel(provingState, txIndex, functionIndex, vmProof) {
-        const txProvingState = provingState.getTxProvingState(txIndex);
-        const kernelRequest = txProvingState.getNextPublicKernelFromVMProof(functionIndex, vmProof);
-        if (kernelRequest.code === TX_PROVING_CODE.READY) {
-            if (kernelRequest.function === undefined) {
-                // Should not be possible
-                throw new Error(`Error occurred, public function request undefined after VM proof completed`);
+                const inputs = await buildBaseRollupInput(tx, provingState.globalVariables, this.db, kernelVk);
+                const promises = [MerkleTreeId.NOTE_HASH_TREE, MerkleTreeId.NULLIFIER_TREE, MerkleTreeId.PUBLIC_DATA_TREE].map(async (id) => {
+                    return { key: id, value: await getTreeSnapshot(id, this.db) };
+                });
+                const treeSnapshots = new Map((await Promise.all(promises)).map(obj => [obj.key, obj.value]));
+                if (!provingState?.verifyState()) {
+                    logger.debug(`Discarding proving job, state no longer valid`);
+                    return;
+                }
+                return [inputs, treeSnapshots];
             }
-            logger.debug(`Enqueuing kernel from VM for tx ${txIndex}, function ${functionIndex}`);
-            this.enqueuePublicKernel(provingState, txIndex, functionIndex);
-        }
-    }
-    /**
-     * Executes the kernel circuit for a public function, will enqueue the next kernel circuit if it's VM is already proven
-     * or the base rollup circuit if there are no more kernels to be proven
-     * @param provingState - The proving state being operated on
-     * @param txIndex - The index of the transaction being proven
-     * @param functionIndex - The index of the function/kernel being proven
-     */
-    enqueuePublicKernel(provingState, txIndex, functionIndex) {
-        if (!provingState?.verifyState()) {
-            logger.debug(`Not running public kernel circuit as state is no longer valid`);
-            return;
-        }
-        const txProvingState = provingState.getTxProvingState(txIndex);
-        const request = txProvingState.getPublicFunctionState(functionIndex).publicKernelRequest;
-        this.deferredProving(provingState, (signal) => {
-            if (request.type === PublicKernelType.TAIL) {
-                return this.prover.getPublicTailProof(request, signal);
+            // Stores the intermediate inputs prepared for a merge proof
+            storeMergeInputs(provingState, currentLevel, currentIndex, mergeInputs) {
+                const [mergeLevel, indexWithinMergeLevel, indexWithinMerge] = provingState.findMergeLevel(currentLevel, currentIndex);
+                const mergeIndex = 2n ** mergeLevel - 1n + indexWithinMergeLevel;
+                const ready = provingState.storeMergeInputs(mergeInputs, Number(indexWithinMerge), Number(mergeIndex));
+                return {
+                    ready,
+                    indexWithinMergeLevel,
+                    mergeLevel,
+                    mergeInputData: provingState.getMergeInputs(Number(mergeIndex)),
+                };
+            }
+            // Executes the base rollup circuit and stored the output as intermediate state for the parent merge/root circuit
+            // Executes the next level of merge if all inputs are available
+            enqueueBaseRollup(provingState, index, tx) {
+                if (!provingState?.verifyState()) {
+                    logger.debug('Not running base rollup, state invalid');
+                    return;
+                }
+                if (!tx.baseRollupInputs.kernelData.publicInputs.end.noteEncryptedLogsHash
+                    .toBuffer()
+                    .equals(tx.processedTx.noteEncryptedLogs.hash())) {
+                    provingState.reject(`Note encrypted logs hash mismatch: ${tx.baseRollupInputs.kernelData.publicInputs.end.noteEncryptedLogsHash} === ${Fr.fromBuffer(tx.processedTx.noteEncryptedLogs.hash())}`);
+                    return;
+                }
+                if (!tx.baseRollupInputs.kernelData.publicInputs.end.encryptedLogsHash
+                    .toBuffer()
+                    .equals(tx.processedTx.encryptedLogs.hash())) {
+                    // @todo This rejection messages is never seen. Never making it out to the logs
+                    provingState.reject(`Encrypted logs hash mismatch: ${tx.baseRollupInputs.kernelData.publicInputs.end.encryptedLogsHash} === ${Fr.fromBuffer(tx.processedTx.encryptedLogs.hash())}`);
+                    return;
+                }
+                if (!tx.baseRollupInputs.kernelData.publicInputs.end.unencryptedLogsHash
+                    .toBuffer()
+                    .equals(tx.processedTx.unencryptedLogs.hash())) {
+                    provingState.reject(`Unencrypted logs hash mismatch: ${tx.baseRollupInputs.kernelData.publicInputs.end.unencryptedLogsHash} === ${Fr.fromBuffer(tx.processedTx.unencryptedLogs.hash())}`);
+                    return;
+                }
+                logger.debug(`Enqueuing deferred proving base rollup${tx.processedTx.isEmpty ? ' with padding tx' : ''} for ${tx.processedTx.hash.toString()}`);
+                this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getBaseRollupProof', {
+                    [Attributes.TX_HASH]: tx.processedTx.hash.toString(),
+                    [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+                    [Attributes.PROTOCOL_CIRCUIT_NAME]: 'base-rollup',
+                }, signal => this.prover.getBaseRollupProof(tx.baseRollupInputs, signal)), result => {
+                    logger.debug(`Completed proof for base rollup for tx ${tx.processedTx.hash.toString()}`);
+                    validatePartialState(result.inputs.end, tx.treeSnapshots);
+                    const currentLevel = provingState.numMergeLevels + 1n;
+                    this.storeAndExecuteNextMergeLevel(provingState, currentLevel, index, [
+                        result.inputs,
+                        result.proof,
+                        result.verificationKey.keyAsFields,
+                    ]);
+                });
             }
-            else {
-                return this.prover.getPublicKernelProof(request, signal);
+            // Executes the merge rollup circuit and stored the output as intermediate state for the parent merge/root circuit
+            // Enqueues the next level of merge if all inputs are available
+            enqueueMergeRollup(provingState, level, index, mergeInputData) {
+                const inputs = createMergeRollupInputs([mergeInputData.inputs[0], mergeInputData.proofs[0], mergeInputData.verificationKeys[0]], [mergeInputData.inputs[1], mergeInputData.proofs[1], mergeInputData.verificationKeys[1]]);
+                this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getMergeRollupProof', {
+                    [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+                    [Attributes.PROTOCOL_CIRCUIT_NAME]: 'merge-rollup',
+                }, signal => this.prover.getMergeRollupProof(inputs, signal)), result => {
+                    this.storeAndExecuteNextMergeLevel(provingState, level, index, [
+                        result.inputs,
+                        result.proof,
+                        result.verificationKey.keyAsFields,
+                    ]);
+                });
             }
-        }, result => {
-            const nextKernelRequest = txProvingState.getNextPublicKernelFromKernelProof(functionIndex, result.proof, result.verificationKey);
-            // What's the status of the next kernel?
-            if (nextKernelRequest.code === TX_PROVING_CODE.NOT_READY) {
-                // Must be waiting on a VM proof
-                return;
+            // Executes the root rollup circuit
+            async enqueueRootRollup(provingState) {
+                if (!provingState?.verifyState()) {
+                    logger.debug('Not running root rollup, state no longer valid');
+                    return;
+                }
+                const mergeInputData = provingState.getMergeInputs(0);
+                const rootParityInput = provingState.finalRootParityInput;
+                const inputs = await getRootRollupInput(mergeInputData.inputs[0], mergeInputData.proofs[0], mergeInputData.verificationKeys[0], mergeInputData.inputs[1], mergeInputData.proofs[1], mergeInputData.verificationKeys[1], rootParityInput, provingState.newL1ToL2Messages, provingState.messageTreeSnapshot, provingState.messageTreeRootSiblingPath, this.db);
+                this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getRootRollupProof', {
+                    [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+                    [Attributes.PROTOCOL_CIRCUIT_NAME]: 'root-rollup',
+                }, signal => this.prover.getRootRollupProof(inputs, signal)), result => {
+                    provingState.rootRollupPublicInputs = result.inputs;
+                    provingState.finalAggregationObject = extractAggregationObject(result.proof.binaryProof, result.verificationKey.numPublicInputs);
+                    provingState.finalProof = result.proof.binaryProof;
+                    const provingResult = {
+                        status: PROVING_STATUS.SUCCESS,
+                    };
+                    provingState.resolve(provingResult);
+                });
             }
-            if (nextKernelRequest.code === TX_PROVING_CODE.COMPLETED) {
-                // We must have completed all public function proving, we now move to the base rollup
-                logger.debug(`Public functions completed for tx ${txIndex} enqueueing base rollup`);
-                // Take the final public tail proof and verification key and pass them to the base rollup
-                txProvingState.baseRollupInputs.kernelData.proof = result.proof;
-                txProvingState.baseRollupInputs.kernelData.vk = result.verificationKey;
-                this.enqueueBaseRollup(provingState, BigInt(txIndex), txProvingState);
-                return;
+            // Executes the base parity circuit and stores the intermediate state for the root parity circuit
+            // Enqueues the root parity circuit if all inputs are available
+            enqueueBaseParityCircuit(provingState, inputs, index) {
+                this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getBaseParityProof', {
+                    [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+                    [Attributes.PROTOCOL_CIRCUIT_NAME]: 'base-parity',
+                }, signal => this.prover.getBaseParityProof(inputs, signal)), rootInput => {
+                    provingState.setRootParityInputs(rootInput, index);
+                    if (provingState.areRootParityInputsReady()) {
+                        const rootParityInputs = new RootParityInputs(provingState.rootParityInput);
+                        this.enqueueRootParityCircuit(provingState, rootParityInputs);
+                    }
+                });
             }
-            // There must be another kernel ready to be proven
-            if (nextKernelRequest.function === undefined) {
-                // Should not be possible
-                throw new Error(`Error occurred, public function request undefined after kernel proof completed`);
+            // Runs the root parity circuit ans stored the outputs
+            // Enqueues the root rollup proof if all inputs are available
+            enqueueRootParityCircuit(provingState, inputs) {
+                this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getRootParityProof', {
+                    [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+                    [Attributes.PROTOCOL_CIRCUIT_NAME]: 'root-parity',
+                }, signal => this.prover.getRootParityProof(inputs, signal)), async (rootInput) => {
+                    provingState.finalRootParityInput = rootInput;
+                    await this.checkAndEnqueueRootRollup(provingState);
+                });
             }
-            this.enqueuePublicKernel(provingState, txIndex, functionIndex + 1);
-        });
-    }
-}
+            async checkAndEnqueueRootRollup(provingState) {
+                if (!provingState?.isReadyForRootRollup()) {
+                    logger.debug('Not ready for root rollup');
+                    return;
+                }
+                await this.enqueueRootRollup(provingState);
+            }
+            /**
+             * Stores the inputs to a 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
+             */
+            storeAndExecuteNextMergeLevel(provingState, currentLevel, currentIndex, mergeInputData) {
+                const result = this.storeMergeInputs(provingState, currentLevel, currentIndex, mergeInputData);
+                // Are we ready to execute the next circuit?
+                if (!result.ready) {
+                    return;
+                }
+                if (result.mergeLevel === 0n) {
+                    // TODO (alexg) remove this `void`
+                    void this.checkAndEnqueueRootRollup(provingState);
+                }
+                else {
+                    // onto the next merge level
+                    this.enqueueMergeRollup(provingState, result.mergeLevel, result.indexWithinMergeLevel, result.mergeInputData);
+                }
+            }
+            /**
+             * 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
+             * @param functionIndex - The index of the function/kernel being proven
+             */
+            enqueueVM(provingState, txIndex, functionIndex) {
+                if (!provingState?.verifyState()) {
+                    logger.debug(`Not running VM circuit as state is no longer valid`);
+                    return;
+                }
+                const txProvingState = provingState.getTxProvingState(txIndex);
+                const publicFunction = txProvingState.getPublicFunctionState(functionIndex);
+                // If there is a VM request, we need to prove it. Otherwise, continue with the kernel.
+                if (publicFunction.vmRequest) {
+                    // This function tries to do AVM proving. If there is a failure, it fakes the proof unless AVM_PROVING_STRICT is defined.
+                    // Nothing downstream depends on the AVM proof yet. So having this mode lets us incrementally build the AVM circuit.
+                    const doAvmProving = wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getAvmProof', {
+                        [Attributes.TX_HASH]: txProvingState.processedTx.hash.toString(),
+                        [Attributes.APP_CIRCUIT_NAME]: publicFunction.vmRequest.functionName,
+                    }, async (signal) => {
+                        const inputs = new AvmCircuitInputs(publicFunction.vmRequest.functionName, publicFunction.vmRequest.bytecode, publicFunction.vmRequest.calldata, publicFunction.vmRequest.kernelRequest.inputs.publicCall.callStackItem.publicInputs, publicFunction.vmRequest.avmHints);
+                        try {
+                            return await this.prover.getAvmProof(inputs, signal);
+                        }
+                        catch (err) {
+                            if (process.env.AVM_PROVING_STRICT) {
+                                throw err;
+                            }
+                            else {
+                                logger.warn(`Error thrown when proving AVM circuit: ${err}`);
+                                logger.warn(`AVM_PROVING_STRICT is off, faking AVM proof and carrying on...`);
+                                return { proof: makeEmptyProof(), verificationKey: VerificationKeyData.makeFake() };
+                            }
+                        }
+                    });
+                    this.deferredProving(provingState, doAvmProving, proofAndVk => {
+                        logger.debug(`Proven VM for function index ${functionIndex} of tx index ${txIndex}`);
+                        this.checkAndEnqueuePublicKernel(provingState, txIndex, functionIndex, proofAndVk.proof);
+                    });
+                }
+                else {
+                    this.checkAndEnqueuePublicKernel(provingState, txIndex, functionIndex, /*vmProof=*/ makeEmptyProof());
+                }
+            }
+            checkAndEnqueuePublicKernel(provingState, txIndex, functionIndex, vmProof) {
+                const txProvingState = provingState.getTxProvingState(txIndex);
+                const kernelRequest = txProvingState.getNextPublicKernelFromVMProof(functionIndex, vmProof);
+                if (kernelRequest.code === TX_PROVING_CODE.READY) {
+                    if (kernelRequest.function === undefined) {
+                        // Should not be possible
+                        throw new Error(`Error occurred, public function request undefined after VM proof completed`);
+                    }
+                    logger.debug(`Enqueuing kernel from VM for tx ${txIndex}, function ${functionIndex}`);
+                    this.enqueuePublicKernel(provingState, txIndex, functionIndex);
+                }
+            }
+            /**
+             * Executes the kernel circuit for a public function, will enqueue the next kernel circuit if it's VM is already proven
+             * or the base rollup circuit if there are no more kernels to be proven
+             * @param provingState - The proving state being operated on
+             * @param txIndex - The index of the transaction being proven
+             * @param functionIndex - The index of the function/kernel being proven
+             */
+            enqueuePublicKernel(provingState, txIndex, functionIndex) {
+                if (!provingState?.verifyState()) {
+                    logger.debug(`Not running public kernel circuit as state is no longer valid`);
+                    return;
+                }
+                const txProvingState = provingState.getTxProvingState(txIndex);
+                const request = txProvingState.getPublicFunctionState(functionIndex).publicKernelRequest;
+                this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, request.type === PublicKernelType.TAIL
+                    ? 'ProvingOrchestrator.prover.getPublicTailProof'
+                    : 'ProvingOrchestrator.prover.getPublicKernelProof', {
+                    [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+                    [Attributes.PROTOCOL_CIRCUIT_NAME]: mapPublicKernelToCircuitName(request.type),
+                }, (signal) => {
+                    if (request.type === PublicKernelType.TAIL) {
+                        return this.prover.getPublicTailProof(request, signal);
+                    }
+                    else {
+                        return this.prover.getPublicKernelProof(request, signal);
+                    }
+                }), result => {
+                    const nextKernelRequest = txProvingState.getNextPublicKernelFromKernelProof(functionIndex, result.proof, result.verificationKey);
+                    // What's the status of the next kernel?
+                    if (nextKernelRequest.code === TX_PROVING_CODE.NOT_READY) {
+                        // Must be waiting on a VM proof
+                        return;
+                    }
+                    if (nextKernelRequest.code === TX_PROVING_CODE.COMPLETED) {
+                        // We must have completed all public function proving, we now move to the base rollup
+                        logger.debug(`Public functions completed for tx ${txIndex} enqueueing base rollup`);
+                        // Take the final public tail proof and verification key and pass them to the base rollup
+                        txProvingState.baseRollupInputs.kernelData.proof = result.proof;
+                        txProvingState.baseRollupInputs.kernelData.vk = result.verificationKey;
+                        this.enqueueBaseRollup(provingState, BigInt(txIndex), txProvingState);
+                        return;
+                    }
+                    // There must be another kernel ready to be proven
+                    if (nextKernelRequest.function === undefined) {
+                        // Should not be possible
+                        throw new Error(`Error occurred, public function request undefined after kernel proof completed`);
+                    }
+                    this.enqueuePublicKernel(provingState, txIndex, functionIndex + 1);
+                });
+            }
+        },
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _startNewBlock_decorators = [trackSpan('ProvingOrchestrator.startNewBlock', (numTxs, globalVariables) => ({
+                    [Attributes.BLOCK_SIZE]: numTxs,
+                    [Attributes.BLOCK_NUMBER]: globalVariables.blockNumber.toNumber(),
+                }))];
+            _addNewTx_decorators = [trackSpan('ProvingOrchestrator.addNewTx', tx => ({
+                    [Attributes.TX_HASH]: tx.hash.toString(),
+                }))];
+            _setBlockCompleted_decorators = [trackSpan('ProvingOrchestrator.setBlockCompleted', function () {
+                    if (!this.provingState) {
+                        return {};
+                    }
+                    return {
+                        [Attributes.BLOCK_NUMBER]: this.provingState.globalVariables.blockNumber.toNumber(),
+                        [Attributes.BLOCK_SIZE]: this.provingState.totalNumTxs,
+                        [Attributes.BLOCK_TXS_COUNT]: this.provingState.transactionsReceived,
+                    };
+                })];
+            _finaliseBlock_decorators = [trackSpan('ProvingOrchestrator.finaliseBlock', function () {
+                    return {
+                        [Attributes.BLOCK_NUMBER]: this.provingState.globalVariables.blockNumber.toNumber(),
+                        [Attributes.BLOCK_TXS_COUNT]: this.provingState.transactionsReceived,
+                        [Attributes.BLOCK_SIZE]: this.provingState.totalNumTxs,
+                    };
+                })];
+            _prepareBaseRollupInputs_decorators = [trackSpan('ProvingOrchestrator.prepareBaseRollupInputs', (_, tx) => ({
+                    [Attributes.TX_HASH]: tx.hash.toString(),
+                }))];
+            __esDecorate(_a, null, _startNewBlock_decorators, { kind: "method", name: "startNewBlock", static: false, private: false, access: { has: obj => "startNewBlock" in obj, get: obj => obj.startNewBlock }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _addNewTx_decorators, { kind: "method", name: "addNewTx", static: false, private: false, access: { has: obj => "addNewTx" in obj, get: obj => obj.addNewTx }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _setBlockCompleted_decorators, { kind: "method", name: "setBlockCompleted", static: false, private: false, access: { has: obj => "setBlockCompleted" in obj, get: obj => obj.setBlockCompleted }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _finaliseBlock_decorators, { kind: "method", name: "finaliseBlock", static: false, private: false, access: { has: obj => "finaliseBlock" in obj, get: obj => obj.finaliseBlock }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _prepareBaseRollupInputs_decorators, { kind: "method", name: "prepareBaseRollupInputs", static: false, private: false, access: { has: obj => "prepareBaseRollupInputs" in obj, get: obj => obj.prepareBaseRollupInputs }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+export { ProvingOrchestrator };
 function extractAggregationObject(proof, numPublicInputs) {
     const buffer = proof.buffer.subarray(Fr.SIZE_IN_BYTES * (numPublicInputs - AGGREGATION_OBJECT_LENGTH), Fr.SIZE_IN_BYTES * numPublicInputs);
+    // TODO(#7159): Remove the following workaround
+    if (buffer.length === 0) {
+        return Array.from({ length: AGGREGATION_OBJECT_LENGTH }, () => Fr.ZERO);
+    }
     return BufferReader.asReader(buffer).readArray(AGGREGATION_OBJECT_LENGTH, Fr);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"orchestrator.js","sourceRoot":"","sources":["../../src/orchestrator/orchestrator.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"orchestrator.js","sourceRoot":"","sources":["../../src/orchestrator/orchestrator.ts"],"names":[],"mappings":"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"}