@aztec/prover-client 0.0.1-commit.b9865e97 → 0.0.1-commit.be03c316

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

@@ -1,62 +0,0 @@
-import type { NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
-import type { EpochNumber } from '@aztec/foundation/branded-types';
-import type { LoggerBindings } from '@aztec/foundation/log';
-import type { TreeNodeLocation } from '@aztec/foundation/trees';
-import type { PublicInputsAndRecursiveProof, ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
-import type { CheckpointMergeRollupPrivateInputs, CheckpointPaddingRollupPrivateInputs, CheckpointRollupPublicInputs, RootRollupPrivateInputs, RootRollupPublicInputs } from '@aztec/stdlib/rollup';
-import { ProvingScheduler, type ProvingStateLike } from './proving-scheduler.js';
-type CheckpointRollupProof = PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>;
-type RootRollupProof = PublicInputsAndRecursiveProof<RootRollupPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>;
-/**
- * State interface required by the top-tree proving drivers (checkpoint-merge → padding →
- * root-rollup). Both `EpochProvingState` and `TopTreeProvingState` satisfy it structurally;
- * the per-checkpoint state in `EpochProvingState` (block/tx proving, world-state forks)
- * is owned outside this surface.
- */
-export interface TopTreeStateLike extends ProvingStateLike {
-    readonly epochNumber: EpochNumber;
-    readonly totalNumCheckpoints: number;
-    tryStartProvingCheckpointMerge(location: TreeNodeLocation): boolean;
-    setCheckpointMergeRollupProof(location: TreeNodeLocation, provingOutput: CheckpointRollupProof): void;
-    isReadyForCheckpointMerge(location: TreeNodeLocation): boolean;
-    getParentLocation(location: TreeNodeLocation): TreeNodeLocation;
-    getCheckpointMergeRollupInputs(location: TreeNodeLocation): CheckpointMergeRollupPrivateInputs;
-    tryStartProvingPaddingCheckpoint(): boolean;
-    setCheckpointPaddingProof(provingOutput: CheckpointRollupProof): void;
-    getPaddingCheckpointInputs(): CheckpointPaddingRollupPrivateInputs;
-    tryStartProvingRootRollup(): boolean;
-    setRootRollupProof(provingOutput: RootRollupProof): void;
-    isReadyForRootRollup(): boolean;
-    getRootRollupInputs(): RootRollupPrivateInputs;
-}
-/**
- * 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 declare abstract class TopTreeProvingScheduler extends ProvingScheduler {
-    protected readonly prover: ServerCircuitProver;
-    constructor(prover: ServerCircuitProver, enqueueConcurrency: number, loggerName?: string, bindings?: LoggerBindings);
-    /**
-     * Wraps a circuit call for telemetry. Default is identity; the orchestrator overrides
-     * to wrap with `wrapCallbackInSpan`.
-     */
-    protected wrapCircuitCall<T>(_circuitName: string, fn: (signal: AbortSignal) => Promise<T>): (signal: AbortSignal) => Promise<T>;
-    /** Called once the root rollup proof has been set; subclasses call `state.resolve(...)` with the right shape. */
-    protected abstract onRootRollupComplete(state: TopTreeStateLike): void;
-    protected enqueueCheckpointMergeRollup(state: TopTreeStateLike, location: TreeNodeLocation): void;
-    protected enqueueEpochPadding(state: TopTreeStateLike): void;
-    protected enqueueRootRollup(state: TopTreeStateLike): void;
-    protected checkAndEnqueueNextCheckpointMergeRollup(state: TopTreeStateLike, currentLocation: TreeNodeLocation): void;
-    protected checkAndEnqueueRootRollup(state: TopTreeStateLike): void;
-}
-export {};
-//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +0,0 @@
-{"version":3,"file":"top-tree-proving-scheduler.d.ts","sourceRoot":"","sources":["../../src/orchestrator/top-tree-proving-scheduler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,yCAAyC,EAAE,MAAM,kBAAkB,CAAC;AACjH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,6BAA6B,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAC1G,OAAO,KAAK,EACV,kCAAkC,EAClC,oCAAoC,EACpC,4BAA4B,EAC5B,uBAAuB,EACvB,sBAAsB,EACvB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAEjF,KAAK,qBAAqB,GAAG,6BAA6B,CACxD,4BAA4B,EAC5B,OAAO,yCAAyC,CACjD,CAAC;AAEF,KAAK,eAAe,GAAG,6BAA6B,CAAC,sBAAsB,EAAE,OAAO,6BAA6B,CAAC,CAAC;AAEnH;;;;;GAKG;AACH,MAAM,WAAW,gBAAiB,SAAQ,gBAAgB;IACxD,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IAErC,8BAA8B,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC;IACpE,6BAA6B,CAAC,QAAQ,EAAE,gBAAgB,EAAE,aAAa,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACtG,yBAAyB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC;IAC/D,iBAAiB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,gBAAgB,CAAC;IAChE,8BAA8B,CAAC,QAAQ,EAAE,gBAAgB,GAAG,kCAAkC,CAAC;IAE/F,gCAAgC,IAAI,OAAO,CAAC;IAC5C,yBAAyB,CAAC,aAAa,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACtE,0BAA0B,IAAI,oCAAoC,CAAC;IAEnE,yBAAyB,IAAI,OAAO,CAAC;IACrC,kBAAkB,CAAC,aAAa,EAAE,eAAe,GAAG,IAAI,CAAC;IACzD,oBAAoB,IAAI,OAAO,CAAC;IAChC,mBAAmB,IAAI,uBAAuB,CAAC;CAChD;AAED;;;;;;;;;;;;GAYG;AACH,8BAAsB,uBAAwB,SAAQ,gBAAgB;IAElE,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,mBAAmB;IADhD,YACqB,MAAM,EAAE,mBAAmB,EAC9C,kBAAkB,EAAE,MAAM,EAC1B,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,cAAc,EAG1B;IAED;;;OAGG;IACH,SAAS,CAAC,eAAe,CAAC,CAAC,EACzB,YAAY,EAAE,MAAM,EACpB,EAAE,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GACtC,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,CAErC;IAED,iHAAiH;IACjH,SAAS,CAAC,QAAQ,CAAC,oBAAoB,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAEvE,SAAS,CAAC,4BAA4B,CAAC,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,gBAAgB,QAezF;IAED,SAAS,CAAC,mBAAmB,CAAC,KAAK,EAAE,gBAAgB,QAepD;IAED,SAAS,CAAC,iBAAiB,CAAC,KAAK,EAAE,gBAAgB,QAclD;IAED,SAAS,CAAC,wCAAwC,CAAC,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,gBAAgB,QAU5G;IAED,SAAS,CAAC,yBAAyB,CAAC,KAAK,EAAE,gBAAgB,QAK1D;CACF"}

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

@@ -1,73 +0,0 @@
-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/prover-client/server-epoch-prover.d.ts

@@ -1,32 +0,0 @@
-import type { BatchedBlob, FinalBlobBatchingChallenges } from '@aztec/blob-lib/types';
-import { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
-import type { Fr } from '@aztec/foundation/curves/bn254';
-import type { EthAddress } from '@aztec/stdlib/block';
-import type { EpochProver } from '@aztec/stdlib/interfaces/server';
-import type { Proof } from '@aztec/stdlib/proofs';
-import type { CheckpointConstantData, RootRollupPublicInputs } from '@aztec/stdlib/rollup';
-import type { BlockHeader, ProcessedTx, Tx } from '@aztec/stdlib/tx';
-import type { UInt64 } from '@aztec/stdlib/types';
-import type { ProvingOrchestrator } from '../orchestrator/orchestrator.js';
-import type { BrokerCircuitProverFacade } from '../proving_broker/broker_prover_facade.js';
-/** Encapsulates the proving orchestrator and the broker facade */
-export declare class ServerEpochProver implements EpochProver {
-    private facade;
-    private orchestrator;
-    constructor(facade: BrokerCircuitProverFacade, orchestrator: ProvingOrchestrator);
-    startNewEpoch(epochNumber: EpochNumber, totalNumCheckpoints: number, finalBlobBatchingChallenges: FinalBlobBatchingChallenges): void;
-    startNewCheckpoint(checkpointIndex: number, constants: CheckpointConstantData, l1ToL2Messages: Fr[], totalNumBlocks: number, headerOfLastBlockInPreviousCheckpoint: BlockHeader): Promise<void>;
-    startChonkVerifierCircuits(txs: Tx[]): Promise<void>;
-    setBlockCompleted(blockNumber: BlockNumber, expectedBlockHeader?: BlockHeader): Promise<BlockHeader>;
-    finalizeEpoch(): Promise<{
-        publicInputs: RootRollupPublicInputs;
-        proof: Proof;
-        batchedBlobInputs: BatchedBlob;
-    }>;
-    cancel(): void;
-    getProverId(): EthAddress;
-    stop(): Promise<void>;
-    startNewBlock(blockNumber: BlockNumber, timestamp: UInt64, totalNumTxs: number): Promise<void>;
-    addTxs(txs: ProcessedTx[]): Promise<void>;
-}
-//# sourceMappingURL=data:application/json;base64,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

package/dest/prover-client/server-epoch-prover.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server-epoch-prover.d.ts","sourceRoot":"","sources":["../../src/prover-client/server-epoch-prover.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAC;AACtF,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAC3F,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AACrE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AAE3F,kEAAkE;AAClE,qBAAa,iBAAkB,YAAW,WAAW;IAEjD,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,YAAY;IAFtB,YACU,MAAM,EAAE,yBAAyB,EACjC,YAAY,EAAE,mBAAmB,EACvC;IAEJ,aAAa,CACX,WAAW,EAAE,WAAW,EACxB,mBAAmB,EAAE,MAAM,EAC3B,2BAA2B,EAAE,2BAA2B,GACvD,IAAI,CAGN;IACD,kBAAkB,CAChB,eAAe,EAAE,MAAM,EACvB,SAAS,EAAE,sBAAsB,EACjC,cAAc,EAAE,EAAE,EAAE,EACpB,cAAc,EAAE,MAAM,EACtB,qCAAqC,EAAE,WAAW,GACjD,OAAO,CAAC,IAAI,CAAC,CAQf;IACD,0BAA0B,CAAC,GAAG,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAEnD;IACD,iBAAiB,CAAC,WAAW,EAAE,WAAW,EAAE,mBAAmB,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAEnG;IACD,aAAa,IAAI,OAAO,CAAC;QAAE,YAAY,EAAE,sBAAsB,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC;QAAC,iBAAiB,EAAE,WAAW,CAAA;KAAE,CAAC,CAE/G;IACD,MAAM,IAAI,IAAI,CAEb;IACD,WAAW,IAAI,UAAU,CAExB;IACK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAG1B;IACD,aAAa,CAAC,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE7F;IACD,MAAM,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAExC;CACF"}

package/dest/prover-client/server-epoch-prover.js

@@ -1,40 +0,0 @@
-/** Encapsulates the proving orchestrator and the broker facade */ export class ServerEpochProver {
-    facade;
-    orchestrator;
-    constructor(facade, orchestrator){
-        this.facade = facade;
-        this.orchestrator = orchestrator;
-    }
-    startNewEpoch(epochNumber, totalNumCheckpoints, finalBlobBatchingChallenges) {
-        this.orchestrator.startNewEpoch(epochNumber, totalNumCheckpoints, finalBlobBatchingChallenges);
-        this.facade.start();
-    }
-    startNewCheckpoint(checkpointIndex, constants, l1ToL2Messages, totalNumBlocks, headerOfLastBlockInPreviousCheckpoint) {
-        return this.orchestrator.startNewCheckpoint(checkpointIndex, constants, l1ToL2Messages, totalNumBlocks, headerOfLastBlockInPreviousCheckpoint);
-    }
-    startChonkVerifierCircuits(txs) {
-        return this.orchestrator.startChonkVerifierCircuits(txs);
-    }
-    setBlockCompleted(blockNumber, expectedBlockHeader) {
-        return this.orchestrator.setBlockCompleted(blockNumber, expectedBlockHeader);
-    }
-    finalizeEpoch() {
-        return this.orchestrator.finalizeEpoch();
-    }
-    cancel() {
-        this.orchestrator.cancel();
-    }
-    getProverId() {
-        return this.orchestrator.getProverId();
-    }
-    async stop() {
-        await this.facade.stop();
-        await this.orchestrator.stop();
-    }
-    startNewBlock(blockNumber, timestamp, totalNumTxs) {
-        return this.orchestrator.startNewBlock(blockNumber, timestamp, totalNumTxs);
-    }
-    addTxs(txs) {
-        return this.orchestrator.addTxs(txs);
-    }
-}

package/src/orchestrator/epoch-proving-context.ts

@@ -1,101 +0,0 @@
-import type { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
-import type { EpochNumber } from '@aztec/foundation/branded-types';
-import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
-import type { PublicInputsAndRecursiveProof, ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
-import type { PublicChonkVerifierPrivateInputs, PublicChonkVerifierPublicInputs } from '@aztec/stdlib/rollup';
-
-/**
- * Result of a chonk-verifier proof, cached per tx hash on `EpochProvingContext`.
- */
-export type ChonkVerifierProofResult = PublicInputsAndRecursiveProof<
-  PublicChonkVerifierPublicInputs,
-  typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
->;
-
-/**
- * Per-epoch state shared across every `CheckpointSubTreeOrchestrator` constructed for
- * the same epoch. Owns the chonk-verifier proof cache so a tx whose checkpoint is
- * reorged out and re-appears in a replacement checkpoint does not have to re-prove
- * its chonk circuit.
- *
- * The context's chonk-verifier broker jobs are deliberately submitted **outside** the
- * sub-tree's deferred-proving queue. The sub-tree's `cancel()` therefore does not abort
- * them — by design, because their result is tx-scoped, not sub-tree-scoped, and a
- * replacement sub-tree should be able to consume the cached proof.
- *
- * Callers (`EpochProvingJob`, or unit tests) construct one context per epoch and pass
- * it into every sub-tree they create. `stop()` aborts every in-flight chonk job.
- */
-export class EpochProvingContext {
-  private readonly cache = new Map<string, Promise<ChonkVerifierProofResult>>();
-  /** Abort controllers for in-flight chonk jobs, keyed by tx hash. */
-  private readonly pending = new Map<string, AbortController>();
-  private readonly log: Logger;
-  private stopped = false;
-
-  constructor(
-    private readonly prover: ServerCircuitProver,
-    public readonly epochNumber: EpochNumber,
-    bindings?: LoggerBindings,
-  ) {
-    this.log = createLogger('prover-client:epoch-proving-context', bindings);
-  }
-
-  /**
-   * Returns the cached chonk-verifier proof promise for the given tx hash, or
-   * `undefined` if none has been enqueued yet. Non-mutating.
-   */
-  public getCached(txHash: string): Promise<ChonkVerifierProofResult> | undefined {
-    return this.cache.get(txHash);
-  }
-
-  /**
-   * Enqueues a chonk-verifier proof for the given tx hash, returning the promise (or
-   * the already-cached one if already enqueued). The promise resolves when the broker
-   * delivers the result; on rejection (including `stop()`), the cache entry is removed
-   * so a subsequent caller can re-enqueue.
-   */
-  public enqueue(txHash: string, inputs: PublicChonkVerifierPrivateInputs): Promise<ChonkVerifierProofResult> {
-    if (this.stopped) {
-      return Promise.reject(new Error('EpochProvingContext is stopped'));
-    }
-
-    const cached = this.cache.get(txHash);
-    if (cached) {
-      return cached;
-    }
-
-    const controller = new AbortController();
-    this.pending.set(txHash, controller);
-    this.log.debug(`Enqueueing chonk-verifier circuit`, { txHash, epochNumber: this.epochNumber });
-
-    const promise = this.prover
-      .getPublicChonkVerifierProof(inputs, controller.signal, this.epochNumber)
-      .finally(() => this.pending.delete(txHash));
-
-    // Self-clean on rejection so a future caller can re-enqueue. Mark the rejection
-    // path as observed to silence unhandled-rejection warnings when no consumer
-    // awaits the promise (e.g. when the only `.then` chain belonged to a cancelled
-    // sub-tree's tx-proving state).
-    promise.catch(err => {
-      this.cache.delete(txHash);
-      this.log.debug(`Chonk-verifier proof failed; evicted from cache`, { txHash, error: `${err}` });
-    });
-
-    this.cache.set(txHash, promise);
-    return promise;
-  }
-
-  /**
-   * Aborts every in-flight chonk-verifier broker job and clears the cache. Called by
-   * the owning `EpochProvingJob` when the job stops.
-   */
-  public stop() {
-    this.stopped = true;
-    for (const controller of this.pending.values()) {
-      controller.abort();
-    }
-    this.pending.clear();
-    this.cache.clear();
-  }
-}