@aztec/prover-client 0.0.0-test.1 → 0.0.1-commit.017a351

package/dest/orchestrator/top-tree-proving-scheduler.js

@@ -0,0 +1,73 @@
+import { ProvingScheduler } from './proving-scheduler.js';
+/**
+ * Shared scheduling for the top-tree section of epoch proving — checkpoint-merge,
+ * padding (single-checkpoint case), and root rollup. Both `ProvingOrchestrator` and
+ * `TopTreeOrchestrator` extend this; their per-checkpoint-root drivers diverge (one
+ * drains state-derived inputs once block-merge is done, the other builds inputs from
+ * caller-supplied checkpoint data), but the rest of the tree is identical.
+ *
+ * Subclasses provide a `wrapCircuitCall` hook for telemetry (the orchestrator wraps
+ * each call in a span; the top-tree leaves it as identity), and an
+ * `onRootRollupComplete` hook to invoke the right shape of `state.resolve()` —
+ * `EpochProvingState.resolve` takes a `ProvingResult`, `TopTreeProvingState.resolve`
+ * is no-arg.
+ */ export class TopTreeProvingScheduler extends ProvingScheduler {
+    prover;
+    constructor(prover, enqueueConcurrency, loggerName, bindings){
+        super(enqueueConcurrency, loggerName, bindings), this.prover = prover;
+    }
+    /**
+   * Wraps a circuit call for telemetry. Default is identity; the orchestrator overrides
+   * to wrap with `wrapCallbackInSpan`.
+   */ wrapCircuitCall(_circuitName, fn) {
+        return fn;
+    }
+    enqueueCheckpointMergeRollup(state, location) {
+        if (!state.verifyState() || !state.tryStartProvingCheckpointMerge(location)) {
+            return;
+        }
+        const inputs = state.getCheckpointMergeRollupInputs(location);
+        this.deferredProving(state, this.wrapCircuitCall('rollup-checkpoint-merge', (signal)=>this.prover.getCheckpointMergeRollupProof(inputs, signal, state.epochNumber)), (result)=>{
+            state.setCheckpointMergeRollupProof(location, result);
+            this.checkAndEnqueueNextCheckpointMergeRollup(state, location);
+        });
+    }
+    enqueueEpochPadding(state) {
+        if (!state.verifyState() || !state.tryStartProvingPaddingCheckpoint()) {
+            return;
+        }
+        const inputs = state.getPaddingCheckpointInputs();
+        this.deferredProving(state, this.wrapCircuitCall('rollup-checkpoint-padding', (signal)=>this.prover.getCheckpointPaddingRollupProof(inputs, signal, state.epochNumber)), (result)=>{
+            state.setCheckpointPaddingProof(result);
+            this.checkAndEnqueueRootRollup(state);
+        });
+    }
+    enqueueRootRollup(state) {
+        if (!state.verifyState() || !state.tryStartProvingRootRollup()) {
+            return;
+        }
+        const inputs = state.getRootRollupInputs();
+        this.deferredProving(state, this.wrapCircuitCall('rollup-root', (signal)=>this.prover.getRootRollupProof(inputs, signal, state.epochNumber)), (result)=>{
+            this.logger.verbose(`Completed root rollup for epoch ${state.epochNumber}`);
+            state.setRootRollupProof(result);
+            this.onRootRollupComplete(state);
+        });
+    }
+    checkAndEnqueueNextCheckpointMergeRollup(state, currentLocation) {
+        if (!state.isReadyForCheckpointMerge(currentLocation)) {
+            return;
+        }
+        const parentLocation = state.getParentLocation(currentLocation);
+        if (parentLocation.level === 0) {
+            this.checkAndEnqueueRootRollup(state);
+        } else {
+            this.enqueueCheckpointMergeRollup(state, parentLocation);
+        }
+    }
+    checkAndEnqueueRootRollup(state) {
+        if (!state.isReadyForRootRollup()) {
+            return;
+        }
+        this.enqueueRootRollup(state);
+    }
+}

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

