@aztec/prover-client 0.42.0

package/dest/orchestrator/block-building-helpers.js

@@ -0,0 +1,236 @@
+import { MerkleTreeId } from '@aztec/circuit-types';
+import { ARCHIVE_HEIGHT, AppendOnlyTreeSnapshot, BaseRollupInputs, ConstantRollupData, Fr, KernelData, MAX_NEW_NULLIFIERS_PER_TX, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, MembershipWitness, MergeRollupInputs, NESTED_RECURSIVE_PROOF_LENGTH, NOTE_HASH_SUBTREE_HEIGHT, NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH, NULLIFIER_SUBTREE_HEIGHT, NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH, NULLIFIER_TREE_HEIGHT, NullifierLeafPreimage, PUBLIC_DATA_SUBTREE_HEIGHT, PUBLIC_DATA_SUBTREE_SIBLING_PATH_LENGTH, PUBLIC_DATA_TREE_HEIGHT, PartialStateReference, PreviousRollupData, PublicDataHint, PublicDataTreeLeaf, PublicDataUpdateRequest, ROLLUP_VK_TREE_HEIGHT, RootRollupInputs, StateDiffHints, VK_TREE_HEIGHT, makeRecursiveProofFromBinary, } from '@aztec/circuits.js';
+import { assertPermutation, makeTuple } from '@aztec/foundation/array';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { assertLength, toFriendlyJSON } from '@aztec/foundation/serialize';
+import { HintsBuilder, computeFeePayerBalanceLeafSlot } from '@aztec/simulator';
+// Denotes fields that are not used now, but will be in the future
+const FUTURE_FR = new Fr(0n);
+const FUTURE_NUM = 0;
+// Denotes fields that should be deleted
+const DELETE_FR = new Fr(0n);
+// Builds the base rollup inputs, updating the contract, nullifier, and data trees in the process
+export async function buildBaseRollupInput(tx, globalVariables, db, kernelVk) {
+    // Get trees info before any changes hit
+    const constants = await getConstantRollupData(globalVariables, db);
+    const start = new PartialStateReference(await getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE, db), await getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE, db), await getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE, db));
+    // Get the subtree sibling paths for the circuit
+    const noteHashSubtreeSiblingPathArray = await getSubtreeSiblingPath(MerkleTreeId.NOTE_HASH_TREE, NOTE_HASH_SUBTREE_HEIGHT, db);
+    const noteHashSubtreeSiblingPath = makeTuple(NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH, i => i < noteHashSubtreeSiblingPathArray.length ? noteHashSubtreeSiblingPathArray[i] : Fr.ZERO);
+    // Create data hint for reading fee payer initial balance in gas tokens
+    // If no fee payer is set, read hint should be empty
+    // If there is already a public data write for this slot, also skip the read hint
+    const hintsBuilder = new HintsBuilder(db);
+    const leafSlot = computeFeePayerBalanceLeafSlot(tx.data.feePayer);
+    const existingBalanceWrite = tx.data.end.publicDataUpdateRequests.find(write => write.leafSlot.equals(leafSlot));
+    const feePayerGasTokenBalanceReadHint = leafSlot.isZero() || existingBalanceWrite
+        ? PublicDataHint.empty()
+        : await hintsBuilder.getPublicDataHint(leafSlot.toBigInt());
+    // Update the note hash trees with the new items being inserted to get the new roots
+    // that will be used by the next iteration of the base rollup circuit, skipping the empty ones
+    const newNoteHashes = tx.data.end.newNoteHashes;
+    await db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, newNoteHashes);
+    // The read witnesses for a given TX should be generated before the writes of the same TX are applied.
+    // All reads that refer to writes in the same tx are transient and can be simplified out.
+    const txPublicDataUpdateRequestInfo = await processPublicDataUpdateRequests(tx, db);
+    // Update the nullifier tree, capturing the low nullifier info for each individual operation
+    const { lowLeavesWitnessData: nullifierWitnessLeaves, newSubtreeSiblingPath: newNullifiersSubtreeSiblingPath, sortedNewLeaves: sortedNewNullifiers, sortedNewLeavesIndexes, } = await db.batchInsert(MerkleTreeId.NULLIFIER_TREE, tx.data.end.newNullifiers.map(n => n.toBuffer()), NULLIFIER_SUBTREE_HEIGHT);
+    if (nullifierWitnessLeaves === undefined) {
+        throw new Error(`Could not craft nullifier batch insertion proofs`);
+    }
+    // Extract witness objects from returned data
+    const nullifierPredecessorMembershipWitnessesWithoutPadding = nullifierWitnessLeaves.map(l => MembershipWitness.fromBufferArray(l.index, assertLength(l.siblingPath.toBufferArray(), NULLIFIER_TREE_HEIGHT)));
+    const nullifierSubtreeSiblingPathArray = newNullifiersSubtreeSiblingPath.toFields();
+    const nullifierSubtreeSiblingPath = makeTuple(NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH, i => i < nullifierSubtreeSiblingPathArray.length ? nullifierSubtreeSiblingPathArray[i] : Fr.ZERO);
+    const publicDataSiblingPath = txPublicDataUpdateRequestInfo.newPublicDataSubtreeSiblingPath;
+    const stateDiffHints = StateDiffHints.from({
+        nullifierPredecessorPreimages: makeTuple(MAX_NEW_NULLIFIERS_PER_TX, i => i < nullifierWitnessLeaves.length
+            ? nullifierWitnessLeaves[i].leafPreimage
+            : NullifierLeafPreimage.empty()),
+        nullifierPredecessorMembershipWitnesses: makeTuple(MAX_NEW_NULLIFIERS_PER_TX, i => i < nullifierPredecessorMembershipWitnessesWithoutPadding.length
+            ? nullifierPredecessorMembershipWitnessesWithoutPadding[i]
+            : makeEmptyMembershipWitness(NULLIFIER_TREE_HEIGHT)),
+        sortedNullifiers: makeTuple(MAX_NEW_NULLIFIERS_PER_TX, i => Fr.fromBuffer(sortedNewNullifiers[i])),
+        sortedNullifierIndexes: makeTuple(MAX_NEW_NULLIFIERS_PER_TX, i => sortedNewLeavesIndexes[i]),
+        noteHashSubtreeSiblingPath,
+        nullifierSubtreeSiblingPath,
+        publicDataSiblingPath,
+    });
+    const blockHash = tx.data.constants.historicalHeader.hash();
+    const archiveRootMembershipWitness = await getMembershipWitnessFor(blockHash, MerkleTreeId.ARCHIVE, ARCHIVE_HEIGHT, db);
+    return BaseRollupInputs.from({
+        kernelData: getKernelDataFor(tx, kernelVk),
+        start,
+        stateDiffHints,
+        feePayerGasTokenBalanceReadHint,
+        sortedPublicDataWrites: txPublicDataUpdateRequestInfo.sortedPublicDataWrites,
+        sortedPublicDataWritesIndexes: txPublicDataUpdateRequestInfo.sortedPublicDataWritesIndexes,
+        lowPublicDataWritesPreimages: txPublicDataUpdateRequestInfo.lowPublicDataWritesPreimages,
+        lowPublicDataWritesMembershipWitnesses: txPublicDataUpdateRequestInfo.lowPublicDataWritesMembershipWitnesses,
+        archiveRootMembershipWitness,
+        constants,
+    });
+}
+export function createMergeRollupInputs(left, right) {
+    const mergeInputs = new MergeRollupInputs([
+        getPreviousRollupDataFromPublicInputs(left[0], left[1], left[2]),
+        getPreviousRollupDataFromPublicInputs(right[0], right[1], right[2]),
+    ]);
+    return mergeInputs;
+}
+// Validate that the roots of all local trees match the output of the root circuit simulation
+export async function validateRootOutput(rootOutput, db) {
+    await Promise.all([
+        validateState(rootOutput.header.state, db),
+        validateSimulatedTree(await getTreeSnapshot(MerkleTreeId.ARCHIVE, db), rootOutput.archive, 'Archive'),
+    ]);
+}
+export async function validateState(state, db) {
+    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 snapshots = new Map((await Promise.all(promises)).map(obj => [obj.key, obj.value]));
+    validatePartialState(state.partial, snapshots);
+    validateSimulatedTree(await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db), state.l1ToL2MessageTree, 'L1ToL2MessageTree');
+}
+// Builds the inputs for the root rollup circuit, without making any changes to trees
+export async function getRootRollupInput(rollupOutputLeft, rollupProofLeft, verificationKeyLeft, rollupOutputRight, rollupProofRight, verificationKeyRight, l1ToL2Roots, newL1ToL2Messages, messageTreeSnapshot, messageTreeRootSiblingPath, db) {
+    const previousRollupData = [
+        getPreviousRollupDataFromPublicInputs(rollupOutputLeft, rollupProofLeft, verificationKeyLeft),
+        getPreviousRollupDataFromPublicInputs(rollupOutputRight, rollupProofRight, verificationKeyRight),
+    ];
+    const getRootTreeSiblingPath = async (treeId) => {
+        const { size } = await db.getTreeInfo(treeId);
+        const path = await db.getSiblingPath(treeId, size);
+        return path.toFields();
+    };
+    // Get blocks tree
+    const startArchiveSnapshot = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
+    const newArchiveSiblingPathArray = await getRootTreeSiblingPath(MerkleTreeId.ARCHIVE);
+    const newArchiveSiblingPath = makeTuple(ARCHIVE_HEIGHT, i => (i < newArchiveSiblingPathArray.length ? newArchiveSiblingPathArray[i] : Fr.ZERO), 0);
+    return RootRollupInputs.from({
+        previousRollupData,
+        l1ToL2Roots,
+        newL1ToL2Messages,
+        newL1ToL2MessageTreeRootSiblingPath: messageTreeRootSiblingPath,
+        startL1ToL2MessageTreeSnapshot: messageTreeSnapshot,
+        startArchiveSnapshot,
+        newArchiveSiblingPath,
+    });
+}
+export function getPreviousRollupDataFromPublicInputs(rollupOutput, rollupProof, vk) {
+    return new PreviousRollupData(rollupOutput, rollupProof, vk, 
+    // MembershipWitness for a VK tree to be implemented in the future
+    FUTURE_NUM, new MembershipWitness(ROLLUP_VK_TREE_HEIGHT, BigInt(FUTURE_NUM), makeTuple(ROLLUP_VK_TREE_HEIGHT, () => FUTURE_FR)));
+}
+export async function getConstantRollupData(globalVariables, db) {
+    return ConstantRollupData.from({
+        baseRollupVkHash: DELETE_FR,
+        mergeRollupVkHash: DELETE_FR,
+        privateKernelVkTreeRoot: FUTURE_FR,
+        publicKernelVkTreeRoot: FUTURE_FR,
+        lastArchive: await getTreeSnapshot(MerkleTreeId.ARCHIVE, db),
+        globalVariables,
+    });
+}
+export async function getTreeSnapshot(id, db) {
+    const treeInfo = await db.getTreeInfo(id);
+    return new AppendOnlyTreeSnapshot(Fr.fromBuffer(treeInfo.root), Number(treeInfo.size));
+}
+export function getKernelDataFor(tx, vk) {
+    const recursiveProof = makeRecursiveProofFromBinary(tx.proof, NESTED_RECURSIVE_PROOF_LENGTH);
+    return new KernelData(tx.data, recursiveProof, 
+    // VK for the kernel circuit
+    vk, 
+    // MembershipWitness for a VK tree to be implemented in the future
+    FUTURE_NUM, assertLength(Array(VK_TREE_HEIGHT).fill(FUTURE_FR), VK_TREE_HEIGHT));
+}
+export function makeEmptyMembershipWitness(height) {
+    return new MembershipWitness(height, 0n, makeTuple(height, () => Fr.ZERO));
+}
+export async function processPublicDataUpdateRequests(tx, db) {
+    const allPublicDataUpdateRequests = padArrayEnd(tx.finalPublicDataUpdateRequests, PublicDataUpdateRequest.empty(), MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX);
+    const allPublicDataWrites = allPublicDataUpdateRequests.map(({ leafSlot, newValue }) => new PublicDataTreeLeaf(leafSlot, newValue));
+    const { lowLeavesWitnessData, newSubtreeSiblingPath, sortedNewLeaves, sortedNewLeavesIndexes } = await db.batchInsert(MerkleTreeId.PUBLIC_DATA_TREE, allPublicDataWrites.map(x => x.toBuffer()), 
+    // TODO(#3675) remove oldValue from update requests
+    PUBLIC_DATA_SUBTREE_HEIGHT);
+    if (lowLeavesWitnessData === undefined) {
+        throw new Error(`Could not craft public data batch insertion proofs`);
+    }
+    const sortedPublicDataWrites = makeTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, i => {
+        return PublicDataTreeLeaf.fromBuffer(sortedNewLeaves[i]);
+    });
+    const sortedPublicDataWritesIndexes = makeTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, i => {
+        return sortedNewLeavesIndexes[i];
+    });
+    const subtreeSiblingPathAsFields = newSubtreeSiblingPath.toFields();
+    const newPublicDataSubtreeSiblingPath = makeTuple(PUBLIC_DATA_SUBTREE_SIBLING_PATH_LENGTH, i => {
+        return subtreeSiblingPathAsFields[i];
+    });
+    const lowPublicDataWritesMembershipWitnesses = makeTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, i => {
+        const witness = lowLeavesWitnessData[i];
+        return MembershipWitness.fromBufferArray(witness.index, assertLength(witness.siblingPath.toBufferArray(), PUBLIC_DATA_TREE_HEIGHT));
+    });
+    const lowPublicDataWritesPreimages = makeTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, i => {
+        return lowLeavesWitnessData[i].leafPreimage;
+    });
+    // validate that the sortedPublicDataWrites and sortedPublicDataWritesIndexes are in the correct order
+    // otherwise it will just fail in the circuit
+    assertPermutation(allPublicDataWrites, sortedPublicDataWrites, sortedPublicDataWritesIndexes, (a, b) => a.equals(b));
+    return {
+        lowPublicDataWritesPreimages,
+        lowPublicDataWritesMembershipWitnesses,
+        newPublicDataSubtreeSiblingPath,
+        sortedPublicDataWrites,
+        sortedPublicDataWritesIndexes,
+    };
+}
+export async function getSubtreeSiblingPath(treeId, subtreeHeight, db) {
+    const nextAvailableLeafIndex = await db.getTreeInfo(treeId).then(t => t.size);
+    const fullSiblingPath = await db.getSiblingPath(treeId, nextAvailableLeafIndex);
+    // Drop the first subtreeHeight items since we only care about the path to the subtree root
+    return fullSiblingPath.getSubtreeSiblingPath(subtreeHeight).toFields();
+}
+// Scan a tree searching for a specific value and return a membership witness proof for it
+export async function getMembershipWitnessFor(value, treeId, height, db) {
+    // If this is an empty tx, then just return zeroes
+    if (value.isZero()) {
+        return makeEmptyMembershipWitness(height);
+    }
+    const index = await db.findLeafIndex(treeId, value.toBuffer());
+    if (index === undefined) {
+        throw new Error(`Leaf with value ${value} not found in tree ${MerkleTreeId[treeId]}`);
+    }
+    const path = await db.getSiblingPath(treeId, index);
+    return new MembershipWitness(height, index, assertLength(path.toFields(), height));
+}
+export function validatePartialState(partialState, treeSnapshots) {
+    validateSimulatedTree(treeSnapshots.get(MerkleTreeId.NOTE_HASH_TREE), partialState.noteHashTree, 'NoteHashTree');
+    validateSimulatedTree(treeSnapshots.get(MerkleTreeId.NULLIFIER_TREE), partialState.nullifierTree, 'NullifierTree');
+    validateSimulatedTree(treeSnapshots.get(MerkleTreeId.PUBLIC_DATA_TREE), partialState.publicDataTree, 'PublicDataTree');
+}
+// Helper for comparing two trees snapshots
+export function validateSimulatedTree(localTree, simulatedTree, name, label) {
+    if (!simulatedTree.root.toBuffer().equals(localTree.root.toBuffer())) {
+        throw new Error(`${label ?? name} tree root mismatch (local ${localTree.root}, simulated ${simulatedTree.root})`);
+    }
+    if (simulatedTree.nextAvailableLeafIndex !== localTree.nextAvailableLeafIndex) {
+        throw new Error(`${label ?? name} tree next available leaf index mismatch (local ${localTree.nextAvailableLeafIndex}, simulated ${simulatedTree.nextAvailableLeafIndex})`);
+    }
+}
+export function validateTx(tx) {
+    const txHeader = tx.data.constants.historicalHeader;
+    if (txHeader.state.l1ToL2MessageTree.isZero()) {
+        throw new Error(`Empty L1 to L2 messages tree in tx: ${toFriendlyJSON(tx)}`);
+    }
+    if (txHeader.state.partial.noteHashTree.isZero()) {
+        throw new Error(`Empty note hash tree in tx: ${toFriendlyJSON(tx)}`);
+    }
+    if (txHeader.state.partial.nullifierTree.isZero()) {
+        throw new Error(`Empty nullifier tree in tx: ${toFriendlyJSON(tx)}`);
+    }
+    if (txHeader.state.partial.publicDataTree.isZero()) {
+        throw new Error(`Empty public data tree in tx: ${toFriendlyJSON(tx)}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"block-building-helpers.js","sourceRoot":"","sources":["../../src/orchestrator/block-building-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAoB,MAAM,sBAAsB,CAAC;AACtE,OAAO,EACL,cAAc,EACd,sBAAsB,EAEtB,gBAAgB,EAChB,kBAAkB,EAClB,EAAE,EAEF,UAAU,EAEV,yBAAyB,EACzB,4CAA4C,EAC5C,iBAAiB,EACjB,iBAAiB,EACjB,6BAA6B,EAC7B,wBAAwB,EACxB,qCAAqC,EACrC,wBAAwB,EACxB,qCAAqC,EACrC,qBAAqB,EAErB,qBAAqB,EACrB,0BAA0B,EAC1B,uCAAuC,EACvC,uBAAuB,EACvB,qBAAqB,EACrB,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAElB,uBAAuB,EACvB,qBAAqB,EAGrB,gBAAgB,EAEhB,cAAc,EAEd,cAAc,EAGd,4BAA4B,GAC7B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACvE,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAc,YAAY,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AACvF,OAAO,EAAE,YAAY,EAAE,8BAA8B,EAAE,MAAM,kBAAkB,CAAC;AAGhF,kEAAkE;AAClE,MAAM,SAAS,GAAG,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;AAC7B,MAAM,UAAU,GAAG,CAAC,CAAC;AAErB,wCAAwC;AACxC,MAAM,SAAS,GAAG,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;AAW7B,iGAAiG;AACjG,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,EAAe,EACf,eAAgC,EAChC,EAAwB,EACxB,QAA6B;IAE7B,wCAAwC;IACxC,MAAM,SAAS,GAAG,MAAM,qBAAqB,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC;IACnE,MAAM,KAAK,GAAG,IAAI,qBAAqB,CACrC,MAAM,eAAe,CAAC,YAAY,CAAC,cAAc,EAAE,EAAE,CAAC,EACtD,MAAM,eAAe,CAAC,YAAY,CAAC,cAAc,EAAE,EAAE,CAAC,EACtD,MAAM,eAAe,CAAC,YAAY,CAAC,gBAAgB,EAAE,EAAE,CAAC,CACzD,CAAC;IACF,gDAAgD;IAChD,MAAM,+BAA+B,GAAG,MAAM,qBAAqB,CACjE,YAAY,CAAC,cAAc,EAC3B,wBAAwB,EACxB,EAAE,CACH,CAAC;IAEF,MAAM,0BAA0B,GAAG,SAAS,CAAC,qCAAqC,EAAE,CAAC,CAAC,EAAE,CACtF,CAAC,GAAG,+BAA+B,CAAC,MAAM,CAAC,CAAC,CAAC,+BAA+B,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAC1F,CAAC;IAEF,uEAAuE;IACvE,oDAAoD;IACpD,iFAAiF;IACjF,MAAM,YAAY,GAAG,IAAI,YAAY,CAAC,EAAE,CAAC,CAAC;IAC1C,MAAM,QAAQ,GAAG,8BAA8B,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAClE,MAAM,oBAAoB,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,wBAAwB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;IACjH,MAAM,+BAA+B,GACnC,QAAQ,CAAC,MAAM,EAAE,IAAI,oBAAoB;QACvC,CAAC,CAAC,cAAc,CAAC,KAAK,EAAE;QACxB,CAAC,CAAC,MAAM,YAAY,CAAC,iBAAiB,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC;IAEhE,oFAAoF;IACpF,8FAA8F;IAC9F,MAAM,aAAa,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC;IAChD,MAAM,EAAE,CAAC,YAAY,CAAC,YAAY,CAAC,cAAc,EAAE,aAAa,CAAC,CAAC;IAElE,sGAAsG;IACtG,yFAAyF;IACzF,MAAM,6BAA6B,GAAG,MAAM,+BAA+B,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;IAEpF,4FAA4F;IAC5F,MAAM,EACJ,oBAAoB,EAAE,sBAAsB,EAC5C,qBAAqB,EAAE,+BAA+B,EACtD,eAAe,EAAE,mBAAmB,EACpC,sBAAsB,GACvB,GAAG,MAAM,EAAE,CAAC,WAAW,CACtB,YAAY,CAAC,cAAc,EAC3B,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,EAChD,wBAAwB,CACzB,CAAC;IACF,IAAI,sBAAsB,KAAK,SAAS,EAAE,CAAC;QACzC,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IACtE,CAAC;IAED,6CAA6C;IAC7C,MAAM,qDAAqD,GACzD,sBAAsB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAC7B,iBAAiB,CAAC,eAAe,CAAC,CAAC,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,WAAW,CAAC,aAAa,EAAE,EAAE,qBAAqB,CAAC,CAAC,CAC/G,CAAC;IAEJ,MAAM,gCAAgC,GAAG,+BAA+B,CAAC,QAAQ,EAAE,CAAC;IAEpF,MAAM,2BAA2B,GAAG,SAAS,CAAC,qCAAqC,EAAE,CAAC,CAAC,EAAE,CACvF,CAAC,GAAG,gCAAgC,CAAC,MAAM,CAAC,CAAC,CAAC,gCAAgC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAC5F,CAAC;IAEF,MAAM,qBAAqB,GAAG,6BAA6B,CAAC,+BAA+B,CAAC;IAE5F,MAAM,cAAc,GAAG,cAAc,CAAC,IAAI,CAAC;QACzC,6BAA6B,EAAE,SAAS,CAAC,yBAAyB,EAAE,CAAC,CAAC,EAAE,CACtE,CAAC,GAAG,sBAAsB,CAAC,MAAM;YAC/B,CAAC,CAAE,sBAAsB,CAAC,CAAC,CAAC,CAAC,YAAsC;YACnE,CAAC,CAAC,qBAAqB,CAAC,KAAK,EAAE,CAClC;QACD,uCAAuC,EAAE,SAAS,CAAC,yBAAyB,EAAE,CAAC,CAAC,EAAE,CAChF,CAAC,GAAG,qDAAqD,CAAC,MAAM;YAC9D,CAAC,CAAC,qDAAqD,CAAC,CAAC,CAAC;YAC1D,CAAC,CAAC,0BAA0B,CAAC,qBAAqB,CAAC,CACtD;QACD,gBAAgB,EAAE,SAAS,CAAC,yBAAyB,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,UAAU,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;QAClG,sBAAsB,EAAE,SAAS,CAAC,yBAAyB,EAAE,CAAC,CAAC,EAAE,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC;QAC5F,0BAA0B;QAC1B,2BAA2B;QAC3B,qBAAqB;KACtB,CAAC,CAAC;IAEH,MAAM,SAAS,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC;IAC5D,MAAM,4BAA4B,GAAG,MAAM,uBAAuB,CAChE,SAAS,EACT,YAAY,CAAC,OAAO,EACpB,cAAc,EACd,EAAE,CACH,CAAC;IAEF,OAAO,gBAAgB,CAAC,IAAI,CAAC;QAC3B,UAAU,EAAE,gBAAgB,CAAC,EAAE,EAAE,QAAQ,CAAC;QAC1C,KAAK;QACL,cAAc;QACd,+BAA+B;QAC/B,sBAAsB,EAAE,6BAA6B,CAAC,sBAAsB;QAC5E,6BAA6B,EAAE,6BAA6B,CAAC,6BAA6B;QAC1F,4BAA4B,EAAE,6BAA6B,CAAC,4BAA4B;QACxF,sCAAsC,EAAE,6BAA6B,CAAC,sCAAsC;QAE5G,4BAA4B;QAE5B,SAAS;KACV,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,uBAAuB,CACrC,IAAoH,EACpH,KAAqH;IAErH,MAAM,WAAW,GAAG,IAAI,iBAAiB,CAAC;QACxC,qCAAqC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;QAChE,qCAAqC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;KACpE,CAAC,CAAC;IACH,OAAO,WAAW,CAAC;AACrB,CAAC;AAED,6FAA6F;AAC7F,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAAC,UAAkC,EAAE,EAAwB;IACnG,MAAM,OAAO,CAAC,GAAG,CAAC;QAChB,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC;QAC1C,qBAAqB,CAAC,MAAM,eAAe,CAAC,YAAY,CAAC,OAAO,EAAE,EAAE,CAAC,EAAE,UAAU,CAAC,OAAO,EAAE,SAAS,CAAC;KACtG,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,KAAqB,EAAE,EAAwB;IACjF,MAAM,QAAQ,GAAG,CAAC,YAAY,CAAC,cAAc,EAAE,YAAY,CAAC,cAAc,EAAE,YAAY,CAAC,gBAAgB,CAAC,CAAC,GAAG,CAC5G,KAAK,EAAE,EAAgB,EAAE,EAAE;QACzB,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;IAC3D,CAAC,CACF,CAAC;IACF,MAAM,SAAS,GAA8C,IAAI,GAAG,CAClE,CAAC,MAAM,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CAC/D,CAAC;IACF,oBAAoB,CAAC,KAAK,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IAC/C,qBAAqB,CACnB,MAAM,eAAe,CAAC,YAAY,CAAC,qBAAqB,EAAE,EAAE,CAAC,EAC7D,KAAK,CAAC,iBAAiB,EACvB,mBAAmB,CACpB,CAAC;AACJ,CAAC;AAED,qFAAqF;AACrF,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,gBAA+C,EAC/C,eAAqE,EACrE,mBAA4C,EAC5C,iBAAgD,EAChD,gBAAsE,EACtE,oBAA6C,EAC7C,WAAkE,EAClE,iBAAwE,EACxE,mBAA2C,EAC3C,0BAAsF,EACtF,EAAwB;IAExB,MAAM,kBAAkB,GAA2C;QACjE,qCAAqC,CAAC,gBAAgB,EAAE,eAAe,EAAE,mBAAmB,CAAC;QAC7F,qCAAqC,CAAC,iBAAiB,EAAE,gBAAgB,EAAE,oBAAoB,CAAC;KACjG,CAAC;IAEF,MAAM,sBAAsB,GAAG,KAAK,EAAE,MAAoB,EAAE,EAAE;QAC5D,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QAC9C,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACnD,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC,CAAC;IAEF,kBAAkB;IAClB,MAAM,oBAAoB,GAAG,MAAM,eAAe,CAAC,YAAY,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IAC7E,MAAM,0BAA0B,GAAG,MAAM,sBAAsB,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IAEtF,MAAM,qBAAqB,GAAG,SAAS,CACrC,cAAc,EACd,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,0BAA0B,CAAC,MAAM,CAAC,CAAC,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,EACtF,CAAC,CACF,CAAC;IAEF,OAAO,gBAAgB,CAAC,IAAI,CAAC;QAC3B,kBAAkB;QAClB,WAAW;QACX,iBAAiB;QACjB,mCAAmC,EAAE,0BAA0B;QAC/D,8BAA8B,EAAE,mBAAmB;QACnD,oBAAoB;QACpB,qBAAqB;KACtB,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,qCAAqC,CACnD,YAA2C,EAC3C,WAAiE,EACjE,EAA2B;IAE3B,OAAO,IAAI,kBAAkB,CAC3B,YAAY,EACZ,WAAW,EACX,EAAE;IAEF,kEAAkE;IAClE,UAAU,EACV,IAAI,iBAAiB,CACnB,qBAAqB,EACrB,MAAM,CAAC,UAAU,CAAC,EAClB,SAAS,CAAC,qBAAqB,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,CAClD,CACF,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,eAAgC,EAChC,EAAwB;IAExB,OAAO,kBAAkB,CAAC,IAAI,CAAC;QAC7B,gBAAgB,EAAE,SAAS;QAC3B,iBAAiB,EAAE,SAAS;QAC5B,uBAAuB,EAAE,SAAS;QAClC,sBAAsB,EAAE,SAAS;QACjC,WAAW,EAAE,MAAM,eAAe,CAAC,YAAY,CAAC,OAAO,EAAE,EAAE,CAAC;QAC5D,eAAe;KAChB,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,EAAgB,EAAE,EAAwB;IAC9E,MAAM,QAAQ,GAAG,MAAM,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;IAC1C,OAAO,IAAI,sBAAsB,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;AACzF,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,EAAe,EAAE,EAAuB;IACvE,MAAM,cAAc,GAAG,4BAA4B,CAAC,EAAE,CAAC,KAAK,EAAE,6BAA6B,CAAC,CAAC;IAC7F,OAAO,IAAI,UAAU,CACnB,EAAE,CAAC,IAAI,EACP,cAAc;IAEd,4BAA4B;IAC5B,EAAE;IAEF,kEAAkE;IAClE,UAAU,EACV,YAAY,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,cAAc,CAAC,CACpE,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,0BAA0B,CAAmB,MAAS;IACpE,OAAO,IAAI,iBAAiB,CAC1B,MAAM,EACN,EAAE,EACF,SAAS,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,CACjC,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,+BAA+B,CAAC,EAAe,EAAE,EAAwB;IAC7F,MAAM,2BAA2B,GAAG,WAAW,CAC7C,EAAE,CAAC,6BAA6B,EAChC,uBAAuB,CAAC,KAAK,EAAE,EAC/B,4CAA4C,CAC7C,CAAC;IAEF,MAAM,mBAAmB,GAAG,2BAA2B,CAAC,GAAG,CACzD,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,IAAI,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CACvE,CAAC;IACF,MAAM,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,eAAe,EAAE,sBAAsB,EAAE,GAAG,MAAM,EAAE,CAAC,WAAW,CACnH,YAAY,CAAC,gBAAgB,EAC7B,mBAAmB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;IAC1C,mDAAmD;IACnD,0BAA0B,CAC3B,CAAC;IAEF,IAAI,oBAAoB,KAAK,SAAS,EAAE,CAAC;QACvC,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;IACxE,CAAC;IAED,MAAM,sBAAsB,GAAG,SAAS,CAAC,4CAA4C,EAAE,CAAC,CAAC,EAAE;QACzF,OAAO,kBAAkB,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3D,CAAC,CAAC,CAAC;IAEH,MAAM,6BAA6B,GAAG,SAAS,CAAC,4CAA4C,EAAE,CAAC,CAAC,EAAE;QAChG,OAAO,sBAAsB,CAAC,CAAC,CAAC,CAAC;IACnC,CAAC,CAAC,CAAC;IAEH,MAAM,0BAA0B,GAAG,qBAAqB,CAAC,QAAQ,EAAE,CAAC;IACpE,MAAM,+BAA+B,GAAG,SAAS,CAAC,uCAAuC,EAAE,CAAC,CAAC,EAAE;QAC7F,OAAO,0BAA0B,CAAC,CAAC,CAAC,CAAC;IACvC,CAAC,CAAC,CAAC;IAEH,MAAM,sCAAsC,GAGxC,SAAS,CAAC,4CAA4C,EAAE,CAAC,CAAC,EAAE;QAC9D,MAAM,OAAO,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC;QACxC,OAAO,iBAAiB,CAAC,eAAe,CACtC,OAAO,CAAC,KAAK,EACb,YAAY,CAAC,OAAO,CAAC,WAAW,CAAC,aAAa,EAAE,EAAE,uBAAuB,CAAC,CAC3E,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,MAAM,4BAA4B,GAG9B,SAAS,CAAC,4CAA4C,EAAE,CAAC,CAAC,EAAE;QAC9D,OAAO,oBAAoB,CAAC,CAAC,CAAC,CAAC,YAA0C,CAAC;IAC5E,CAAC,CAAC,CAAC;IAEH,sGAAsG;IACtG,6CAA6C;IAC7C,iBAAiB,CAAC,mBAAmB,EAAE,sBAAsB,EAAE,6BAA6B,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAErH,OAAO;QACL,4BAA4B;QAC5B,sCAAsC;QACtC,+BAA+B;QAC/B,sBAAsB;QACtB,6BAA6B;KAC9B,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,MAAoB,EACpB,aAAqB,EACrB,EAAwB;IAExB,MAAM,sBAAsB,GAAG,MAAM,EAAE,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC9E,MAAM,eAAe,GAAG,MAAM,EAAE,CAAC,cAAc,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;IAEhF,2FAA2F;IAC3F,OAAO,eAAe,CAAC,qBAAqB,CAAC,aAAa,CAAC,CAAC,QAAQ,EAAE,CAAC;AACzE,CAAC;AAED,0FAA0F;AAC1F,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,KAAS,EACT,MAAoB,EACpB,MAAS,EACT,EAAwB;IAExB,kDAAkD;IAClD,IAAI,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;QACnB,OAAO,0BAA0B,CAAC,MAAM,CAAC,CAAC;IAC5C,CAAC;IAED,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,aAAa,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC/D,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CAAC,mBAAmB,KAAK,sBAAsB,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IACxF,CAAC;IACD,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC,cAAc,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACpD,OAAO,IAAI,iBAAiB,CAAC,MAAM,EAAE,KAAK,EAAE,YAAY,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC;AACrF,CAAC;AAED,MAAM,UAAU,oBAAoB,CAClC,YAAmC,EACnC,aAAwD;IAExD,qBAAqB,CAAC,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,cAAc,CAAE,EAAE,YAAY,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC;IAClH,qBAAqB,CAAC,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,cAAc,CAAE,EAAE,YAAY,CAAC,aAAa,EAAE,eAAe,CAAC,CAAC;IACpH,qBAAqB,CACnB,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,gBAAgB,CAAE,EACjD,YAAY,CAAC,cAAc,EAC3B,gBAAgB,CACjB,CAAC;AACJ,CAAC;AAED,2CAA2C;AAC3C,MAAM,UAAU,qBAAqB,CACnC,SAAiC,EACjC,aAAqC,EACrC,IAAe,EACf,KAAc;IAEd,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,EAAE,CAAC;QACrE,MAAM,IAAI,KAAK,CAAC,GAAG,KAAK,IAAI,IAAI,8BAA8B,SAAS,CAAC,IAAI,eAAe,aAAa,CAAC,IAAI,GAAG,CAAC,CAAC;IACpH,CAAC;IACD,IAAI,aAAa,CAAC,sBAAsB,KAAK,SAAS,CAAC,sBAAsB,EAAE,CAAC;QAC9E,MAAM,IAAI,KAAK,CACb,GAAG,KAAK,IAAI,IAAI,mDAAmD,SAAS,CAAC,sBAAsB,eACjG,aAAa,CAAC,sBAChB,GAAG,CACJ,CAAC;IACJ,CAAC;AACH,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,EAAe;IACxC,MAAM,QAAQ,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC;IACpD,IAAI,QAAQ,CAAC,KAAK,CAAC,iBAAiB,CAAC,MAAM,EAAE,EAAE,CAAC;QAC9C,MAAM,IAAI,KAAK,CAAC,uCAAuC,cAAc,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAC/E,CAAC;IACD,IAAI,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,MAAM,EAAE,EAAE,CAAC;QACjD,MAAM,IAAI,KAAK,CAAC,+BAA+B,cAAc,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACvE,CAAC;IACD,IAAI,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC;QAClD,MAAM,IAAI,KAAK,CAAC,+BAA+B,cAAc,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACvE,CAAC;IACD,IAAI,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,CAAC;QACnD,MAAM,IAAI,KAAK,CAAC,iCAAiC,cAAc,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACzE,CAAC;AACH,CAAC"}

package/dest/orchestrator/orchestrator.d.ts

@@ -0,0 +1,113 @@
+import { type ProcessedTx } from '@aztec/circuit-types';
+import { type BlockResult, type ProvingTicket, type ServerCircuitProver } from '@aztec/circuit-types/interfaces';
+import { Fr, type GlobalVariables, type Header, type VerificationKeys } from '@aztec/circuits.js';
+import { type MerkleTreeOperations } from '@aztec/world-state';
+/**
+ * Implements an event driven proving scheduler to build the recursive proof tree. The idea being:
+ * 1. Transactions are provided to the scheduler post simulation.
+ * 2. Tree insertions are performed as required to generate transaction specific proofs
+ * 3. Those transaction specific proofs are generated in the necessary order accounting for dependencies
+ * 4. Once a transaction is proven, it will be incorporated into a merge proof
+ * 5. Merge proofs are produced at each level of the tree until the root proof is produced
+ *
+ * The proving implementation is determined by the provided prover. This could be for example a local prover or a remote prover pool.
+ */
+/**
+ * The orchestrator, managing the flow of recursive proving operations required to build the rollup proof tree.
+ */
+export declare class ProvingOrchestrator {
+    private db;
+    private prover;
+    private initialHeader?;
+    private provingState;
+    private pendingProvingJobs;
+    private paddingTx;
+    constructor(db: MerkleTreeOperations, prover: ServerCircuitProver, initialHeader?: Header | undefined);
+    /**
+     * Resets the orchestrator's cached padding tx.
+     */
+    reset(): void;
+    /**
+     * 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
+     */
+    startNewBlock(numTxs: number, globalVariables: GlobalVariables, l1ToL2Messages: Fr[], verificationKeys: VerificationKeys): Promise<ProvingTicket>;
+    /**
+     * The interface to add a simulated transaction to the scheduler
+     * @param tx - The transaction to be proven
+     */
+    addNewTx(tx: ProcessedTx): Promise<void>;
+    /**
+     * Marks the block as full and pads it to the full power of 2 block size, no more transactions will be accepted.
+     */
+    setBlockCompleted(): Promise<void>;
+    private enqueuePaddingTxs;
+    /**
+     * 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
+     */
+    private provePaddingTransactions;
+    /**
+     * Cancel any further proving of the block
+     */
+    cancelBlock(): void;
+    /**
+     * Performs the final tree update for the block and returns the fully proven block.
+     * @returns The fully proven block and proof.
+     */
+    finaliseBlock(): Promise<BlockResult>;
+    /**
+     * Starts the proving process for the given transaction and adds it to our state
+     * @param tx - The transaction whose proving we wish to commence
+     * @param provingState - The proving state being worked on
+     */
+    private prepareTransaction;
+    private enqueueFirstProof;
+    /**
+     * Enqueue a job to be scheduled
+     * @param provingState - The proving state object being operated on
+     * @param jobType - The type of job to be queued
+     * @param job - The actual job, returns a promise notifying of the job's completion
+     */
+    private deferredProving;
+    private prepareBaseRollupInputs;
+    private storeMergeInputs;
+    private enqueueBaseRollup;
+    private enqueueMergeRollup;
+    private enqueueRootRollup;
+    private enqueueBaseParityCircuit;
+    private enqueueRootParityCircuit;
+    private checkAndEnqueueRootRollup;
+    /**
+     * 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
+     */
+    private storeAndExecuteNextMergeLevel;
+    /**
+     * 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
+     */
+    private enqueueVM;
+    private checkAndEnqueuePublicKernel;
+    /**
+     * 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
+     */
+    private enqueuePublicKernel;
+}
+//# sourceMappingURL=orchestrator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../src/orchestrator/orchestrator.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,WAAW,EAOjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAEL,KAAK,WAAW,EAGhB,KAAK,aAAa,EAElB,KAAK,mBAAmB,EACzB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAML,EAAE,EACF,KAAK,eAAe,EACpB,KAAK,MAAM,EAeX,KAAK,gBAAgB,EAEtB,MAAM,oBAAoB,CAAC;AAQ5B,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAmB/D;;;;;;;;;GASG;AAEH;;GAEG;AACH,qBAAa,mBAAmB;IAKlB,OAAO,CAAC,EAAE;IAAwB,OAAO,CAAC,MAAM;IAAuB,OAAO,CAAC,aAAa,CAAC;IAJzG,OAAO,CAAC,YAAY,CAAuC;IAC3D,OAAO,CAAC,kBAAkB,CAAyB;IACnD,OAAO,CAAC,SAAS,CAA6C;gBAE1C,EAAE,EAAE,oBAAoB,EAAU,MAAM,EAAE,mBAAmB,EAAU,aAAa,CAAC,oBAAQ;IAEjH;;OAEG;IACI,KAAK;IAIZ;;;;;;;OAOG;IACU,aAAa,CACxB,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,eAAe,EAChC,cAAc,EAAE,EAAE,EAAE,EACpB,gBAAgB,EAAE,gBAAgB,GACjC,OAAO,CAAC,aAAa,CAAC;IA4EzB;;;OAGG;IACU,QAAQ,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBrD;;OAEG;IACU,iBAAiB;IAqC9B,OAAO,CAAC,iBAAiB;IAkCzB;;;;;OAKG;IACH,OAAO,CAAC,wBAAwB;IAchC;;OAEG;IACI,WAAW;IAQlB;;;OAGG;IACU,aAAa;IAoE1B;;;;OAIG;YACW,kBAAkB;IAahC,OAAO,CAAC,iBAAiB;IA4BzB;;;;;OAKG;IACH,OAAO,CAAC,eAAe;YAyDT,uBAAuB;IAyBrC,OAAO,CAAC,gBAAgB;IAqBxB,OAAO,CAAC,iBAAiB;IAmEzB,OAAO,CAAC,kBAAkB;YAyBZ,iBAAiB;IA2C/B,OAAO,CAAC,wBAAwB;IAqBhC,OAAO,CAAC,wBAAwB;YAWlB,yBAAyB;IAQvC;;;;;;OAMG;IACH,OAAO,CAAC,6BAA6B;IA0BrC;;;;;;OAMG;IACH,OAAO,CAAC,SAAS;IAyCjB,OAAO,CAAC,2BAA2B;IAkBnC;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;CAiD5B"}