@aztec/prover-client 0.0.0-test.0

package/dest/proving_broker/proving_broker_database/persisted.js

@@ -0,0 +1,182 @@
+import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
+import { createLogger } from '@aztec/foundation/log';
+import { BatchQueue } from '@aztec/foundation/queue';
+import { openVersionedStoreAt } from '@aztec/kv-store/lmdb-v2';
+import { ProvingJob, ProvingJobSettledResult, getEpochFromProvingJobId } from '@aztec/stdlib/interfaces/server';
+import { Attributes, LmdbMetrics, getTelemetryClient } from '@aztec/telemetry-client';
+import { mkdir, readdir } from 'fs/promises';
+import { join } from 'path';
+class SingleEpochDatabase {
+    store;
+    static SCHEMA_VERSION = 1;
+    jobs;
+    jobResults;
+    constructor(store){
+        this.store = store;
+        this.jobs = store.openMap('proving_jobs');
+        this.jobResults = store.openMap('proving_job_results');
+    }
+    estimateSize() {
+        return this.store.estimateSize();
+    }
+    async batchWrite(jobs, results) {
+        await this.store.transactionAsync(async ()=>{
+            for (const job of jobs){
+                await this.jobs.set(job.id, jsonStringify(job));
+            }
+            for (const [id, result] of results){
+                await this.jobResults.set(id, jsonStringify(result));
+            }
+        });
+    }
+    async *allProvingJobs() {
+        for await (const jobStr of this.jobs.valuesAsync()){
+            const job = await jsonParseWithSchema(jobStr, ProvingJob);
+            const resultStr = await this.jobResults.getAsync(job.id);
+            const result = resultStr ? await jsonParseWithSchema(resultStr, ProvingJobSettledResult) : undefined;
+            yield [
+                job,
+                result
+            ];
+        }
+    }
+    async setProvingJobError(id, reason) {
+        const result = {
+            status: 'rejected',
+            reason
+        };
+        await this.jobResults.set(id, jsonStringify(result));
+    }
+    async setProvingJobResult(id, value) {
+        const result = {
+            status: 'fulfilled',
+            value
+        };
+        await this.jobResults.set(id, jsonStringify(result));
+    }
+    delete() {
+        return this.store.delete();
+    }
+    close() {
+        return this.store.close();
+    }
+}
+export class KVBrokerDatabase {
+    epochs;
+    config;
+    logger;
+    metrics;
+    batchQueue;
+    constructor(epochs, config, client = getTelemetryClient(), logger){
+        this.epochs = epochs;
+        this.config = config;
+        this.logger = logger;
+        this.metrics = new LmdbMetrics(client.getMeter('KVBrokerDatabase'), {
+            [Attributes.DB_DATA_TYPE]: 'prover-broker'
+        }, ()=>this.estimateSize());
+        this.batchQueue = new BatchQueue((items, key)=>this.commitWrites(items, key), config.proverBrokerBatchSize, config.proverBrokerBatchIntervalMs, createLogger('proving-client:proving-broker-database:batch-queue'));
+    }
+    // exposed for testing
+    async commitWrites(items, epochNumber) {
+        const jobsToAdd = items.filter((item)=>'id' in item);
+        const resultsToAdd = items.filter((item)=>Array.isArray(item));
+        const db = await this.getEpochDatabase(epochNumber);
+        await db.batchWrite(jobsToAdd, resultsToAdd);
+    }
+    async estimateSize() {
+        const sizes = await Promise.all(Array.from(this.epochs.values()).map((x)=>x.estimateSize()));
+        return {
+            mappingSize: this.config.dataStoreMapSizeKB,
+            numItems: sizes.reduce((prev, curr)=>prev + curr.numItems, 0),
+            actualSize: sizes.reduce((prev, curr)=>prev + curr.actualSize, 0)
+        };
+    }
+    static async new(config, client = getTelemetryClient(), logger = createLogger('prover-client:proving-broker-database')) {
+        const epochs = new Map();
+        const files = await readdir(config.dataDirectory, {
+            recursive: false,
+            withFileTypes: true
+        });
+        for (const file of files){
+            if (!file.isDirectory()) {
+                continue;
+            }
+            const fullDirectory = join(config.dataDirectory, file.name);
+            const epochDirectory = file.name;
+            const epochNumber = parseInt(epochDirectory, 10);
+            if (!Number.isSafeInteger(epochNumber) || epochNumber < 0) {
+                logger.warn(`Found invalid epoch directory ${fullDirectory} when loading epoch databases, ignoring`);
+                continue;
+            }
+            logger.info(`Loading broker database for epoch ${epochNumber} from ${fullDirectory} with map size ${config.dataStoreMapSizeKB}KB`);
+            const db = await openVersionedStoreAt(fullDirectory, SingleEpochDatabase.SCHEMA_VERSION, config.l1Contracts.rollupAddress, config.dataStoreMapSizeKB);
+            const epochDb = new SingleEpochDatabase(db);
+            epochs.set(epochNumber, epochDb);
+        }
+        const db = new KVBrokerDatabase(epochs, config, client, logger);
+        db.start();
+        return db;
+    }
+    start() {
+        this.batchQueue.start();
+    }
+    async close() {
+        await this.batchQueue.stop();
+        for (const [_, v] of this.epochs){
+            await v.close();
+        }
+    }
+    async deleteAllProvingJobsOlderThanEpoch(epochNumber) {
+        const oldEpochs = Array.from(this.epochs.keys()).filter((e)=>e < epochNumber);
+        for (const old of oldEpochs){
+            const db = this.epochs.get(old);
+            if (!db) {
+                continue;
+            }
+            this.logger.info(`Deleting broker database for epoch ${old}`);
+            await db.delete();
+            this.epochs.delete(old);
+        }
+    }
+    addProvingJob(job) {
+        return this.batchQueue.put(job, job.epochNumber);
+    }
+    async *allProvingJobs() {
+        const iterators = Array.from(this.epochs.values()).map((x)=>x.allProvingJobs());
+        for (const it of iterators){
+            yield* it;
+        }
+    }
+    setProvingJobError(id, reason) {
+        return this.batchQueue.put([
+            id,
+            {
+                status: 'rejected',
+                reason
+            }
+        ], getEpochFromProvingJobId(id));
+    }
+    setProvingJobResult(id, value) {
+        return this.batchQueue.put([
+            id,
+            {
+                status: 'fulfilled',
+                value
+            }
+        ], getEpochFromProvingJobId(id));
+    }
+    async getEpochDatabase(epochNumber) {
+        let epochDb = this.epochs.get(epochNumber);
+        if (!epochDb) {
+            const newEpochDirectory = join(this.config.dataDirectory, epochNumber.toString());
+            await mkdir(newEpochDirectory, {
+                recursive: true
+            });
+            this.logger.info(`Creating broker database for epoch ${epochNumber} at ${newEpochDirectory} with map size ${this.config.dataStoreMapSizeKB}`);
+            const db = await openVersionedStoreAt(newEpochDirectory, SingleEpochDatabase.SCHEMA_VERSION, this.config.l1Contracts.rollupAddress, this.config.dataStoreMapSizeKB);
+            epochDb = new SingleEpochDatabase(db);
+            this.epochs.set(epochNumber, epochDb);
+        }
+        return epochDb;
+    }
+}

