@aztec-labs/prover-client 6.0.0-nightly.20260829

package/dest/proving_broker/broker_prover_facade.js

@@ -0,0 +1,360 @@
+import { asyncPool } from '@aztec-labs/foundation/async-pool';
+import { EpochNumber } from '@aztec-labs/foundation/branded-types';
+import { chunk } from '@aztec-labs/foundation/collection';
+import { createLogger } from '@aztec-labs/foundation/log';
+import { RunningPromise, promiseWithResolvers } from '@aztec-labs/foundation/promise';
+import { truncate } from '@aztec-labs/foundation/string';
+import { makeProvingJobId } from '@aztec-labs/stdlib/interfaces/server';
+import { ProvingRequestType } from '@aztec-labs/stdlib/proofs';
+import { createHash } from 'node:crypto';
+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;
+    jobs;
+    runningPromise;
+    timeOfLastSnapshotSync;
+    jobsToRetrieve;
+    log;
+    constructor(broker, proofStore = new InlineProofStore(), failedProofStore, pollIntervalMs = 1000, bindings){
+        this.broker = broker;
+        this.proofStore = proofStore;
+        this.failedProofStore = failedProofStore;
+        this.pollIntervalMs = pollIntervalMs;
+        this.jobs = new Map();
+        this.timeOfLastSnapshotSync = Date.now();
+        this.jobsToRetrieve = new Set();
+        this.log = createLogger('prover-client:broker-circuit-prover-facade', bindings);
+    }
+    /**
+   * 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
+        // We install an error handler to prevent unhandled rejections in the process before the
+        // job promise is awaited by the caller (see #13166)
+        const promise = promiseWithResolvers();
+        promise.promise.catch((err)=>this.log.error(`Job errored with '${err.message ?? err}' id=${id} type=${ProvingRequestType[type]}`, {
+                provingJobId: id,
+                provingJobType: ProvingRequestType[type]
+            }));
+        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 = EpochNumber.ZERO, 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);
+            // Only retain the inputs URI on the long-lived job when a failed-proof store is configured: it is
+            // read solely by `backupFailedProofInputs` on failure. With the default `InlineProofStore` the URI
+            // embeds the full circuit inputs, so retaining it for every in-flight job would pin those inputs in
+            // memory until the job settles for no purpose when no failed-proof store exists. The broker still
+            // receives the URI below regardless; this only governs what the facade holds onto.
+            if (this.failedProofStore) {
+                job.inputsUri = inputsUri;
+            }
+            // Send the job to the broker
+            const jobStatus = await this.broker.enqueueProvingJob({
+                id,
+                type,
+                inputsUri,
+                epochNumber
+            });
+            const jobLogText = `id=${id} type=${ProvingRequestType[type]} epochNumber=${epochNumber}`;
+            const jobLogData = {
+                provingJobId: id,
+                provingJobType: ProvingRequestType[type],
+                epochNumber,
+                inputsUri: truncate(inputsUri),
+                status: jobStatus.status,
+                numOutstandingJobs: this.jobs.size
+            };
+            // 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 ${jobLogText}`, jobLogData);
+                // 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 ${jobLogText}`, jobLogData);
+                } 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 ${jobLogText}`, jobLogData);
+                }
+            }
+        } 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 {
+                const batches = ids.length > 0 ? chunk(ids, SNAPSHOT_SYNC_CHECK_MAX_REQUEST_SIZE) : [
+                    []
+                ];
+                await asyncPool(1, batches, async (batch)=>{
+                    const completed = await this.broker.getCompletedJobs(batch);
+                    completed.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 if (result.status === 'aborted') {
+                return {
+                    success: false,
+                    reason: 'Aborted'
+                };
+            } 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;
+        const results = await asyncPool(MAX_CONCURRENT_JOB_SETTLED_REQUESTS, toBeRetrieved, (job)=>processJob(job));
+        const 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);
+    }
+    getInboxParityProof(inputs, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.INBOX_PARITY, inputs, epochNumber), ProvingRequestType.INBOX_PARITY, inputs, epochNumber, signal);
+    }
+    getTxMergeRollupProof(input, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.TX_MERGE_ROLLUP, input, epochNumber), ProvingRequestType.TX_MERGE_ROLLUP, input, epochNumber, signal);
+    }
+    getPublicChonkVerifierProof(inputs, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.PUBLIC_CHONK_VERIFIER, inputs, epochNumber), ProvingRequestType.PUBLIC_CHONK_VERIFIER, inputs, epochNumber, signal);
+    }
+    getPrivateTxBaseRollupProof(baseRollupInput, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.PRIVATE_TX_BASE_ROLLUP, baseRollupInput, epochNumber), ProvingRequestType.PRIVATE_TX_BASE_ROLLUP, baseRollupInput, epochNumber, signal);
+    }
+    getPublicTxBaseRollupProof(inputs, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.PUBLIC_TX_BASE_ROLLUP, inputs, epochNumber), ProvingRequestType.PUBLIC_TX_BASE_ROLLUP, inputs, epochNumber, signal);
+    }
+    getBlockRootNoTxsRollupProof(input, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.BLOCK_ROOT_NO_TXS_ROLLUP, input, epochNumber), ProvingRequestType.BLOCK_ROOT_NO_TXS_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);
+    }
+    getBlockRootSingleTxRollupProof(input, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP, input, epochNumber), ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP, input, epochNumber, signal);
+    }
+    getBlockMergeRollupProof(input, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.BLOCK_MERGE_ROLLUP, input, epochNumber), ProvingRequestType.BLOCK_MERGE_ROLLUP, input, epochNumber, signal);
+    }
+    getCheckpointRootRollupProof(input, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.CHECKPOINT_ROOT_ROLLUP, input, epochNumber), ProvingRequestType.CHECKPOINT_ROOT_ROLLUP, input, epochNumber, signal);
+    }
+    getCheckpointRootSingleBlockRollupProof(input, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP, input, epochNumber), ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP, input, epochNumber, signal);
+    }
+    getCheckpointPaddingRollupProof(input, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.CHECKPOINT_PADDING_ROLLUP, input, epochNumber), ProvingRequestType.CHECKPOINT_PADDING_ROLLUP, input, epochNumber, signal);
+    }
+    getCheckpointMergeRollupProof(input, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.CHECKPOINT_MERGE_ROLLUP, input, epochNumber), ProvingRequestType.CHECKPOINT_MERGE_ROLLUP, input, epochNumber, signal);
+    }
+    getRootRollupProof(input, signal, epochNumber) {
+        return this.enqueueJob(this.generateId(ProvingRequestType.ROOT_ROLLUP, input, epochNumber), ProvingRequestType.ROOT_ROLLUP, input, epochNumber, signal);
+    }
+    generateId(type, inputs, epochNumber = EpochNumber.ZERO) {
+        const inputsHash = createHash('sha256').update(inputs.toBuffer()).digest('hex');
+        return makeProvingJobId(epochNumber, type, inputsHash);
+    }
+}

package/dest/proving_broker/config.d.ts

@@ -0,0 +1,40 @@
+import { type L1ReaderConfig } from '@aztec-labs/ethereum/l1-reader';
+import { type ConfigMappingsType } from '@aztec-labs/foundation/config';
+import { type ChainConfig } from '@aztec-labs/stdlib/config';
+import { type DataStoreConfig } from '@aztec-labs/stdlib/kv-store';
+import { ProvingRequestType } from '@aztec-labs/stdlib/proofs';
+import { z } from 'zod';
+export declare const ProverBrokerConfig: z.ZodObject<{
+    proverBrokerJobMaxRetries: z.ZodNumber;
+    proverBrokerJobTimeoutMs: z.ZodNumber;
+    proverBrokerPollIntervalMs: z.ZodNumber;
+    dataDirectory: z.ZodOptional<z.ZodString>;
+    dataStoreMapSizeKb: z.ZodNumber;
+    proverBrokerStoreMapSizeKb: z.ZodOptional<z.ZodNumber>;
+    proverBrokerBatchSize: z.ZodNumber;
+    proverBrokerBatchIntervalMs: z.ZodNumber;
+    proverBrokerMaxEpochsToKeepResultsFor: z.ZodNumber;
+    proverBrokerDebugReplayEnabled: z.ZodBoolean;
+}, z.core.$strip>;
+export type ProverBrokerConfig = z.infer<typeof ProverBrokerConfig> & Pick<DataStoreConfig, 'dataStoreMapSizeKb' | 'dataDirectory'> & L1ReaderConfig & Pick<ChainConfig, 'rollupVersion'>;
+export declare const proverBrokerConfigMappings: ConfigMappingsType<ProverBrokerConfig>;
+export declare const defaultProverBrokerConfig: ProverBrokerConfig;
+export declare const ProverAgentConfig: z.ZodObject<{
+    proverAgentCount: z.ZodNumber;
+    proverAgentProofTypes: z.ZodArray<z.ZodEnum<typeof ProvingRequestType>>;
+    proverAgentPollIntervalMs: z.ZodNumber;
+    proverBrokerUrl: z.ZodOptional<z.ZodString>;
+    realProofs: z.ZodBoolean;
+    proverTestDelayType: z.ZodEnum<{
+        fixed: "fixed";
+        realistic: "realistic";
+    }>;
+    proverTestDelayMs: z.ZodNumber;
+    proverTestDelayFactor: z.ZodNumber;
+    proverTestVerificationDelayMs: z.ZodOptional<z.ZodNumber>;
+    cancelJobsOnStop: z.ZodBoolean;
+    proofStore: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ProverAgentConfig = z.infer<typeof ProverAgentConfig>;
+export declare const proverAgentConfigMappings: ConfigMappingsType<ProverAgentConfig>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvdmluZ19icm9rZXIvY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLGNBQWMsRUFBMEIsTUFBTSxnQ0FBZ0MsQ0FBQztBQUM3RixPQUFPLEVBQ0wsS0FBSyxrQkFBa0IsRUFLeEIsTUFBTSwrQkFBK0IsQ0FBQztBQUV2QyxPQUFPLEVBQUUsS0FBSyxXQUFXLEVBQXVCLE1BQU0sMkJBQTJCLENBQUM7QUFDbEYsT0FBTyxFQUFFLEtBQUssZUFBZSxFQUFzQixNQUFNLDZCQUE2QixDQUFDO0FBQ3ZGLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQy9ELE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEIsZUFBTyxNQUFNLGtCQUFrQjs7Ozs7Ozs7Ozs7aUJBcUI3QixDQUFDO0FBRUgsTUFBTSxNQUFNLGtCQUFrQixHQUFHLENBQUMsQ0FBQyxLQUFLLENBQUMsT0FBTyxrQkFBa0IsQ0FBQyxHQUNqRSxJQUFJLENBQUMsZUFBZSxFQUFFLG9CQUFvQixHQUFHLGVBQWUsQ0FBQyxHQUM3RCxjQUFjLEdBQ2QsSUFBSSxDQUFDLFdBQVcsRUFBRSxlQUFlLENBQUMsQ0FBQztBQUVyQyxlQUFPLE1BQU0sMEJBQTBCLEVBQUUsa0JBQWtCLENBQUMsa0JBQWtCLENBNEM3RSxDQUFDO0FBRUYsZUFBTyxNQUFNLHlCQUF5QixFQUFFLGtCQUFpRSxDQUFDO0FBRTFHLGVBQU8sTUFBTSxpQkFBaUI7Ozs7Ozs7Ozs7Ozs7OztpQkF1QjVCLENBQUM7QUFFSCxNQUFNLE1BQU0saUJBQWlCLEdBQUcsQ0FBQyxDQUFDLEtBQUssQ0FBQyxPQUFPLGlCQUFpQixDQUFDLENBQUM7QUFFbEUsZUFBTyxNQUFNLHlCQUF5QixFQUFFLGtCQUFrQixDQUFDLGlCQUFpQixDQTREM0UsQ0FBQyJ9

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,gCAAgC,CAAC;AAC7F,OAAO,EACL,KAAK,kBAAkB,EAKxB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,KAAK,WAAW,EAAuB,MAAM,2BAA2B,CAAC;AAClF,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,6BAA6B,CAAC;AACvF,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;iBAqB7B,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,GACjE,IAAI,CAAC,eAAe,EAAE,oBAAoB,GAAG,eAAe,CAAC,GAC7D,cAAc,GACd,IAAI,CAAC,WAAW,EAAE,eAAe,CAAC,CAAC;AAErC,eAAO,MAAM,0BAA0B,EAAE,kBAAkB,CAAC,kBAAkB,CA4C7E,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,kBAAiE,CAAC;AAE1G,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;iBAuB5B,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,eAAO,MAAM,yBAAyB,EAAE,kBAAkB,CAAC,iBAAiB,CA4D3E,CAAC"}

package/dest/proving_broker/config.js

@@ -0,0 +1,138 @@
+import { l1ReaderConfigMappings } from '@aztec-labs/ethereum/l1-reader';
+import { booleanConfigHelper, getDefaultConfig, numberConfigHelper, optionalNumberConfigHelper } from '@aztec-labs/foundation/config';
+import { pickConfigMappings } from '@aztec-labs/foundation/config';
+import { chainConfigMappings } from '@aztec-labs/stdlib/config';
+import { dataConfigMappings } from '@aztec-labs/stdlib/kv-store';
+import { ProvingRequestType } from '@aztec-labs/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 size of the prover broker's database. Will override the dataStoreMapSizeKb if set. */ proverBrokerStoreMapSizeKb: z.number().int().nonnegative().optional(),
+    /** 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(),
+    /** Enable debug replay mode for replaying proving jobs from stored inputs */ proverBrokerDebugReplayEnabled: z.boolean()
+});
+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)
+    },
+    proverBrokerStoreMapSizeKb: {
+        env: 'PROVER_BROKER_STORE_MAP_SIZE_KB',
+        ...optionalNumberConfigHelper(),
+        description: "The size of the prover broker's database. Will override the dataStoreMapSizeKb if set."
+    },
+    proverBrokerDebugReplayEnabled: {
+        env: 'PROVER_BROKER_DEBUG_REPLAY_ENABLED',
+        description: 'Enable debug replay mode for replaying proving jobs from stored inputs',
+        ...booleanConfigHelper(false)
+    },
+    ...dataConfigMappings,
+    ...l1ReaderConfigMappings,
+    ...pickConfigMappings(chainConfigMappings, [
+        'rollupVersion'
+    ])
+};
+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(),
+    /** The delay (ms) to inject during fake proof verification */ proverTestVerificationDelayMs: z.number().optional(),
+    /** Whether to abort pending proving jobs when the orchestrator is cancelled */ cancelJobsOnStop: z.boolean(),
+    /** Where to store proving results. Must be accessible to both prover node and agents. If not set will inline-encode the parameters */ proofStore: z.string().optional()
+});
+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(1000)
+    },
+    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(true)
+    },
+    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)
+    },
+    proverTestVerificationDelayMs: {
+        env: 'PROVER_TEST_VERIFICATION_DELAY_MS',
+        description: 'The delay (ms) to inject during fake proof verification',
+        ...numberConfigHelper(10)
+    },
+    cancelJobsOnStop: {
+        env: 'PROVER_CANCEL_JOBS_ON_STOP',
+        description: 'Whether to abort pending proving jobs when the orchestrator is cancelled. ' + 'When false (default), jobs remain in the broker queue and can be reused on restart/reorg.',
+        ...booleanConfigHelper(false)
+    },
+    proofStore: {
+        env: 'PROVER_PROOF_STORE',
+        description: 'Optional proof input store for the prover'
+    }
+};

