@aztec/prover-client 0.42.0

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

@@ -0,0 +1,68 @@
+import { type L2Block, type MerkleTreeId, type ProvingResult } from '@aztec/circuit-types';
+import { type AppendOnlyTreeSnapshot, type BaseOrMergeRollupPublicInputs, type Fr, type GlobalVariables, type L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, type NESTED_RECURSIVE_PROOF_LENGTH, type NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, type Proof, type RECURSIVE_PROOF_LENGTH, type RecursiveProof, type RootParityInput, type RootRollupPublicInputs, type VerificationKeyAsFields, type VerificationKeys } from '@aztec/circuits.js';
+import { type Tuple } from '@aztec/foundation/serialize';
+import { type TxProvingState } from './tx-proving-state.js';
+export type MergeRollupInputData = {
+    inputs: [BaseOrMergeRollupPublicInputs | undefined, BaseOrMergeRollupPublicInputs | undefined];
+    proofs: [
+        RecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH> | undefined,
+        RecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH> | undefined
+    ];
+    verificationKeys: [VerificationKeyAsFields | undefined, VerificationKeyAsFields | undefined];
+};
+export type TreeSnapshots = Map<MerkleTreeId, AppendOnlyTreeSnapshot>;
+/**
+ * The current state of the proving schedule. Contains the raw inputs (txs) and intermediate state to generate every constituent proof in the tree.
+ * Carries an identifier so we can identify if the proving state is discarded and a new one started.
+ * Captures resolve and reject callbacks to provide a promise base interface to the consumer of our proving.
+ */
+export declare class ProvingState {
+    readonly totalNumTxs: number;
+    private completionCallback;
+    private rejectionCallback;
+    readonly globalVariables: GlobalVariables;
+    readonly newL1ToL2Messages: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>;
+    readonly messageTreeSnapshot: AppendOnlyTreeSnapshot;
+    readonly messageTreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>;
+    readonly privateKernelVerificationKeys: VerificationKeys;
+    private provingStateLifecycle;
+    private mergeRollupInputs;
+    private rootParityInputs;
+    private finalRootParityInputs;
+    rootRollupPublicInputs: RootRollupPublicInputs | undefined;
+    finalAggregationObject: Fr[] | undefined;
+    finalProof: Proof | undefined;
+    block: L2Block | undefined;
+    private txs;
+    constructor(totalNumTxs: number, completionCallback: (result: ProvingResult) => void, rejectionCallback: (reason: string) => void, globalVariables: GlobalVariables, newL1ToL2Messages: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>, numRootParityInputs: number, messageTreeSnapshot: AppendOnlyTreeSnapshot, messageTreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>, privateKernelVerificationKeys: VerificationKeys);
+    get numMergeLevels(): bigint;
+    addNewTx(tx: TxProvingState): number;
+    get transactionsReceived(): number;
+    get finalRootParityInput(): RootParityInput<typeof NESTED_RECURSIVE_PROOF_LENGTH> | undefined;
+    set finalRootParityInput(input: RootParityInput<typeof NESTED_RECURSIVE_PROOF_LENGTH> | undefined);
+    get rootParityInput(): (RootParityInput<93> | undefined)[];
+    verifyState(): boolean;
+    isAcceptingTransactions(): boolean;
+    get allTxs(): TxProvingState[];
+    /**
+     * Stores the inputs to a merge circuit and determines if the circuit is ready to be executed
+     * @param mergeInputs - The inputs to store
+     * @param indexWithinMerge - The index in the set of inputs to this merge circuit
+     * @param indexOfMerge - The global index of this merge circuit
+     * @returns True if the merge circuit is ready to be executed, false otherwise
+     */
+    storeMergeInputs(mergeInputs: [
+        BaseOrMergeRollupPublicInputs,
+        RecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>,
+        VerificationKeyAsFields
+    ], indexWithinMerge: number, indexOfMerge: number): boolean;
+    getTxProvingState(txIndex: number): TxProvingState;
+    getMergeInputs(indexOfMerge: number): MergeRollupInputData;
+    isReadyForRootRollup(): boolean;
+    setRootParityInputs(inputs: RootParityInput<typeof RECURSIVE_PROOF_LENGTH>, index: number): void;
+    areRootParityInputsReady(): boolean;
+    cancel(): void;
+    reject(reason: string): void;
+    resolve(result: ProvingResult): void;
+}
+//# sourceMappingURL=proving-state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"proving-state.d.ts","sourceRoot":"","sources":["../../src/orchestrator/proving-state.ts"],"names":[],"mappings":"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"}

package/dest/orchestrator/proving-state.js

