@aztec/prover-client 0.76.4-devnet-test-rc3 → 0.77.0-testnet-ignition.17

package/dest/proving_broker/broker_prover_facade.js

@@ -1,15 +1,25 @@
-import { ProvingRequestType, makeProvingJobId, } from '@aztec/circuit-types';
 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 = 30000;
+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 {
-    constructor(broker, proofStore = new InlineProofStore(), failedProofStore, pollIntervalMs = 1000, log = createLogger('prover-client:broker-circuit-prover-facade')) {
+    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;
@@ -20,37 +30,42 @@ export class BrokerCircuitProverFacade {
         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) {
+   * 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],
+                provingJobType: ProvingRequestType[type]
             });
-            return { job: existingJob, isEnqueued: true };
+            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 = () => {
+        const abortFn = ()=>{
             signal?.removeEventListener('abort', abortFn);
-            void this.broker.cancelProvingJob(id).catch(err => this.log.warn(`Error cancelling job id=${id}`, err));
+            void this.broker.cancelProvingJob(id).catch((err)=>this.log.warn(`Error cancelling job id=${id}`, err));
         };
         const job = {
             id,
             type,
             deferred: promise,
             abortFn,
-            signal,
+            signal
         };
         this.jobs.set(id, job);
-        return { job, isEnqueued: false };
+        return {
+            job,
+            isEnqueued: false
+        };
     }
     async enqueueJob(id, type, inputs, epochNumber = 0, signal) {
         const { job: job, isEnqueued } = this.getOrCreateProvingJob(id, type, signal);
@@ -64,7 +79,7 @@ export class BrokerCircuitProverFacade {
                 id,
                 type,
                 inputsUri,
-                epochNumber,
+                epochNumber
             });
             // If we are here then the job was successfully accepted by the broker
             // the returned status is for before any action was performed
@@ -75,12 +90,11 @@ export class BrokerCircuitProverFacade {
                     provingJobId: id,
                     provingJobType: ProvingRequestType[type],
                     epochNumber,
-                    inputsUri: truncate(inputsUri),
+                    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 {
+            } else {
                 // notify the broker if job is aborted
                 signal?.addEventListener('abort', job.abortFn);
                 // Job added for the first time
@@ -90,21 +104,19 @@ export class BrokerCircuitProverFacade {
                         provingJobType: ProvingRequestType[type],
                         epochNumber,
                         inputsUri: truncate(inputsUri),
-                        numOutstandingJobs: this.jobs.size,
+                        numOutstandingJobs: this.jobs.size
                     });
-                }
-                else {
+                } 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),
+                        inputsUri: truncate(inputsUri)
                     });
                 }
             }
-        }
-        catch (err) {
+        } catch (err) {
             this.jobs.delete(job.id);
             job.deferred.reject(err);
         }
@@ -115,7 +127,7 @@ export class BrokerCircuitProverFacade {
             throw new Error('BrokerCircuitProverFacade already started');
         }
         this.log.verbose('Starting BrokerCircuitProverFacade');
-        this.runningPromise = new RunningPromise(() => this.monitorForCompletedJobs(), this.log, this.pollIntervalMs);
+        this.runningPromise = new RunningPromise(()=>this.monitorForCompletedJobs(), this.log, this.pollIntervalMs);
         this.runningPromise.start();
     }
     async stop() {
@@ -125,7 +137,7 @@ export class BrokerCircuitProverFacade {
         this.log.verbose('Stopping BrokerCircuitProverFacade');
         await this.runningPromise.stop();
         // Reject any outstanding promises as stopped
-        for (const [_, v] of this.jobs) {
+        for (const [_, v] of this.jobs){
             v.deferred.reject(new Error('Broker facade stopped'));
         }
         this.jobs.clear();
@@ -138,24 +150,23 @@ export class BrokerCircuitProverFacade {
         // 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) => {
+        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) {
+                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));
+                    completed.forEach((id)=>allCompleted.add(id));
                     ++numRequests;
                 }
                 if (numRequests === 0) {
                     const final = await this.broker.getCompletedJobs([]);
-                    final.forEach(id => allCompleted.add(id));
+                    final.forEach((id)=>allCompleted.add(id));
                 }
-            }
-            catch (err) {
+            } catch (err) {
                 this.log.error(`Error thrown when requesting completed job notifications from the broker`, err);
             }
             return allCompleted;
@@ -167,50 +178,58 @@ export class BrokerCircuitProverFacade {
             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 });
+        } 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)));
+        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 {
+        } 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) => {
+        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}` };
+                    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 {
+            } 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) => {
+        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) {
+            } 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);
@@ -220,8 +239,7 @@ export class BrokerCircuitProverFacade {
             let result;
             try {
                 result = await convertJobResult(settledResult, job.type);
-            }
-            catch (err) {
+            } 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);
@@ -230,8 +248,7 @@ export class BrokerCircuitProverFacade {
             if (result.success) {
                 this.log.verbose(`Resolved proving job id=${job.id} type=${ProvingRequestType[job.type]}`);
                 job.deferred.resolve(result.result);
-            }
-            else {
+            } 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);
@@ -246,15 +263,13 @@ export class BrokerCircuitProverFacade {
             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 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) {
+        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;
+            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}`);
@@ -270,10 +285,9 @@ export class BrokerCircuitProverFacade {
             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,
+                uri
             });
