@aztec/prover-client 0.0.0-test.0

package/dest/proving_broker/broker_prover_facade.js

@@ -0,0 +1,344 @@
+import { sha256 } from '@aztec/foundation/crypto';
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise, promiseWithResolvers } from '@aztec/foundation/promise';
+import { truncate } from '@aztec/foundation/string';
+import { makeProvingJobId } from '@aztec/stdlib/interfaces/server';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+import { InlineProofStore } from './proof_store/index.js';
+// Perform a snapshot sync every 30 seconds
+const SNAPSHOT_SYNC_INTERVAL_MS = 30_000;
+const MAX_CONCURRENT_JOB_SETTLED_REQUESTS = 10;
+const SNAPSHOT_SYNC_CHECK_MAX_REQUEST_SIZE = 1000;
+export class BrokerCircuitProverFacade {
+    broker;
+    proofStore;
+    failedProofStore;
+    pollIntervalMs;
+    log;
+    jobs;
+    runningPromise;
+    timeOfLastSnapshotSync;
+    jobsToRetrieve;
+    constructor(broker, proofStore = new InlineProofStore(), failedProofStore, pollIntervalMs = 1000, log = createLogger('prover-client:broker-circuit-prover-facade')){
+        this.broker = broker;
+        this.proofStore = proofStore;
+        this.failedProofStore = failedProofStore;
+        this.pollIntervalMs = pollIntervalMs;
+        this.log = log;
+        this.jobs = new Map();
+        this.timeOfLastSnapshotSync = Date.now();
+        this.jobsToRetrieve = new Set();
+    }
+    /**
+   * This is a critical section. This function can not be async since it writes
+   * to the jobs map which acts as a mutex, ensuring a job is only ever created once.
+   *
+   * This could be called in a SerialQueue if it needs to become async.
+   */ getOrCreateProvingJob(id, type, signal) {
+        // Check if there is already a promise for this job
+        const existingJob = this.jobs.get(id);
+        if (existingJob) {
+            this.log.verbose(`Job already found in facade id=${id} type=${ProvingRequestType[type]}`, {
+                provingJobId: id,
+                provingJobType: ProvingRequestType[type]
+            });
+            return {
+                job: existingJob,
+                isEnqueued: true
+            };
+        }
+        // Create a promise for this job id, regardless of whether it was enqueued at the broker
+        // The running promise will monitor for the job to be completed and resolve it either way
+        const promise = promiseWithResolvers();
+        const abortFn = ()=>{
+            signal?.removeEventListener('abort', abortFn);
+            void this.broker.cancelProvingJob(id).catch((err)=>this.log.warn(`Error cancelling job id=${id}`, err));
+        };
+        const job = {
+            id,
+            type,
+            deferred: promise,
+            abortFn,
+            signal
+        };
+        this.jobs.set(id, job);
+        return {
+            job,
+            isEnqueued: false
+        };
+    }
+    async enqueueJob(id, type, inputs, epochNumber = 0, signal) {
+        const { job: job, isEnqueued } = this.getOrCreateProvingJob(id, type, signal);
+        if (isEnqueued) {
+            return job.deferred.promise;
+        }
+        try {
+            const inputsUri = await this.proofStore.saveProofInput(id, type, inputs);
+            job.inputsUri = inputsUri;
+            const jobStatus = await this.broker.enqueueProvingJob({
+                id,
+                type,
+                inputsUri,
+                epochNumber
+            });
+            // If we are here then the job was successfully accepted by the broker
+            // the returned status is for before any action was performed
+            if (jobStatus.status === 'fulfilled' || jobStatus.status === 'rejected') {
+                // Job was already completed by the broker
+                // No need to notify the broker on aborted job
+                this.log.verbose(`Job already completed when sent to broker id=${id} type=${ProvingRequestType[type]} epochNumber=${epochNumber}`, {
+                    provingJobId: id,
+                    provingJobType: ProvingRequestType[type],
+                    epochNumber,
+                    inputsUri: truncate(inputsUri)
+                });
+                // Job was not enqueued. It must be completed already, add to our set of already completed jobs
+                this.jobsToRetrieve.add(id);
+            } else {
+                // notify the broker if job is aborted
+                signal?.addEventListener('abort', job.abortFn);
+                // Job added for the first time
+                if (jobStatus.status === 'not-found') {
+                    this.log.verbose(`Job enqueued with broker id=${id} type=${ProvingRequestType[type]} epochNumber=${epochNumber}`, {
+                        provingJobId: id,
+                        provingJobType: ProvingRequestType[type],
+                        epochNumber,
+                        inputsUri: truncate(inputsUri),
+                        numOutstandingJobs: this.jobs.size
+                    });
+                } else {
+                    // Job was previously sent to the broker but is not completed
+                    this.log.verbose(`Job already in queue or in progress when sent to broker id=${id} type=${ProvingRequestType[type]} epochNumber=${epochNumber}`, {
+                        provingJobId: id,
+                        provingJobType: ProvingRequestType[type],
+                        epochNumber,
+                        inputsUri: truncate(inputsUri)
+                    });
+                }
+            }
+        } catch (err) {
+            this.jobs.delete(job.id);
+            job.deferred.reject(err);
+        }
+        return job.deferred.promise;
+    }
+    start() {
+        if (this.runningPromise) {
+            throw new Error('BrokerCircuitProverFacade already started');
+        }
+        this.log.verbose('Starting BrokerCircuitProverFacade');
+        this.runningPromise = new RunningPromise(()=>this.monitorForCompletedJobs(), this.log, this.pollIntervalMs);
+        this.runningPromise.start();
+    }
+    async stop() {
+        if (!this.runningPromise) {
+            throw new Error('BrokerCircuitProverFacade not started');
+        }
+        this.log.verbose('Stopping BrokerCircuitProverFacade');
+        await this.runningPromise.stop();
+        // Reject any outstanding promises as stopped
+        for (const [_, v] of this.jobs){
+            v.deferred.reject(new Error('Broker facade stopped'));
+        }
+        this.jobs.clear();
+    }
+    async updateCompletedJobs() {
+        // Here we check for completed jobs. If everything works well (there are no service restarts etc) then all we need to do
+        // to maintain correct job state is to check for incrementally completed jobs. i.e. call getCompletedJobs with an empty array
+        // However, if there are any problems then we may lose sync with the broker's actual set of completed jobs.
+        // In this case we need to perform a full snapshot sync. This involves sending all of our outstanding job Ids to the broker
+        // and have the broker report on whether they are completed or not.
+        // We perform an incremental sync on every call of this function with a full snapshot sync periodically.
+        // This should keep us in sync without over-burdening the broker with snapshot sync requests
+        const getAllCompletedJobs = async (ids)=>{
+            // In this function we take whatever set of snapshot ids and we ask the broker for completed job notifications
+            // We collect all returned notifications and return them
+            const allCompleted = new Set();
+            try {
+                let numRequests = 0;
+                while(ids.length > 0){
+                    const slice = ids.splice(0, SNAPSHOT_SYNC_CHECK_MAX_REQUEST_SIZE);
+                    const completed = await this.broker.getCompletedJobs(slice);
+                    completed.forEach((id)=>allCompleted.add(id));
+                    ++numRequests;
+                }
+                if (numRequests === 0) {
+                    const final = await this.broker.getCompletedJobs([]);
+                    final.forEach((id)=>allCompleted.add(id));
+                }
+            } catch (err) {
+                this.log.error(`Error thrown when requesting completed job notifications from the broker`, err);
+            }
+            return allCompleted;
+        };
+        const snapshotSyncIds = [];
+        const currentTime = Date.now();
+        const secondsSinceLastSnapshotSync = currentTime - this.timeOfLastSnapshotSync;
+        if (secondsSinceLastSnapshotSync > SNAPSHOT_SYNC_INTERVAL_MS) {
+            this.timeOfLastSnapshotSync = currentTime;
+            snapshotSyncIds.push(...this.jobs.keys());
+            this.log.trace(`Performing full snapshot sync of completed jobs with ${snapshotSyncIds.length} job(s)`);
+        } else {
+            this.log.trace(`Performing incremental sync of completed jobs`, {
+                snapshotSyncIds
+            });
+        }
+        // Now request the notifications from the broker
+        const snapshotIdsLength = snapshotSyncIds.length;
+        const completedJobs = await getAllCompletedJobs(snapshotSyncIds);
+        // We now have an additional set of completed job notifications to add to our cached set giving us the full set of jobs that we have been told are ready
+        // We filter this list to what we actually need, in case for any reason it is different and store in our cache
+        const allJobsReady = [
+            ...completedJobs,
+            ...this.jobsToRetrieve
+        ];
+        this.jobsToRetrieve = new Set(allJobsReady.filter((id)=>this.jobs.has(id)));
+        if (completedJobs.size > 0) {
+            this.log.verbose(`Check for job completion notifications returned ${completedJobs.size} job(s), snapshot ids length: ${snapshotIdsLength}, num outstanding jobs: ${this.jobs.size}, total jobs ready: ${this.jobsToRetrieve.size}`);
+        } else {
+            this.log.trace(`Check for job completion notifications returned 0 jobs, snapshot ids length: ${snapshotIdsLength}, num outstanding jobs: ${this.jobs.size}, total jobs ready: ${this.jobsToRetrieve.size}`);
+        }
+    }
+    async retrieveJobsThatShouldBeReady() {
+        const convertJobResult = async (result, jobType)=>{
+            if (result.status === 'fulfilled') {
+                const output = await this.proofStore.getProofOutput(result.value);
+                if (output.type === jobType) {
+                    return {
+                        result: output.result,
+                        success: true
+                    };
+                } else {
+                    return {
+                        success: false,
+                        reason: `Unexpected proof type: ${output.type}. Expected: ${jobType}`
+                    };
+                }
+            } else if (result.status === 'rejected') {
+                return {
+                    success: false,
+                    reason: result.reason
+                };
+            } else {
+                throw new Error(`Unexpected proving job status ${result.status}`);
+            }
+        };
+        const processJob = async (job)=>{
+            // First retrieve the settled job from the broker
+            this.log.debug(`Received notification of completed job id=${job.id} type=${ProvingRequestType[job.type]}`);
+            let settledResult;
+            try {
+                settledResult = await this.broker.getProvingJobStatus(job.id);
+            } catch (err) {
+                // If an error occurs retrieving the job result then just log it and move on.
+                // We will try again on the next iteration
+                this.log.error(`Error retrieving job result from broker job id=${job.id} type=${ProvingRequestType[job.type]}`, err);
+                return false;
+            }
+            // Then convert the result and resolve/reject the promise
+            let result;
+            try {
+                result = await convertJobResult(settledResult, job.type);
+            } catch (err) {
+                // If an error occurs retrieving the job result then just log it and move on.
+                // We will try again on the next iteration
+                this.log.error(`Error processing job result job id=${job.id} type=${ProvingRequestType[job.type]}`, err);
+                return false;
+            }
+            if (result.success) {
+                this.log.verbose(`Resolved proving job id=${job.id} type=${ProvingRequestType[job.type]}`);
+                job.deferred.resolve(result.result);
+            } else {
+                this.log.error(`Resolving proving job with error id=${job.id} type=${ProvingRequestType[job.type]}`, result.reason);
+                if (result.reason !== 'Aborted') {
+                    void this.backupFailedProofInputs(job);
+                }
+                job.deferred.reject(new Error(result.reason));
+            }
+            if (job.abortFn && job.signal) {
+                job.signal?.removeEventListener('abort', job.abortFn);
+            }
+            // Job is now processed removed from our cache
+            this.jobs.delete(job.id);
+            this.jobsToRetrieve.delete(job.id);
+            return true;
+        };
+        const toBeRetrieved = Array.from(this.jobsToRetrieve.values()).map((id)=>this.jobs.get(id)).filter((x)=>x !== undefined);
+        const totalJobsToRetrieve = toBeRetrieved.length;
+        let totalJobsRetrieved = 0;
+        while(toBeRetrieved.length > 0){
+            const slice = toBeRetrieved.splice(0, MAX_CONCURRENT_JOB_SETTLED_REQUESTS);
+            const results = await Promise.all(slice.map((job)=>processJob(job)));
+            totalJobsRetrieved += results.filter((x)=>x).length;
+        }
+        if (totalJobsToRetrieve > 0) {
+            this.log.verbose(`Successfully retrieved ${totalJobsRetrieved} of ${totalJobsToRetrieve} jobs that should be ready, total ready jobs is now: ${this.jobsToRetrieve.size}`);
+        }
+    }
+    async backupFailedProofInputs(job) {
+        try {
+            if (!this.failedProofStore || !job.inputsUri) {
+                return;
+            }
+            const inputs = await this.proofStore.getProofInput(job.inputsUri);
+            const uri = await this.failedProofStore.saveProofInput(job.id, inputs.type, inputs.inputs);
+            this.log.info(`Stored proof inputs for failed job id=${job.id} type=${ProvingRequestType[job.type]} at ${uri}`, {
+                id: job.id,
+                type: job.type,
+                uri
+            });
+        } catch (err) {
+            this.log.error(`Error backing up proof inputs for failed job id=${job.id} type=${ProvingRequestType[job.type]}`, err);
+        }
+    }
+    async monitorForCompletedJobs() {
+        // Monitoring for completed jobs involves 2 stages.
+        // 1. Update our list of completed jobs.
+        // We poll the broker for any new job completion notifications and after filtering/deduplication add them to our cached
+        // list of jobs that we have been told are ready.
+        await this.updateCompletedJobs();
+        // 2. Retrieve the jobs that should be ready.
+        // We have a list of jobs that we have been told are ready, so we go ahead and ask for their results
+        await this.retrieveJobsThatShouldBeReady();
+    }
+    getAvmProof(inputs, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.PUBLIC_VM, inputs, epochNumber), ProvingRequestType.PUBLIC_VM, inputs, epochNumber, signal);
+    }
+    getBaseParityProof(inputs, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.BASE_PARITY, inputs, epochNumber), ProvingRequestType.BASE_PARITY, inputs, epochNumber, signal);
+    }
+    getBlockMergeRollupProof(input, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.BLOCK_MERGE_ROLLUP, input, epochNumber), ProvingRequestType.BLOCK_MERGE_ROLLUP, input, epochNumber, signal);
+    }
+    getBlockRootRollupProof(input, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.BLOCK_ROOT_ROLLUP, input, epochNumber), ProvingRequestType.BLOCK_ROOT_ROLLUP, input, epochNumber, signal);
+    }
+    getSingleTxBlockRootRollupProof(input, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.BLOCK_ROOT_ROLLUP, input, epochNumber), ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP, input, epochNumber, signal);
+    }
+    getEmptyBlockRootRollupProof(input, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP, input, epochNumber), ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP, input, epochNumber, signal);
+    }
+    getMergeRollupProof(input, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.MERGE_ROLLUP, input, epochNumber), ProvingRequestType.MERGE_ROLLUP, input, epochNumber, signal);
+    }
+    getPrivateBaseRollupProof(baseRollupInput, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.PRIVATE_BASE_ROLLUP, baseRollupInput, epochNumber), ProvingRequestType.PRIVATE_BASE_ROLLUP, baseRollupInput, epochNumber, signal);
+    }
+    getPublicBaseRollupProof(inputs, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.PUBLIC_BASE_ROLLUP, inputs, epochNumber), ProvingRequestType.PUBLIC_BASE_ROLLUP, inputs, epochNumber, signal);
+    }
+    getRootParityProof(inputs, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.ROOT_PARITY, inputs, epochNumber), ProvingRequestType.ROOT_PARITY, inputs, epochNumber, signal);
+    }
+    getRootRollupProof(input, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.ROOT_ROLLUP, input, epochNumber), ProvingRequestType.ROOT_ROLLUP, input, epochNumber, signal);
+    }
+    getTubeProof(tubeInput, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.TUBE_PROOF, tubeInput, epochNumber), ProvingRequestType.TUBE_PROOF, tubeInput, epochNumber, signal);
+    }
+    generateId(type, inputs, epochNumber = 0) {
+        const inputsHash = sha256(inputs.toBuffer());
+        return makeProvingJobId(epochNumber, type, inputsHash.toString('hex'));
+    }
+}