package/dest/proving_broker/factory.d.ts

@@ -0,0 +1,5 @@
+import type { TelemetryClient } from '@aztec-labs/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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjdG9yeS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Byb3ZpbmdfYnJva2VyL2ZhY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsZUFBZSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFcEUsT0FBTyxLQUFLLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDdEQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBSXBELHdCQUFzQiwyQkFBMkIsQ0FDL0MsT0FBTyxFQUFFLGtCQUFrQixFQUMzQixNQUFNLEVBQUUsZUFBZSxHQUN0QixPQUFPLENBQUMsYUFBYSxDQUFDLENBUXhCIn0=

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,8BAA8B,CAAC;AAEpE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIpD,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,aAAa,CAAC,CAQxB"}

package/dest/proving_broker/factory.js

@@ -0,0 +1,13 @@
+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 config = {
+        ..._config,
+        dataStoreMapSizeKb: _config.proverBrokerStoreMapSizeKb ?? _config.dataStoreMapSizeKb
+    };
+    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,6 @@
+import { EpochNumber } from '@aztec-labs/foundation/branded-types';
+import { type ProofUri, type ProvingJobId } from '@aztec-labs/stdlib/interfaces/server';
+export declare function makeRandomProvingJobId(epochNumber?: EpochNumber): ProvingJobId;
+export declare function makeInputsUri(): ProofUri;
+export declare function makeOutputsUri(): ProofUri;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZml4dHVyZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcm92aW5nX2Jyb2tlci9maXh0dXJlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFFbkUsT0FBTyxFQUFFLEtBQUssUUFBUSxFQUFFLEtBQUssWUFBWSxFQUFvQixNQUFNLHNDQUFzQyxDQUFDO0FBRzFHLHdCQUFnQixzQkFBc0IsQ0FBQyxXQUFXLENBQUMsRUFBRSxXQUFXLEdBQUcsWUFBWSxDQU05RTtBQUVELHdCQUFnQixhQUFhLElBQUksUUFBUSxDQUV4QztBQUVELHdCQUFnQixjQUFjLElBQUksUUFBUSxDQUV6QyJ9

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":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AAEnE,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,YAAY,EAAoB,MAAM,sCAAsC,CAAC;AAG1G,wBAAgB,sBAAsB,CAAC,WAAW,CAAC,EAAE,WAAW,GAAG,YAAY,CAM9E;AAED,wBAAgB,aAAa,IAAI,QAAQ,CAExC;AAED,wBAAgB,cAAc,IAAI,QAAQ,CAEzC"}

