@aztec/prover-client 0.42.0

package/dest/prover-agent/memory-proving-queue.js

@@ -0,0 +1,187 @@
+import { ProvingRequestType, } from '@aztec/circuit-types';
+import { randomBytes } from '@aztec/foundation/crypto';
+import { AbortedError, TimeoutError } from '@aztec/foundation/error';
+import { MemoryFifo } from '@aztec/foundation/fifo';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
+const MAX_RETRIES = 3;
+const defaultIdGenerator = () => randomBytes(4).toString('hex');
+/**
+ * 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 class MemoryProvingQueue {
+    constructor(generateId = defaultIdGenerator) {
+        this.generateId = generateId;
+        this.log = createDebugLogger('aztec:prover-client:prover-pool:queue');
+        this.queue = new MemoryFifo();
+        this.jobsInProgress = new Map();
+    }
+    async getProvingJob({ timeoutSec = 1 } = {}) {
+        try {
+            const job = await this.queue.get(timeoutSec);
+            if (!job) {
+                return undefined;
+            }
+            if (job.signal?.aborted) {
+                this.log.debug(`Job ${job.id} type=${job.request.type} has been aborted`);
+                return undefined;
+            }
+            this.jobsInProgress.set(job.id, job);
+            return {
+                id: job.id,
+                request: job.request,
+            };
+        }
+        catch (err) {
+            if (err instanceof TimeoutError) {
+                return undefined;
+            }
+            throw err;
+        }
+    }
+    resolveProvingJob(jobId, result) {
+        const job = this.jobsInProgress.get(jobId);
+        if (!job) {
+            return Promise.reject(new Error('Job not found'));
+        }
+        this.jobsInProgress.delete(jobId);
+        if (job.signal?.aborted) {
+            return Promise.resolve();
+        }
+        job.resolve(result);
+        return Promise.resolve();
+    }
+    rejectProvingJob(jobId, err) {
+        const job = this.jobsInProgress.get(jobId);
+        if (!job) {
+            return Promise.reject(new Error('Job not found'));
+        }
+        this.jobsInProgress.delete(jobId);
+        if (job.signal?.aborted) {
+            return Promise.resolve();
+        }
+        if (job.attempts < MAX_RETRIES) {
+            job.attempts++;
+            this.log.warn(`Job id=${job.id} type=${ProvingRequestType[job.request.type]} failed with error: ${err}. Retry ${job.attempts}/${MAX_RETRIES}`);
+            this.queue.put(job);
+        }
+        else {
+            this.log.error(`Job id=${job.id} type=${ProvingRequestType[job.request.type]} failed with error: ${err}`);
+            job.reject(err);
+        }
+        return Promise.resolve();
+    }
+    enqueue(request, signal) {
+        const { promise, resolve, reject } = promiseWithResolvers();
+        const item = {
+            id: this.generateId(),
+            request,
+            signal,
+            promise,
+            resolve,
+            reject,
+            attempts: 1,
+        };
+        if (signal) {
+            signal.addEventListener('abort', () => reject(new AbortedError('Operation has been aborted')));
+        }
+        this.log.debug(`Adding id=${item.id} type=${ProvingRequestType[request.type]} proving job to queue depth=${this.queue.length()}`);
+        // TODO (alexg) remove the `any`
+        if (!this.queue.put(item)) {
+            throw new Error();
+        }
+        return promise;
+    }
+    getEmptyPrivateKernelProof(inputs, signal) {
+        return this.enqueue({ type: ProvingRequestType.PRIVATE_KERNEL_EMPTY, inputs }, signal);
+    }
+    /**
+     * Creates a proof for the given input.
+     * @param input - Input to the circuit.
+     */
+    getBaseParityProof(inputs, signal) {
+        return this.enqueue({
+            type: ProvingRequestType.BASE_PARITY,
+            inputs,
+        }, signal);
+    }
+    /**
+     * Creates a proof for the given input.
+     * @param input - Input to the circuit.
+     */
+    getRootParityProof(inputs, signal) {
+        return this.enqueue({
+            type: ProvingRequestType.ROOT_PARITY,
+            inputs,
+        }, signal);
+    }
+    /**
+     * Creates a proof for the given input.
+     * @param input - Input to the circuit.
+     */
+    getBaseRollupProof(input, signal) {
+        return this.enqueue({
+            type: ProvingRequestType.BASE_ROLLUP,
+            inputs: input,
+        }, signal);
+    }
+    /**
+     * Creates a proof for the given input.
+     * @param input - Input to the circuit.
+     */
+    getMergeRollupProof(input, signal) {
+        return this.enqueue({
+            type: ProvingRequestType.MERGE_ROLLUP,
+            inputs: input,
+        }, signal);
+    }
+    /**
+     * Creates a proof for the given input.
+     * @param input - Input to the circuit.
+     */
+    getRootRollupProof(input, signal) {
+        return this.enqueue({
+            type: ProvingRequestType.ROOT_ROLLUP,
+            inputs: input,
+        }, signal);
+    }
+    /**
+     * Create a public kernel proof.
+     * @param kernelRequest - Object containing the details of the proof required
+     */
+    getPublicKernelProof(kernelRequest, signal) {
+        return this.enqueue({
+            type: ProvingRequestType.PUBLIC_KERNEL_NON_TAIL,
+            kernelType: kernelRequest.type,
+            inputs: kernelRequest.inputs,
+        }, signal);
+    }
+    /**
+     * Create a public kernel tail proof.
+     * @param kernelRequest - Object containing the details of the proof required
+     */
+    getPublicTailProof(kernelRequest, signal) {
+        return this.enqueue({
+            type: ProvingRequestType.PUBLIC_KERNEL_TAIL,
+            kernelType: kernelRequest.type,
+            inputs: kernelRequest.inputs,
+        }, signal);
+    }
+    /**
+     * Creates an AVM proof.
+     */
+    getAvmProof(inputs, signal) {
+        return this.enqueue({
+            type: ProvingRequestType.PUBLIC_VM,
+            inputs,
+        }, signal);
+    }
+    /**
+     * Verifies a circuit proof
+     */
+    verifyProof() {
+        return Promise.reject('not implemented');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,30 @@
+import { type ProvingJobSource, type ServerCircuitProver } from '@aztec/circuit-types';
+/**
+ * A helper class that encapsulates a circuit prover and connects it to a job source.
+ */
+export declare class ProverAgent {
+    /** The prover implementation to defer jobs to */
+    private circuitProver;
+    /** How many proving jobs this agent can handle in parallel */
+    private maxConcurrency;
+    /** How long to wait between jobs */
+    private pollIntervalMs;
+    private log;
+    private inFlightPromises;
+    private runningPromise?;
+    constructor(
+    /** The prover implementation to defer jobs to */
+    circuitProver: ServerCircuitProver, 
+    /** How many proving jobs this agent can handle in parallel */
+    maxConcurrency?: number, 
+    /** How long to wait between jobs */
+    pollIntervalMs?: number, log?: import("@aztec/foundation/log").Logger);
+    setMaxConcurrency(maxConcurrency: number): void;
+    setCircuitProver(circuitProver: ServerCircuitProver): void;
+    isRunning(): boolean;
+    start(jobSource: ProvingJobSource): void;
+    stop(): Promise<void>;
+    private work;
+    private getProof;
+}
+//# sourceMappingURL=prover-agent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prover-agent.d.ts","sourceRoot":"","sources":["../../src/prover-agent/prover-agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,gBAAgB,EAIrB,KAAK,mBAAmB,EACzB,MAAM,sBAAsB,CAAC;AAO9B;;GAEG;AACH,qBAAa,WAAW;IAKpB,iDAAiD;IACjD,OAAO,CAAC,aAAa;IACrB,8DAA8D;IAC9D,OAAO,CAAC,cAAc;IACtB,oCAAoC;IACpC,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,GAAG;IAVb,OAAO,CAAC,gBAAgB,CAA2B;IACnD,OAAO,CAAC,cAAc,CAAC,CAAiB;;IAGtC,iDAAiD;IACzC,aAAa,EAAE,mBAAmB;IAC1C,8DAA8D;IACtD,cAAc,SAAI;IAC1B,oCAAoC;IAC5B,cAAc,SAAM,EACpB,GAAG,yCAAwD;IAGrE,iBAAiB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAO/C,gBAAgB,CAAC,aAAa,EAAE,mBAAmB,GAAG,IAAI;IAI1D,SAAS;IAIT,KAAK,CAAC,SAAS,EAAE,gBAAgB,GAAG,IAAI;IAsBlC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;YAWb,IAAI;IAalB,OAAO,CAAC,QAAQ;CAmDjB"}

package/dest/prover-agent/prover-agent.js

@@ -0,0 +1,115 @@
+import { ProvingRequestType, } from '@aztec/circuit-types';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { elapsed } from '@aztec/foundation/timer';
+import { ProvingError } from './proving-error.js';
+/**
+ * A helper class that encapsulates a circuit prover and connects it to a job source.
+ */
+export class ProverAgent {
+    constructor(
+    /** The prover implementation to defer jobs to */
+    circuitProver, 
+    /** How many proving jobs this agent can handle in parallel */
+    maxConcurrency = 1, 
+    /** How long to wait between jobs */
+    pollIntervalMs = 100, log = createDebugLogger('aztec:prover-client:prover-agent')) {
+        this.circuitProver = circuitProver;
+        this.maxConcurrency = maxConcurrency;
+        this.pollIntervalMs = pollIntervalMs;
+        this.log = log;
+        this.inFlightPromises = new Set();
+    }
+    setMaxConcurrency(maxConcurrency) {
+        if (maxConcurrency < 1) {
+            throw new Error('Concurrency must be at least 1');
+        }
+        this.maxConcurrency = maxConcurrency;
+    }
+    setCircuitProver(circuitProver) {
+        this.circuitProver = circuitProver;
+    }
+    isRunning() {
+        return this.runningPromise?.isRunning() ?? false;
+    }
+    start(jobSource) {
+        if (this.runningPromise) {
+            throw new Error('Agent is already running');
+        }
+        this.runningPromise = new RunningPromise(async () => {
+            while (this.inFlightPromises.size < this.maxConcurrency) {
+                const job = await jobSource.getProvingJob();
+                if (!job) {
+                    // job source is fully drained, sleep for a bit and try again
+                    return;
+                }
+                const promise = this.work(jobSource, job).finally(() => this.inFlightPromises.delete(promise));
+                this.inFlightPromises.add(promise);
+            }
+        }, this.pollIntervalMs);
+        this.runningPromise.start();
+        this.log.info('Agent started');
+    }
+    async stop() {
+        if (!this.runningPromise?.isRunning()) {
+            return;
+        }
+        await this.runningPromise.stop();
+        this.runningPromise = undefined;
+        this.log.info('Agent stopped');
+    }
+    async work(jobSource, job) {
+        try {
+            const [time, result] = await elapsed(this.getProof(job.request));
+            await jobSource.resolveProvingJob(job.id, result);
+            this.log.debug(`Processed proving job id=${job.id} type=${ProvingRequestType[job.request.type]} duration=${time}ms`);
+        }
+        catch (err) {
+            this.log.error(`Error processing proving job id=${job.id} type=${ProvingRequestType[job.request.type]}: ${err}`);
+            await jobSource.rejectProvingJob(job.id, new ProvingError(err?.message ?? String(err)));
+        }
+    }
+    getProof(request) {
+        const { type, inputs } = request;
+        switch (type) {
+            case ProvingRequestType.PUBLIC_VM: {
+                return this.circuitProver.getAvmProof(inputs);
+            }
+            case ProvingRequestType.PUBLIC_KERNEL_NON_TAIL: {
+                return this.circuitProver.getPublicKernelProof({
+                    type: request.kernelType,
+                    inputs,
+                });
+            }
+            case ProvingRequestType.PUBLIC_KERNEL_TAIL: {
+                return this.circuitProver.getPublicTailProof({
+                    type: request.kernelType,
+                    inputs,
+                });
+            }
+            case ProvingRequestType.BASE_ROLLUP: {
+                return this.circuitProver.getBaseRollupProof(inputs);
+            }
+            case ProvingRequestType.MERGE_ROLLUP: {
+                return this.circuitProver.getMergeRollupProof(inputs);
+            }
+            case ProvingRequestType.ROOT_ROLLUP: {
+                return this.circuitProver.getRootRollupProof(inputs);
+            }
+            case ProvingRequestType.BASE_PARITY: {
+                return this.circuitProver.getBaseParityProof(inputs);
+            }
+            case ProvingRequestType.ROOT_PARITY: {
+                return this.circuitProver.getRootParityProof(inputs);
+            }
+            case ProvingRequestType.PRIVATE_KERNEL_EMPTY: {
+                return this.circuitProver.getEmptyPrivateKernelProof(inputs);
+            }
+            default: {
+                const _exhaustive = type;
+                return Promise.reject(new Error(`Invalid proof request type: ${type}`));
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/prover-agent/proving-error.d.ts

@@ -0,0 +1,5 @@
+export declare class ProvingError extends Error {
+    toString(): string;
+    static fromString(message: string): ProvingError;
+}
+//# sourceMappingURL=proving-error.d.ts.map

package/dest/prover-agent/proving-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proving-error.d.ts","sourceRoot":"","sources":["../../src/prover-agent/proving-error.ts"],"names":[],"mappings":"AAAA,qBAAa,YAAa,SAAQ,KAAK;IAC5B,QAAQ;IAIjB,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM;CAGlC"}

package/dest/prover-agent/proving-error.js

@@ -0,0 +1,9 @@
+export class ProvingError extends Error {
+    toString() {
+        return this.message;
+    }
+    static fromString(message) {
+        return new ProvingError(message);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmluZy1lcnJvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcm92ZXItYWdlbnQvcHJvdmluZy1lcnJvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sWUFBYSxTQUFRLEtBQUs7SUFDNUIsUUFBUTtRQUNmLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQztJQUN0QixDQUFDO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxPQUFlO1FBQy9CLE9BQU8sSUFBSSxZQUFZLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDbkMsQ0FBQztDQUNGIn0=

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

@@ -0,0 +1,5 @@
+import { type ProvingJobSource } from '@aztec/circuit-types';
+import { JsonRpcServer } from '@aztec/foundation/json-rpc/server';
+export declare function createProvingJobSourceServer(queue: ProvingJobSource): JsonRpcServer;
+export declare function createProvingJobSourceClient(url: string, namespace?: string, fetch?: (host: string, rpcMethod: string, body: any, useApiEndpoints: boolean) => Promise<any>): ProvingJobSource;
+//# sourceMappingURL=rpc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../../src/prover-agent/rpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAuB7D,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAIlE,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,gBAAgB,GAAG,aAAa,CA2BnF;AAED,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM,EAClB,KAAK,yFAA8B,GAClC,gBAAgB,CA8BlB"}

package/dest/prover-agent/rpc.js

@@ -0,0 +1,53 @@
+import { AvmCircuitInputs, BaseOrMergeRollupPublicInputs, BaseParityInputs, BaseRollupInputs, Fr, Header, KernelCircuitPublicInputs, MergeRollupInputs, ParityPublicInputs, Proof, PublicKernelCircuitPrivateInputs, PublicKernelCircuitPublicInputs, PublicKernelTailCircuitPrivateInputs, RecursiveProof, RootParityInput, RootParityInputs, RootRollupInputs, RootRollupPublicInputs, VerificationKeyData, } from '@aztec/circuits.js';
+import { createJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
+import { JsonRpcServer } from '@aztec/foundation/json-rpc/server';
+import { ProvingError } from './proving-error.js';
+export function createProvingJobSourceServer(queue) {
+    return new JsonRpcServer(queue, {
+        Header,
+        Fr,
+        AvmCircuitInputs,
+        BaseParityInputs,
+        BaseOrMergeRollupPublicInputs,
+        BaseRollupInputs,
+        MergeRollupInputs,
+        ParityPublicInputs,
+        Proof,
+        RootParityInput,
+        RootParityInputs,
+        RootRollupInputs,
+        RootRollupPublicInputs,
+        PublicKernelCircuitPrivateInputs,
+        PublicKernelCircuitPublicInputs,
+        PublicKernelTailCircuitPrivateInputs,
+        KernelCircuitPublicInputs,
+        ProvingError,
+        RecursiveProof,
+        VerificationKeyData,
+    }, {});
+}
+export function createProvingJobSourceClient(url, namespace, fetch = makeFetch([1, 2, 3], false)) {
+    return createJsonRpcClient(url, {
+        Header,
+        Fr,
+        AvmCircuitInputs,
+        BaseParityInputs,
+        BaseOrMergeRollupPublicInputs,
+        BaseRollupInputs,
+        MergeRollupInputs,
+        ParityPublicInputs,
+        Proof,
+        RootParityInput,
+        RootParityInputs,
+        RootRollupInputs,
+        RootRollupPublicInputs,
+        PublicKernelCircuitPrivateInputs,
+        PublicKernelCircuitPublicInputs,
+        PublicKernelTailCircuitPrivateInputs,
+        KernelCircuitPublicInputs,
+        ProvingError,
+        RecursiveProof,
+        VerificationKeyData,
+    }, {}, false, namespace, fetch);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnBjLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Byb3Zlci1hZ2VudC9ycGMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUNMLGdCQUFnQixFQUNoQiw2QkFBNkIsRUFDN0IsZ0JBQWdCLEVBQ2hCLGdCQUFnQixFQUNoQixFQUFFLEVBQ0YsTUFBTSxFQUNOLHlCQUF5QixFQUN6QixpQkFBaUIsRUFDakIsa0JBQWtCLEVBQ2xCLEtBQUssRUFDTCxnQ0FBZ0MsRUFDaEMsK0JBQStCLEVBQy9CLG9DQUFvQyxFQUNwQyxjQUFjLEVBQ2QsZUFBZSxFQUNmLGdCQUFnQixFQUNoQixnQkFBZ0IsRUFDaEIsc0JBQXNCLEVBQ3RCLG1CQUFtQixHQUNwQixNQUFNLG9CQUFvQixDQUFDO0FBQzVCLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxTQUFTLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUNuRixPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFFbEUsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRWxELE1BQU0sVUFBVSw0QkFBNEIsQ0FBQyxLQUF1QjtJQUNsRSxPQUFPLElBQUksYUFBYSxDQUN0QixLQUFLLEVBQ0w7UUFDRSxNQUFNO1FBQ04sRUFBRTtRQUNGLGdCQUFnQjtRQUNoQixnQkFBZ0I7UUFDaEIsNkJBQTZCO1FBQzdCLGdCQUFnQjtRQUNoQixpQkFBaUI7UUFDakIsa0JBQWtCO1FBQ2xCLEtBQUs7UUFDTCxlQUFlO1FBQ2YsZ0JBQWdCO1FBQ2hCLGdCQUFnQjtRQUNoQixzQkFBc0I7UUFDdEIsZ0NBQWdDO1FBQ2hDLCtCQUErQjtRQUMvQixvQ0FBb0M7UUFDcEMseUJBQXlCO1FBQ3pCLFlBQVk7UUFDWixjQUFjO1FBQ2QsbUJBQW1CO0tBQ3BCLEVBQ0QsRUFBRSxDQUNILENBQUM7QUFDSixDQUFDO0FBRUQsTUFBTSxVQUFVLDRCQUE0QixDQUMxQyxHQUFXLEVBQ1gsU0FBa0IsRUFDbEIsS0FBSyxHQUFHLFNBQVMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsS0FBSyxDQUFDO0lBRW5DLE9BQU8sbUJBQW1CLENBQ3hCLEdBQUcsRUFDSDtRQUNFLE1BQU07UUFDTixFQUFFO1FBQ0YsZ0JBQWdCO1FBQ2hCLGdCQUFnQjtRQUNoQiw2QkFBNkI7UUFDN0IsZ0JBQWdCO1FBQ2hCLGlCQUFpQjtRQUNqQixrQkFBa0I7UUFDbEIsS0FBSztRQUNMLGVBQWU7UUFDZixnQkFBZ0I7UUFDaEIsZ0JBQWdCO1FBQ2hCLHNCQUFzQjtRQUN0QixnQ0FBZ0M7UUFDaEMsK0JBQStCO1FBQy9CLG9DQUFvQztRQUNwQyx5QkFBeUI7UUFDekIsWUFBWTtRQUNaLGNBQWM7UUFDZCxtQkFBbUI7S0FDcEIsRUFDRCxFQUFFLEVBQ0YsS0FBSyxFQUNMLFNBQVMsRUFDVCxLQUFLLENBQ2MsQ0FBQztBQUN4QixDQUFDIn0=

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

@@ -0,0 +1,65 @@
+import { type ProcessedTx } from '@aztec/circuit-types';
+import { type BlockResult, type ProverClient, type ProvingJobSource, type ProvingTicket } from '@aztec/circuit-types/interfaces';
+import { type Fr, type GlobalVariables, type Header, type VerificationKeys } from '@aztec/circuits.js';
+import { type WorldStateSynchronizer } from '@aztec/world-state';
+import { type ProverClientConfig } from '../config.js';
+/**
+ * A prover accepting individual transaction requests
+ */
+export declare class TxProver implements ProverClient {
+    private config;
+    private worldStateSynchronizer;
+    private vks;
+    private agent?;
+    private orchestrator;
+    private queue;
+    private running;
+    private constructor();
+    updateProverConfig(config: Partial<ProverClientConfig & {
+        vks: VerificationKeys;
+    }>): Promise<void>;
+    /**
+     * Starts the prover instance
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the prover instance
+     */
+    stop(): Promise<void>;
+    /**
+     * Creates a new prover client and starts it
+     * @param config - The prover configuration.
+     * @param vks - The verification keys for the prover
+     * @param worldStateSynchronizer - An instance of the world state
+     * @returns An instance of the prover, constructed and started.
+     */
+    static new(config: ProverClientConfig, vks: VerificationKeys, worldStateSynchronizer: WorldStateSynchronizer, initialHeader?: Header): Promise<TxProver>;
+    private static buildCircuitProver;
+    /**
+     * Cancels any block that is currently being built and prepares for a new one to be built
+     * @param numTxs - The complete size of the block, must be a power of 2
+     * @param globalVariables - The global variables for this block
+     * @param l1ToL2Messages - The set of L1 to L2 messages to be included in this block
+     */
+    startNewBlock(numTxs: number, globalVariables: GlobalVariables, newL1ToL2Messages: Fr[]): Promise<ProvingTicket>;
+    /**
+     * Add a processed transaction to the current block
+     * @param tx - The transaction to be added
+     */
+    addNewTx(tx: ProcessedTx): Promise<void>;
+    /**
+     * Cancels the block currently being proven. Proofs already bring built may continue but further proofs should not be started.
+     */
+    cancelBlock(): void;
+    /**
+     * Performs the final archive tree insertion for this block and returns the L2Block and Proof instances
+     */
+    finaliseBlock(): Promise<BlockResult>;
+    /**
+     * Mark the block as having all the transactions it is going to contain.
+     * Will pad the block to it's complete size with empty transactions and prove all the way to the root rollup.
+     */
+    setBlockCompleted(): Promise<void>;
+    getProvingJobSource(): ProvingJobSource;
+}
+//# sourceMappingURL=tx-prover.d.ts.map

package/dest/tx-prover/tx-prover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx-prover.d.ts","sourceRoot":"","sources":["../../src/tx-prover/tx-prover.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAEnB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,EAAE,KAAK,eAAe,EAAE,KAAK,MAAM,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEvG,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAEjE,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAKvD;;GAEG;AACH,qBAAa,QAAS,YAAW,YAAY;IAMzC,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,sBAAsB;IAC9B,OAAO,CAAC,GAAG;IACX,OAAO,CAAC,KAAK,CAAC;IARhB,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,KAAK,CAA4B;IACzC,OAAO,CAAC,OAAO,CAAS;IAExB,OAAO;IAUD,kBAAkB,CAAC,MAAM,EAAE,OAAO,CAAC,kBAAkB,GAAG;QAAE,GAAG,EAAE,gBAAgB,CAAA;KAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBxG;;OAEG;IACI,KAAK;IAUZ;;OAEG;IACU,IAAI;IAQjB;;;;;;OAMG;WACiB,GAAG,CACrB,MAAM,EAAE,kBAAkB,EAC1B,GAAG,EAAE,gBAAgB,EACrB,sBAAsB,EAAE,sBAAsB,EAC9C,aAAa,CAAC,EAAE,MAAM;mBAeH,kBAAkB;IAYvC;;;;;OAKG;IACU,aAAa,CACxB,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,eAAe,EAChC,iBAAiB,EAAE,EAAE,EAAE,GACtB,OAAO,CAAC,aAAa,CAAC;IAMzB;;;OAGG;IACI,QAAQ,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/C;;OAEG;IACI,WAAW,IAAI,IAAI;IAI1B;;OAEG;IACI,aAAa,IAAI,OAAO,CAAC,WAAW,CAAC;IAI5C;;;OAGG;IACI,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAIlC,mBAAmB,IAAI,gBAAgB;CAG/C"}

package/dest/tx-prover/tx-prover.js

@@ -0,0 +1,122 @@
+import { BBNativeRollupProver, TestCircuitProver } from '@aztec/bb-prover';
+import { NativeACVMSimulator } from '@aztec/simulator';
+import { ProvingOrchestrator } from '../orchestrator/orchestrator.js';
+import { MemoryProvingQueue } from '../prover-agent/memory-proving-queue.js';
+import { ProverAgent } from '../prover-agent/prover-agent.js';
+/**
+ * A prover accepting individual transaction requests
+ */
+export class TxProver {
+    constructor(config, worldStateSynchronizer, vks, agent, initialHeader) {
+        this.config = config;
+        this.worldStateSynchronizer = worldStateSynchronizer;
+        this.vks = vks;
+        this.agent = agent;
+        this.queue = new MemoryProvingQueue();
+        this.running = false;
+        this.orchestrator = new ProvingOrchestrator(worldStateSynchronizer.getLatest(), this.queue, initialHeader);
+    }
+    async updateProverConfig(config) {
+        const newConfig = { ...this.config, ...config };
+        if (config.vks) {
+            this.vks = config.vks;
+        }
+        if (newConfig.realProofs !== this.config.realProofs && this.agent) {
+            const circuitProver = await TxProver.buildCircuitProver(newConfig);
+            this.agent.setCircuitProver(circuitProver);
+        }
+        if (this.config.proverAgentConcurrency !== newConfig.proverAgentConcurrency) {
+            this.agent?.setMaxConcurrency(newConfig.proverAgentConcurrency);
+        }
+        if (!this.config.realProofs && newConfig.realProofs) {
+            this.orchestrator.reset();
+        }
+        this.config = newConfig;
+    }
+    /**
+     * Starts the prover instance
+     */
+    start() {
+        if (this.running) {
+            return Promise.resolve();
+        }
+        this.running = true;
+        this.agent?.start(this.queue);
+        return Promise.resolve();
+    }
+    /**
+     * Stops the prover instance
+     */
+    async stop() {
+        if (!this.running) {
+            return;
+        }
+        this.running = false;
+        await this.agent?.stop();
+    }
+    /**
+     * Creates a new prover client and starts it
+     * @param config - The prover configuration.
+     * @param vks - The verification keys for the prover
+     * @param worldStateSynchronizer - An instance of the world state
+     * @returns An instance of the prover, constructed and started.
+     */
+    static async new(config, vks, worldStateSynchronizer, initialHeader) {
+        const agent = config.proverAgentEnabled
+            ? new ProverAgent(await TxProver.buildCircuitProver(config), config.proverAgentConcurrency, config.proverAgentPollInterval)
+            : undefined;
+        const prover = new TxProver(config, worldStateSynchronizer, vks, agent, initialHeader);
+        await prover.start();
+        return prover;
+    }
+    static async buildCircuitProver(config) {
+        if (config.realProofs) {
+            return await BBNativeRollupProver.new(config);
+        }
+        const simulationProvider = config.acvmBinaryPath
+            ? new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath)
+            : undefined;
+        return new TestCircuitProver(simulationProvider);
+    }
+    /**
+     * Cancels any block that is currently being built and prepares for a new one to be built
+     * @param numTxs - The complete size of the block, must be a power of 2
+     * @param globalVariables - The global variables for this block
+     * @param l1ToL2Messages - The set of L1 to L2 messages to be included in this block
+     */
+    async startNewBlock(numTxs, globalVariables, newL1ToL2Messages) {
+        const previousBlockNumber = globalVariables.blockNumber.toNumber() - 1;
+        await this.worldStateSynchronizer.syncImmediate(previousBlockNumber);
+        return this.orchestrator.startNewBlock(numTxs, globalVariables, newL1ToL2Messages, this.vks);
+    }
+    /**
+     * Add a processed transaction to the current block
+     * @param tx - The transaction to be added
+     */
+    addNewTx(tx) {
+        return this.orchestrator.addNewTx(tx);
+    }
+    /**
+     * Cancels the block currently being proven. Proofs already bring built may continue but further proofs should not be started.
+     */
+    cancelBlock() {
+        this.orchestrator.cancelBlock();
+    }
+    /**
+     * Performs the final archive tree insertion for this block and returns the L2Block and Proof instances
+     */
+    finaliseBlock() {
+        return this.orchestrator.finaliseBlock();
+    }
+    /**
+     * Mark the block as having all the transactions it is going to contain.
+     * Will pad the block to it's complete size with empty transactions and prove all the way to the root rollup.
+     */
+    setBlockCompleted() {
+        return this.orchestrator.setBlockCompleted();
+    }
+    getProvingJobSource() {
+        return this.queue;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHgtcHJvdmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3R4LXByb3Zlci90eC1wcm92ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG9CQUFvQixFQUFFLGlCQUFpQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFVM0UsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFJdkQsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDdEUsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0seUNBQXlDLENBQUM7QUFDN0UsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRTlEOztHQUVHO0FBQ0gsTUFBTSxPQUFPLFFBQVE7SUFLbkIsWUFDVSxNQUEwQixFQUMxQixzQkFBOEMsRUFDOUMsR0FBcUIsRUFDckIsS0FBbUIsRUFDM0IsYUFBc0I7UUFKZCxXQUFNLEdBQU4sTUFBTSxDQUFvQjtRQUMxQiwyQkFBc0IsR0FBdEIsc0JBQXNCLENBQXdCO1FBQzlDLFFBQUcsR0FBSCxHQUFHLENBQWtCO1FBQ3JCLFVBQUssR0FBTCxLQUFLLENBQWM7UUFQckIsVUFBSyxHQUFHLElBQUksa0JBQWtCLEVBQUUsQ0FBQztRQUNqQyxZQUFPLEdBQUcsS0FBSyxDQUFDO1FBU3RCLElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxtQkFBbUIsQ0FBQyxzQkFBc0IsQ0FBQyxTQUFTLEVBQUUsRUFBRSxJQUFJLENBQUMsS0FBSyxFQUFFLGFBQWEsQ0FBQyxDQUFDO0lBQzdHLENBQUM7SUFFRCxLQUFLLENBQUMsa0JBQWtCLENBQUMsTUFBK0Q7UUFDdEYsTUFBTSxTQUFTLEdBQUcsRUFBRSxHQUFHLElBQUksQ0FBQyxNQUFNLEVBQUUsR0FBRyxNQUFNLEVBQUUsQ0FBQztRQUVoRCxJQUFJLE1BQU0sQ0FBQyxHQUFHLEVBQUUsQ0FBQztZQUNmLElBQUksQ0FBQyxHQUFHLEdBQUcsTUFBTSxDQUFDLEdBQUcsQ0FBQztRQUN4QixDQUFDO1FBRUQsSUFBSSxTQUFTLENBQUMsVUFBVSxLQUFLLElBQUksQ0FBQyxNQUFNLENBQUMsVUFBVSxJQUFJLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUNsRSxNQUFNLGFBQWEsR0FBRyxNQUFNLFFBQVEsQ0FBQyxrQkFBa0IsQ0FBQyxTQUFTLENBQUMsQ0FBQztZQUNuRSxJQUFJLENBQUMsS0FBSyxDQUFDLGdCQUFnQixDQUFDLGFBQWEsQ0FBQyxDQUFDO1FBQzdDLENBQUM7UUFFRCxJQUFJLElBQUksQ0FBQyxNQUFNLENBQUMsc0JBQXNCLEtBQUssU0FBUyxDQUFDLHNCQUFzQixFQUFFLENBQUM7WUFDNUUsSUFBSSxDQUFDLEtBQUssRUFBRSxpQkFBaUIsQ0FBQyxTQUFTLENBQUMsc0JBQXNCLENBQUMsQ0FBQztRQUNsRSxDQUFDO1FBRUQsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsVUFBVSxJQUFJLFNBQVMsQ0FBQyxVQUFVLEVBQUUsQ0FBQztZQUNwRCxJQUFJLENBQUMsWUFBWSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQzVCLENBQUM7UUFFRCxJQUFJLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQztJQUMxQixDQUFDO0lBRUQ7O09BRUc7SUFDSSxLQUFLO1FBQ1YsSUFBSSxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDakIsT0FBTyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDM0IsQ0FBQztRQUVELElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDO1FBQ3BCLElBQUksQ0FBQyxLQUFLLEVBQUUsS0FBSyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUM5QixPQUFPLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUMzQixDQUFDO0lBRUQ7O09BRUc7SUFDSSxLQUFLLENBQUMsSUFBSTtRQUNmLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDbEIsT0FBTztRQUNULENBQUM7UUFDRCxJQUFJLENBQUMsT0FBTyxHQUFHLEtBQUssQ0FBQztRQUNyQixNQUFNLElBQUksQ0FBQyxLQUFLLEVBQUUsSUFBSSxFQUFFLENBQUM7SUFDM0IsQ0FBQztJQUVEOzs7Ozs7T0FNRztJQUNJLE1BQU0sQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUNyQixNQUEwQixFQUMxQixHQUFxQixFQUNyQixzQkFBOEMsRUFDOUMsYUFBc0I7UUFFdEIsTUFBTSxLQUFLLEdBQUcsTUFBTSxDQUFDLGtCQUFrQjtZQUNyQyxDQUFDLENBQUMsSUFBSSxXQUFXLENBQ2IsTUFBTSxRQUFRLENBQUMsa0JBQWtCLENBQUMsTUFBTSxDQUFDLEVBQ3pDLE1BQU0sQ0FBQyxzQkFBc0IsRUFDN0IsTUFBTSxDQUFDLHVCQUF1QixDQUMvQjtZQUNILENBQUMsQ0FBQyxTQUFTLENBQUM7UUFFZCxNQUFNLE1BQU0sR0FBRyxJQUFJLFFBQVEsQ0FBQyxNQUFNLEVBQUUsc0JBQXNCLEVBQUUsR0FBRyxFQUFFLEtBQUssRUFBRSxhQUFhLENBQUMsQ0FBQztRQUN2RixNQUFNLE1BQU0sQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNyQixPQUFPLE1BQU0sQ0FBQztJQUNoQixDQUFDO0lBRU8sTUFBTSxDQUFDLEtBQUssQ0FBQyxrQkFBa0IsQ0FBQyxNQUEwQjtRQUNoRSxJQUFJLE1BQU0sQ0FBQyxVQUFVLEVBQUUsQ0FBQztZQUN0QixPQUFPLE1BQU0sb0JBQW9CLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ2hELENBQUM7UUFFRCxNQUFNLGtCQUFrQixHQUFHLE1BQU0sQ0FBQyxjQUFjO1lBQzlDLENBQUMsQ0FBQyxJQUFJLG1CQUFtQixDQUFDLE1BQU0sQ0FBQyxvQkFBb0IsRUFBRSxNQUFNLENBQUMsY0FBYyxDQUFDO1lBQzdFLENBQUMsQ0FBQyxTQUFTLENBQUM7UUFFZCxPQUFPLElBQUksaUJBQWlCLENBQUMsa0JBQWtCLENBQUMsQ0FBQztJQUNuRCxDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSSxLQUFLLENBQUMsYUFBYSxDQUN4QixNQUFjLEVBQ2QsZUFBZ0MsRUFDaEMsaUJBQXVCO1FBRXZCLE1BQU0sbUJBQW1CLEdBQUcsZUFBZSxDQUFDLFdBQVcsQ0FBQyxRQUFRLEVBQUUsR0FBRyxDQUFDLENBQUM7UUFDdkUsTUFBTSxJQUFJLENBQUMsc0JBQXNCLENBQUMsYUFBYSxDQUFDLG1CQUFtQixDQUFDLENBQUM7UUFDckUsT0FBTyxJQUFJLENBQUMsWUFBWSxDQUFDLGFBQWEsQ0FBQyxNQUFNLEVBQUUsZUFBZSxFQUFFLGlCQUFpQixFQUFFLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUMvRixDQUFDO0lBRUQ7OztPQUdHO0lBQ0ksUUFBUSxDQUFDLEVBQWU7UUFDN0IsT0FBTyxJQUFJLENBQUMsWUFBWSxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUN4QyxDQUFDO0lBRUQ7O09BRUc7SUFDSSxXQUFXO1FBQ2hCLElBQUksQ0FBQyxZQUFZLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDbEMsQ0FBQztJQUVEOztPQUVHO0lBQ0ksYUFBYTtRQUNsQixPQUFPLElBQUksQ0FBQyxZQUFZLENBQUMsYUFBYSxFQUFFLENBQUM7SUFDM0MsQ0FBQztJQUVEOzs7T0FHRztJQUNJLGlCQUFpQjtRQUN0QixPQUFPLElBQUksQ0FBQyxZQUFZLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztJQUMvQyxDQUFDO0lBRU0sbUJBQW1CO1FBQ3hCLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQztJQUNwQixDQUFDO0NBQ0YifQ==