package/dest/proving_broker/config.d.ts

@@ -0,0 +1,83 @@
+import { type L1ReaderConfig } from '@aztec/ethereum';
+import { type ConfigMappingsType } from '@aztec/foundation/config';
+import { type DataStoreConfig } from '@aztec/kv-store/config';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+import { z } from 'zod';
+export declare const ProverBrokerConfig: z.ZodObject<{
+    /** If starting a prover broker locally, the max number of retries per proving job */
+    proverBrokerJobMaxRetries: z.ZodNumber;
+    /** If starting a prover broker locally, the time after which a job times out and gets assigned to a different agent */
+    proverBrokerJobTimeoutMs: z.ZodNumber;
+    /** If starting a prover broker locally, the interval the broker checks for timed out jobs */
+    proverBrokerPollIntervalMs: z.ZodNumber;
+    /** If starting a prover broker locally, the directory to store broker data */
+    dataDirectory: z.ZodOptional<z.ZodString>;
+    /** The size of the data store map */
+    dataStoreMapSizeKB: z.ZodNumber;
+    /** The prover broker may batch jobs together before writing to the database */
+    proverBrokerBatchSize: z.ZodNumber;
+    /** How often the job batches get flushed */
+    proverBrokerBatchIntervalMs: z.ZodNumber;
+    /** The maximum number of epochs to keep results for */
+    proverBrokerMaxEpochsToKeepResultsFor: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    proverBrokerJobMaxRetries: number;
+    proverBrokerJobTimeoutMs: number;
+    proverBrokerPollIntervalMs: number;
+    dataStoreMapSizeKB: number;
+    proverBrokerBatchSize: number;
+    proverBrokerBatchIntervalMs: number;
+    proverBrokerMaxEpochsToKeepResultsFor: number;
+    dataDirectory?: string | undefined;
+}, {
+    proverBrokerJobMaxRetries: number;
+    proverBrokerJobTimeoutMs: number;
+    proverBrokerPollIntervalMs: number;
+    dataStoreMapSizeKB: number;
+    proverBrokerBatchSize: number;
+    proverBrokerBatchIntervalMs: number;
+    proverBrokerMaxEpochsToKeepResultsFor: number;
+    dataDirectory?: string | undefined;
+}>;
+export type ProverBrokerConfig = z.infer<typeof ProverBrokerConfig> & Pick<DataStoreConfig, 'dataStoreMapSizeKB' | 'dataDirectory'> & L1ReaderConfig;
+export declare const proverBrokerConfigMappings: ConfigMappingsType<ProverBrokerConfig>;
+export declare const defaultProverBrokerConfig: ProverBrokerConfig;
+export declare const ProverAgentConfig: z.ZodObject<{
+    /** The number of prover agents to start */
+    proverAgentCount: z.ZodNumber;
+    /** The types of proofs the prover agent can generate */
+    proverAgentProofTypes: z.ZodArray<z.ZodNativeEnum<typeof ProvingRequestType>, "many">;
+    /** How often the prover agents poll for jobs */
+    proverAgentPollIntervalMs: z.ZodNumber;
+    /** The URL where this agent takes jobs from */
+    proverBrokerUrl: z.ZodOptional<z.ZodString>;
+    /** Whether to construct real proofs */
+    realProofs: z.ZodBoolean;
+    /** The type of artificial delay to introduce */
+    proverTestDelayType: z.ZodEnum<["fixed", "realistic"]>;
+    /** If using fixed delay, the time each operation takes. */
+    proverTestDelayMs: z.ZodNumber;
+    /** If using realistic delays, what percentage of realistic times to apply. */
+    proverTestDelayFactor: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    proverAgentCount: number;
+    proverAgentProofTypes: ProvingRequestType[];
+    proverAgentPollIntervalMs: number;
+    realProofs: boolean;
+    proverTestDelayType: "fixed" | "realistic";
+    proverTestDelayMs: number;
+    proverTestDelayFactor: number;
+    proverBrokerUrl?: string | undefined;
+}, {
+    proverAgentCount: number;
+    proverAgentProofTypes: ProvingRequestType[];
+    proverAgentPollIntervalMs: number;
+    realProofs: boolean;
+    proverTestDelayType: "fixed" | "realistic";
+    proverTestDelayMs: number;
+    proverTestDelayFactor: number;
+    proverBrokerUrl?: string | undefined;
+}>;
+export type ProverAgentConfig = z.infer<typeof ProverAgentConfig>;
+export declare const proverAgentConfigMappings: ConfigMappingsType<ProverAgentConfig>;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/proving_broker/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAA0B,MAAM,iBAAiB,CAAC;AAC9E,OAAO,EACL,KAAK,kBAAkB,EAIxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,wBAAwB,CAAC;AAClF,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;IAC7B,qFAAqF;;IAErF,uHAAuH;;IAEvH,6FAA6F;;IAE7F,8EAA8E;;IAE9E,qCAAqC;;IAErC,+EAA+E;;IAE/E,4CAA4C;;IAE5C,uDAAuD;;;;;;;;;;;;;;;;;;;;EAEvD,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,GACjE,IAAI,CAAC,eAAe,EAAE,oBAAoB,GAAG,eAAe,CAAC,GAC7D,cAAc,CAAC;AAEjB,eAAO,MAAM,0BAA0B,EAAE,kBAAkB,CAAC,kBAAkB,CAiC7E,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,kBAAiE,CAAC;AAE1G,eAAO,MAAM,iBAAiB;IAC5B,2CAA2C;;IAE3C,wDAAwD;;IAExD,gDAAgD;;IAEhD,+CAA+C;;IAE/C,uCAAuC;;IAEvC,gDAAgD;;IAEhD,2DAA2D;;IAE3D,8EAA8E;;;;;;;;;;;;;;;;;;;;EAE9E,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,eAAO,MAAM,yBAAyB,EAAE,kBAAkB,CAAC,iBAAiB,CA4C3E,CAAC"}