package/dest/proving_broker/proving_broker_database.d.ts

@@ -0,0 +1,39 @@
+import type { ProofUri, ProvingJob, ProvingJobId, ProvingJobSettledResult } from '@aztec/stdlib/interfaces/server';
+/**
+ * A database for storing proof requests and their results
+ */
+export interface ProvingBrokerDatabase {
+    /**
+     * Saves a proof request so it can be retrieved later
+     * @param job - The proof request to save
+     */
+    addProvingJob(job: ProvingJob): Promise<void>;
+    /**
+     * Deletes all proving jobs belonging to epochs older than the given epoch
+     * @param epochNumber - The epoch number beyond which jobs should be deleted
+     */
+    deleteAllProvingJobsOlderThanEpoch(epochNumber: number): Promise<void>;
+    /**
+     * Returns an iterator over all saved proving jobs
+     */
+    allProvingJobs(): AsyncIterableIterator<[ProvingJob, ProvingJobSettledResult | undefined]>;
+    /**
+     * Saves the result of a proof request
+     * @param id - The ID of the proof request to save the result for
+     * @param ProvingRequestType - The type of proof that was requested
+     * @param value - The result of the proof request
+     */
+    setProvingJobResult(id: ProvingJobId, value: ProofUri): Promise<void>;
+    /**
+     * Saves an error that occurred while processing a proof request
+     * @param id - The ID of the proof request to save the error for
+     * @param ProvingRequestType - The type of proof that was requested
+     * @param err - The error that occurred while processing the proof request
+     */
+    setProvingJobError(id: ProvingJobId, err: string): Promise<void>;
+    /**
+     * Closes the database
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=proving_broker_database.d.ts.map

package/dest/proving_broker/proving_broker_database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proving_broker_database.d.ts","sourceRoot":"","sources":["../../src/proving_broker/proving_broker_database.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAEnH;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,aAAa,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE9C;;;OAGG;IACH,kCAAkC,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvE;;OAEG;IACH,cAAc,IAAI,qBAAqB,CAAC,CAAC,UAAU,EAAE,uBAAuB,GAAG,SAAS,CAAC,CAAC,CAAC;IAE3F;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtE;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjE;;OAEG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB"}

package/dest/proving_broker/proving_broker_database.js

@@ -0,0 +1,3 @@
+/**
+ * A database for storing proof requests and their results
+ */ export { };

package/dest/proving_broker/proving_broker_instrumentation.d.ts

@@ -0,0 +1,29 @@
+import type { Timer } from '@aztec/foundation/timer';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+export type MonitorCallback = (proofType: ProvingRequestType) => number;
+export declare class ProvingBrokerInstrumentation {
+    private queueSize;
+    private activeJobs;
+    private resolvedJobs;
+    private rejectedJobs;
+    private timedOutJobs;
+    private cachedJobs;
+    private totalJobs;
+    private jobWait;
+    private jobDuration;
+    private retriedJobs;
+    constructor(client: TelemetryClient, name?: string);
+    monitorQueueDepth(fn: MonitorCallback): void;
+    monitorActiveJobs(fn: MonitorCallback): void;
+    incResolvedJobs(proofType: ProvingRequestType): void;
+    incRejectedJobs(proofType: ProvingRequestType): void;
+    incRetriedJobs(proofType: ProvingRequestType): void;
+    incTimedOutJobs(proofType: ProvingRequestType): void;
+    incCachedJobs(proofType: ProvingRequestType): void;
+    incTotalJobs(proofType: ProvingRequestType): void;
+    recordJobWait(proofType: ProvingRequestType, msOrTimer: Timer | number): void;
+    recordJobDuration(proofType: ProvingRequestType, msOrTimer: Timer | number): void;
+    private observe;
+}
+//# sourceMappingURL=proving_broker_instrumentation.d.ts.map

package/dest/proving_broker/proving_broker_instrumentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proving_broker_instrumentation.d.ts","sourceRoot":"","sources":["../../src/proving_broker/proving_broker_instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAML,KAAK,eAAe,EAGrB,MAAM,yBAAyB,CAAC;AAEjC,MAAM,MAAM,eAAe,GAAG,CAAC,SAAS,EAAE,kBAAkB,KAAK,MAAM,CAAC;AAExE,qBAAa,4BAA4B;IACvC,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,UAAU,CAAkB;IACpC,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,SAAS,CAAgB;IACjC,OAAO,CAAC,OAAO,CAAY;IAC3B,OAAO,CAAC,WAAW,CAAY;IAC/B,OAAO,CAAC,WAAW,CAAgB;gBAEvB,MAAM,EAAE,eAAe,EAAE,IAAI,SAAkB;IAgD3D,iBAAiB,CAAC,EAAE,EAAE,eAAe;IAIrC,iBAAiB,CAAC,EAAE,EAAE,eAAe;IAIrC,eAAe,CAAC,SAAS,EAAE,kBAAkB;IAM7C,eAAe,CAAC,SAAS,EAAE,kBAAkB;IAM7C,cAAc,CAAC,SAAS,EAAE,kBAAkB;IAM5C,eAAe,CAAC,SAAS,EAAE,kBAAkB;IAM7C,aAAa,CAAC,SAAS,EAAE,kBAAkB;IAM3C,YAAY,CAAC,SAAS,EAAE,kBAAkB;IAM1C,aAAa,CAAC,SAAS,EAAE,kBAAkB,EAAE,SAAS,EAAE,KAAK,GAAG,MAAM;IAOtE,iBAAiB,CAAC,SAAS,EAAE,kBAAkB,EAAE,SAAS,EAAE,KAAK,GAAG,MAAM;IAO1E,OAAO,CAAC,OAAO;CAWhB"}

package/dest/proving_broker/proving_broker_instrumentation.js

@@ -0,0 +1,110 @@
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
+export class ProvingBrokerInstrumentation {
+    queueSize;
+    activeJobs;
+    resolvedJobs;
+    rejectedJobs;
+    timedOutJobs;
+    cachedJobs;
+    totalJobs;
+    jobWait;
+    jobDuration;
+    retriedJobs;
+    constructor(client, name = 'ProvingBroker'){
+        const meter = client.getMeter(name);
+        this.queueSize = meter.createObservableGauge(Metrics.PROVING_QUEUE_SIZE, {
+            valueType: ValueType.INT
+        });
+        this.activeJobs = meter.createObservableGauge(Metrics.PROVING_QUEUE_ACTIVE_JOBS, {
+            valueType: ValueType.INT
+        });
+        this.resolvedJobs = meter.createUpDownCounter(Metrics.PROVING_QUEUE_RESOLVED_JOBS, {
+            valueType: ValueType.INT
+        });
+        this.rejectedJobs = meter.createUpDownCounter(Metrics.PROVING_QUEUE_REJECTED_JOBS, {
+            valueType: ValueType.INT
+        });
+        this.retriedJobs = meter.createUpDownCounter(Metrics.PROVING_QUEUE_RETRIED_JOBS, {
+            valueType: ValueType.INT
+        });
+        this.timedOutJobs = meter.createUpDownCounter(Metrics.PROVING_QUEUE_TIMED_OUT_JOBS, {
+            valueType: ValueType.INT
+        });
+        this.cachedJobs = meter.createUpDownCounter(Metrics.PROVING_QUEUE_CACHED_JOBS, {
+            valueType: ValueType.INT
+        });
+        this.totalJobs = meter.createUpDownCounter(Metrics.PROVING_QUEUE_TOTAL_JOBS, {
+            valueType: ValueType.INT
+        });
+        this.jobWait = meter.createHistogram(Metrics.PROVING_QUEUE_JOB_WAIT, {
+            description: 'Records how long a job sits in the queue',
+            unit: 'ms',
+            valueType: ValueType.INT
+        });
+        this.jobDuration = meter.createHistogram(Metrics.PROVING_QUEUE_JOB_DURATION, {
+            description: 'Records how long a job takes to complete',
+            unit: 'ms',
+            valueType: ValueType.INT
+        });
+    }
+    monitorQueueDepth(fn) {
+        this.queueSize.addCallback((obs)=>this.observe(obs, fn));
+    }
+    monitorActiveJobs(fn) {
+        this.activeJobs.addCallback((obs)=>this.observe(obs, fn));
+    }
+    incResolvedJobs(proofType) {
+        this.resolvedJobs.add(1, {
+            [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[proofType]
+        });
+    }
+    incRejectedJobs(proofType) {
+        this.rejectedJobs.add(1, {
+            [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[proofType]
+        });
+    }
+    incRetriedJobs(proofType) {
+        this.retriedJobs.add(1, {
+            [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[proofType]
+        });
+    }
+    incTimedOutJobs(proofType) {
+        this.timedOutJobs.add(1, {
+            [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[proofType]
+        });
+    }
+    incCachedJobs(proofType) {
+        this.cachedJobs.add(1, {
+            [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[proofType]
+        });
+    }
+    incTotalJobs(proofType) {
+        this.totalJobs.add(1, {
+            [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[proofType]
+        });
+    }
+    recordJobWait(proofType, msOrTimer) {
+        const duration = typeof msOrTimer === 'number' ? msOrTimer : Math.floor(msOrTimer.ms());
+        this.jobWait.record(duration, {
+            [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[proofType]
+        });
+    }
+    recordJobDuration(proofType, msOrTimer) {
+        const duration = typeof msOrTimer === 'number' ? msOrTimer : Math.floor(msOrTimer.ms());
+        this.jobDuration.record(duration, {
+            [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[proofType]
+        });
+    }
+    observe(obs, fn) {
+        for (const proofType of Object.values(ProvingRequestType)){
+            // a type predicate for TypeScript to recognize that we're only iterating over enum values
+            if (typeof proofType !== 'number') {
+                continue;
+            }
+            obs.observe(fn(proofType), {
+                [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[proofType]
+            });
+        }
+    }
+}

package/dest/proving_broker/proving_job_controller.d.ts

@@ -0,0 +1,33 @@
+import type { ProvingJobId, ProvingJobInputs, ProvingJobResultsMap, ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+export declare enum ProvingJobControllerStatus {
+    IDLE = "idle",
+    PROVING = "proving",
+    DONE = "done",
+    ABORTED = "aborted"
+}
+interface ProvingJobCompletionCallback<T extends ProvingRequestType = ProvingRequestType> {
+    (jobId: ProvingJobId, type: T, error: Error | undefined, result: ProvingJobResultsMap[T] | undefined): void | Promise<void>;
+}
+export declare class ProvingJobController {
+    private jobId;
+    private inputs;
+    private epochNumber;
+    private startedAt;
+    private circuitProver;
+    private onComplete;
+    private log;
+    private status;
+    private promise?;
+    private abortController;
+    constructor(jobId: ProvingJobId, inputs: ProvingJobInputs, epochNumber: number, startedAt: number, circuitProver: ServerCircuitProver, onComplete: ProvingJobCompletionCallback, log?: import("@aztec/foundation/log").Logger);
+    start(): void;
+    getStatus(): ProvingJobControllerStatus;
+    abort(): void;
+    getJobId(): ProvingJobId;
+    getStartedAt(): number;
+    getProofTypeName(): string;
+    private generateProof;
+}
+export {};
+//# sourceMappingURL=proving_job_controller.d.ts.map

package/dest/proving_broker/proving_job_controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proving_job_controller.d.ts","sourceRoot":"","sources":["../../src/proving_broker/proving_job_controller.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAChB,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,oBAAY,0BAA0B;IACpC,IAAI,SAAS;IACb,OAAO,YAAY;IACnB,IAAI,SAAS;IACb,OAAO,YAAY;CACpB;AAED,UAAU,4BAA4B,CAAC,CAAC,SAAS,kBAAkB,GAAG,kBAAkB;IACtF,CACE,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC,GAAG,SAAS,GAC1C,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAED,qBAAa,oBAAoB;IAM7B,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,GAAG;IAXb,OAAO,CAAC,MAAM,CAA+D;IAC7E,OAAO,CAAC,OAAO,CAAC,CAAgB;IAChC,OAAO,CAAC,eAAe,CAAyB;gBAGtC,KAAK,EAAE,YAAY,EACnB,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,mBAAmB,EAClC,UAAU,EAAE,4BAA4B,EACxC,GAAG,yCAA6D;IAGnE,KAAK,IAAI,IAAI;IA+Db,SAAS,IAAI,0BAA0B;IAIvC,KAAK,IAAI,IAAI;IAgBb,QAAQ,IAAI,YAAY;IAIxB,YAAY,IAAI,MAAM;IAItB,gBAAgB,IAAI,MAAM;YAInB,aAAa;CA0D5B"}

package/dest/proving_broker/proving_job_controller.js

@@ -0,0 +1,166 @@
+import { createLogger } from '@aztec/foundation/log';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+export var ProvingJobControllerStatus = /*#__PURE__*/ function(ProvingJobControllerStatus) {
+    ProvingJobControllerStatus["IDLE"] = "idle";
+    ProvingJobControllerStatus["PROVING"] = "proving";
+    ProvingJobControllerStatus["DONE"] = "done";
+    ProvingJobControllerStatus["ABORTED"] = "aborted";
+    return ProvingJobControllerStatus;
+}({});
+export class ProvingJobController {
+    jobId;
+    inputs;
+    epochNumber;
+    startedAt;
+    circuitProver;
+    onComplete;
+    log;
+    status;
+    promise;
+    abortController;
+    constructor(jobId, inputs, epochNumber, startedAt, circuitProver, onComplete, log = createLogger('prover-client:proving-agent:job-controller')){
+        this.jobId = jobId;
+        this.inputs = inputs;
+        this.epochNumber = epochNumber;
+        this.startedAt = startedAt;
+        this.circuitProver = circuitProver;
+        this.onComplete = onComplete;
+        this.log = log;
+        this.status = "idle";
+        this.abortController = new AbortController();
+    }
+    start() {
+        if (this.status !== "idle") {
+            this.log.verbose(`Job controller for jobId=${this.jobId} not starting because it is not idle currentStatus=${this.status}`, {
+                currentStatus: this.status,
+                jobId: this.jobId
+            });
+            return;
+        }
+        this.status = "proving";
+        this.log.verbose(`Job controller started jobId=${this.jobId}`, {
+            jobId: this.jobId
+        });
+        this.promise = this.generateProof().then((result)=>{
+            if (this.status === "aborted") {
+                this.log.warn(`Job controller for jobId=${this.jobId} completed successfully but job was aborted`, {
+                    currentStatus: this.status,
+                    jobId: this.jobId
+                });
+                return;
+            }
+            this.status = "done";
+            this.log.verbose(`Job controller for jobId=${this.jobId} completed successfully`, {
+                jobId: this.jobId
+            });
+            return this.onComplete(this.jobId, this.inputs.type, undefined, result);
+        }, (error)=>{
+            if (this.status === "aborted") {
+                this.log.warn(`Job controller for jobId=${this.jobId} finished with an error but job was aborted`, {
+                    currentStatus: this.status,
+                    jobId: this.jobId
+                });
+                return;
+            }
+            if (error.name === 'AbortError') {
+                // Ignore abort errors
+                return;
+            }
+            this.log.verbose(`Job controller for jobId=${this.jobId} finished with an error`, {
+                jobId: this.jobId,
+                err: error
+            });
+            this.status = "done";
+            return this.onComplete(this.jobId, this.inputs.type, error, undefined);
+        }).catch((err)=>{
+            this.log.error(`Job constroller failed to send result for jobId=${this.jobId}: ${err}`, err, {
+                jobId: this.jobId
+            });
+        });
+    }
+    getStatus() {
+        return this.status;
+    }
+    abort() {
+        if (this.status !== "proving") {
+            this.log.warn(`Tried to abort job controller for jobId=${this.jobId} but it is not running`, {
+                currentStatus: this.status,
+                jobId: this.jobId
+            });
+            return;
+        }
+        this.status = "aborted";
+        this.abortController.abort();
+        this.log.verbose(`Aborted job controller for jobId=${this.jobId}`, {
+            jobId: this.jobId
+        });
+    }
+    getJobId() {
+        return this.jobId;
+    }
+    getStartedAt() {
+        return this.startedAt;
+    }
+    getProofTypeName() {
+        return ProvingRequestType[this.inputs.type];
+    }
+    async generateProof() {
+        const { type, inputs } = this.inputs;
+        const signal = this.abortController.signal;
+        switch(type){
+            case ProvingRequestType.PUBLIC_VM:
+                {
+                    return await this.circuitProver.getAvmProof(inputs, signal, this.epochNumber);
+                }
+            case ProvingRequestType.PRIVATE_BASE_ROLLUP:
+                {
+                    return await this.circuitProver.getPrivateBaseRollupProof(inputs, signal, this.epochNumber);
+                }
+            case ProvingRequestType.PUBLIC_BASE_ROLLUP:
+                {
+                    return await this.circuitProver.getPublicBaseRollupProof(inputs, signal, this.epochNumber);
+                }
+            case ProvingRequestType.MERGE_ROLLUP:
+                {
+                    return await this.circuitProver.getMergeRollupProof(inputs, signal, this.epochNumber);
+                }
+            case ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP:
+                {
+                    return await this.circuitProver.getEmptyBlockRootRollupProof(inputs, signal, this.epochNumber);
+                }
+            case ProvingRequestType.BLOCK_ROOT_ROLLUP:
+                {
+                    return await this.circuitProver.getBlockRootRollupProof(inputs, signal, this.epochNumber);
+                }
+            case ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP:
+                {
+                    return await this.circuitProver.getSingleTxBlockRootRollupProof(inputs, signal, this.epochNumber);
+                }
+            case ProvingRequestType.BLOCK_MERGE_ROLLUP:
+                {
+                    return await this.circuitProver.getBlockMergeRollupProof(inputs, signal, this.epochNumber);
+                }
+            case ProvingRequestType.ROOT_ROLLUP:
+                {
+                    return await this.circuitProver.getRootRollupProof(inputs, signal, this.epochNumber);
+                }
+            case ProvingRequestType.BASE_PARITY:
+                {
+                    return await this.circuitProver.getBaseParityProof(inputs, signal, this.epochNumber);
+                }
+            case ProvingRequestType.ROOT_PARITY:
+                {
+                    return await this.circuitProver.getRootParityProof(inputs, signal, this.epochNumber);
+                }
+            case ProvingRequestType.TUBE_PROOF:
+                {
+                    return await this.circuitProver.getTubeProof(inputs, signal, this.epochNumber);
+                }
+            default:
+                {
+                    const _exhaustive = type;
+                    return Promise.reject(new Error(`Invalid proof request type: ${type}`));
+                }
+        }
+    }
+}

package/dest/proving_broker/rpc.d.ts

@@ -0,0 +1,27 @@
+import type { SafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
+import { type ProvingJobBroker, type ProvingJobConsumer, type ProvingJobProducer } from '@aztec/stdlib/interfaces/server';
+import { type ApiSchemaFor } from '@aztec/stdlib/schemas';
+import { type ComponentsVersions } from '@aztec/stdlib/versioning';
+export declare const ProvingJobProducerSchema: ApiSchemaFor<ProvingJobProducer>;
+export declare const ProvingJobConsumerSchema: ApiSchemaFor<ProvingJobConsumer>;
+export declare const ProvingJobBrokerSchema: ApiSchemaFor<ProvingJobBroker>;
+export declare function createProvingBrokerServer(broker: ProvingJobBroker): SafeJsonRpcServer;
+export declare function createProvingJobBrokerClient(url: string, versions: Partial<ComponentsVersions>, fetch?: (host: string, rpcMethod: string, body: any, useApiEndpoints: boolean, extraHeaders?: Record<string, string> | undefined, noRetry?: boolean | undefined) => Promise<{
+    response: any;
+    headers: {
+        get: (header: string) => string | null | undefined;
+    };
+}>): ProvingJobBroker;
+export declare function createProvingJobProducerClient(url: string, versions: Partial<ComponentsVersions>, fetch?: (host: string, rpcMethod: string, body: any, useApiEndpoints: boolean, extraHeaders?: Record<string, string> | undefined, noRetry?: boolean | undefined) => Promise<{
+    response: any;
+    headers: {
+        get: (header: string) => string | null | undefined;
+    };
+}>): ProvingJobProducer;
+export declare function createProvingJobConsumerClient(url: string, versions: Partial<ComponentsVersions>, fetch?: (host: string, rpcMethod: string, body: any, useApiEndpoints: boolean, extraHeaders?: Record<string, string> | undefined, noRetry?: boolean | undefined) => Promise<{
+    response: any;
+    headers: {
+        get: (header: string) => string | null | undefined;
+    };
+}>): ProvingJobConsumer;
+//# sourceMappingURL=rpc.d.ts.map

package/dest/proving_broker/rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../../src/proving_broker/rpc.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EAEvB,KAAK,kBAAkB,EAExB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,KAAK,YAAY,EAAY,MAAM,uBAAuB,CAAC;AACpE,OAAO,EAAE,KAAK,kBAAkB,EAAgC,MAAM,0BAA0B,CAAC;AAcjG,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,kBAAkB,CAKrE,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,kBAAkB,CAcrE,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,gBAAgB,CAGjE,CAAC;AAEF,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,gBAAgB,GAAG,iBAAiB,CAErF;AAED,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,EACrC,KAAK;;;;;EAAoC,GACxC,gBAAgB,CAMlB;AAED,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,EACrC,KAAK;;;;;EAAoC,GACxC,kBAAkB,CAMpB;AAED,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,EACrC,KAAK;;;;;EAAoC,GACxC,kBAAkB,CAMpB"}