@@ -0,0 +1,61 @@
+import type { BatchedBlob, BatchedBlobAccumulator, FinalBlobBatchingChallenges } from '@aztec/blob-lib';
+import type { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import { EpochNumber } from '@aztec/foundation/branded-types';
+import { type TreeNodeLocation } from '@aztec/foundation/trees';
+import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
+import type { Proof } from '@aztec/stdlib/proofs';
+import { CheckpointMergeRollupPrivateInputs, CheckpointPaddingRollupPrivateInputs, CheckpointRollupPublicInputs, RootRollupPrivateInputs, type RootRollupPublicInputs } from '@aztec/stdlib/rollup';
+/**
+ * Lean top-tree-only state. Owns the merge tree of checkpoint root proofs, the
+ * single-checkpoint padding proof slot, the final root rollup proof, and the blob
+ * accumulator endpoints needed to finalise the epoch's batched blob proof.
+ *
+ * Constructed with `totalNumCheckpoints` and `finalBlobBatchingChallenges` upfront —
+ * by the time the top tree starts, all checkpoints are known and the challenges are
+ * derivable from their blob fields.
+ */
+export declare class TopTreeProvingState {
+    #private;
+    readonly epochNumber: EpochNumber;
+    readonly totalNumCheckpoints: number;
+    readonly finalBlobBatchingChallenges: FinalBlobBatchingChallenges;
+    readonly startBlobAccumulator: BatchedBlobAccumulator;
+    private readonly completionCallback;
+    private readonly rejectionCallback;
+    private checkpointProofs;
+    private checkpointPaddingProof;
+    private rootRollupProof;
+    private endBlobAccumulator;
+    private finalBatchedBlob;
+    private lifecycle;
+    constructor(epochNumber: EpochNumber, totalNumCheckpoints: number, finalBlobBatchingChallenges: FinalBlobBatchingChallenges, startBlobAccumulator: BatchedBlobAccumulator, completionCallback: () => void, rejectionCallback: (reason: string) => void);
+    setCheckpointRootRollupProof(checkpointIndex: number, provingOutput: PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): TreeNodeLocation;
+    tryStartProvingCheckpointMerge(location: TreeNodeLocation): boolean;
+    setCheckpointMergeRollupProof(location: TreeNodeLocation, provingOutput: PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
+    isReadyForCheckpointMerge(location: TreeNodeLocation): boolean;
+    getParentLocation(location: TreeNodeLocation): TreeNodeLocation;
+    getCheckpointMergeRollupInputs(mergeLocation: TreeNodeLocation): CheckpointMergeRollupPrivateInputs;
+    tryStartProvingPaddingCheckpoint(): boolean;
+    setCheckpointPaddingProof(provingOutput: PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
+    getPaddingCheckpointInputs(): CheckpointPaddingRollupPrivateInputs;
+    tryStartProvingRootRollup(): boolean;
+    setRootRollupProof(provingOutput: PublicInputsAndRecursiveProof<RootRollupPublicInputs>): void;
+    isReadyForRootRollup(): boolean;
+    getRootRollupInputs(): RootRollupPrivateInputs;
+    /**
+     * Sets the end-of-epoch blob accumulator, computed by the top-tree orchestrator
+     * from the surviving checkpoints' blob fields. Required before `finalizeBatchedBlob`.
+     */
+    setEndBlobAccumulator(accumulator: BatchedBlobAccumulator): void;
+    finalizeBatchedBlob(): Promise<void>;
+    getEpochProofResult(): {
+        proof: Proof;
+        publicInputs: RootRollupPublicInputs;
+        batchedBlobInputs: BatchedBlob;
+    };
+    verifyState(): boolean;
+    resolve(): void;
+    reject(reason: string): void;
+    cancel(): void;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"top-tree-proving-state.d.ts","sourceRoot":"","sources":["../../src/orchestrator/top-tree-proving-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,sBAAsB,EAAE,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AACxG,OAAO,KAAK,EAAiC,yCAAyC,EAAE,MAAM,kBAAkB,CAAC;AACjH,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,KAAK,gBAAgB,EAAuB,MAAM,yBAAyB,CAAC;AACrF,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AACrF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EACL,kCAAkC,EAClC,oCAAoC,EACpC,4BAA4B,EAC5B,uBAAuB,EACvB,KAAK,sBAAsB,EAC5B,MAAM,sBAAsB,CAAC;AAW9B;;;;;;;;GAQG;AACH,qBAAa,mBAAmB;;aAaZ,WAAW,EAAE,WAAW;aACxB,mBAAmB,EAAE,MAAM;aAC3B,2BAA2B,EAAE,2BAA2B;aACxD,oBAAoB,EAAE,sBAAsB;IAC5D,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAjBpC,OAAO,CAAC,gBAAgB,CAEtB;IACF,OAAO,CAAC,sBAAsB,CAEhB;IACd,OAAO,CAAC,eAAe,CAAuF;IAC9G,OAAO,CAAC,kBAAkB,CAAqC;IAC/D,OAAO,CAAC,gBAAgB,CAA0B;IAClD,OAAO,CAAC,SAAS,CAA8B;IAE/C,YACkB,WAAW,EAAE,WAAW,EACxB,mBAAmB,EAAE,MAAM,EAC3B,2BAA2B,EAAE,2BAA2B,EACxD,oBAAoB,EAAE,sBAAsB,EAC3C,kBAAkB,EAAE,MAAM,IAAI,EAC9B,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EAM7D;IAIM,4BAA4B,CACjC,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,6BAA6B,CAC1C,4BAA4B,EAC5B,OAAO,yCAAyC,CACjD,GACA,gBAAgB,CAElB;IAIM,8BAA8B,CAAC,QAAQ,EAAE,gBAAgB,WAM/D;IAEM,6BAA6B,CAClC,QAAQ,EAAE,gBAAgB,EAC1B,aAAa,EAAE,6BAA6B,CAC1C,4BAA4B,EAC5B,OAAO,yCAAyC,CACjD,QAGF;IAEM,yBAAyB,CAAC,QAAQ,EAAE,gBAAgB,WAE1D;IAEM,iBAAiB,CAAC,QAAQ,EAAE,gBAAgB,oBAElD;IAEM,8BAA8B,CAAC,aAAa,EAAE,gBAAgB,sCAMpE;IAIM,gCAAgC,YAMtC;IAEM,yBAAyB,CAC9B,aAAa,EAAE,6BAA6B,CAC1C,4BAA4B,EAC5B,OAAO,yCAAyC,CACjD,QAGF;IAEM,0BAA0B,yCAEhC;IAIM,yBAAyB,YAM/B;IAEM,kBAAkB,CAAC,aAAa,EAAE,6BAA6B,CAAC,sBAAsB,CAAC,QAE7F;IAEM,oBAAoB,YAG1B;IAEM,mBAAmB,4BAQzB;IAID;;;OAGG;IACI,qBAAqB,CAAC,WAAW,EAAE,sBAAsB,QAE/D;IAEY,mBAAmB,kBAK/B;IAEM,mBAAmB,IAAI;QAAE,KAAK,EAAE,KAAK,CAAC;QAAC,YAAY,EAAE,sBAAsB,CAAC;QAAC,iBAAiB,EAAE,WAAW,CAAA;KAAE,CAUnH;IAIM,WAAW,YAEjB;IAEM,OAAO,SAMb;IAEM,MAAM,CAAC,MAAM,EAAE,MAAM,QAM3B;IAEM,MAAM,SAEZ;CAQF"}

package/dest/orchestrator/top-tree-proving-state.js

@@ -0,0 +1,185 @@
+import { UnbalancedTreeStore } from '@aztec/foundation/trees';
+import { CheckpointMergeRollupPrivateInputs, CheckpointPaddingRollupPrivateInputs, RootRollupPrivateInputs } from '@aztec/stdlib/rollup';
+import { toProofData } from './block-building-helpers.js';
+var TOP_TREE_LIFECYCLE = /*#__PURE__*/ function(TOP_TREE_LIFECYCLE) {
+    TOP_TREE_LIFECYCLE[TOP_TREE_LIFECYCLE["CREATED"] = 0] = "CREATED";
+    TOP_TREE_LIFECYCLE[TOP_TREE_LIFECYCLE["RESOLVED"] = 1] = "RESOLVED";
+    TOP_TREE_LIFECYCLE[TOP_TREE_LIFECYCLE["REJECTED"] = 2] = "REJECTED";
+    return TOP_TREE_LIFECYCLE;
+}(TOP_TREE_LIFECYCLE || {});
+/**
+ * Lean top-tree-only state. Owns the merge tree of checkpoint root proofs, the
+ * single-checkpoint padding proof slot, the final root rollup proof, and the blob
+ * accumulator endpoints needed to finalise the epoch's batched blob proof.
+ *
+ * Constructed with `totalNumCheckpoints` and `finalBlobBatchingChallenges` upfront —
+ * by the time the top tree starts, all checkpoints are known and the challenges are
+ * derivable from their blob fields.
+ */ export class TopTreeProvingState {
+    epochNumber;
+    totalNumCheckpoints;
+    finalBlobBatchingChallenges;
+    startBlobAccumulator;
+    completionCallback;
+    rejectionCallback;
+    checkpointProofs;
+    checkpointPaddingProof;
+    rootRollupProof;
+    endBlobAccumulator;
+    finalBatchedBlob;
+    lifecycle;
+    constructor(epochNumber, totalNumCheckpoints, finalBlobBatchingChallenges, startBlobAccumulator, completionCallback, rejectionCallback){
+        this.epochNumber = epochNumber;
+        this.totalNumCheckpoints = totalNumCheckpoints;
+        this.finalBlobBatchingChallenges = finalBlobBatchingChallenges;
+        this.startBlobAccumulator = startBlobAccumulator;
+        this.completionCallback = completionCallback;
+        this.rejectionCallback = rejectionCallback;
+        this.lifecycle = 0;
+        if (totalNumCheckpoints < 1) {
+            throw new Error(`TopTreeProvingState requires at least one checkpoint; got ${totalNumCheckpoints}.`);
+        }
+        this.checkpointProofs = new UnbalancedTreeStore(totalNumCheckpoints);
+    }
+    // --- checkpoint root rollup ---
+    setCheckpointRootRollupProof(checkpointIndex, provingOutput) {
+        return this.checkpointProofs.setLeaf(checkpointIndex, {
+            provingOutput
+        });
+    }
+    // --- checkpoint merge rollup ---
+    tryStartProvingCheckpointMerge(location) {
+        if (this.checkpointProofs.getNode(location)?.isProving) {
+            return false;
+        }
+        this.checkpointProofs.setNode(location, {
+            isProving: true
+        });
+        return true;
+    }
+    setCheckpointMergeRollupProof(location, provingOutput) {
+        this.checkpointProofs.setNode(location, {
+            provingOutput
+        });
+    }
+    isReadyForCheckpointMerge(location) {
+        return !!this.checkpointProofs.getSibling(location)?.provingOutput;
+    }
+    getParentLocation(location) {
+        return this.checkpointProofs.getParentLocation(location);
+    }
+    getCheckpointMergeRollupInputs(mergeLocation) {
+        const [left, right] = this.checkpointProofs.getChildren(mergeLocation).map((c)=>c?.provingOutput);
+        if (!left || !right) {
+            throw new Error('At least one child is not ready for the checkpoint merge rollup.');
+        }
+        return new CheckpointMergeRollupPrivateInputs([
+            toProofData(left),
+            toProofData(right)
+        ]);
+    }
+    // --- padding (single-checkpoint case) ---
+    tryStartProvingPaddingCheckpoint() {
+        if (this.checkpointPaddingProof?.isProving) {
+            return false;
+        }
+        this.checkpointPaddingProof = {
+            isProving: true
+        };
+        return true;
+    }
+    setCheckpointPaddingProof(provingOutput) {
+        this.checkpointPaddingProof = {
+            provingOutput
+        };
+    }
+    getPaddingCheckpointInputs() {
+        return new CheckpointPaddingRollupPrivateInputs();
+    }
+    // --- root rollup ---
+    tryStartProvingRootRollup() {
+        if (this.rootRollupProof?.isProving) {
+            return false;
+        }
+        this.rootRollupProof = {
+            isProving: true
+        };
+        return true;
+    }
+    setRootRollupProof(provingOutput) {
+        this.rootRollupProof = {
+            provingOutput
+        };
+    }
+    isReadyForRootRollup() {
+        const childProofs = this.#getChildProofsForRoot();
+        return childProofs.every((p)=>!!p);
+    }
+    getRootRollupInputs() {
+        const [left, right] = this.#getChildProofsForRoot();
+        if (!left || !right) {
+            throw new Error('At least one child is not ready for the root rollup.');
+        }
+        return RootRollupPrivateInputs.from({
+            previousRollups: [
+                toProofData(left),
+                toProofData(right)
+            ]
+        });
+    }
+    // --- blob accumulator finalisation ---
+    /**
+   * Sets the end-of-epoch blob accumulator, computed by the top-tree orchestrator
+   * from the surviving checkpoints' blob fields. Required before `finalizeBatchedBlob`.
+   */ setEndBlobAccumulator(accumulator) {
+        this.endBlobAccumulator = accumulator;
+    }
+    async finalizeBatchedBlob() {
+        if (!this.endBlobAccumulator) {
+            throw new Error('End blob accumulator not set; call setEndBlobAccumulator before finalize.');
+        }
+        this.finalBatchedBlob = await this.endBlobAccumulator.finalize(true);
+    }
+    getEpochProofResult() {
+        const provingOutput = this.rootRollupProof?.provingOutput;
+        if (!provingOutput || !this.finalBatchedBlob) {
+            throw new Error('Top-tree proof not ready; root rollup or batched blob missing.');
+        }
+        return {
+            proof: provingOutput.proof.binaryProof,
+            publicInputs: provingOutput.inputs,
+            batchedBlobInputs: this.finalBatchedBlob
+        };
+    }
+    // --- lifecycle ---
+    verifyState() {
+        return this.lifecycle === 0;
+    }
+    resolve() {
+        if (!this.verifyState()) {
+            return;
+        }
+        this.lifecycle = 1;
+        this.completionCallback();
+    }
+    reject(reason) {
+        if (!this.verifyState()) {
+            return;
+        }
+        this.lifecycle = 2;
+        this.rejectionCallback(reason);
+    }
+    cancel() {
+        this.reject('Top-tree proving cancelled');
+    }
+    #getChildProofsForRoot() {
+        const rootLocation = {
+            level: 0,
+            index: 0
+        };
+        return this.totalNumCheckpoints === 1 ? [
+            this.checkpointProofs.getNode(rootLocation)?.provingOutput,
+            this.checkpointPaddingProof?.provingOutput
+        ] : this.checkpointProofs.getChildren(rootLocation).map((c)=>c?.provingOutput);
+    }
+}

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

@@ -1,7 +1,9 @@
-import { type AVM_PROOF_LENGTH_IN_FIELDS, type TUBE_PROOF_LENGTH } from '@aztec/constants';
+import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
-import type { ProofAndVerificationKey } from '@aztec/stdlib/interfaces/server';
-import { type BaseRollupHints, PrivateBaseRollupInputs, PublicBaseRollupInputs, TubeInputs } from '@aztec/stdlib/rollup';
+import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
+import { RecursiveProof } from '@aztec/stdlib/proofs';
+import { type BaseRollupHints, PrivateTxBaseRollupPrivateInputs, PublicChonkVerifierPublicInputs, PublicTxBaseRollupPrivateInputs } from '@aztec/stdlib/rollup';
 import type { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
 import type { ProcessedTx } from '@aztec/stdlib/tx';
 /**
@@ -14,21 +16,22 @@ export declare class TxProvingState {
     readonly processedTx: ProcessedTx;
     private readonly baseRollupHints;
     readonly treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>;
-    private tube?;
-    private avm?;
-    constructor(processedTx: ProcessedTx, baseRollupHints: BaseRollupHints, treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>);
+    private readonly proverId;
+    private publicChonkVerifier?;
+    private avmProof?;
+    constructor(processedTx: ProcessedTx, baseRollupHints: BaseRollupHints, treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>, proverId: Fr);
     get requireAvmProof(): boolean;
     ready(): boolean;
-    getTubeInputs(): TubeInputs;
     getAvmInputs(): AvmCircuitInputs;
+    getPublicChonkVerifierPrivateInputs(): import("@aztec/stdlib/rollup").PublicChonkVerifierPrivateInputs;
     getBaseRollupTypeAndInputs(): {
         rollupType: string;
-        inputs: PublicBaseRollupInputs;
+        inputs: PublicTxBaseRollupPrivateInputs;
     } | {
         rollupType: string;
-        inputs: PrivateBaseRollupInputs;
+        inputs: PrivateTxBaseRollupPrivateInputs;
     };
-    setTubeProof(tubeProofAndVk: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>): void;
-    setAvmProof(avmProofAndVk: ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>): void;
+    setPublicChonkVerifierProof(publicChonkVerifierProofAndVk: PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
+    setAvmProof(avmProof: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>): void;
 }
-//# sourceMappingURL=tx-proving-state.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHgtcHJvdmluZy1zdGF0ZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL29yY2hlc3RyYXRvci90eC1wcm92aW5nLXN0YXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxvQ0FBb0MsRUFBRSx5Q0FBeUMsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ25ILE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXpELE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDMUQsT0FBTyxLQUFLLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNyRixPQUFPLEVBQWtDLGNBQWMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3RGLE9BQU8sRUFDTCxLQUFLLGVBQWUsRUFFcEIsZ0NBQWdDLEVBRWhDLCtCQUErQixFQUMvQiwrQkFBK0IsRUFDaEMsTUFBTSxzQkFBc0IsQ0FBQztBQUU5QixPQUFPLEtBQUssRUFBRSxzQkFBc0IsRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNoRixPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQVFwRDs7OztHQUlHO0FBQ0gscUJBQWEsY0FBYzs7YUFRUCxXQUFXLEVBQUUsV0FBVztJQUN4QyxPQUFPLENBQUMsUUFBUSxDQUFDLGVBQWU7YUFDaEIsYUFBYSxFQUFFLEdBQUcsQ0FBQyxZQUFZLEVBQUUsc0JBQXNCLENBQUM7SUFDeEUsT0FBTyxDQUFDLFFBQVEsQ0FBQyxRQUFRO0lBVjNCLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBQyxDQUcxQjtJQUNGLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBOEQ7SUFFL0UsWUFDa0IsV0FBVyxFQUFFLFdBQVcsRUFDdkIsZUFBZSxFQUFFLGVBQWUsRUFDakMsYUFBYSxFQUFFLEdBQUcsQ0FBQyxZQUFZLEVBQUUsc0JBQXNCLENBQUMsRUFDdkQsUUFBUSxFQUFFLEVBQUUsRUFDM0I7SUFFSixJQUFJLGVBQWUsWUFFbEI7SUFFTSxLQUFLLFlBRVg7SUFFTSxZQUFZLElBQUksZ0JBQWdCLENBRXRDO0lBRU0sbUNBQW1DLG9FQUV6QztJQUVNLDBCQUEwQjs7Ozs7O01BWWhDO0lBRU0sMkJBQTJCLENBQ2hDLDZCQUE2QixFQUFFLDZCQUE2QixDQUMxRCwrQkFBK0IsRUFDL0IsT0FBTyx5Q0FBeUMsQ0FDakQsUUFHRjtJQUVNLFdBQVcsQ0FBQyxRQUFRLEVBQUUsY0FBYyxDQUFDLE9BQU8sb0NBQW9DLENBQUMsUUFFdkY7Q0FvQ0YifQ==

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

@@ -1 +1 @@
-{"version":3,"file":"tx-proving-state.d.ts","sourceRoot":"","sources":["../../src/orchestrator/tx-proving-state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,0BAA0B,EAAgB,KAAK,iBAAiB,EAAiB,MAAM,kBAAkB,CAAC;AAExH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC/E,OAAO,EAEL,KAAK,eAAe,EAEpB,uBAAuB,EAGvB,sBAAsB,EAEtB,UAAU,EACX,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,sBAAsB,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAChF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAGpD;;;;GAIG;AACH,qBAAa,cAAc;;aAKP,WAAW,EAAE,WAAW;IACxC,OAAO,CAAC,QAAQ,CAAC,eAAe;aAChB,aAAa,EAAE,GAAG,CAAC,YAAY,EAAE,sBAAsB,CAAC;IAN1E,OAAO,CAAC,IAAI,CAAC,CAAoD;IACjE,OAAO,CAAC,GAAG,CAAC,CAA6D;gBAGvD,WAAW,EAAE,WAAW,EACvB,eAAe,EAAE,eAAe,EACjC,aAAa,EAAE,GAAG,CAAC,YAAY,EAAE,sBAAsB,CAAC;IAG1E,IAAI,eAAe,YAElB;IAEM,KAAK;IAIL,aAAa;IAIb,YAAY,IAAI,gBAAgB;IAIhC,0BAA0B;;;;;;;IAc1B,YAAY,CAAC,cAAc,EAAE,uBAAuB,CAAC,OAAO,iBAAiB,CAAC;IAI9E,WAAW,CAAC,aAAa,EAAE,uBAAuB,CAAC,OAAO,0BAA0B,CAAC;CAqE7F"}
+{"version":3,"file":"tx-proving-state.d.ts","sourceRoot":"","sources":["../../src/orchestrator/tx-proving-state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oCAAoC,EAAE,yCAAyC,EAAE,MAAM,kBAAkB,CAAC;AACnH,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AACrF,OAAO,EAAkC,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtF,OAAO,EACL,KAAK,eAAe,EAEpB,gCAAgC,EAEhC,+BAA+B,EAC/B,+BAA+B,EAChC,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,sBAAsB,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAChF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAQpD;;;;GAIG;AACH,qBAAa,cAAc;;aAQP,WAAW,EAAE,WAAW;IACxC,OAAO,CAAC,QAAQ,CAAC,eAAe;aAChB,aAAa,EAAE,GAAG,CAAC,YAAY,EAAE,sBAAsB,CAAC;IACxE,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAV3B,OAAO,CAAC,mBAAmB,CAAC,CAG1B;IACF,OAAO,CAAC,QAAQ,CAAC,CAA8D;IAE/E,YACkB,WAAW,EAAE,WAAW,EACvB,eAAe,EAAE,eAAe,EACjC,aAAa,EAAE,GAAG,CAAC,YAAY,EAAE,sBAAsB,CAAC,EACvD,QAAQ,EAAE,EAAE,EAC3B;IAEJ,IAAI,eAAe,YAElB;IAEM,KAAK,YAEX;IAEM,YAAY,IAAI,gBAAgB,CAEtC;IAEM,mCAAmC,oEAEzC;IAEM,0BAA0B;;;;;;MAYhC;IAEM,2BAA2B,CAChC,6BAA6B,EAAE,6BAA6B,CAC1D,+BAA+B,EAC/B,OAAO,yCAAyC,CACjD,QAGF;IAEM,WAAW,CAAC,QAAQ,EAAE,cAAc,CAAC,OAAO,oCAAoC,CAAC,QAEvF;CAoCF"}

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

@@ -1,7 +1,7 @@
-import { AVM_VK_INDEX, TUBE_VK_INDEX } from '@aztec/constants';
-import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { AvmProofData, PrivateBaseRollupHints, PrivateBaseRollupInputs, PrivateTubeData, PublicBaseRollupHints, PublicBaseRollupInputs, PublicTubeData, TubeInputs } from '@aztec/stdlib/rollup';
-import { VkWitnessData } from '@aztec/stdlib/vks';
+import { getVkData } from '@aztec/noir-protocol-circuits-types/server/vks';
+import { ProofData, ProofDataForFixedVk } from '@aztec/stdlib/proofs';
+import { PrivateBaseRollupHints, PrivateTxBaseRollupPrivateInputs, PublicBaseRollupHints, PublicTxBaseRollupPrivateInputs } from '@aztec/stdlib/rollup';
+import { getChonkProofFromTx, getPublicChonkVerifierPrivateInputsFromTx, toProofData } from './block-building-helpers.js';
 /**
  * Helper class to manage the proving cycle of a transaction
  * This includes the public VMs and the public kernels
@@ -10,85 +10,68 @@ import { VkWitnessData } from '@aztec/stdlib/vks';
     processedTx;
     baseRollupHints;
     treeSnapshots;
-    tube;
-    avm;
-    constructor(processedTx, baseRollupHints, treeSnapshots){
+    proverId;
+    publicChonkVerifier;
+    avmProof;
+    constructor(processedTx, baseRollupHints, treeSnapshots, proverId){
         this.processedTx = processedTx;
         this.baseRollupHints = baseRollupHints;
         this.treeSnapshots = treeSnapshots;
+        this.proverId = proverId;
     }
     get requireAvmProof() {
         return !!this.processedTx.avmProvingRequest;
     }
     ready() {
-        return !!this.tube && (!this.requireAvmProof || !!this.avm);
-    }
-    getTubeInputs() {
-        return new TubeInputs(this.processedTx.clientIvcProof);
+        return !this.requireAvmProof || !!this.avmProof && !!this.publicChonkVerifier;
     }
     getAvmInputs() {
         return this.processedTx.avmProvingRequest.inputs;
     }
+    getPublicChonkVerifierPrivateInputs() {
+        return getPublicChonkVerifierPrivateInputsFromTx(this.processedTx, this.proverId);
+    }
     getBaseRollupTypeAndInputs() {
         if (this.requireAvmProof) {
             return {
-                rollupType: 'public-base-rollup',
+                rollupType: 'rollup-tx-base-public',
                 inputs: this.#getPublicBaseInputs()
             };
         } else {
             return {
-                rollupType: 'private-base-rollup',
+                rollupType: 'rollup-tx-base-private',
                 inputs: this.#getPrivateBaseInputs()
             };
         }
     }
-    setTubeProof(tubeProofAndVk) {
-        this.tube = tubeProofAndVk;
+    setPublicChonkVerifierProof(publicChonkVerifierProofAndVk) {
+        this.publicChonkVerifier = publicChonkVerifierProofAndVk;
     }
-    setAvmProof(avmProofAndVk) {
-        this.avm = avmProofAndVk;
+    setAvmProof(avmProof) {
+        this.avmProof = avmProof;
     }
     #getPrivateBaseInputs() {
-        if (!this.tube) {
-            throw new Error('Tx not ready for proving base rollup.');
-        }
-        const vkData = this.#getTubeVkData();
-        const tubeData = new PrivateTubeData(this.processedTx.data.toPrivateToRollupKernelCircuitPublicInputs(), this.tube.proof, vkData);
         if (!(this.baseRollupHints instanceof PrivateBaseRollupHints)) {
             throw new Error('Mismatched base rollup hints, expected private base rollup hints');
         }
-        return new PrivateBaseRollupInputs(tubeData, this.baseRollupHints);
+        const privateTailProofData = new ProofData(this.processedTx.data.toPrivateToRollupKernelCircuitPublicInputs(), getChonkProofFromTx(this.processedTx), getVkData('HidingKernelToRollup'));
+        return new PrivateTxBaseRollupPrivateInputs(privateTailProofData, this.baseRollupHints);
     }
     #getPublicBaseInputs() {
         if (!this.processedTx.avmProvingRequest) {
             throw new Error('Should create private base rollup for a tx not requiring avm proof.');
         }
-        if (!this.tube) {
-            throw new Error('Tx not ready for proving base rollup: tube proof undefined');
+        if (!this.publicChonkVerifier) {
+            throw new Error('Tx not ready for proving base rollup: public chonk verifier proof undefined');
         }
-        if (!this.avm) {
+        if (!this.avmProof) {
             throw new Error('Tx not ready for proving base rollup: avm proof undefined');
         }
-        const tubeData = new PublicTubeData(this.processedTx.data.toPrivateToPublicKernelCircuitPublicInputs(), this.tube.proof, this.#getTubeVkData());
-        const avmProofData = new AvmProofData(this.processedTx.avmProvingRequest.inputs.publicInputs, this.avm.proof, this.#getAvmVkData());
         if (!(this.baseRollupHints instanceof PublicBaseRollupHints)) {
             throw new Error('Mismatched base rollup hints, expected public base rollup hints');
         }
-        return new PublicBaseRollupInputs(tubeData, avmProofData, this.baseRollupHints);
-    }
-    #getTubeVkData() {
-        let vkIndex = TUBE_VK_INDEX;
-        try {
-            vkIndex = getVKIndex(this.tube.verificationKey);
-        } catch (_ignored) {
-        // TODO(#7410) The VK for the tube won't be in the tree for now, so we manually set it to the tube vk index
-        }
-        const vkPath = getVKSiblingPath(vkIndex);
-        return new VkWitnessData(this.tube.verificationKey, vkIndex, vkPath);
-    }
-    #getAvmVkData() {
-        const vkIndex = AVM_VK_INDEX;
-        const vkPath = getVKSiblingPath(vkIndex);
-        return new VkWitnessData(this.avm.verificationKey, AVM_VK_INDEX, vkPath);
+        const publicChonkVerifierProofData = toProofData(this.publicChonkVerifier);
+        const avmProofData = new ProofDataForFixedVk(this.processedTx.avmProvingRequest.inputs.publicInputs, this.avmProof);
+        return new PublicTxBaseRollupPrivateInputs(publicChonkVerifierProofData, avmProofData, this.baseRollupHints);
     }
 }

package/dest/prover-client/factory.d.ts

@@ -1,6 +1,6 @@
-import type { ForkMerkleTreeOperations, ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
+import type { ForkMerkleTreeOperations, ProvingJobBroker, ReadonlyWorldStateAccess } from '@aztec/stdlib/interfaces/server';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 import type { ProverClientConfig } from '../config.js';
 import { ProverClient } from './prover-client.js';
-export declare function createProverClient(config: ProverClientConfig, worldState: ForkMerkleTreeOperations, broker: ProvingJobBroker, telemetry?: TelemetryClient): Promise<ProverClient>;
-//# sourceMappingURL=factory.d.ts.map
+export declare function createProverClient(config: ProverClientConfig, worldState: ForkMerkleTreeOperations & ReadonlyWorldStateAccess, broker: ProvingJobBroker, telemetry?: TelemetryClient): Promise<ProverClient>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjdG9yeS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Byb3Zlci1jbGllbnQvZmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFDVix3QkFBd0IsRUFDeEIsZ0JBQWdCLEVBQ2hCLHdCQUF3QixFQUN6QixNQUFNLGlDQUFpQyxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxLQUFLLGVBQWUsRUFBc0IsTUFBTSx5QkFBeUIsQ0FBQztBQUVuRixPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUN2RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFbEQsd0JBQWdCLGtCQUFrQixDQUNoQyxNQUFNLEVBQUUsa0JBQWtCLEVBQzFCLFVBQVUsRUFBRSx3QkFBd0IsR0FBRyx3QkFBd0IsRUFDL0QsTUFBTSxFQUFFLGdCQUFnQixFQUN4QixTQUFTLEdBQUUsZUFBc0MseUJBR2xEIn0=

package/dest/prover-client/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/prover-client/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAClG,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAEnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,kBAAkB,EAC1B,UAAU,EAAE,wBAAwB,EACpC,MAAM,EAAE,gBAAgB,EACxB,SAAS,GAAE,eAAsC,yBAGlD"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/prover-client/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,gBAAgB,EAChB,wBAAwB,EACzB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAEnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,kBAAkB,EAC1B,UAAU,EAAE,wBAAwB,GAAG,wBAAwB,EAC/D,MAAM,EAAE,gBAAgB,EACxB,SAAS,GAAE,eAAsC,yBAGlD"}

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

@@ -1,3 +1,3 @@
 export * from './factory.js';
 export * from './prover-client.js';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcm92ZXItY2xpZW50L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsb0JBQW9CLENBQUMifQ==

package/dest/prover-client/prover-client.d.ts

@@ -1,23 +1,82 @@
 import { type ACVMConfig, type BBConfig } from '@aztec/bb-prover';
-import { Fr } from '@aztec/foundation/fields';
-import type { ActualProverConfig, EpochProver, EpochProverManager, ForkMerkleTreeOperations, ProvingJobBroker, ProvingJobConsumer, ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
+import type { EpochNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { type ActualProverConfig, type EpochProver, type EpochProverManager, type ForkMerkleTreeOperations, type ProvingJobBroker, type ProvingJobConsumer, type ReadonlyWorldStateAccess, type ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
+import type { CheckpointConstantData } from '@aztec/stdlib/rollup';
+import type { BlockHeader } from '@aztec/stdlib/tx';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 import type { ProverClientConfig } from '../config.js';
+import { CheckpointSubTreeOrchestrator } from '../orchestrator/checkpoint-sub-tree-orchestrator.js';
+import { EpochProvingContext } from '../orchestrator/epoch-proving-context.js';
+import { TopTreeOrchestrator } from '../orchestrator/top-tree-orchestrator.js';
+/**
+ * The factory surface that `EpochProvingJob` (in `prover-node`) depends on. Implemented
+ * by `ProverClient`. Defined here rather than in stdlib because the return types
+ * (`CheckpointSubTreeOrchestrator`, `TopTreeOrchestrator`) are concrete classes from
+ * this package.
+ *
+ * A single `BrokerCircuitProverFacade` is owned by `ProverClient` and shared across
+ * every orchestrator (every sub-tree and every top-tree across every concurrent epoch
+ * job). The broker delivers each completed-job notification exactly once (drained on
+ * the first `getCompletedJobs` poll), so multiple facades polling the same broker
+ * race and lose notifications
+ *
+ * The facade's job map cleans up entries on resolve/reject, and the prover-node
+ * keeps `ProverClient` alive for its whole lifetime
+ */
+export interface EpochProverFactory {
+    getProverId(): EthAddress;
+    /**
+     * Constructs a per-epoch shared context for the caching of e.g. chonk verifier results
+     */
+    createEpochProvingContext(epochNumber: EpochNumber): EpochProvingContext;
+    /**
+     * Constructs and starts a `CheckpointSubTreeOrchestrator` for a single checkpoint.
+     */
+    createCheckpointSubTreeOrchestrator(epochContext: EpochProvingContext, checkpointConstants: CheckpointConstantData, l1ToL2Messages: Fr[], totalNumBlocks: number, headerOfLastBlockInPreviousCheckpoint: BlockHeader): Promise<CheckpointSubTreeOrchestrator>;
+    createTopTreeOrchestrator(): TopTreeOrchestrator;
+}
 /** Manages proving of epochs by orchestrating the proving of individual blocks relying on a pool of prover agents. */
-export declare class ProverClient implements EpochProverManager {
+export declare class ProverClient implements EpochProverManager, EpochProverFactory {
     private config;
     private worldState;
     private orchestratorClient;
+    private proofStore;
+    private failedProofStore;
     private agentClient?;
     private telemetry;
     private log;
     private running;
     private agents;
-    private proofStore;
-    private failedProofStore;
+    /**
+     * The single broker facade shared by every orchestrator created from this client.
+     * Constructed lazily on `start()` and torn down on `stop()` — see the comment on
+     * `EpochProverFactory` for why a single shared facade is required.
+     */
+    private facade;
     private constructor();
+    /**
+     * Lazy-init the shared facade. The broker delivers each completed-job notification
+     * exactly once (drained on the first `getCompletedJobs` poll), so we cannot start
+     * a shared facade alongside the per-call facades that `createEpochProver` builds —
+     * they would race for notifications and one side would silently drop them. Starting
+     * the shared facade only on first use of one of the new factory methods keeps the
+     * legacy `createEpochProver` path race-free.
+     */
+    private getFacade;
+    /**
+     * Legacy single-class epoch prover. Each call constructs its own
+     * `BrokerCircuitProverFacade`; the new factory methods (`createCheckpointSubTreeOrchestrator`,
+     * `createTopTreeOrchestrator`, `createEpochProvingContext`) share a single facade
+     * owned by `ProverClient`. Both APIs coexist while the prover-node migrates onto
+     * the new pair.
+     */
     createEpochProver(): EpochProver;
-    getProverId(): Fr;
+    createEpochProvingContext(epochNumber: EpochNumber): EpochProvingContext;
+    createCheckpointSubTreeOrchestrator(epochContext: EpochProvingContext, checkpointConstants: CheckpointConstantData, l1ToL2Messages: Fr[], totalNumBlocks: number, headerOfLastBlockInPreviousCheckpoint: BlockHeader): Promise<CheckpointSubTreeOrchestrator>;
+    createTopTreeOrchestrator(): TopTreeOrchestrator;
+    getProverId(): EthAddress;
     updateProverConfig(config: Partial<ProverClientConfig>): Promise<void>;
     /**
      * Starts the prover instance
@@ -33,10 +92,10 @@ export declare class ProverClient implements EpochProverManager {
      * @param worldState - An instance of the world state
      * @returns An instance of the prover, constructed and started.
      */
-    static new(config: ProverClientConfig, worldState: ForkMerkleTreeOperations, broker: ProvingJobBroker, telemetry?: TelemetryClient): Promise<ProverClient>;
+    static new(config: ProverClientConfig, worldState: ForkMerkleTreeOperations & ReadonlyWorldStateAccess, broker: ProvingJobBroker, telemetry?: TelemetryClient): Promise<ProverClient>;
     getProvingJobSource(): ProvingJobConsumer;
     private createAndStartAgents;
     private stopAgents;
 }
-export declare function buildServerCircuitProver(config: ActualProverConfig & ACVMConfig & BBConfig, telemetry: TelemetryClient): Promise<ServerCircuitProver>;
-//# sourceMappingURL=prover-client.d.ts.map
+export declare function buildServerCircuitProver(config: Omit<ActualProverConfig, 'enqueueConcurrency'> & ACVMConfig & BBConfig, telemetry: TelemetryClient): Promise<ServerCircuitProver>;
+//# sourceMappingURL=data:application/json;base64,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