package/dest/proving_broker/config.js

@@ -0,0 +1,104 @@
+import { l1ReaderConfigMappings } from '@aztec/ethereum';
+import { booleanConfigHelper, getDefaultConfig, numberConfigHelper } from '@aztec/foundation/config';
+import { dataConfigMappings } from '@aztec/kv-store/config';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+import { z } from 'zod';
+export const ProverBrokerConfig = z.object({
+    /** If starting a prover broker locally, the max number of retries per proving job */ proverBrokerJobMaxRetries: z.number().int().nonnegative(),
+    /** If starting a prover broker locally, the time after which a job times out and gets assigned to a different agent */ proverBrokerJobTimeoutMs: z.number().int().nonnegative(),
+    /** If starting a prover broker locally, the interval the broker checks for timed out jobs */ proverBrokerPollIntervalMs: z.number().int().nonnegative(),
+    /** If starting a prover broker locally, the directory to store broker data */ dataDirectory: z.string().optional(),
+    /** The size of the data store map */ dataStoreMapSizeKB: z.number().int().nonnegative(),
+    /** The prover broker may batch jobs together before writing to the database */ proverBrokerBatchSize: z.number().int().nonnegative(),
+    /** How often the job batches get flushed */ proverBrokerBatchIntervalMs: z.number().int().nonnegative(),
+    /** The maximum number of epochs to keep results for */ proverBrokerMaxEpochsToKeepResultsFor: z.number().int().nonnegative()
+});
+export const proverBrokerConfigMappings = {
+    proverBrokerJobTimeoutMs: {
+        env: 'PROVER_BROKER_JOB_TIMEOUT_MS',
+        description: 'Jobs are retried if not kept alive for this long',
+        ...numberConfigHelper(30_000)
+    },
+    proverBrokerPollIntervalMs: {
+        env: 'PROVER_BROKER_POLL_INTERVAL_MS',
+        description: 'The interval to check job health status',
+        ...numberConfigHelper(1_000)
+    },
+    proverBrokerJobMaxRetries: {
+        env: 'PROVER_BROKER_JOB_MAX_RETRIES',
+        description: 'If starting a prover broker locally, the max number of retries per proving job',
+        ...numberConfigHelper(3)
+    },
+    proverBrokerBatchSize: {
+        env: 'PROVER_BROKER_BATCH_SIZE',
+        description: 'The prover broker writes jobs to disk in batches',
+        ...numberConfigHelper(100)
+    },
+    proverBrokerBatchIntervalMs: {
+        env: 'PROVER_BROKER_BATCH_INTERVAL_MS',
+        description: 'How often to flush batches to disk',
+        ...numberConfigHelper(50)
+    },
+    proverBrokerMaxEpochsToKeepResultsFor: {
+        env: 'PROVER_BROKER_MAX_EPOCHS_TO_KEEP_RESULTS_FOR',
+        description: 'The maximum number of epochs to keep results for',
+        ...numberConfigHelper(1)
+    },
+    ...l1ReaderConfigMappings,
+    ...dataConfigMappings
+};
+export const defaultProverBrokerConfig = getDefaultConfig(proverBrokerConfigMappings);
+export const ProverAgentConfig = z.object({
+    /** The number of prover agents to start */ proverAgentCount: z.number(),
+    /** The types of proofs the prover agent can generate */ proverAgentProofTypes: z.array(z.nativeEnum(ProvingRequestType)),
+    /** How often the prover agents poll for jobs */ proverAgentPollIntervalMs: z.number(),
+    /** The URL where this agent takes jobs from */ proverBrokerUrl: z.string().optional(),
+    /** Whether to construct real proofs */ realProofs: z.boolean(),
+    /** The type of artificial delay to introduce */ proverTestDelayType: z.enum([
+        'fixed',
+        'realistic'
+    ]),
+    /** If using fixed delay, the time each operation takes. */ proverTestDelayMs: z.number(),
+    /** If using realistic delays, what percentage of realistic times to apply. */ proverTestDelayFactor: z.number()
+});
+export const proverAgentConfigMappings = {
+    proverAgentCount: {
+        env: 'PROVER_AGENT_COUNT',
+        description: 'Whether this prover has a local prover agent',
+        ...numberConfigHelper(1)
+    },
+    proverAgentPollIntervalMs: {
+        env: 'PROVER_AGENT_POLL_INTERVAL_MS',
+        description: 'The interval agents poll for jobs at',
+        ...numberConfigHelper(100)
+    },
+    proverAgentProofTypes: {
+        env: 'PROVER_AGENT_PROOF_TYPES',
+        description: 'The types of proofs the prover agent can generate',
+        parseEnv: (val)=>val.split(',').map((v)=>ProvingRequestType[v]).filter((v)=>typeof v === 'number')
+    },
+    proverBrokerUrl: {
+        env: 'PROVER_BROKER_HOST',
+        description: 'The URL where this agent takes jobs from'
+    },
+    realProofs: {
+        env: 'PROVER_REAL_PROOFS',
+        description: 'Whether to construct real proofs',
+        ...booleanConfigHelper(false)
+    },
+    proverTestDelayType: {
+        env: 'PROVER_TEST_DELAY_TYPE',
+        description: 'The type of artificial delay to introduce',
+        defaultValue: 'fixed'
+    },
+    proverTestDelayMs: {
+        env: 'PROVER_TEST_DELAY_MS',
+        description: 'Artificial delay to introduce to all operations to the test prover.',
+        ...numberConfigHelper(0)
+    },
+    proverTestDelayFactor: {
+        env: 'PROVER_TEST_DELAY_FACTOR',
+        description: 'If using realistic delays, what percentage of realistic times to apply.',
+        ...numberConfigHelper(1)
+    }
+};

