@aztec/prover-client 0.76.4 → 0.77.0-testnet-ignition.21

package/dest/orchestrator/orchestrator.js

@@ -1,18 +1,29 @@
-import { __esDecorate, __runInitializers } from "tslib";
-import { L2Block, MerkleTreeId, toNumBlobFields, } from '@aztec/circuit-types';
-import { AVM_PROOF_LENGTH_IN_FIELDS, AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS, 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, VerificationKeyData, makeEmptyRecursiveProof, } from '@aztec/circuits.js';
-import { EmptyBlockRootRollupInputs, PrivateBaseRollupInputs, SingleTxBlockRootRollupInputs, TubeInputs, } from '@aztec/circuits.js/rollup';
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { AVM_PROOF_LENGTH_IN_FIELDS, AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS, 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 } from '@aztec/constants';
 import { padArrayEnd, times } from '@aztec/foundation/collection';
 import { AbortError } from '@aztec/foundation/error';
+import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { assertLength } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
 import { elapsed } from '@aztec/foundation/timer';
-import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vks';
-import { Attributes, getTelemetryClient, trackSpan, wrapCallbackInSpan, } from '@aztec/telemetry-client';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { L2Block } from '@aztec/stdlib/block';
+import { BaseParityInputs } from '@aztec/stdlib/parity';
+import { makeEmptyRecursiveProof } from '@aztec/stdlib/proofs';
+import { EmptyBlockRootRollupInputs, PrivateBaseRollupInputs, SingleTxBlockRootRollupInputs, TubeInputs } from '@aztec/stdlib/rollup';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { toNumBlobFields } from '@aztec/stdlib/tx';
+import { VerificationKeyData } from '@aztec/stdlib/vks';
+import { Attributes, getTelemetryClient, trackSpan, wrapCallbackInSpan } from '@aztec/telemetry-client';
 import { inspect } from 'util';
-import { buildBaseRollupHints, buildHeaderAndBodyFromTxs, getRootTreeSiblingPath, getSubtreeSiblingPath, getTreeSnapshot, validatePartialState, validateTx, } from './block-building-helpers.js';
+import { buildBaseRollupHints, buildHeaderAndBodyFromTxs, getRootTreeSiblingPath, getSubtreeSiblingPath, getTreeSnapshot, validatePartialState, validateTx } from './block-building-helpers.js';
 import { EpochProvingState } from './epoch-proving-state.js';
 import { ProvingOrchestratorMetrics } from './orchestrator_metrics.js';
 import { TxProvingState } from './tx-proving-state.js';
@@ -26,663 +37,654 @@ const logger = createLogger('prover-client:orchestrator');
  * 5. Merge proofs are produced at each level of the tree until the root proof is produced
  *
  * The proving implementation is determined by the provided prover. This could be for example a local prover or a remote prover pool.