package/dest/proving_broker/fixtures.js

@@ -0,0 +1,13 @@
+import { EpochNumber } from '@aztec-labs/foundation/branded-types';
+import { randomBytes } from '@aztec-labs/foundation/crypto/random';
+import { makeProvingJobId } from '@aztec-labs/stdlib/interfaces/server';
+import { ProvingRequestType } from '@aztec-labs/stdlib/proofs';
+export function makeRandomProvingJobId(epochNumber) {
+    return makeProvingJobId(epochNumber ?? EpochNumber(1), ProvingRequestType.INBOX_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,11 @@
+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';
+export { BrokerCircuitProverFacade } from './broker_prover_facade.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcm92aW5nX2Jyb2tlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsd0NBQXdDLENBQUM7QUFDdkQsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGFBQWEsQ0FBQztBQUM1QixPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQyJ9

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;AAC5B,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC"}

package/dest/proving_broker/index.js

@@ -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';
+export { BrokerCircuitProverFacade } from './broker_prover_facade.js';

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

@@ -0,0 +1,3 @@
+import type { ProofStore } from './proof_store.js';
+export declare function createProofStore(config: string | undefined, logger?: import("@aztec-labs/foundation/log").Logger): Promise<ProofStore>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjdG9yeS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Byb3ZpbmdfYnJva2VyL3Byb29mX3N0b3JlL2ZhY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBS0EsT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFbkQsd0JBQXNCLGdCQUFnQixDQUNwQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFNBQVMsRUFDMUIsTUFBTSw4Q0FBNEMsR0FDakQsT0FBTyxDQUFDLFVBQVUsQ0FBQyxDQVNyQiJ9

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":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,MAAM,8CAA4C,GACjD,OAAO,CAAC,UAAU,CAAC,CASrB"}

package/dest/proving_broker/proof_store/factory.js

@@ -0,0 +1,13 @@
+import { createLogger } from '@aztec-labs/foundation/log';
+import { createFileStore } from '@aztec-labs/stdlib/file-store';
+import { FileStoreProofStore } from './file_store_proof_store.js';
+import { InlineProofStore } from './inline_proof_store.js';
+export async function createProofStore(config, logger = createLogger('prover-client:proof-store')) {
+    if (!config) {
+        logger.info('Creating inline proof store');
+        return new InlineProofStore();
+    }
+    const fileStore = await createFileStore(config, logger);
+    logger.info(`Creating file store proof store at ${config}`);
+    return new FileStoreProofStore(fileStore);
+}