package/dest/proving_broker/factory.d.ts

@@ -0,0 +1,5 @@
+import type { TelemetryClient } from '@aztec/telemetry-client';
+import type { ProverBrokerConfig } from './config.js';
+import { ProvingBroker } from './proving_broker.js';
+export declare function createAndStartProvingBroker(config: ProverBrokerConfig, client: TelemetryClient): Promise<ProvingBroker>;
+//# sourceMappingURL=factory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/proving_broker/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIpD,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,kBAAkB,EAC1B,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,aAAa,CAAC,CAOxB"}

package/dest/proving_broker/factory.js

@@ -0,0 +1,9 @@
+import { ProvingBroker } from './proving_broker.js';
+import { InMemoryBrokerDatabase } from './proving_broker_database/memory.js';
+import { KVBrokerDatabase } from './proving_broker_database/persisted.js';
+export async function createAndStartProvingBroker(config, client) {
+    const database = config.dataDirectory ? await KVBrokerDatabase.new(config, client) : new InMemoryBrokerDatabase();
+    const broker = new ProvingBroker(database, config, client);
+    await broker.start();
+    return broker;
+}

package/dest/proving_broker/fixtures.d.ts

@@ -0,0 +1,5 @@
+import { type ProofUri, type ProvingJobId } from '@aztec/stdlib/interfaces/server';
+export declare function makeRandomProvingJobId(epochNumber?: number): ProvingJobId;
+export declare function makeInputsUri(): ProofUri;
+export declare function makeOutputsUri(): ProofUri;
+//# sourceMappingURL=fixtures.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/proving_broker/fixtures.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,YAAY,EAAoB,MAAM,iCAAiC,CAAC;AAGrG,wBAAgB,sBAAsB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,YAAY,CAEzE;AAED,wBAAgB,aAAa,IAAI,QAAQ,CAExC;AAED,wBAAgB,cAAc,IAAI,QAAQ,CAEzC"}