-        }
-        catch (err) {
+        } catch (err) {
             this.log.error(`Error backing up proof inputs for failed job id=${job.id} type=${ProvingRequestType[job.type]}`, err);
         }
     }
@@ -328,4 +342,3 @@ export class BrokerCircuitProverFacade {
         return makeProvingJobId(epochNumber, type, inputsHash.toString('hex'));
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"broker_prover_facade.js","sourceRoot":"","sources":["../../src/proving_broker/broker_prover_facade.ts"],"names":[],"mappings":"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"}

package/dest/proving_broker/config.d.ts

@@ -1,6 +1,6 @@
-import { ProvingRequestType } from '@aztec/circuit-types';
 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 */
@@ -17,6 +17,8 @@ export declare const ProverBrokerConfig: z.ZodObject<{
     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;
@@ -24,6 +26,7 @@ export declare const ProverBrokerConfig: z.ZodObject<{
     dataStoreMapSizeKB: number;
     proverBrokerBatchSize: number;
     proverBrokerBatchIntervalMs: number;
+    proverBrokerMaxEpochsToKeepResultsFor: number;
     dataDirectory?: string | undefined;
 }, {
     proverBrokerJobMaxRetries: number;
@@ -32,10 +35,12 @@ export declare const ProverBrokerConfig: z.ZodObject<{
     dataStoreMapSizeKB: number;
     proverBrokerBatchSize: number;
     proverBrokerBatchIntervalMs: number;
+    proverBrokerMaxEpochsToKeepResultsFor: number;
     dataDirectory?: string | undefined;
 }>;
 export type ProverBrokerConfig = z.infer<typeof ProverBrokerConfig> & Pick<DataStoreConfig, 'dataStoreMapSizeKB' | 'dataDirectory'>;
 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;
@@ -47,21 +52,29 @@ export declare const ProverAgentConfig: z.ZodObject<{
     proverBrokerUrl: z.ZodOptional<z.ZodString>;
     /** Whether to construct real proofs */
     realProofs: z.ZodBoolean;
-    /** Artificial delay to introduce to all operations to the test prover. */
+    /** 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>;

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

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/proving_broker/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,KAAK,kBAAkB,EAA2C,MAAM,0BAA0B,CAAC;AAC5G,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,wBAAwB,CAAC;AAElF,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;;;;;;;;;;;;;;;;;;EAE5C,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,GACjE,IAAI,CAAC,eAAe,EAAE,oBAAoB,GAAG,eAAe,CAAC,CAAC;AAEhE,eAAO,MAAM,0BAA0B,EAAE,kBAAkB,CAAC,kBAAkB,CA2B7E,CAAC;AAEF,eAAO,MAAM,iBAAiB;IAC5B,2CAA2C;;IAE3C,wDAAwD;;IAExD,gDAAgD;;IAEhD,+CAA+C;;IAE/C,uCAAuC;;IAEvC,0EAA0E;;;;;;;;;;;;;;;;EAE1E,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,eAAO,MAAM,yBAAyB,EAAE,kBAAkB,CAAC,iBAAiB,CAkC3E,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/proving_broker/config.ts"],"names":[],"mappings":"AAAA,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,CAAC;AAEhE,eAAO,MAAM,0BAA0B,EAAE,kBAAkB,CAAC,kBAAkB,CAgC7E,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

@@ -1,97 +1,102 @@
-import { ProvingRequestType } from '@aztec/circuit-types';
-import { booleanConfigHelper, numberConfigHelper } from '@aztec/foundation/config';
+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(),
-    /** If starting a prover broker locally, the time after which a job times out and gets assigned to a different agent */
-    proverBrokerJobTimeoutMs: z.number(),
-    /** If starting a prover broker locally, the interval the broker checks for timed out jobs */
-    proverBrokerPollIntervalMs: z.number(),
-    /** 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(),
-    /** The prover broker may batch jobs together before writing to the database */
-    proverBrokerBatchSize: z.number(),
-    /** How often the job batches get flushed */
-    proverBrokerBatchIntervalMs: z.number(),
+    /** If starting a prover broker locally, the max number of retries per proving job */ proverBrokerJobMaxRetries: z.number(),
+    /** If starting a prover broker locally, the time after which a job times out and gets assigned to a different agent */ proverBrokerJobTimeoutMs: z.number(),
+    /** If starting a prover broker locally, the interval the broker checks for timed out jobs */ proverBrokerPollIntervalMs: z.number(),
+    /** 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(),
+    /** The prover broker may batch jobs together before writing to the database */ proverBrokerBatchSize: z.number(),
+    /** How often the job batches get flushed */ proverBrokerBatchIntervalMs: z.number(),
+    /** The maximum number of epochs to keep results for */ proverBrokerMaxEpochsToKeepResultsFor: z.number()
 });
 export const proverBrokerConfigMappings = {
     proverBrokerJobTimeoutMs: {
         env: 'PROVER_BROKER_JOB_TIMEOUT_MS',
         description: 'Jobs are retried if not kept alive for this long',
-        ...numberConfigHelper(30000),
+        ...numberConfigHelper(30_000)
     },
     proverBrokerPollIntervalMs: {
         env: 'PROVER_BROKER_POLL_INTERVAL_MS',
         description: 'The interval to check job health status',
-        ...numberConfigHelper(1000),
+        ...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),
+        ...numberConfigHelper(3)
     },
     proverBrokerBatchSize: {
         env: 'PROVER_BROKER_BATCH_SIZE',
         description: 'The prover broker writes jobs to disk in batches',
-        ...numberConfigHelper(100),
+        ...numberConfigHelper(100)
     },
     proverBrokerBatchIntervalMs: {
         env: 'PROVER_BROKER_BATCH_INTERVAL_MS',
         description: 'How often to flush batches to disk',
-        ...numberConfigHelper(50),
+        ...numberConfigHelper(50)
     },
-    ...dataConfigMappings,
+    proverBrokerMaxEpochsToKeepResultsFor: {
+        env: 'PROVER_BROKER_MAX_EPOCHS_TO_KEEP_RESULTS_FOR',
+        description: 'The maximum number of epochs to keep results for',
+        ...numberConfigHelper(1)
+    },
+    ...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(),
-    /** Artificial delay to introduce to all operations to the test prover. */
-    proverTestDelayMs: z.number(),
+    /** 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),
+        ...numberConfigHelper(1)
     },
     proverAgentPollIntervalMs: {
         env: 'PROVER_AGENT_POLL_INTERVAL_MS',
         description: 'The interval agents poll for jobs at',
-        ...numberConfigHelper(100),
+        ...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'),
+        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',
+        description: 'The URL where this agent takes jobs from'
     },
     realProofs: {
         env: 'PROVER_REAL_PROOFS',
         description: 'Whether to construct real proofs',
-        ...booleanConfigHelper(false),
+        ...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),
+        ...numberConfigHelper(0)
     },
+    proverTestDelayFactor: {
+        env: 'PROVER_TEST_DELAY_FACTOR',
+        description: 'If using realistic delays, what percentage of realistic times to apply.',
+        ...numberConfigHelper(1)
+    }
 };
-//# sourceMappingURL=data:application/json;base64,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

package/dest/proving_broker/factory.d.ts

@@ -1,5 +1,5 @@
-import { type TelemetryClient } from '@aztec/telemetry-client';
-import { type ProverBrokerConfig } from './config.js';
+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

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/proving_broker/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D,OAAO,EAAE,KAAK,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,CAexB"}
+{"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

@@ -3,12 +3,7 @@ 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, {
-        jobTimeoutMs: config.proverBrokerJobTimeoutMs,
-        maxRetries: config.proverBrokerJobMaxRetries,
-        timeoutIntervalMs: config.proverBrokerPollIntervalMs,
-    }, client);
+    const broker = new ProvingBroker(database, config, client);
     await broker.start();
     return broker;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjdG9yeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcm92aW5nX2Jyb2tlci9mYWN0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNwRCxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUM3RSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx3Q0FBd0MsQ0FBQztBQUUxRSxNQUFNLENBQUMsS0FBSyxVQUFVLDJCQUEyQixDQUMvQyxNQUEwQixFQUMxQixNQUF1QjtJQUV2QixNQUFNLFFBQVEsR0FBRyxNQUFNLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQyxNQUFNLGdCQUFnQixDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksc0JBQXNCLEVBQUUsQ0FBQztJQUVsSCxNQUFNLE1BQU0sR0FBRyxJQUFJLGFBQWEsQ0FDOUIsUUFBUSxFQUNSO1FBQ0UsWUFBWSxFQUFFLE1BQU0sQ0FBQyx3QkFBd0I7UUFDN0MsVUFBVSxFQUFFLE1BQU0sQ0FBQyx5QkFBeUI7UUFDNUMsaUJBQWlCLEVBQUUsTUFBTSxDQUFDLDBCQUEwQjtLQUNyRCxFQUNELE1BQU0sQ0FDUCxDQUFDO0lBRUYsTUFBTSxNQUFNLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDckIsT0FBTyxNQUFNLENBQUM7QUFDaEIsQ0FBQyJ9

package/dest/proving_broker/fixtures.d.ts

@@ -1,4 +1,4 @@
-import { type ProofUri, type ProvingJobId } from '@aztec/circuit-types';
+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;

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

@@ -1 +1 @@
-{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/proving_broker/fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,YAAY,EAAwC,MAAM,sBAAsB,CAAC;AAG9G,wBAAgB,sBAAsB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,YAAY,CAEzE;AAED,wBAAgB,aAAa,IAAI,QAAQ,CAExC;AAED,wBAAgB,cAAc,IAAI,QAAQ,CAEzC"}
+{"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"}