- */
-/**
+ */ /**
  * The orchestrator, managing the flow of recursive proving operations required to build the rollup proof tree.
- */
-let ProvingOrchestrator = (() => {
-    var _a;
-    let _instanceExtraInitializers = [];
-    let _startNewBlock_decorators;
-    let _addTxs_decorators;
-    let _startTubeCircuits_decorators;
-    let _setBlockCompleted_decorators;
-    let _prepareBaseRollupInputs_decorators;
-    return _a = class ProvingOrchestrator {
-            constructor(dbProvider, prover, proverId = Fr.ZERO, telemetryClient = getTelemetryClient()) {
-                this.dbProvider = (__runInitializers(this, _instanceExtraInitializers), dbProvider);
-                this.prover = prover;
-                this.proverId = proverId;
-                this.provingState = undefined;
-                this.pendingProvingJobs = [];
-                this.provingPromise = undefined;
-                this.dbs = new Map();
-                this.metrics = new ProvingOrchestratorMetrics(telemetryClient, 'ProvingOrchestrator');
-            }
-            get tracer() {
-                return this.metrics.tracer;
-            }
-            getProverId() {
-                return this.proverId;
-            }
-            stop() {
-                this.cancel();
-                return Promise.resolve();
-            }
-            startNewEpoch(epochNumber, firstBlockNumber, totalNumBlocks) {
-                const { promise: _promise, resolve, reject } = promiseWithResolvers();
-                const promise = _promise.catch((reason) => ({ status: 'failure', reason }));
-                if (totalNumBlocks <= 0 || !Number.isInteger(totalNumBlocks)) {
-                    throw new Error(`Invalid number of blocks for epoch (got ${totalNumBlocks})`);
-                }
-                logger.info(`Starting epoch ${epochNumber} with ${totalNumBlocks} blocks`);
-                this.provingState = new EpochProvingState(epochNumber, firstBlockNumber, totalNumBlocks, resolve, reject);
-                this.provingPromise = promise;
-            }
-            /**
-             * Starts off a new block
-             * @param globalVariables - The global variables for the block
-             * @param l1ToL2Messages - The l1 to l2 messages for the block
-             * @returns A proving ticket, containing a promise notifying of proving completion
-             */
-            async startNewBlock(globalVariables, l1ToL2Messages, previousBlockHeader) {
-                if (!this.provingState) {
-                    throw new Error(`Invalid proving state, call startNewEpoch before starting a block`);
-                }
-                if (!this.provingState?.isAcceptingBlocks()) {
-                    throw new Error(`Epoch not accepting further blocks`);
-                }
-                logger.info(`Starting block ${globalVariables.blockNumber.toNumber()} for slot ${globalVariables.slotNumber.toNumber()}`);
-                // Fork world state at the end of the immediately previous block
-                const db = await this.dbProvider.fork(globalVariables.blockNumber.toNumber() - 1);
-                this.dbs.set(globalVariables.blockNumber.toNumber(), db);
-                // we start the block by enqueueing all of the base parity circuits
-                const { l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, baseParityInputs } = await this.prepareBaseParityInputs(l1ToL2Messages, db);
-                // Get archive snapshot before this block lands
-                const lastArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
-                const newArchiveSiblingPath = await getRootTreeSiblingPath(MerkleTreeId.ARCHIVE, db);
-                const blockProvingState = this.provingState.startNewBlock(globalVariables, l1ToL2Messages, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchive, newArchiveSiblingPath, previousBlockHeader);
-                // Enqueue base parity circuits for the block
-                for (let i = 0; i < baseParityInputs.length; i++) {
-                    this.enqueueBaseParityCircuit(blockProvingState, baseParityInputs[i], i);
-                }
-            }
-            /**
-             * The interface to add simulated transactions to the scheduler. This can only be called once per block.
-             * @param txs - The transactions to be proven
-             */
-            async addTxs(txs) {
-                if (!txs.length) {
-                    // To avoid an ugly throw below. If we require an empty block, we can just call setBlockCompleted
-                    // on a block with no txs. We cannot do that here because we cannot find the blockNumber without any txs.
-                    logger.warn(`Provided no txs to orchestrator addTxs.`);
-                    return;
-                }
-                const blockNumber = txs[0].constants.globalVariables.blockNumber.toNumber();
-                const provingState = this.provingState?.getBlockProvingStateByBlockNumber(blockNumber);
-                if (!provingState) {
-                    throw new Error(`Block proving state for ${blockNumber} not found`);
-                }
-                if (provingState.totalNumTxs) {
-                    throw new Error(`Block ${blockNumber} has been initialized with transactions.`);
-                }
-                const numBlobFields = toNumBlobFields(txs);
-                provingState.startNewBlock(txs.length, numBlobFields);
-                logger.info(`Adding ${txs.length} transactions with ${numBlobFields} blob fields to block ${provingState.blockNumber}`);
-                for (const tx of txs) {
-                    try {
-                        if (!provingState.verifyState()) {
-                            throw new Error(`Invalid proving state when adding a tx`);
-                        }
-                        validateTx(tx);
-                        logger.info(`Received transaction: ${tx.hash}`);
-                        const [hints, treeSnapshots] = await this.prepareTransaction(tx, provingState);
-                        const txProvingState = new TxProvingState(tx, hints, treeSnapshots);
-                        const txIndex = provingState.addNewTx(txProvingState);
-                        this.getOrEnqueueTube(provingState, txIndex);
-                        if (txProvingState.requireAvmProof) {
-                            logger.debug(`Enqueueing public VM for tx ${txIndex}`);
-                            this.enqueueVM(provingState, txIndex);
-                        }
-                    }
-                    catch (err) {
-                        throw new Error(`Error adding transaction ${tx.hash.toString()} to block ${blockNumber}: ${err.message}`, {
-                            cause: err,
-                        });
-                    }
-                }
-            }
-            /**
-             * Kickstarts tube circuits for the specified txs. These will be used during epoch proving.
-             * Note that if the tube circuits are not started this way, they will be started nontheless after processing.
-             */
-            async startTubeCircuits(txs) {
-                if (!this.provingState?.verifyState()) {
-                    throw new Error(`Invalid proving state, call startNewEpoch before starting tube circuits`);
-                }
-                for (const tx of txs) {
-                    const txHash = (await tx.getTxHash()).toString();
-                    const tubeInputs = new TubeInputs(tx.clientIvcProof);
-                    const tubeProof = promiseWithResolvers();
-                    logger.debug(`Starting tube circuit for tx ${txHash}`);
-                    this.doEnqueueTube(txHash, tubeInputs, proof => tubeProof.resolve(proof));
-                    this.provingState?.cachedTubeProofs.set(txHash, tubeProof.promise);
-                }
-            }
-            /**
-             * Marks the block as completed.
-             * Computes the block header and updates the archive tree.
-             */
-            async setBlockCompleted(blockNumber, expectedHeader) {
-                const provingState = this.provingState?.getBlockProvingStateByBlockNumber(blockNumber);
-                if (!provingState) {
-                    throw new Error(`Block proving state for ${blockNumber} not found`);
-                }
-                if (!provingState.spongeBlobState) {
-                    // If we are completing an empty block, initialise the provingState.
-                    // We will have 0 txs and no blob fields.
-                    provingState.startNewBlock(0, 0);
-                }
+ */ export class ProvingOrchestrator {
+    dbProvider;
+    prover;
+    proverId;
+    provingState;
+    pendingProvingJobs;
+    provingPromise;
+    metrics;
+    dbs;
+    constructor(dbProvider, prover, proverId = Fr.ZERO, telemetryClient = getTelemetryClient()){
+        this.dbProvider = dbProvider;
+        this.prover = prover;
+        this.proverId = proverId;
+        this.provingState = undefined;
+        this.pendingProvingJobs = [];
+        this.provingPromise = undefined;
+        this.dbs = new Map();
+        this.metrics = new ProvingOrchestratorMetrics(telemetryClient, 'ProvingOrchestrator');
+    }
+    get tracer() {
+        return this.metrics.tracer;
+    }
+    getProverId() {
+        return this.proverId;
+    }
+    stop() {
+        this.cancel();
+        return Promise.resolve();
+    }
+    startNewEpoch(epochNumber, firstBlockNumber, totalNumBlocks) {
+        const { promise: _promise, resolve, reject } = promiseWithResolvers();
+        const promise = _promise.catch((reason)=>({
+                status: 'failure',
+                reason
+            }));
+        if (totalNumBlocks <= 0 || !Number.isInteger(totalNumBlocks)) {
+            throw new Error(`Invalid number of blocks for epoch (got ${totalNumBlocks})`);
+        }
+        logger.info(`Starting epoch ${epochNumber} with ${totalNumBlocks} blocks`);
+        this.provingState = new EpochProvingState(epochNumber, firstBlockNumber, totalNumBlocks, resolve, reject);
+        this.provingPromise = promise;
+    }
+    /**
+   * Starts off a new block
+   * @param globalVariables - The global variables for the block
+   * @param l1ToL2Messages - The l1 to l2 messages for the block
+   * @returns A proving ticket, containing a promise notifying of proving completion
+   */ async startNewBlock(globalVariables, l1ToL2Messages, previousBlockHeader) {
+        if (!this.provingState) {
+            throw new Error(`Invalid proving state, call startNewEpoch before starting a block`);
+        }
+        if (!this.provingState?.isAcceptingBlocks()) {
+            throw new Error(`Epoch not accepting further blocks`);
+        }
+        logger.info(`Starting block ${globalVariables.blockNumber.toNumber()} for slot ${globalVariables.slotNumber.toNumber()}`);
+        // Fork world state at the end of the immediately previous block
+        const db = await this.dbProvider.fork(globalVariables.blockNumber.toNumber() - 1);
+        this.dbs.set(globalVariables.blockNumber.toNumber(), db);
+        // we start the block by enqueueing all of the base parity circuits
+        const { l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, baseParityInputs } = await this.prepareBaseParityInputs(l1ToL2Messages, db);
+        // Get archive snapshot before this block lands
+        const lastArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
+        const newArchiveSiblingPath = await getRootTreeSiblingPath(MerkleTreeId.ARCHIVE, db);
+        const blockProvingState = this.provingState.startNewBlock(globalVariables, l1ToL2Messages, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchive, newArchiveSiblingPath, previousBlockHeader);
+        // Enqueue base parity circuits for the block
+        for(let i = 0; i < baseParityInputs.length; i++){
+            this.enqueueBaseParityCircuit(blockProvingState, baseParityInputs[i], i);
+        }
+    }
+    /**
+   * The interface to add simulated transactions to the scheduler. This can only be called once per block.
+   * @param txs - The transactions to be proven
+   */ async addTxs(txs) {
+        if (!txs.length) {
+            // To avoid an ugly throw below. If we require an empty block, we can just call setBlockCompleted
+            // on a block with no txs. We cannot do that here because we cannot find the blockNumber without any txs.
+            logger.warn(`Provided no txs to orchestrator addTxs.`);
+            return;
+        }
+        const blockNumber = txs[0].constants.globalVariables.blockNumber.toNumber();
+        const provingState = this.provingState?.getBlockProvingStateByBlockNumber(blockNumber);
+        if (!provingState) {
+            throw new Error(`Block proving state for ${blockNumber} not found`);
+        }
+        if (provingState.totalNumTxs) {
+            throw new Error(`Block ${blockNumber} has been initialized with transactions.`);
+        }
+        const numBlobFields = toNumBlobFields(txs);
+        provingState.startNewBlock(txs.length, numBlobFields);
+        logger.info(`Adding ${txs.length} transactions with ${numBlobFields} blob fields to block ${provingState.blockNumber}`);
+        for (const tx of txs){
+            try {
                 if (!provingState.verifyState()) {
-                    throw new Error(`Block proving failed: ${provingState.error}`);
-                }
-                // And build the block header
-                logger.verbose(`Block ${blockNumber} completed. Assembling header.`);
-                await this.buildBlock(provingState, expectedHeader);
-                // If the proofs were faster than the block building, then we need to try the block root rollup again here
-                await this.checkAndEnqueueBlockRootRollup(provingState);
-                return provingState.block;
-            }
-            /** Returns the block as built for a given index. */
-            getBlock(index) {
-                const block = this.provingState?.blocks[index]?.block;
-                if (!block) {
-                    throw new Error(`Block at index ${index} not available`);
-                }
-                return block;
-            }
-            async buildBlock(provingState, expectedHeader) {
-                // Collect all new nullifiers, commitments, and contracts from all txs in this block to build body
-                const txs = provingState.allTxs.map(a => a.processedTx);
-                // Get db for this block
-                const db = this.dbs.get(provingState.blockNumber);
-                // Given we've applied every change from this block, now assemble the block header
-                // and update the archive tree, so we're ready to start processing the next block
-                const { header, body } = await buildHeaderAndBodyFromTxs(txs, provingState.globalVariables, provingState.newL1ToL2Messages, db);
-                if (expectedHeader && !header.equals(expectedHeader)) {
-                    logger.error(`Block header mismatch: header=${header} expectedHeader=${expectedHeader}`);
-                    throw new Error('Block header mismatch');
-                }
-                logger.verbose(`Updating archive tree with block ${provingState.blockNumber} header ${(await header.hash()).toString()}`);
-                await db.updateArchive(header);
-                // Assemble the L2 block
-                const newArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
-                const l2Block = new L2Block(newArchive, header, body);
-                await this.verifyBuiltBlockAgainstSyncedState(l2Block, newArchive);
-                logger.verbose(`Orchestrator finalised block ${l2Block.number}`);
-                provingState.block = l2Block;
-            }
-            // Flagged as protected to disable in certain unit tests
-            async verifyBuiltBlockAgainstSyncedState(l2Block, newArchive) {
-                const syncedArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.dbProvider.getSnapshot(l2Block.number));
-                if (!syncedArchive.equals(newArchive)) {
-                    throw new Error(`Archive tree mismatch for block ${l2Block.number}: world state synced to ${inspect(syncedArchive)} but built ${inspect(newArchive)}`);
-                }
-            }
-            /**
-             * Cancel any further proving
-             */
-            cancel() {
-                for (const controller of this.pendingProvingJobs) {
-                    controller.abort();
-                }
-                this.provingState?.cancel();
-            }
-            /**
-             * Returns the proof for the current epoch.
-             */
-            async finaliseEpoch() {
-                if (!this.provingState || !this.provingPromise) {
-                    throw new Error(`Invalid proving state, an epoch must be proven before it can be finalised`);
-                }
-                const result = await this.provingPromise;
-                if (result.status === 'failure') {
-                    throw new Error(`Epoch proving failed: ${result.reason}`);
-                }
-                const epochProofResult = this.provingState.getEpochProofResult();
-                pushTestData('epochProofResult', {
-                    proof: epochProofResult.proof.toString(),
-                    publicInputs: epochProofResult.publicInputs.toString(),
-                });
-                return epochProofResult;
-            }
-            /**
-             * 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) {
-                const txInputs = await this.prepareBaseRollupInputs(provingState, tx);
-                if (!txInputs) {
-                    // This should not be possible
-                    throw new Error(`Unable to add transaction, preparing base inputs failed`);
-                }
-                return txInputs;
-            }
-            /**
-             * 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);
-                    }
-                    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`, err);
-                        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(() => void safeJob());
-            }
-            async prepareBaseParityInputs(l1ToL2Messages, db) {
-                const l1ToL2MessagesPadded = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, 'Too many L1 to L2 messages');
-                const baseParityInputs = times(NUM_BASE_PARITY_PER_ROOT_PARITY, i => BaseParityInputs.fromSlice(l1ToL2MessagesPadded, i, getVKTreeRoot()));
-                const l1ToL2MessageSubtreeSiblingPath = assertLength(await getSubtreeSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, L1_TO_L2_MSG_SUBTREE_HEIGHT, db), L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH);
-                // Update the local trees to include the new l1 to l2 messages
-                await db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
-                const l1ToL2MessageTreeSnapshotAfterInsertion = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
-                return {
-                    l1ToL2MessageSubtreeSiblingPath,
-                    l1ToL2MessageTreeSnapshotAfterInsertion,
-                    baseParityInputs,
-                };
-            }
-            // Updates the merkle trees for a transaction. The first enqueued job for a transaction
-            async prepareBaseRollupInputs(provingState, tx) {
-                if (!provingState.verifyState() || !provingState.spongeBlobState) {
-                    logger.debug('Not preparing base rollup inputs, state invalid');
-                    return;
-                }
-                const db = this.dbs.get(provingState.blockNumber);
-                // We build the base rollup inputs using a mock proof and verification key.
-                // These will be overwritten later once we have proven the tube circuit and any public kernels
-                const [ms, hints] = await elapsed(buildBaseRollupHints(tx, provingState.globalVariables, db, provingState.spongeBlobState));
-                this.metrics.recordBaseRollupInputs(ms);
-                const promises = [MerkleTreeId.NOTE_HASH_TREE, MerkleTreeId.NULLIFIER_TREE, MerkleTreeId.PUBLIC_DATA_TREE].map(async (id) => {
-                    return { key: id, value: await getTreeSnapshot(id, db) };
+                    throw new Error(`Invalid proving state when adding a tx`);
+                }
+                validateTx(tx);
+                logger.info(`Received transaction: ${tx.hash}`);
+                const [hints, treeSnapshots] = await this.prepareTransaction(tx, provingState);
+                const txProvingState = new TxProvingState(tx, hints, treeSnapshots);
+                const txIndex = provingState.addNewTx(txProvingState);
+                this.getOrEnqueueTube(provingState, txIndex);
+                if (txProvingState.requireAvmProof) {
+                    logger.debug(`Enqueueing public VM for tx ${txIndex}`);
+                    this.enqueueVM(provingState, txIndex);
+                }
+            } catch (err) {
+                throw new Error(`Error adding transaction ${tx.hash.toString()} to block ${blockNumber}: ${err.message}`, {
+                    cause: err
                 });
-                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 [hints, treeSnapshots];
             }
-            // 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, txIndex) {
-                if (!provingState.verifyState()) {
-                    logger.debug('Not running base rollup, state invalid');
+        }
+    }
+    /**
+   * Kickstarts tube circuits for the specified txs. These will be used during epoch proving.
+   * Note that if the tube circuits are not started this way, they will be started nontheless after processing.
+   */ async startTubeCircuits(txs) {
+        if (!this.provingState?.verifyState()) {
+            throw new Error(`Invalid proving state, call startNewEpoch before starting tube circuits`);
+        }
+        for (const tx of txs){
+            const txHash = (await tx.getTxHash()).toString();
+            const tubeInputs = new TubeInputs(tx.clientIvcProof);
+            const tubeProof = promiseWithResolvers();
+            logger.debug(`Starting tube circuit for tx ${txHash}`);
+            this.doEnqueueTube(txHash, tubeInputs, (proof)=>tubeProof.resolve(proof));
+            this.provingState?.cachedTubeProofs.set(txHash, tubeProof.promise);
+        }
+    }
+    /**
+   * Marks the block as completed.
+   * Computes the block header and updates the archive tree.
+   */ async setBlockCompleted(blockNumber, expectedHeader) {
+        const provingState = this.provingState?.getBlockProvingStateByBlockNumber(blockNumber);
+        if (!provingState) {
+            throw new Error(`Block proving state for ${blockNumber} not found`);
+        }
+        if (!provingState.spongeBlobState) {
+            // If we are completing an empty block, initialise the provingState.
+            // We will have 0 txs and no blob fields.
+            provingState.startNewBlock(0, 0);
+        }
+        if (!provingState.verifyState()) {
+            throw new Error(`Block proving failed: ${provingState.error}`);
+        }
+        // And build the block header
+        logger.verbose(`Block ${blockNumber} completed. Assembling header.`);
+        await this.buildBlock(provingState, expectedHeader);
+        // If the proofs were faster than the block building, then we need to try the block root rollup again here
+        await this.checkAndEnqueueBlockRootRollup(provingState);
+        return provingState.block;
+    }
+    /** Returns the block as built for a given index. */ getBlock(index) {
+        const block = this.provingState?.blocks[index]?.block;
+        if (!block) {
+            throw new Error(`Block at index ${index} not available`);
+        }
+        return block;
+    }
+    async buildBlock(provingState, expectedHeader) {
+        // Collect all new nullifiers, commitments, and contracts from all txs in this block to build body
+        const txs = provingState.allTxs.map((a)=>a.processedTx);
+        // Get db for this block
+        const db = this.dbs.get(provingState.blockNumber);
+        // Given we've applied every change from this block, now assemble the block header
+        // and update the archive tree, so we're ready to start processing the next block
+        const { header, body } = await buildHeaderAndBodyFromTxs(txs, provingState.globalVariables, provingState.newL1ToL2Messages, db);
+        if (expectedHeader && !header.equals(expectedHeader)) {
+            logger.error(`Block header mismatch: header=${header} expectedHeader=${expectedHeader}`);
+            throw new Error('Block header mismatch');
+        }
+        logger.verbose(`Updating archive tree with block ${provingState.blockNumber} header ${(await header.hash()).toString()}`);
+        await db.updateArchive(header);
+        // Assemble the L2 block
+        const newArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
+        const l2Block = new L2Block(newArchive, header, body);
+        await this.verifyBuiltBlockAgainstSyncedState(l2Block, newArchive);
+        logger.verbose(`Orchestrator finalised block ${l2Block.number}`);
+        provingState.block = l2Block;
+    }
+    // Flagged as protected to disable in certain unit tests
+    async verifyBuiltBlockAgainstSyncedState(l2Block, newArchive) {
+        const syncedArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.dbProvider.getSnapshot(l2Block.number));
+        if (!syncedArchive.equals(newArchive)) {
+            throw new Error(`Archive tree mismatch for block ${l2Block.number}: world state synced to ${inspect(syncedArchive)} but built ${inspect(newArchive)}`);
+        }
+    }
+    /**
+   * Cancel any further proving
+   */ cancel() {
+        for (const controller of this.pendingProvingJobs){
+            controller.abort();
+        }
+        this.provingState?.cancel();
+    }
+    /**
+   * Returns the proof for the current epoch.
+   */ async finaliseEpoch() {
+        if (!this.provingState || !this.provingPromise) {
+            throw new Error(`Invalid proving state, an epoch must be proven before it can be finalised`);
+        }
+        const result = await this.provingPromise;
+        if (result.status === 'failure') {
+            throw new Error(`Epoch proving failed: ${result.reason}`);
+        }
+        const epochProofResult = this.provingState.getEpochProofResult();
+        pushTestData('epochProofResult', {
+            proof: epochProofResult.proof.toString(),
+            publicInputs: epochProofResult.publicInputs.toString()
+        });
+        return epochProofResult;
+    }
+    /**
+   * 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) {
+        const txInputs = await this.prepareBaseRollupInputs(provingState, tx);
+        if (!txInputs) {
+            // This should not be possible
+            throw new Error(`Unable to add transaction, preparing base inputs failed`);
+        }
+        return txInputs;
+    }
+    /**
+   * 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 txProvingState = provingState.getTxProvingState(txIndex);
-                const { processedTx } = txProvingState;
-                const { rollupType, inputs } = txProvingState.getBaseRollupTypeAndInputs();
-                logger.debug(`Enqueuing deferred proving base rollup for ${processedTx.hash.toString()}`);
-                this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, `ProvingOrchestrator.prover.${inputs instanceof PrivateBaseRollupInputs ? 'getPrivateBaseRollupProof' : 'getPublicBaseRollupProof'}`, {
-                    [Attributes.TX_HASH]: processedTx.hash.toString(),
-                    [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
-                    [Attributes.PROTOCOL_CIRCUIT_NAME]: rollupType,
-                }, signal => {
-                    if (inputs instanceof PrivateBaseRollupInputs) {
-                        return this.prover.getPrivateBaseRollupProof(inputs, signal, provingState.epochNumber);
-                    }
-                    else {
-                        return this.prover.getPublicBaseRollupProof(inputs, signal, provingState.epochNumber);
-                    }
-                }), async (result) => {
-                    logger.debug(`Completed proof for ${rollupType} for tx ${processedTx.hash.toString()}`);
-                    validatePartialState(result.inputs.end, txProvingState.treeSnapshots);
-                    const leafLocation = provingState.setBaseRollupProof(txIndex, result);
-                    if (provingState.totalNumTxs === 1) {
-                        await this.checkAndEnqueueBlockRootRollup(provingState);
-                    }
-                    else {
-                        await this.checkAndEnqueueNextMergeRollup(provingState, leafLocation);
-                    }
-                });
-            }
-            // Enqueues the tube circuit for a given transaction index, or reuses the one already enqueued
-            // Once completed, will enqueue the next circuit, either a public kernel or the base rollup
-            getOrEnqueueTube(provingState, txIndex) {
-                if (!provingState.verifyState()) {
-                    logger.debug('Not running tube circuit, state invalid');
-                    return;
-                }
-                const txProvingState = provingState.getTxProvingState(txIndex);
-                const txHash = txProvingState.processedTx.hash.toString();
-                const handleResult = (result) => {
-                    logger.debug(`Got tube proof for tx index: ${txIndex}`, { txHash });
-                    txProvingState.setTubeProof(result);
-                    this.provingState?.cachedTubeProofs.delete(txHash);
-                    this.checkAndEnqueueNextTxCircuit(provingState, txIndex);
-                };
-                if (this.provingState?.cachedTubeProofs.has(txHash)) {
-                    logger.debug(`Tube proof already enqueued for tx index: ${txIndex}`, { txHash });
-                    void this.provingState.cachedTubeProofs.get(txHash).then(handleResult);
-                    return;
-                }
-                logger.debug(`Enqueuing tube circuit for tx index: ${txIndex}`);
-                this.doEnqueueTube(txHash, txProvingState.getTubeInputs(), handleResult);
-            }
-            doEnqueueTube(txHash, inputs, handler, provingState = this.provingState) {
+                const result = await request(controller.signal);
                 if (!provingState?.verifyState()) {
-                    logger.debug('Not running tube circuit, state invalid');
+                    logger.debug(`State no longer valid, discarding result`);
                     return;
                 }
-                this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getTubeProof', {
-                    [Attributes.TX_HASH]: txHash,
-                    [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
-                    [Attributes.PROTOCOL_CIRCUIT_NAME]: 'tube-circuit',
-                }, signal => this.prover.getTubeProof(inputs, signal, this.provingState.epochNumber)), handler);
-            }
-            // Executes the merge rollup circuit and stored the output as intermediate state for the parent merge/block root circuit
-            // Enqueues the next level of merge if all inputs are available
-            enqueueMergeRollup(provingState, location) {
-                if (!provingState.verifyState()) {
-                    logger.debug('Not running merge rollup. State no longer valid.');
+                // 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;
                 }
-                const inputs = provingState.getMergeRollupInputs(location);
-                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, provingState.epochNumber)), async (result) => {
-                    provingState.setMergeRollupProof(location, result);
-                    await this.checkAndEnqueueNextMergeRollup(provingState, location);
-                });
-            }
-            // Executes the block root rollup circuit
-            async enqueueBlockRootRollup(provingState) {
-                if (!provingState.verifyState()) {
-                    logger.debug('Not running block root rollup, state no longer valid');
-                    return;
-                }
-                provingState.blockRootRollupStarted = true;
-                const { rollupType, inputs } = await provingState.getBlockRootRollupTypeAndInputs(this.proverId);
-                logger.debug(`Enqueuing ${rollupType} for block ${provingState.blockNumber} with ${provingState.newL1ToL2Messages.length} l1 to l2 msgs.`);
-                this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getBlockRootRollupProof', {
-                    [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
-                    [Attributes.PROTOCOL_CIRCUIT_NAME]: rollupType,
-                }, signal => {
-                    if (inputs instanceof EmptyBlockRootRollupInputs) {
-                        return this.prover.getEmptyBlockRootRollupProof(inputs, signal, provingState.epochNumber);
-                    }
-                    else if (inputs instanceof SingleTxBlockRootRollupInputs) {
-                        return this.prover.getSingleTxBlockRootRollupProof(inputs, signal, provingState.epochNumber);
-                    }
-                    else {
-                        return this.prover.getBlockRootRollupProof(inputs, signal, provingState.epochNumber);
-                    }
-                }), async (result) => {
-                    provingState.setBlockRootRollupProof(result);
-                    const header = await provingState.buildHeaderFromProvingOutputs(logger);
-                    if (!(await header.hash()).equals(await provingState.block.header.hash())) {
-                        logger.error(`Block header mismatch\nCircuit:${inspect(header)}\nComputed:${inspect(provingState.block.header)}`);
-                        provingState.reject(`Block header hash mismatch`);
-                    }
-                    logger.debug(`Completed ${rollupType} proof for block ${provingState.block.number}`);
-                    // validatePartialState(result.inputs.end, tx.treeSnapshots); // TODO(palla/prover)
-                    const epochProvingState = this.provingState;
-                    const leafLocation = epochProvingState.setBlockRootRollupProof(provingState.index, result);
-                    if (epochProvingState.totalNumBlocks === 1) {
-                        await this.enqueueEpochPadding(epochProvingState);
-                    }
-                    else {
-                        this.checkAndEnqueueNextBlockMergeRollup(epochProvingState, leafLocation);
-                    }
-                });
-            }
-            // 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) {
-                if (!provingState.verifyState()) {
-                    logger.debug('Not running base parity. State no longer valid.');
-                    return;
-                }
-                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, provingState.epochNumber)), provingOutput => {
-                    provingState.setBaseParityProof(index, provingOutput);
-                    this.checkAndEnqueueRootParityCircuit(provingState);
-                });
-            }
-            checkAndEnqueueRootParityCircuit(provingState) {
-                if (!provingState.isReadyForRootParity()) {
-                    return;
-                }
-                this.enqueueRootParityCircuit(provingState);
-            }
-            // Runs the root parity circuit ans stored the outputs
-            // Enqueues the root rollup proof if all inputs are available
-            enqueueRootParityCircuit(provingState) {
-                if (!provingState.verifyState()) {
-                    logger.debug('Not running root parity. State no longer valid.');
-                    return;
-                }
-                const inputs = provingState.getRootParityInputs();
-                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, provingState.epochNumber)), async (result) => {
-                    provingState.setRootParityProof(result);
-                    await this.checkAndEnqueueBlockRootRollup(provingState);
-                });
-            }
-            // Executes the block merge rollup circuit and stored the output as intermediate state for the parent merge/block root circuit
-            // Enqueues the next level of merge if all inputs are available
-            enqueueBlockMergeRollup(provingState, location) {
-                if (!provingState.verifyState()) {
-                    logger.debug('Not running block merge rollup. State no longer valid.');
-                    return;
-                }
-                const inputs = provingState.getBlockMergeRollupInputs(location);
-                this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getBlockMergeRollupProof', {
-                    [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
-                    [Attributes.PROTOCOL_CIRCUIT_NAME]: 'block-merge-rollup',
-                }, signal => this.prover.getBlockMergeRollupProof(inputs, signal, provingState.epochNumber)), result => {
-                    provingState.setBlockMergeRollupProof(location, result);
-                    this.checkAndEnqueueNextBlockMergeRollup(provingState, location);
-                });
-            }
-            async enqueueEpochPadding(provingState) {
-                if (!provingState.verifyState()) {
-                    logger.debug('Not running epoch padding. State no longer valid.');
-                    return;
-                }
-                logger.debug('Padding epoch proof with an empty block root proof.');
-                const inputs = await provingState.getPaddingBlockRootInputs(this.proverId);
-                this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getEmptyBlockRootRollupProof', {
-                    [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
-                    [Attributes.PROTOCOL_CIRCUIT_NAME]: 'empty-block-root-rollup',
-                }, signal => this.prover.getEmptyBlockRootRollupProof(inputs, signal, provingState.epochNumber)), result => {
-                    logger.debug('Completed proof for padding block root.');
-                    provingState.setPaddingBlockRootProof(result);
-                    this.checkAndEnqueueRootRollup(provingState);
-                });
-            }
-            // Executes the root rollup circuit
-            enqueueRootRollup(provingState) {
-                if (!provingState.verifyState()) {
-                    logger.debug('Not running root rollup, state no longer valid');
+                await callback(result);
+            } catch (err) {
+                if (err instanceof AbortError) {
+                    // operation was cancelled, probably because the block was cancelled
+                    // drop this result
                     return;
                 }
-                logger.debug(`Preparing root rollup`);
-                const inputs = provingState.getRootRollupInputs(this.proverId);
-                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, provingState.epochNumber)), result => {
-                    logger.verbose(`Orchestrator completed root rollup for epoch ${provingState.epochNumber}`);
-                    provingState.setRootRollupProof(result);
-                    provingState.resolve({ status: 'success' });
-                });
-            }
-            async checkAndEnqueueNextMergeRollup(provingState, currentLocation) {
-                if (!provingState.isReadyForMergeRollup(currentLocation)) {
-                    return;
-                }
-                const parentLocation = provingState.getParentLocation(currentLocation);
-                if (parentLocation.level === 0) {
-                    await this.checkAndEnqueueBlockRootRollup(provingState);
-                }
-                else {
-                    this.enqueueMergeRollup(provingState, parentLocation);
-                }
-            }
-            async checkAndEnqueueBlockRootRollup(provingState) {
-                if (!provingState.isReadyForBlockRootRollup()) {
-                    logger.debug('Not ready for root rollup');
-                    return;
-                }
-                if (provingState.blockRootRollupStarted) {
-                    logger.debug('Block root rollup already started');
-                    return;
-                }
-                const blockNumber = provingState.blockNumber;
-                // TODO(palla/prover): This closes the fork only on the happy path. If this epoch orchestrator
-                // is aborted and never reaches this point, it will leak the fork. We need to add a global cleanup,
-                // but have to make sure it only runs once all operations are completed, otherwise some function here
-                // will attempt to access the fork after it was closed.
-                logger.debug(`Cleaning up world state fork for ${blockNumber}`);
-                void this.dbs
-                    .get(blockNumber)
-                    ?.close()
-                    .then(() => this.dbs.delete(blockNumber))
-                    .catch(err => logger.error(`Error closing db for block ${blockNumber}`, err));
-                await this.enqueueBlockRootRollup(provingState);
-            }
-            checkAndEnqueueNextBlockMergeRollup(provingState, currentLocation) {
-                if (!provingState.isReadyForBlockMerge(currentLocation)) {
-                    return;
-                }
-                const parentLocation = provingState.getParentLocation(currentLocation);
-                if (parentLocation.level === 0) {
-                    this.checkAndEnqueueRootRollup(provingState);
-                }
-                else {
-                    this.enqueueBlockMergeRollup(provingState, parentLocation);
-                }
-            }
-            checkAndEnqueueRootRollup(provingState) {
-                if (!provingState.isReadyForRootRollup()) {
-                    logger.debug('Not ready for root rollup');
-                    return;
-                }
-                this.enqueueRootRollup(provingState);
-            }
-            /**
-             * 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
-             */
-            enqueueVM(provingState, txIndex) {
-                if (!provingState.verifyState()) {
-                    logger.debug(`Not running VM circuit as state is no longer valid`);
-                    return;
-                }
-                const txProvingState = provingState.getTxProvingState(txIndex);
-                // 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(),
-                }, async (signal) => {
-                    const inputs = txProvingState.getAvmInputs();
-                    try {
-                        return await this.prover.getAvmProof(inputs, signal, provingState.epochNumber);
-                    }
-                    catch (err) {
-                        if (process.env.AVM_PROVING_STRICT) {
-                            logger.error(`Error thrown when proving AVM circuit with AVM_PROVING_STRICT on`, err);
-                            throw err;
-                        }
-                        else {
-                            logger.warn(`Error thrown when proving AVM circuit but AVM_PROVING_STRICT is off. Faking AVM proof and carrying on. ${inspect(err)}.`);
-                            return {
-                                proof: makeEmptyRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS),
-                                verificationKey: VerificationKeyData.makeFake(AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS),
-                            };
-                        }
-                    }
-                });
-                this.deferredProving(provingState, doAvmProving, proofAndVk => {
-                    logger.debug(`Proven VM for tx index: ${txIndex}`);
-                    txProvingState.setAvmProof(proofAndVk);
-                    this.checkAndEnqueueNextTxCircuit(provingState, txIndex);
-                });
-            }
-            checkAndEnqueueNextTxCircuit(provingState, txIndex) {
-                const txProvingState = provingState.getTxProvingState(txIndex);
-                if (!txProvingState.ready()) {
-                    return;
-                }
-                // We must have completed all proving (tube proof and (if required) vm proof are generated), we now move to the base rollup.
-                logger.debug(`Public functions completed for tx ${txIndex} enqueueing base rollup`);
-                this.enqueueBaseRollup(provingState, txIndex);
-            }
-        },
-        (() => {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _startNewBlock_decorators = [trackSpan('ProvingOrchestrator.startNewBlock', globalVariables => ({
-                    [Attributes.BLOCK_NUMBER]: globalVariables.blockNumber.toNumber(),
-                }))];
-            _addTxs_decorators = [trackSpan('ProvingOrchestrator.addTxs', txs => ({
-                    [Attributes.BLOCK_TXS_COUNT]: txs.length,
-                }))];
-            _startTubeCircuits_decorators = [trackSpan('ProvingOrchestrator.startTubeCircuits')];
-            _setBlockCompleted_decorators = [trackSpan('ProvingOrchestrator.setBlockCompleted', (blockNumber) => ({
-                    [Attributes.BLOCK_NUMBER]: blockNumber,
-                }))];
-            _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, _addTxs_decorators, { kind: "method", name: "addTxs", static: false, private: false, access: { has: obj => "addTxs" in obj, get: obj => obj.addTxs }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _startTubeCircuits_decorators, { kind: "method", name: "startTubeCircuits", static: false, private: false, access: { has: obj => "startTubeCircuits" in obj, get: obj => obj.startTubeCircuits }, 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, _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 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"orchestrator.js","sourceRoot":"","sources":["../../src/orchestrator/orchestrator.ts"],"names":[],"mappings":"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"}
+                logger.error(`Error thrown when proving job`, err);
+                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(()=>void safeJob());
+    }
+    async prepareBaseParityInputs(l1ToL2Messages, db) {
+        const l1ToL2MessagesPadded = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, 'Too many L1 to L2 messages');
+        const baseParityInputs = times(NUM_BASE_PARITY_PER_ROOT_PARITY, (i)=>BaseParityInputs.fromSlice(l1ToL2MessagesPadded, i, getVKTreeRoot()));
+        const l1ToL2MessageSubtreeSiblingPath = assertLength(await getSubtreeSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, L1_TO_L2_MSG_SUBTREE_HEIGHT, db), L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH);
+        // Update the local trees to include the new l1 to l2 messages
+        await db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
+        const l1ToL2MessageTreeSnapshotAfterInsertion = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
+        return {
+            l1ToL2MessageSubtreeSiblingPath,
+            l1ToL2MessageTreeSnapshotAfterInsertion,
+            baseParityInputs
+        };
+    }
+    // Updates the merkle trees for a transaction. The first enqueued job for a transaction
+    async prepareBaseRollupInputs(provingState, tx) {
+        if (!provingState.verifyState() || !provingState.spongeBlobState) {
+            logger.debug('Not preparing base rollup inputs, state invalid');
+            return;
+        }
+        const db = this.dbs.get(provingState.blockNumber);
+        // We build the base rollup inputs using a mock proof and verification key.
+        // These will be overwritten later once we have proven the tube circuit and any public kernels
+        const [ms, hints] = await elapsed(buildBaseRollupHints(tx, provingState.globalVariables, db, provingState.spongeBlobState));
+        this.metrics.recordBaseRollupInputs(ms);
+        const promises = [
+            MerkleTreeId.NOTE_HASH_TREE,
+            MerkleTreeId.NULLIFIER_TREE,
+            MerkleTreeId.PUBLIC_DATA_TREE
+        ].map(async (id)=>{
+            return {
+                key: id,
+                value: await getTreeSnapshot(id, 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 [
+            hints,
+            treeSnapshots
+        ];
+    }
+    // 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, txIndex) {
+        if (!provingState.verifyState()) {
+            logger.debug('Not running base rollup, state invalid');
+            return;
+        }
+        const txProvingState = provingState.getTxProvingState(txIndex);
+        const { processedTx } = txProvingState;
+        const { rollupType, inputs } = txProvingState.getBaseRollupTypeAndInputs();
+        logger.debug(`Enqueuing deferred proving base rollup for ${processedTx.hash.toString()}`);
+        this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, `ProvingOrchestrator.prover.${inputs instanceof PrivateBaseRollupInputs ? 'getPrivateBaseRollupProof' : 'getPublicBaseRollupProof'}`, {
+            [Attributes.TX_HASH]: processedTx.hash.toString(),
+            [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+            [Attributes.PROTOCOL_CIRCUIT_NAME]: rollupType
+        }, (signal)=>{
+            if (inputs instanceof PrivateBaseRollupInputs) {
+                return this.prover.getPrivateBaseRollupProof(inputs, signal, provingState.epochNumber);
+            } else {
+                return this.prover.getPublicBaseRollupProof(inputs, signal, provingState.epochNumber);
+            }
+        }), async (result)=>{
+            logger.debug(`Completed proof for ${rollupType} for tx ${processedTx.hash.toString()}`);
+            validatePartialState(result.inputs.end, txProvingState.treeSnapshots);
+            const leafLocation = provingState.setBaseRollupProof(txIndex, result);
+            if (provingState.totalNumTxs === 1) {
+                await this.checkAndEnqueueBlockRootRollup(provingState);
+            } else {
+                await this.checkAndEnqueueNextMergeRollup(provingState, leafLocation);
+            }
+        });
+    }
+    // Enqueues the tube circuit for a given transaction index, or reuses the one already enqueued
+    // Once completed, will enqueue the next circuit, either a public kernel or the base rollup
+    getOrEnqueueTube(provingState, txIndex) {
+        if (!provingState.verifyState()) {
+            logger.debug('Not running tube circuit, state invalid');
+            return;
+        }
+        const txProvingState = provingState.getTxProvingState(txIndex);
+        const txHash = txProvingState.processedTx.hash.toString();
+        const handleResult = (result)=>{
+            logger.debug(`Got tube proof for tx index: ${txIndex}`, {
+                txHash
+            });
+            txProvingState.setTubeProof(result);
+            this.provingState?.cachedTubeProofs.delete(txHash);
+            this.checkAndEnqueueNextTxCircuit(provingState, txIndex);
+        };
+        if (this.provingState?.cachedTubeProofs.has(txHash)) {
+            logger.debug(`Tube proof already enqueued for tx index: ${txIndex}`, {
+                txHash
+            });
+            void this.provingState.cachedTubeProofs.get(txHash).then(handleResult);
+            return;
+        }
+        logger.debug(`Enqueuing tube circuit for tx index: ${txIndex}`);
+        this.doEnqueueTube(txHash, txProvingState.getTubeInputs(), handleResult);
+    }
+    doEnqueueTube(txHash, inputs, handler, provingState = this.provingState) {
+        if (!provingState?.verifyState()) {
+            logger.debug('Not running tube circuit, state invalid');
+            return;
+        }
+        this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getTubeProof', {
+            [Attributes.TX_HASH]: txHash,
+            [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+            [Attributes.PROTOCOL_CIRCUIT_NAME]: 'tube-circuit'
+        }, (signal)=>this.prover.getTubeProof(inputs, signal, this.provingState.epochNumber)), handler);
+    }
+    // Executes the merge rollup circuit and stored the output as intermediate state for the parent merge/block root circuit
+    // Enqueues the next level of merge if all inputs are available
+    enqueueMergeRollup(provingState, location) {
+        if (!provingState.verifyState()) {
+            logger.debug('Not running merge rollup. State no longer valid.');
+            return;
+        }
+        const inputs = provingState.getMergeRollupInputs(location);
+        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, provingState.epochNumber)), async (result)=>{
+            provingState.setMergeRollupProof(location, result);
+            await this.checkAndEnqueueNextMergeRollup(provingState, location);
+        });
+    }
+    // Executes the block root rollup circuit
+    async enqueueBlockRootRollup(provingState) {
+        if (!provingState.verifyState()) {
+            logger.debug('Not running block root rollup, state no longer valid');
+            return;
+        }
+        provingState.blockRootRollupStarted = true;
+        const { rollupType, inputs } = await provingState.getBlockRootRollupTypeAndInputs(this.proverId);
+        logger.debug(`Enqueuing ${rollupType} for block ${provingState.blockNumber} with ${provingState.newL1ToL2Messages.length} l1 to l2 msgs.`);
+        this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getBlockRootRollupProof', {
+            [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+            [Attributes.PROTOCOL_CIRCUIT_NAME]: rollupType
+        }, (signal)=>{
+            if (inputs instanceof EmptyBlockRootRollupInputs) {
+                return this.prover.getEmptyBlockRootRollupProof(inputs, signal, provingState.epochNumber);
+            } else if (inputs instanceof SingleTxBlockRootRollupInputs) {
+                return this.prover.getSingleTxBlockRootRollupProof(inputs, signal, provingState.epochNumber);
+            } else {
+                return this.prover.getBlockRootRollupProof(inputs, signal, provingState.epochNumber);
+            }
+        }), async (result)=>{
+            provingState.setBlockRootRollupProof(result);
+            const header = await provingState.buildHeaderFromProvingOutputs(logger);
+            if (!(await header.hash()).equals(await provingState.block.header.hash())) {
+                logger.error(`Block header mismatch\nCircuit:${inspect(header)}\nComputed:${inspect(provingState.block.header)}`);
+                provingState.reject(`Block header hash mismatch`);
+            }
+            logger.debug(`Completed ${rollupType} proof for block ${provingState.block.number}`);
+            // validatePartialState(result.inputs.end, tx.treeSnapshots); // TODO(palla/prover)
+            const epochProvingState = this.provingState;
+            const leafLocation = epochProvingState.setBlockRootRollupProof(provingState.index, result);
+            if (epochProvingState.totalNumBlocks === 1) {
+                await this.enqueueEpochPadding(epochProvingState);
+            } else {
+                this.checkAndEnqueueNextBlockMergeRollup(epochProvingState, leafLocation);
+            }
+        });
+    }
+    // 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) {
+        if (!provingState.verifyState()) {
+            logger.debug('Not running base parity. State no longer valid.');
+            return;
+        }
+        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, provingState.epochNumber)), (provingOutput)=>{
+            provingState.setBaseParityProof(index, provingOutput);
+            this.checkAndEnqueueRootParityCircuit(provingState);
+        });
+    }
+    checkAndEnqueueRootParityCircuit(provingState) {
+        if (!provingState.isReadyForRootParity()) {
+            return;
+        }
+        this.enqueueRootParityCircuit(provingState);
+    }
+    // Runs the root parity circuit ans stored the outputs
+    // Enqueues the root rollup proof if all inputs are available
+    enqueueRootParityCircuit(provingState) {
+        if (!provingState.verifyState()) {
+            logger.debug('Not running root parity. State no longer valid.');
+            return;
+        }
+        const inputs = provingState.getRootParityInputs();
+        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, provingState.epochNumber)), async (result)=>{
+            provingState.setRootParityProof(result);
+            await this.checkAndEnqueueBlockRootRollup(provingState);
+        });
+    }
+    // Executes the block merge rollup circuit and stored the output as intermediate state for the parent merge/block root circuit
+    // Enqueues the next level of merge if all inputs are available
+    enqueueBlockMergeRollup(provingState, location) {
+        if (!provingState.verifyState()) {
+            logger.debug('Not running block merge rollup. State no longer valid.');
+            return;
+        }
+        const inputs = provingState.getBlockMergeRollupInputs(location);
+        this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getBlockMergeRollupProof', {
+            [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+            [Attributes.PROTOCOL_CIRCUIT_NAME]: 'block-merge-rollup'
+        }, (signal)=>this.prover.getBlockMergeRollupProof(inputs, signal, provingState.epochNumber)), (result)=>{
+            provingState.setBlockMergeRollupProof(location, result);
+            this.checkAndEnqueueNextBlockMergeRollup(provingState, location);
+        });
+    }
+    async enqueueEpochPadding(provingState) {
+        if (!provingState.verifyState()) {
+            logger.debug('Not running epoch padding. State no longer valid.');
+            return;
+        }
+        logger.debug('Padding epoch proof with an empty block root proof.');
+        const inputs = await provingState.getPaddingBlockRootInputs(this.proverId);
+        this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getEmptyBlockRootRollupProof', {
+            [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+            [Attributes.PROTOCOL_CIRCUIT_NAME]: 'empty-block-root-rollup'
+        }, (signal)=>this.prover.getEmptyBlockRootRollupProof(inputs, signal, provingState.epochNumber)), (result)=>{
+            logger.debug('Completed proof for padding block root.');
+            provingState.setPaddingBlockRootProof(result);
+            this.checkAndEnqueueRootRollup(provingState);
+        });
+    }
+    // Executes the root rollup circuit
+    enqueueRootRollup(provingState) {
+        if (!provingState.verifyState()) {
+            logger.debug('Not running root rollup, state no longer valid');
+            return;
+        }
+        logger.debug(`Preparing root rollup`);
+        const inputs = provingState.getRootRollupInputs(this.proverId);
+        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, provingState.epochNumber)), (result)=>{
+            logger.verbose(`Orchestrator completed root rollup for epoch ${provingState.epochNumber}`);
+            provingState.setRootRollupProof(result);
+            provingState.resolve({
+                status: 'success'
+            });
+        });
+    }
+    async checkAndEnqueueNextMergeRollup(provingState, currentLocation) {
+        if (!provingState.isReadyForMergeRollup(currentLocation)) {
+            return;
+        }
+        const parentLocation = provingState.getParentLocation(currentLocation);
+        if (parentLocation.level === 0) {
+            await this.checkAndEnqueueBlockRootRollup(provingState);
+        } else {
+            this.enqueueMergeRollup(provingState, parentLocation);
+        }
+    }
+    async checkAndEnqueueBlockRootRollup(provingState) {
+        if (!provingState.isReadyForBlockRootRollup()) {
+            logger.debug('Not ready for root rollup');
+            return;
+        }
+        if (provingState.blockRootRollupStarted) {
+            logger.debug('Block root rollup already started');
+            return;
+        }
+        const blockNumber = provingState.blockNumber;
+        // TODO(palla/prover): This closes the fork only on the happy path. If this epoch orchestrator
+        // is aborted and never reaches this point, it will leak the fork. We need to add a global cleanup,
+        // but have to make sure it only runs once all operations are completed, otherwise some function here
+        // will attempt to access the fork after it was closed.
+        logger.debug(`Cleaning up world state fork for ${blockNumber}`);
+        void this.dbs.get(blockNumber)?.close().then(()=>this.dbs.delete(blockNumber)).catch((err)=>logger.error(`Error closing db for block ${blockNumber}`, err));
+        await this.enqueueBlockRootRollup(provingState);
+    }
+    checkAndEnqueueNextBlockMergeRollup(provingState, currentLocation) {
+        if (!provingState.isReadyForBlockMerge(currentLocation)) {
+            return;
+        }
+        const parentLocation = provingState.getParentLocation(currentLocation);
+        if (parentLocation.level === 0) {
+            this.checkAndEnqueueRootRollup(provingState);
+        } else {
+            this.enqueueBlockMergeRollup(provingState, parentLocation);
+        }
+    }
+    checkAndEnqueueRootRollup(provingState) {
+        if (!provingState.isReadyForRootRollup()) {
+            logger.debug('Not ready for root rollup');
+            return;
+        }
+        this.enqueueRootRollup(provingState);
+    }
+    /**
+   * 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
+   */ enqueueVM(provingState, txIndex) {
+        if (!provingState.verifyState()) {
+            logger.debug(`Not running VM circuit as state is no longer valid`);
+            return;
+        }
+        const txProvingState = provingState.getTxProvingState(txIndex);
+        // 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()
+        }, async (signal)=>{
+            const inputs = txProvingState.getAvmInputs();
+            try {
+                return await this.prover.getAvmProof(inputs, signal, provingState.epochNumber);
+            } catch (err) {
+                if (process.env.AVM_PROVING_STRICT) {
+                    logger.error(`Error thrown when proving AVM circuit with AVM_PROVING_STRICT on`, err);
+                    throw err;
+                } else {
+                    logger.warn(`Error thrown when proving AVM circuit but AVM_PROVING_STRICT is off. Faking AVM proof and carrying on. ${inspect(err)}.`);
+                    return {
+                        proof: makeEmptyRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS),
+                        verificationKey: VerificationKeyData.makeFake(AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS)
+                    };
+                }
+            }
+        });
+        this.deferredProving(provingState, doAvmProving, (proofAndVk)=>{
+            logger.debug(`Proven VM for tx index: ${txIndex}`);
+            txProvingState.setAvmProof(proofAndVk);
+            this.checkAndEnqueueNextTxCircuit(provingState, txIndex);
+        });
+    }
+    checkAndEnqueueNextTxCircuit(provingState, txIndex) {
+        const txProvingState = provingState.getTxProvingState(txIndex);
+        if (!txProvingState.ready()) {
+            return;
+        }
+        // We must have completed all proving (tube proof and (if required) vm proof are generated), we now move to the base rollup.
+        logger.debug(`Public functions completed for tx ${txIndex} enqueueing base rollup`);
+        this.enqueueBaseRollup(provingState, txIndex);
+    }
+}
+_ts_decorate([
+    trackSpan('ProvingOrchestrator.startNewBlock', (globalVariables)=>({
+            [Attributes.BLOCK_NUMBER]: globalVariables.blockNumber.toNumber()
+        }))
+], ProvingOrchestrator.prototype, "startNewBlock", null);
+_ts_decorate([
+    trackSpan('ProvingOrchestrator.addTxs', (txs)=>({
+            [Attributes.BLOCK_TXS_COUNT]: txs.length
+        }))
+], ProvingOrchestrator.prototype, "addTxs", null);
+_ts_decorate([
+    trackSpan('ProvingOrchestrator.startTubeCircuits')
+], ProvingOrchestrator.prototype, "startTubeCircuits", null);
+_ts_decorate([
+    trackSpan('ProvingOrchestrator.setBlockCompleted', (blockNumber)=>({
+            [Attributes.BLOCK_NUMBER]: blockNumber
+        }))
+], ProvingOrchestrator.prototype, "setBlockCompleted", null);
+_ts_decorate([
+    trackSpan('ProvingOrchestrator.prepareBaseRollupInputs', (_, tx)=>({
+            [Attributes.TX_HASH]: tx.hash.toString()
+        }))
+], ProvingOrchestrator.prototype, "prepareBaseRollupInputs", null);