package/dest/proving_broker/fixtures.js

@@ -0,0 +1,12 @@
+import { randomBytes } from '@aztec/foundation/crypto';
+import { makeProvingJobId } from '@aztec/stdlib/interfaces/server';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+export function makeRandomProvingJobId(epochNumber) {
+    return makeProvingJobId(epochNumber ?? 1, ProvingRequestType.BASE_PARITY, randomBytes(8).toString('hex'));
+}
+export function makeInputsUri() {
+    return randomBytes(8).toString('hex');
+}
+export function makeOutputsUri() {
+    return randomBytes(8).toString('hex');
+}

package/dest/proving_broker/index.d.ts

@@ -0,0 +1,10 @@
+export * from './proving_agent.js';
+export * from './proving_broker.js';
+export * from './rpc.js';
+export * from './proving_broker_database.js';
+export * from './proving_broker_database/memory.js';
+export * from './proving_broker_database/persisted.js';
+export * from './proof_store/index.js';
+export * from './factory.js';
+export * from './config.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/proving_broker/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,UAAU,CAAC;AACzB,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qCAAqC,CAAC;AACpD,cAAc,wCAAwC,CAAC;AACvD,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC"}

package/dest/proving_broker/index.js

@@ -0,0 +1,9 @@
+export * from './proving_agent.js';
+export * from './proving_broker.js';
+export * from './rpc.js';
+export * from './proving_broker_database.js';
+export * from './proving_broker_database/memory.js';
+export * from './proving_broker_database/persisted.js';
+export * from './proof_store/index.js';
+export * from './factory.js';
+export * from './config.js';