@@ -0,0 +1,142 @@
+var PROVING_STATE_LIFECYCLE;
+(function (PROVING_STATE_LIFECYCLE) {
+    PROVING_STATE_LIFECYCLE[PROVING_STATE_LIFECYCLE["PROVING_STATE_CREATED"] = 0] = "PROVING_STATE_CREATED";
+    PROVING_STATE_LIFECYCLE[PROVING_STATE_LIFECYCLE["PROVING_STATE_FULL"] = 1] = "PROVING_STATE_FULL";
+    PROVING_STATE_LIFECYCLE[PROVING_STATE_LIFECYCLE["PROVING_STATE_RESOLVED"] = 2] = "PROVING_STATE_RESOLVED";
+    PROVING_STATE_LIFECYCLE[PROVING_STATE_LIFECYCLE["PROVING_STATE_REJECTED"] = 3] = "PROVING_STATE_REJECTED";
+})(PROVING_STATE_LIFECYCLE || (PROVING_STATE_LIFECYCLE = {}));
+/**
+ * The current state of the proving schedule. Contains the raw inputs (txs) and intermediate state to generate every constituent proof in the tree.
+ * Carries an identifier so we can identify if the proving state is discarded and a new one started.
+ * Captures resolve and reject callbacks to provide a promise base interface to the consumer of our proving.
+ */
+export class ProvingState {
+    constructor(totalNumTxs, completionCallback, rejectionCallback, globalVariables, newL1ToL2Messages, numRootParityInputs, messageTreeSnapshot, messageTreeRootSiblingPath, privateKernelVerificationKeys) {
+        this.totalNumTxs = totalNumTxs;
+        this.completionCallback = completionCallback;
+        this.rejectionCallback = rejectionCallback;
+        this.globalVariables = globalVariables;
+        this.newL1ToL2Messages = newL1ToL2Messages;
+        this.messageTreeSnapshot = messageTreeSnapshot;
+        this.messageTreeRootSiblingPath = messageTreeRootSiblingPath;
+        this.privateKernelVerificationKeys = privateKernelVerificationKeys;
+        this.provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED;
+        this.mergeRollupInputs = [];
+        this.rootParityInputs = [];
+        this.txs = [];
+        this.rootParityInputs = Array.from({ length: numRootParityInputs }).map(_ => undefined);
+    }
+    // Returns the number of levels of merge rollups
+    get numMergeLevels() {
+        return BigInt(Math.ceil(Math.log2(this.totalNumTxs)) - 1);
+    }
+    // Adds a transaction to the proving state, returns it's index
+    // Will update the proving life cycle if this is the last transaction
+    addNewTx(tx) {
+        this.txs.push(tx);
+        if (this.txs.length === this.totalNumTxs) {
+            this.provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_FULL;
+        }
+        return this.txs.length - 1;
+    }
+    // Returns the number of received transactions
+    get transactionsReceived() {
+        return this.txs.length;
+    }
+    // Returns the final set of root parity inputs
+    get finalRootParityInput() {
+        return this.finalRootParityInputs;
+    }
+    // Sets the final set of root parity inputs
+    set finalRootParityInput(input) {
+        this.finalRootParityInputs = input;
+    }
+    // Returns the set of root parity inputs
+    get rootParityInput() {
+        return this.rootParityInputs;
+    }
+    // Returns true if this proving state is still valid, false otherwise
+    verifyState() {
+        return (this.provingStateLifecycle === PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED ||
+            this.provingStateLifecycle === PROVING_STATE_LIFECYCLE.PROVING_STATE_FULL);
+    }
+    // Returns true if we are still able to accept transactions, false otherwise
+    isAcceptingTransactions() {
+        return this.provingStateLifecycle === PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED;
+    }
+    // Returns the complete set of transaction proving state objects
+    get allTxs() {
+        return this.txs;
+    }
+    /**
+     * Stores the inputs to a merge circuit and determines if the circuit is ready to be executed
+     * @param mergeInputs - The inputs to store
+     * @param indexWithinMerge - The index in the set of inputs to this merge circuit
+     * @param indexOfMerge - The global index of this merge circuit
+     * @returns True if the merge circuit is ready to be executed, false otherwise
+     */
+    storeMergeInputs(mergeInputs, indexWithinMerge, indexOfMerge) {
+        if (!this.mergeRollupInputs[indexOfMerge]) {
+            const mergeInputData = {
+                inputs: [undefined, undefined],
+                proofs: [undefined, undefined],
+                verificationKeys: [undefined, undefined],
+            };
+            mergeInputData.inputs[indexWithinMerge] = mergeInputs[0];
+            mergeInputData.proofs[indexWithinMerge] = mergeInputs[1];
+            mergeInputData.verificationKeys[indexWithinMerge] = mergeInputs[2];
+            this.mergeRollupInputs[indexOfMerge] = mergeInputData;
+            return false;
+        }
+        const mergeInputData = this.mergeRollupInputs[indexOfMerge];
+        mergeInputData.inputs[indexWithinMerge] = mergeInputs[0];
+        mergeInputData.proofs[indexWithinMerge] = mergeInputs[1];
+        mergeInputData.verificationKeys[indexWithinMerge] = mergeInputs[2];
+        return true;
+    }
+    // Returns a specific transaction proving state
+    getTxProvingState(txIndex) {
+        return this.txs[txIndex];
+    }
+    // Returns a set of merge rollup inputs
+    getMergeInputs(indexOfMerge) {
+        return this.mergeRollupInputs[indexOfMerge];
+    }
+    // Returns true if we have sufficient inputs to execute the root rollup
+    isReadyForRootRollup() {
+        return !(this.mergeRollupInputs[0] === undefined ||
+            this.finalRootParityInput === undefined ||
+            this.mergeRollupInputs[0].inputs.findIndex(p => !p) !== -1);
+    }
+    // Stores a set of root parity inputs at the given index
+    setRootParityInputs(inputs, index) {
+        this.rootParityInputs[index] = inputs;
+    }
+    // Returns true if we have sufficient root parity inputs to execute the root parity circuit
+    areRootParityInputsReady() {
+        return this.rootParityInputs.findIndex(p => !p) === -1;
+    }
+    // Attempts to reject the proving state promise with a reason of 'cancelled'
+    cancel() {
+        this.reject('Proving cancelled');
+    }
+    // Attempts to reject the proving state promise with the given reason
+    // Does nothing if not in a valid state
+    reject(reason) {
+        if (!this.verifyState()) {
+            return;
+        }
+        this.provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_REJECTED;
+        this.rejectionCallback(reason);
+    }
+    // Attempts to resolve the proving state promise with the given result
+    // Does nothing if not in a valid state
+    resolve(result) {
+        if (!this.verifyState()) {
+            return;
+        }
+        this.provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_RESOLVED;
+        this.completionCallback(result);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmluZy1zdGF0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9vcmNoZXN0cmF0b3IvcHJvdmluZy1zdGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFnQ0EsSUFBSyx1QkFLSjtBQUxELFdBQUssdUJBQXVCO0lBQzFCLHVHQUFxQixDQUFBO0lBQ3JCLGlHQUFrQixDQUFBO0lBQ2xCLHlHQUFzQixDQUFBO0lBQ3RCLHlHQUFzQixDQUFBO0FBQ3hCLENBQUMsRUFMSSx1QkFBdUIsS0FBdkIsdUJBQXVCLFFBSzNCO0FBRUQ7Ozs7R0FJRztBQUNILE1BQU0sT0FBTyxZQUFZO0lBVXZCLFlBQ2tCLFdBQW1CLEVBQzNCLGtCQUFtRCxFQUNuRCxpQkFBMkMsRUFDbkMsZUFBZ0MsRUFDaEMsaUJBQXdFLEVBQ3hGLG1CQUEyQixFQUNYLG1CQUEyQyxFQUMzQywwQkFBc0YsRUFDdEYsNkJBQStDO1FBUi9DLGdCQUFXLEdBQVgsV0FBVyxDQUFRO1FBQzNCLHVCQUFrQixHQUFsQixrQkFBa0IsQ0FBaUM7UUFDbkQsc0JBQWlCLEdBQWpCLGlCQUFpQixDQUEwQjtRQUNuQyxvQkFBZSxHQUFmLGVBQWUsQ0FBaUI7UUFDaEMsc0JBQWlCLEdBQWpCLGlCQUFpQixDQUF1RDtRQUV4RSx3QkFBbUIsR0FBbkIsbUJBQW1CLENBQXdCO1FBQzNDLCtCQUEwQixHQUExQiwwQkFBMEIsQ0FBNEQ7UUFDdEYsa0NBQTZCLEdBQTdCLDZCQUE2QixDQUFrQjtRQWxCekQsMEJBQXFCLEdBQUcsdUJBQXVCLENBQUMscUJBQXFCLENBQUM7UUFDdEUsc0JBQWlCLEdBQTJCLEVBQUUsQ0FBQztRQUMvQyxxQkFBZ0IsR0FBc0UsRUFBRSxDQUFDO1FBTXpGLFFBQUcsR0FBcUIsRUFBRSxDQUFDO1FBWWpDLElBQUksQ0FBQyxnQkFBZ0IsR0FBRyxLQUFLLENBQUMsSUFBSSxDQUFDLEVBQUUsTUFBTSxFQUFFLG1CQUFtQixFQUFFLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUMxRixDQUFDO0lBRUQsZ0RBQWdEO0lBQ2hELElBQVcsY0FBYztRQUN2QixPQUFPLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFDNUQsQ0FBQztJQUVELDhEQUE4RDtJQUM5RCxxRUFBcUU7SUFDOUQsUUFBUSxDQUFDLEVBQWtCO1FBQ2hDLElBQUksQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDO1FBQ2xCLElBQUksSUFBSSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEtBQUssSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO1lBQ3pDLElBQUksQ0FBQyxxQkFBcUIsR0FBRyx1QkFBdUIsQ0FBQyxrQkFBa0IsQ0FBQztRQUMxRSxDQUFDO1FBQ0QsT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUM7SUFDN0IsQ0FBQztJQUVELDhDQUE4QztJQUM5QyxJQUFXLG9CQUFvQjtRQUM3QixPQUFPLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDO0lBQ3pCLENBQUM7SUFFRCw4Q0FBOEM7SUFDOUMsSUFBVyxvQkFBb0I7UUFDN0IsT0FBTyxJQUFJLENBQUMscUJBQXFCLENBQUM7SUFDcEMsQ0FBQztJQUVELDJDQUEyQztJQUMzQyxJQUFXLG9CQUFvQixDQUFDLEtBQXdFO1FBQ3RHLElBQUksQ0FBQyxxQkFBcUIsR0FBRyxLQUFLLENBQUM7SUFDckMsQ0FBQztJQUVELHdDQUF3QztJQUN4QyxJQUFXLGVBQWU7UUFDeEIsT0FBTyxJQUFJLENBQUMsZ0JBQWdCLENBQUM7SUFDL0IsQ0FBQztJQUVELHFFQUFxRTtJQUM5RCxXQUFXO1FBQ2hCLE9BQU8sQ0FDTCxJQUFJLENBQUMscUJBQXFCLEtBQUssdUJBQXVCLENBQUMscUJBQXFCO1lBQzVFLElBQUksQ0FBQyxxQkFBcUIsS0FBSyx1QkFBdUIsQ0FBQyxrQkFBa0IsQ0FDMUUsQ0FBQztJQUNKLENBQUM7SUFFRCw0RUFBNEU7SUFDckUsdUJBQXVCO1FBQzVCLE9BQU8sSUFBSSxDQUFDLHFCQUFxQixLQUFLLHVCQUF1QixDQUFDLHFCQUFxQixDQUFDO0lBQ3RGLENBQUM7SUFFRCxnRUFBZ0U7SUFDaEUsSUFBVyxNQUFNO1FBQ2YsT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDO0lBQ2xCLENBQUM7SUFFRDs7Ozs7O09BTUc7SUFDSSxnQkFBZ0IsQ0FDckIsV0FJQyxFQUNELGdCQUF3QixFQUN4QixZQUFvQjtRQUVwQixJQUFJLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLFlBQVksQ0FBQyxFQUFFLENBQUM7WUFDMUMsTUFBTSxjQUFjLEdBQXlCO2dCQUMzQyxNQUFNLEVBQUUsQ0FBQyxTQUFTLEVBQUUsU0FBUyxDQUFDO2dCQUM5QixNQUFNLEVBQUUsQ0FBQyxTQUFTLEVBQUUsU0FBUyxDQUFDO2dCQUM5QixnQkFBZ0IsRUFBRSxDQUFDLFNBQVMsRUFBRSxTQUFTLENBQUM7YUFDekMsQ0FBQztZQUNGLGNBQWMsQ0FBQyxNQUFNLENBQUMsZ0JBQWdCLENBQUMsR0FBRyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDekQsY0FBYyxDQUFDLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxHQUFHLFdBQVcsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUN6RCxjQUFjLENBQUMsZ0JBQWdCLENBQUMsZ0JBQWdCLENBQUMsR0FBRyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDbkUsSUFBSSxDQUFDLGlCQUFpQixDQUFDLFlBQVksQ0FBQyxHQUFHLGNBQWMsQ0FBQztZQUN0RCxPQUFPLEtBQUssQ0FBQztRQUNmLENBQUM7UUFDRCxNQUFNLGNBQWMsR0FBRyxJQUFJLENBQUMsaUJBQWlCLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDNUQsY0FBYyxDQUFDLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxHQUFHLFdBQVcsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUN6RCxjQUFjLENBQUMsTUFBTSxDQUFDLGdCQUFnQixDQUFDLEdBQUcsV0FBVyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ3pELGNBQWMsQ0FBQyxnQkFBZ0IsQ0FBQyxnQkFBZ0IsQ0FBQyxHQUFHLFdBQVcsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNuRSxPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7SUFFRCwrQ0FBK0M7SUFDeEMsaUJBQWlCLENBQUMsT0FBZTtRQUN0QyxPQUFPLElBQUksQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDM0IsQ0FBQztJQUVELHVDQUF1QztJQUNoQyxjQUFjLENBQUMsWUFBb0I7UUFDeEMsT0FBTyxJQUFJLENBQUMsaUJBQWlCLENBQUMsWUFBWSxDQUFDLENBQUM7SUFDOUMsQ0FBQztJQUVELHVFQUF1RTtJQUNoRSxvQkFBb0I7UUFDekIsT0FBTyxDQUFDLENBQ04sSUFBSSxDQUFDLGlCQUFpQixDQUFDLENBQUMsQ0FBQyxLQUFLLFNBQVM7WUFDdkMsSUFBSSxDQUFDLG9CQUFvQixLQUFLLFNBQVM7WUFDdkMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUMzRCxDQUFDO0lBQ0osQ0FBQztJQUVELHdEQUF3RDtJQUNqRCxtQkFBbUIsQ0FBQyxNQUFzRCxFQUFFLEtBQWE7UUFDOUYsSUFBSSxDQUFDLGdCQUFnQixDQUFDLEtBQUssQ0FBQyxHQUFHLE1BQU0sQ0FBQztJQUN4QyxDQUFDO0lBRUQsMkZBQTJGO0lBQ3BGLHdCQUF3QjtRQUM3QixPQUFPLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO0lBQ3pELENBQUM7SUFFRCw0RUFBNEU7SUFDckUsTUFBTTtRQUNYLElBQUksQ0FBQyxNQUFNLENBQUMsbUJBQW1CLENBQUMsQ0FBQztJQUNuQyxDQUFDO0lBRUQscUVBQXFFO0lBQ3JFLHVDQUF1QztJQUNoQyxNQUFNLENBQUMsTUFBYztRQUMxQixJQUFJLENBQUMsSUFBSSxDQUFDLFdBQVcsRUFBRSxFQUFFLENBQUM7WUFDeEIsT0FBTztRQUNULENBQUM7UUFDRCxJQUFJLENBQUMscUJBQXFCLEdBQUcsdUJBQXVCLENBQUMsc0JBQXNCLENBQUM7UUFDNUUsSUFBSSxDQUFDLGlCQUFpQixDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ2pDLENBQUM7SUFFRCxzRUFBc0U7SUFDdEUsdUNBQXVDO0lBQ2hDLE9BQU8sQ0FBQyxNQUFxQjtRQUNsQyxJQUFJLENBQUMsSUFBSSxDQUFDLFdBQVcsRUFBRSxFQUFFLENBQUM7WUFDeEIsT0FBTztRQUNULENBQUM7UUFDRCxJQUFJLENBQUMscUJBQXFCLEdBQUcsdUJBQXVCLENBQUMsc0JBQXNCLENBQUM7UUFDNUUsSUFBSSxDQUFDLGtCQUFrQixDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ2xDLENBQUM7Q0FDRiJ9

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

@@ -0,0 +1,35 @@
+import { type AvmProvingRequest, type MerkleTreeId, type ProcessedTx, type PublicKernelRequest, PublicKernelType } from '@aztec/circuit-types';
+import { type AppendOnlyTreeSnapshot, type BaseRollupInputs, NESTED_RECURSIVE_PROOF_LENGTH, type Proof, type RecursiveProof, type VerificationKeyData } from '@aztec/circuits.js';
+export declare enum TX_PROVING_CODE {
+    NOT_READY = 0,
+    READY = 1,
+    COMPLETED = 2
+}
+export type PublicFunction = {
+    vmRequest: AvmProvingRequest | undefined;
+    vmProof: Proof | undefined;
+    previousProofType: PublicKernelType;
+    previousKernelProven: boolean;
+    publicKernelRequest: PublicKernelRequest;
+};
+export type TxProvingInstruction = {
+    code: TX_PROVING_CODE;
+    function: PublicFunction | undefined;
+};
+/**
+ * Helper class to manage the proving cycle of a transaction
+ * This includes the public VMs and the public kernels
+ * Also stores the inputs to the base rollup for this transaction and the tree snapshots
+ */
+export declare class TxProvingState {
+    readonly processedTx: ProcessedTx;
+    readonly baseRollupInputs: BaseRollupInputs;
+    readonly treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>;
+    private publicFunctions;
+    constructor(processedTx: ProcessedTx, baseRollupInputs: BaseRollupInputs, treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>, privateKernelVk: VerificationKeyData);
+    getNextPublicKernelFromKernelProof(provenIndex: number, proof: RecursiveProof<typeof NESTED_RECURSIVE_PROOF_LENGTH>, verificationKey: VerificationKeyData): TxProvingInstruction;
+    getNextPublicKernelFromVMProof(provenIndex: number, proof: Proof): TxProvingInstruction;
+    getPublicFunctionState(functionIndex: number): PublicFunction;
+    getNumPublicKernels(): number;
+}
+//# sourceMappingURL=tx-proving-state.d.ts.map

package/dest/orchestrator/tx-proving-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx-proving-state.d.ts","sourceRoot":"","sources":["../../src/orchestrator/tx-proving-state.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,gBAAgB,EACjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACrB,6BAA6B,EAC7B,KAAK,KAAK,EACV,KAAK,cAAc,EACnB,KAAK,mBAAmB,EAEzB,MAAM,oBAAoB,CAAC;AAE5B,oBAAY,eAAe;IACzB,SAAS,IAAA;IACT,KAAK,IAAA;IACL,SAAS,IAAA;CACV;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACzC,OAAO,EAAE,KAAK,GAAG,SAAS,CAAC;IAC3B,iBAAiB,EAAE,gBAAgB,CAAC;IACpC,oBAAoB,EAAE,OAAO,CAAC;IAC9B,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAIF,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,eAAe,CAAC;IACtB,QAAQ,EAAE,cAAc,GAAG,SAAS,CAAC;CACtC,CAAC;AAEF;;;;GAIG;AACH,qBAAa,cAAc;aAIP,WAAW,EAAE,WAAW;aACxB,gBAAgB,EAAE,gBAAgB;aAClC,aAAa,EAAE,GAAG,CAAC,YAAY,EAAE,sBAAsB,CAAC;IAL1E,OAAO,CAAC,eAAe,CAAwB;gBAG7B,WAAW,EAAE,WAAW,EACxB,gBAAgB,EAAE,gBAAgB,EAClC,aAAa,EAAE,GAAG,CAAC,YAAY,EAAE,sBAAsB,CAAC,EACxE,eAAe,EAAE,mBAAmB;IA6B/B,kCAAkC,CACvC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,cAAc,CAAC,OAAO,6BAA6B,CAAC,EAC3D,eAAe,EAAE,mBAAmB,GACnC,oBAAoB;IA6BhB,8BAA8B,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,oBAAoB;IAcvF,sBAAsB,CAAC,aAAa,EAAE,MAAM;IAQ5C,mBAAmB;CAG3B"}

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

@@ -0,0 +1,92 @@
+import { AVM_REQUEST, PublicKernelType, } from '@aztec/circuit-types';
+import { NESTED_RECURSIVE_PROOF_LENGTH, makeRecursiveProofFromBinary, } from '@aztec/circuits.js';
+export var TX_PROVING_CODE;
+(function (TX_PROVING_CODE) {
+    TX_PROVING_CODE[TX_PROVING_CODE["NOT_READY"] = 0] = "NOT_READY";
+    TX_PROVING_CODE[TX_PROVING_CODE["READY"] = 1] = "READY";
+    TX_PROVING_CODE[TX_PROVING_CODE["COMPLETED"] = 2] = "COMPLETED";
+})(TX_PROVING_CODE || (TX_PROVING_CODE = {}));
+/**
+ * Helper class to manage the proving cycle of a transaction
+ * This includes the public VMs and the public kernels
+ * Also stores the inputs to the base rollup for this transaction and the tree snapshots
+ */
+export class TxProvingState {
+    constructor(processedTx, baseRollupInputs, treeSnapshots, privateKernelVk) {
+        this.processedTx = processedTx;
+        this.baseRollupInputs = baseRollupInputs;
+        this.treeSnapshots = treeSnapshots;
+        this.publicFunctions = [];
+        let previousKernelProof = makeRecursiveProofFromBinary(processedTx.proof, NESTED_RECURSIVE_PROOF_LENGTH);
+        let previousProofType = PublicKernelType.NON_PUBLIC;
+        for (let i = 0; i < processedTx.publicProvingRequests.length; i++) {
+            const provingRequest = processedTx.publicProvingRequests[i];
+            const kernelRequest = provingRequest.type === AVM_REQUEST ? provingRequest.kernelRequest : provingRequest;
+            // the first circuit has a valid previous proof, it came from private
+            if (previousKernelProof) {
+                kernelRequest.inputs.previousKernel.proof = previousKernelProof;
+                kernelRequest.inputs.previousKernel.vk = privateKernelVk;
+            }
+            const vmRequest = provingRequest.type === AVM_REQUEST ? provingRequest : undefined;
+            const publicFunction = {
+                vmRequest,
+                vmProof: undefined,
+                previousProofType,
+                previousKernelProven: i === 0,
+                publicKernelRequest: kernelRequest,
+            };
+            this.publicFunctions.push(publicFunction);
+            previousKernelProof = undefined;
+            previousProofType = kernelRequest.type;
+        }
+    }
+    // Updates the transaction's proving state after completion of a kernel proof
+    // Returns an instruction as to the next stage of tx proving
+    getNextPublicKernelFromKernelProof(provenIndex, proof, verificationKey) {
+        const kernelRequest = this.getPublicFunctionState(provenIndex).publicKernelRequest;
+        const nextKernelIndex = provenIndex + 1;
+        if (nextKernelIndex >= this.publicFunctions.length) {
+            // The next kernel index is greater than our set of functions, we are done!
+            return { code: TX_PROVING_CODE.COMPLETED, function: undefined };
+        }
+        // There is more work to do, are we ready?
+        const nextFunction = this.publicFunctions[nextKernelIndex];
+        // pass both the proof and verification key forward to the next circuit
+        nextFunction.publicKernelRequest.inputs.previousKernel.proof = proof;
+        nextFunction.publicKernelRequest.inputs.previousKernel.vk = verificationKey;
+        // We need to update this so the state machine knows this proof is ready
+        nextFunction.previousKernelProven = true;
+        nextFunction.previousProofType = kernelRequest.type;
+        if (nextFunction.vmProof === undefined) {
+            // The VM proof for the next function is not ready
+            return { code: TX_PROVING_CODE.NOT_READY, function: undefined };
+        }
+        // The VM proof is ready, we can continue
+        return { code: TX_PROVING_CODE.READY, function: nextFunction };
+    }
+    // Updates the transaction's proving state after completion of a VM proof
+    // Returns an instruction as to the next stage of tx proving
+    getNextPublicKernelFromVMProof(provenIndex, proof) {
+        const provenFunction = this.publicFunctions[provenIndex];
+        provenFunction.vmProof = proof;
+        if (!provenFunction.previousKernelProven) {
+            // The previous kernel is not yet ready
+            return { code: TX_PROVING_CODE.NOT_READY, function: undefined };
+        }
+        // The previous kernel is ready so we can prove this kernel
+        return { code: TX_PROVING_CODE.READY, function: provenFunction };
+    }
+    // Returns the public function state at the given index
+    // Throws if out of bounds
+    getPublicFunctionState(functionIndex) {
+        if (functionIndex < 0 || functionIndex >= this.publicFunctions.length) {
+            throw new Error(`Requested public function index was out of bounds`);
+        }
+        return this.publicFunctions[functionIndex];
+    }
+    // Returns the number of public kernels required by this transaction
+    getNumPublicKernels() {
+        return this.publicFunctions.length;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/prover-agent/index.d.ts

@@ -0,0 +1,4 @@
+export * from './prover-agent.js';
+export * from './memory-proving-queue.js';
+export * from './rpc.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/prover-agent/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/prover-agent/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,UAAU,CAAC"}

package/dest/prover-agent/index.js

@@ -0,0 +1,4 @@
+export * from './prover-agent.js';
+export * from './memory-proving-queue.js';
+export * from './rpc.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvdmVyLWFnZW50L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLFVBQVUsQ0FBQyJ9

package/dest/prover-agent/memory-proving-queue.d.ts

@@ -0,0 +1,64 @@
+import { type ProofAndVerificationKey, type ProvingJob, type ProvingJobSource, type ProvingRequest, type ProvingRequestResult, ProvingRequestType, type PublicInputsAndRecursiveProof, type PublicKernelNonTailRequest, type PublicKernelTailRequest, type ServerCircuitProver } from '@aztec/circuit-types';
+import type { AvmCircuitInputs, BaseOrMergeRollupPublicInputs, BaseParityInputs, BaseRollupInputs, KernelCircuitPublicInputs, MergeRollupInputs, NESTED_RECURSIVE_PROOF_LENGTH, PrivateKernelEmptyInputData, PublicKernelCircuitPublicInputs, RECURSIVE_PROOF_LENGTH, RootParityInput, RootParityInputs, RootRollupInputs, RootRollupPublicInputs } from '@aztec/circuits.js';
+/**
+ * A helper class that sits in between services that need proofs created and agents that can create them.
+ * The queue accumulates jobs and provides them to agents in FIFO order.
+ */
+export declare class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource {
+    private generateId;
+    private log;
+    private queue;
+    private jobsInProgress;
+    constructor(generateId?: () => string);
+    getProvingJob({ timeoutSec }?: {
+        timeoutSec?: number | undefined;
+    }): Promise<ProvingJob<ProvingRequest> | undefined>;
+    resolveProvingJob<T extends ProvingRequestType>(jobId: string, result: ProvingRequestResult<T>): Promise<void>;
+    rejectProvingJob(jobId: string, err: any): Promise<void>;
+    private enqueue;
+    getEmptyPrivateKernelProof(inputs: PrivateKernelEmptyInputData, signal?: AbortSignal): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>>;
+    /**
+     * Creates a proof for the given input.
+     * @param input - Input to the circuit.
+     */
+    getBaseParityProof(inputs: BaseParityInputs, signal?: AbortSignal): Promise<RootParityInput<typeof RECURSIVE_PROOF_LENGTH>>;
+    /**
+     * Creates a proof for the given input.
+     * @param input - Input to the circuit.
+     */
+    getRootParityProof(inputs: RootParityInputs, signal?: AbortSignal): Promise<RootParityInput<typeof NESTED_RECURSIVE_PROOF_LENGTH>>;
+    /**
+     * Creates a proof for the given input.
+     * @param input - Input to the circuit.
+     */
+    getBaseRollupProof(input: BaseRollupInputs, signal?: AbortSignal): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>>;
+    /**
+     * Creates a proof for the given input.
+     * @param input - Input to the circuit.
+     */
+    getMergeRollupProof(input: MergeRollupInputs, signal?: AbortSignal): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>>;
+    /**
+     * Creates a proof for the given input.
+     * @param input - Input to the circuit.
+     */
+    getRootRollupProof(input: RootRollupInputs, signal?: AbortSignal): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>>;
+    /**
+     * Create a public kernel proof.
+     * @param kernelRequest - Object containing the details of the proof required
+     */
+    getPublicKernelProof(kernelRequest: PublicKernelNonTailRequest, signal?: AbortSignal): Promise<PublicInputsAndRecursiveProof<PublicKernelCircuitPublicInputs>>;
+    /**
+     * Create a public kernel tail proof.
+     * @param kernelRequest - Object containing the details of the proof required
+     */
+    getPublicTailProof(kernelRequest: PublicKernelTailRequest, signal?: AbortSignal): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>>;
+    /**
+     * Creates an AVM proof.
+     */
+    getAvmProof(inputs: AvmCircuitInputs, signal?: AbortSignal | undefined): Promise<ProofAndVerificationKey>;
+    /**
+     * Verifies a circuit proof
+     */
+    verifyProof(): Promise<void>;
+}
+//# sourceMappingURL=memory-proving-queue.d.ts.map

package/dest/prover-agent/memory-proving-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-proving-queue.d.ts","sourceRoot":"","sources":["../../src/prover-agent/memory-proving-queue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,kBAAkB,EAClB,KAAK,6BAA6B,EAClC,KAAK,0BAA0B,EAC/B,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EACV,gBAAgB,EAChB,6BAA6B,EAC7B,gBAAgB,EAChB,gBAAgB,EAChB,yBAAyB,EACzB,iBAAiB,EACjB,6BAA6B,EAC7B,2BAA2B,EAC3B,+BAA+B,EAC/B,sBAAsB,EACtB,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,oBAAoB,CAAC;AAkB5B;;;GAGG;AACH,qBAAa,kBAAmB,YAAW,mBAAmB,EAAE,gBAAgB;IAKlE,OAAO,CAAC,UAAU;IAJ9B,OAAO,CAAC,GAAG,CAA8D;IACzE,OAAO,CAAC,KAAK,CAA6C;IAC1D,OAAO,CAAC,cAAc,CAA8C;gBAEhD,UAAU,eAAqB;IAE7C,aAAa,CAAC,EAAE,UAAc,EAAE;;KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IA0B7F,iBAAiB,CAAC,CAAC,SAAS,kBAAkB,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB9G,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IA2BxD,OAAO,CAAC,OAAO;IA8Bf,0BAA0B,CACxB,MAAM,EAAE,2BAA2B,EACnC,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,6BAA6B,CAAC,yBAAyB,CAAC,CAAC;IAIpE;;;OAGG;IACH,kBAAkB,CAChB,MAAM,EAAE,gBAAgB,EACxB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,eAAe,CAAC,OAAO,sBAAsB,CAAC,CAAC;IAU1D;;;OAGG;IACH,kBAAkB,CAChB,MAAM,EAAE,gBAAgB,EACxB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,eAAe,CAAC,OAAO,6BAA6B,CAAC,CAAC;IAUjE;;;OAGG;IACH,kBAAkB,CAChB,KAAK,EAAE,gBAAgB,EACvB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,6BAA6B,CAAC,6BAA6B,CAAC,CAAC;IAUxE;;;OAGG;IACH,mBAAmB,CACjB,KAAK,EAAE,iBAAiB,EACxB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,6BAA6B,CAAC,6BAA6B,CAAC,CAAC;IAUxE;;;OAGG;IACH,kBAAkB,CAChB,KAAK,EAAE,gBAAgB,EACvB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,6BAA6B,CAAC,sBAAsB,CAAC,CAAC;IAUjE;;;OAGG;IACH,oBAAoB,CAClB,aAAa,EAAE,0BAA0B,EACzC,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,6BAA6B,CAAC,+BAA+B,CAAC,CAAC;IAW1E;;;OAGG;IACH,kBAAkB,CAChB,aAAa,EAAE,uBAAuB,EACtC,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,6BAA6B,CAAC,yBAAyB,CAAC,CAAC;IAWpE;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAUzG;;OAEG;IACH,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}