package/dest/proving_broker/proof_store/factory.d.ts

@@ -0,0 +1,6 @@
+import { GoogleCloudStorageProofStore } from './gcs_proof_store.js';
+import { InlineProofStore } from './inline_proof_store.js';
+import type { ProofStore } from './proof_store.js';
+export declare function createProofStore(config: string | undefined, logger?: import("@aztec/foundation/log").Logger): InlineProofStore | GoogleCloudStorageProofStore;
+export declare function createProofStoreForUri(uri: string, logger?: import("@aztec/foundation/log").Logger): Pick<ProofStore, 'getProofInput' | 'getProofOutput'>;
+//# sourceMappingURL=factory.d.ts.map

package/dest/proving_broker/proof_store/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/proving_broker/proof_store/factory.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,4BAA4B,EAAE,MAAM,sBAAsB,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,yCAA4C,mDAmB9G;AAED,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,MAAM,EACX,MAAM,yCAA4C,GACjD,IAAI,CAAC,UAAU,EAAE,eAAe,GAAG,gBAAgB,CAAC,CAWtD"}

package/dest/proving_broker/proof_store/factory.js

@@ -0,0 +1,36 @@
+import { createLogger } from '@aztec/foundation/log';
+import { GoogleCloudStorageProofStore } from './gcs_proof_store.js';
+import { InlineProofStore } from './inline_proof_store.js';
+export function createProofStore(config, logger = createLogger('prover-client:proof-store')) {
+    if (config === undefined) {
+        logger.info('Creating inline proof store');
+        return new InlineProofStore();
+    } else if (config.startsWith('gs://')) {
+        try {
+            const url = new URL(config);
+            const bucket = url.host;
+            const path = url.pathname.replace(/^\/+/, '');
+            logger.info(`Creating google cloud proof store at ${bucket}`, {
+                bucket,
+                path
+            });
+            return new GoogleCloudStorageProofStore(bucket, path);
+        } catch (err) {
+            throw new Error(`Invalid google cloud proof store definition: '${config}'. Supported values are 'gs://bucket-name/path/to/store'.`);
+        }
+    } else {
+        throw new Error(`Unknown proof store config: '${config}'. Supported values are 'gs://bucket-name/path/to/store'.`);
+    }
+}
+export function createProofStoreForUri(uri, logger = createLogger('prover-client:proof-store')) {
+    if (uri.startsWith('data://')) {
+        return createProofStore(undefined, logger);
+    } else if (uri.startsWith('gs://')) {
+        const url = new URL(uri);
+        const basePath = url.pathname.replace(/^\/+/, '').split('/').slice(0, -3);
+        url.pathname = basePath.join('/');
+        return createProofStore(uri, logger);
+    } else {
+        throw new Error(`Unknown proof store config: '${uri}'. Supported protocols are 'data://' and 'gs://'.`);
+    }
+}