@aztec/prover-client 0.0.0-test.0

package/dest/proving_broker/proving_broker.js

@@ -0,0 +1,570 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise, promiseWithResolvers } from '@aztec/foundation/promise';
+import { PriorityMemoryQueue } from '@aztec/foundation/queue';
+import { Timer } from '@aztec/foundation/timer';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+import { getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
+import assert from 'assert';
+import { defaultProverBrokerConfig } from './config.js';
+import { ProvingBrokerInstrumentation } from './proving_broker_instrumentation.js';
+/**
+ * A broker that manages proof requests and distributes them to workers based on their priority.
+ * It takes a backend that is responsible for storing and retrieving proof requests and results.
+ */ export class ProvingBroker {
+    database;
+    logger;
+    queues;
+    // holds a copy of the database in memory in order to quickly fulfill requests
+    // this is fine because this broker is the only one that can modify the database
+    jobsCache;
+    // as above, but for results
+    resultsCache;
+    // tracks when each job was enqueued
+    enqueuedAt;
+    // keeps track of which jobs are currently being processed
+    // in the event of a crash this information is lost, but that's ok
+    // the next time the broker starts it will recreate jobsCache and still
+    // accept results from the workers
+    inProgress;
+    // keep track of which proving job has been retried
+    retries;
+    // a map of promises that will be resolved when a job is settled
+    promises;
+    cleanupPromise;
+    msTimeSource;
+    jobTimeoutMs;
+    maxRetries;
+    instrumentation;
+    tracer;
+    completedJobNotifications;
+    /**
+   * The broker keeps track of the highest epoch its seen.
+   * This information is used for garbage collection: once it reaches the next epoch, it can start pruning the database of old state.
+   * It is important that this value is initialised to zero. This ensures that we don't delete any old jobs until the current
+   * process instance receives a job request informing it of the actual current highest epoch
+   * Example:
+   * proving epoch 11 - the broker will wipe all jobs for epochs 9 and lower
+   * finished proving epoch 11 and got first job for epoch 12 -> the broker will wipe all settled jobs for epochs 10 and lower
+   * reorged back to end of epoch 10 -> epoch 11 is skipped and epoch 12 starts -> the broker will wipe all settled jobs for epochs 10 and lower
+   */ epochHeight;
+    maxEpochsToKeepResultsFor;
+    started;
+    constructor(database, { proverBrokerJobTimeoutMs, proverBrokerPollIntervalMs, proverBrokerJobMaxRetries, proverBrokerMaxEpochsToKeepResultsFor } = defaultProverBrokerConfig, client = getTelemetryClient(), logger = createLogger('prover-client:proving-broker')){
+        this.database = database;
+        this.logger = logger;
+        this.queues = {
+            [ProvingRequestType.PUBLIC_VM]: new PriorityMemoryQueue(provingJobComparator),
+            [ProvingRequestType.TUBE_PROOF]: new PriorityMemoryQueue(provingJobComparator),
+            [ProvingRequestType.PRIVATE_BASE_ROLLUP]: new PriorityMemoryQueue(provingJobComparator),
+            [ProvingRequestType.PUBLIC_BASE_ROLLUP]: new PriorityMemoryQueue(provingJobComparator),
+            [ProvingRequestType.MERGE_ROLLUP]: new PriorityMemoryQueue(provingJobComparator),
+            [ProvingRequestType.ROOT_ROLLUP]: new PriorityMemoryQueue(provingJobComparator),
+            [ProvingRequestType.BLOCK_MERGE_ROLLUP]: new PriorityMemoryQueue(provingJobComparator),
+            [ProvingRequestType.BLOCK_ROOT_ROLLUP]: new PriorityMemoryQueue(provingJobComparator),
+            [ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP]: new PriorityMemoryQueue(provingJobComparator),
+            [ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP]: new PriorityMemoryQueue(provingJobComparator),
+            [ProvingRequestType.BASE_PARITY]: new PriorityMemoryQueue(provingJobComparator),
+            [ProvingRequestType.ROOT_PARITY]: new PriorityMemoryQueue(provingJobComparator)
+        };
+        this.jobsCache = new Map();
+        this.resultsCache = new Map();
+        this.enqueuedAt = new Map();
+        this.inProgress = new Map();
+        this.retries = new Map();
+        this.promises = new Map();
+        this.msTimeSource = ()=>Date.now();
+        this.completedJobNotifications = [];
+        this.epochHeight = 0;
+        this.maxEpochsToKeepResultsFor = 1;
+        this.started = false;
+        this.measureQueueDepth = (type)=>{
+            return this.queues[type].length();
+        };
+        this.countActiveJobs = (type)=>{
+            let count = 0;
+            for (const { id } of this.inProgress.values()){
+                const job = this.jobsCache.get(id);
+                if (job?.type === type) {
+                    count++;
+                }
+            }
+            return count;
+        };
+        this.tracer = client.getTracer('ProvingBroker');
+        this.instrumentation = new ProvingBrokerInstrumentation(client);
+        this.cleanupPromise = new RunningPromise(this.cleanupPass.bind(this), this.logger, proverBrokerPollIntervalMs);
+        this.jobTimeoutMs = proverBrokerJobTimeoutMs;
+        this.maxRetries = proverBrokerJobMaxRetries;
+        this.maxEpochsToKeepResultsFor = proverBrokerMaxEpochsToKeepResultsFor;
+    }
+    measureQueueDepth;
+    countActiveJobs;
+    async start() {
+        if (this.started) {
+            this.logger.info('Proving Broker already started');
+            return Promise.resolve();
+        }
+        this.logger.info('Proving Broker started');
+        for await (const [item, result] of this.database.allProvingJobs()){
+            this.logger.info(`Restoring proving job id=${item.id} settled=${!!result}`, {
+                provingJobId: item.id,
+                status: result ? result.status : 'pending'
+            });
+            this.jobsCache.set(item.id, item);
+            this.promises.set(item.id, promiseWithResolvers());
+            if (result) {
+                this.promises.get(item.id).resolve(result);
+                this.resultsCache.set(item.id, result);
+            } else {
+                this.enqueueJobInternal(item);
+            }
+        }
+        this.cleanupPromise.start();
+        this.instrumentation.monitorQueueDepth(this.measureQueueDepth);
+        this.instrumentation.monitorActiveJobs(this.countActiveJobs);
+        this.started = true;
+    }
+    async stop() {
+        if (!this.started) {
+            this.logger.warn('ProvingBroker not started');
+            return Promise.resolve();
+        }
+        await this.cleanupPromise.stop();
+    }
+    enqueueProvingJob(job) {
+        return this.#enqueueProvingJob(job);
+    }
+    cancelProvingJob(id) {
+        return this.#cancelProvingJob(id);
+    }
+    getProvingJobStatus(id) {
+        return Promise.resolve(this.#getProvingJobStatus(id));
+    }
+    getCompletedJobs(ids) {
+        return this.#getCompletedJobs(ids);
+    }
+    getProvingJob(filter) {
+        return Promise.resolve(this.#getProvingJob(filter));
+    }
+    reportProvingJobSuccess(id, value, filter) {
+        return this.#reportProvingJobSuccess(id, value, filter);
+    }
+    reportProvingJobError(id, err, retry = false, filter) {
+        return this.#reportProvingJobError(id, err, retry, filter);
+    }
+    reportProvingJobProgress(id, startedAt, filter) {
+        return Promise.resolve(this.#reportProvingJobProgress(id, startedAt, filter));
+    }
+    async #enqueueProvingJob(job) {
+        // We return the job status at the start of this call
+        const jobStatus = this.#getProvingJobStatus(job.id);
+        if (this.jobsCache.has(job.id)) {
+            const existing = this.jobsCache.get(job.id);
+            assert.deepStrictEqual(job, existing, 'Duplicate proving job ID');
+            this.logger.warn(`Cached proving job id=${job.id} epochNumber=${job.epochNumber}. Not enqueuing again`, {
+                provingJobId: job.id
+            });
+            this.instrumentation.incCachedJobs(job.type);
+            return jobStatus;
+        }
+        if (this.isJobStale(job)) {
+            this.logger.warn(`Tried enqueueing stale proving job id=${job.id} epochNumber=${job.epochNumber}`, {
+                provingJobId: job.id
+            });
+            throw new Error(`Epoch too old: job epoch ${job.epochNumber}, current epoch: ${this.epochHeight}`);
+        }
+        this.logger.info(`New proving job id=${job.id} epochNumber=${job.epochNumber}`, {
+            provingJobId: job.id
+        });
+        try {
+            // do this first so it acts as a "lock". If this job is enqueued again while we're saving it the if at the top will catch it.
+            this.jobsCache.set(job.id, job);
+            await this.database.addProvingJob(job);
+            this.enqueueJobInternal(job);
+            this.instrumentation.incTotalJobs(job.type);
+        } catch (err) {
+            this.logger.error(`Failed to save proving job id=${job.id}: ${err}`, err, {
+                provingJobId: job.id
+            });
+            this.jobsCache.delete(job.id);
+            throw err;
+        }
+        return jobStatus;
+    }
+    async #cancelProvingJob(id) {
+        if (!this.jobsCache.has(id)) {
+            this.logger.warn(`Can't cancel a job that doesn't exist id=${id}`, {
+                provingJobId: id
+            });
+            return;
+        }
+        // notify listeners of the cancellation
+        if (!this.resultsCache.has(id)) {
+            this.logger.info(`Cancelling job id=${id}`, {
+                provingJobId: id
+            });
+            await this.#reportProvingJobError(id, 'Aborted', false);
+        }
+    }
+    cleanUpProvingJobState(ids) {
+        for (const id of ids){
+            this.jobsCache.delete(id);
+            this.promises.delete(id);
+            this.resultsCache.delete(id);
+            this.inProgress.delete(id);
+            this.retries.delete(id);
+        }
+    }
+    #getProvingJobStatus(id) {
+        const result = this.resultsCache.get(id);
+        if (result) {
+            return result;
+        } else {
+            // no result yet, check if we know the item
+            const item = this.jobsCache.get(id);
+            if (!item) {
+                return {
+                    status: 'not-found'
+                };
+            }
+            return {
+                status: this.inProgress.has(id) ? 'in-progress' : 'in-queue'
+            };
+        }
+    }
+    #getCompletedJobs(ids) {
+        const completedJobs = ids.filter((id)=>this.resultsCache.has(id));
+        const notifications = this.completedJobNotifications;
+        this.completedJobNotifications = [];
+        return Promise.resolve(notifications.concat(completedJobs));
+    }
+    // eslint-disable-next-line require-await
+    #getProvingJob(filter = {
+        allowList: []
+    }) {
+        const allowedProofs = Array.isArray(filter.allowList) && filter.allowList.length > 0 ? [
+            ...filter.allowList
+        ] : Object.values(ProvingRequestType).filter((x)=>typeof x === 'number');
+        allowedProofs.sort(proofTypeComparator);
+        for (const proofType of allowedProofs){
+            const queue = this.queues[proofType];
+            let enqueuedJob;
+            // exhaust the queue and make sure we're not sending a job that's already in progress
+            // or has already been completed
+            // this can happen if the broker crashes and restarts
+            // it's possible agents will report progress or results for jobs that are in the queue (after the restart)
+            while(enqueuedJob = queue.getImmediate()){
+                const job = this.jobsCache.get(enqueuedJob.id);
+                if (job && !this.inProgress.has(enqueuedJob.id) && !this.resultsCache.has(enqueuedJob.id)) {
+                    const time = this.msTimeSource();
+                    this.inProgress.set(job.id, {
+                        id: job.id,
+                        startedAt: time,
+                        lastUpdatedAt: time
+                    });
+                    const enqueuedAt = this.enqueuedAt.get(job.id);
+                    if (enqueuedAt) {
+                        this.instrumentation.recordJobWait(job.type, enqueuedAt);
+                    }
+                    return {
+                        job,
+                        time
+                    };
+                }
+            }
+        }
+        return undefined;
+    }
+    async #reportProvingJobError(id, err, retry = false, filter) {
+        const info = this.inProgress.get(id);
+        const item = this.jobsCache.get(id);
+        const retries = this.retries.get(id) ?? 0;
+        if (!item) {
+            this.logger.warn(`Can't set error on unknown proving job id=${id} err=${err}`, {
+                provingJoId: id
+            });
+            return;
+        }
+        if (!info) {
+            this.logger.warn(`Proving job id=${id} type=${ProvingRequestType[item.type]} not in the in-progress set`, {
+                provingJobId: id
+            });
+        } else {
+            this.inProgress.delete(id);
+        }
+        if (this.resultsCache.has(id)) {
+            this.logger.warn(`Proving job id=${id} is already settled, ignoring err=${err}`, {
+                provingJobId: id
+            });
+            return this.#getProvingJob(filter);
+        }
+        if (retry && retries + 1 < this.maxRetries && !this.isJobStale(item)) {
+            this.logger.info(`Retrying proving job id=${id} type=${ProvingRequestType[item.type]} retry=${retries + 1} err=${err}`, {
+                provingJobId: id
+            });
+            // assign another job to this agent
+            // do this first, before we put the failed job back in the queue
+            const maybeAnotherJob = this.#getProvingJob(filter);
+            this.retries.set(id, retries + 1);
+            this.enqueueJobInternal(item);
+            this.instrumentation.incRetriedJobs(item.type);
+            return maybeAnotherJob;
+        }
+        this.logger.info(`Marking proving job as failed id=${id} type=${ProvingRequestType[item.type]} totalAttempts=${retries + 1} err=${err}`, {
+            provingJobId: id
+        });
+        // save the result to the cache and notify clients of the job status
+        // this should work even if our database breaks because the result is cached in memory
+        const result = {
+            status: 'rejected',
+            reason: String(err)
+        };
+        this.resultsCache.set(id, result);
+        this.promises.get(id).resolve(result);
+        this.completedJobNotifications.push(id);
+        this.instrumentation.incRejectedJobs(item.type);
+        if (info) {
+            const duration = this.msTimeSource() - info.startedAt;
+            this.instrumentation.recordJobDuration(item.type, duration);
+        }
+        try {
+            await this.database.setProvingJobError(id, err);
+        } catch (saveErr) {
+            this.logger.error(`Failed to save proving job error status id=${id} jobErr=${err}`, saveErr, {
+                provingJobId: id
+            });
+            throw saveErr;
+        }
+        return this.#getProvingJob(filter);
+    }
+    #reportProvingJobProgress(id, startedAt, filter) {
+        const job = this.jobsCache.get(id);
+        if (!job) {
+            this.logger.warn(`Proving job id=${id} does not exist`, {
+                provingJobId: id
+            });
+            return this.#getProvingJob(filter);
+        }
+        if (this.resultsCache.has(id)) {
+            this.logger.warn(`Proving job id=${id} has already been completed`, {
+                provingJobId: id
+            });
+            return this.#getProvingJob(filter);
+        }
+        const metadata = this.inProgress.get(id);
+        const now = this.msTimeSource();
+        if (!metadata) {
+            this.logger.warn(`Proving job id=${id} type=${ProvingRequestType[job.type]} not found in the in-progress cache, adding it`, {
+                provingJobId: id
+            });
+            // the queue will still contain the item at this point!
+            // we need to be careful when popping off the queue to make sure we're not sending
+            // a job that's already in progress
+            this.inProgress.set(id, {
+                id,
+                startedAt,
+                lastUpdatedAt: this.msTimeSource()
+            });
+            return undefined;
+        } else if (startedAt <= metadata.startedAt) {
+            if (startedAt < metadata.startedAt) {
+                this.logger.info(`Proving job id=${id} type=${ProvingRequestType[job.type]} startedAt=${startedAt} older agent has taken job`, {
+                    provingJobId: id
+                });
+            } else {
+                this.logger.debug(`Proving job id=${id} type=${ProvingRequestType[job.type]} heartbeat`, {
+                    provingJobId: id
+                });
+            }
+            metadata.startedAt = startedAt;
+            metadata.lastUpdatedAt = now;
+            return undefined;
+        }
+        this.logger.warn(`Proving job id=${id} type=${ProvingRequestType[job.type]} already being worked on by another agent. Sending new one`, {
+            provingJobId: id
+        });
+        return this.#getProvingJob(filter);
+    }
+    async #reportProvingJobSuccess(id, value, filter) {
+        const info = this.inProgress.get(id);
+        const item = this.jobsCache.get(id);
+        const retries = this.retries.get(id) ?? 0;
+        if (!item) {
+            this.logger.warn(`Proving job id=${id} not found`, {
+                provingJobId: id
+            });
+            return;
+        }
+        if (!info) {
+            this.logger.warn(`Proving job id=${id} type=${ProvingRequestType[item.type]} not in the in-progress set`, {
+                provingJobId: id
+            });
+        } else {
+            this.inProgress.delete(id);
+        }
+        if (this.resultsCache.has(id)) {
+            this.logger.warn(`Proving job id=${id} already settled, ignoring result`, {
+                provingJobId: id
+            });
+            return;
+        }
+        this.logger.info(`Proving job complete id=${id} type=${ProvingRequestType[item.type]} totalAttempts=${retries + 1}`, {
+            provingJobId: id
+        });
+        // save result to our local cache and notify clients
+        // if save to database fails, that's ok because we have the result in memory
+        // if the broker crashes and needs the result again, we're covered because we can just recompute it
+        const result = {
+            status: 'fulfilled',
+            value
+        };
+        this.resultsCache.set(id, result);
+        this.promises.get(id).resolve(result);
+        this.completedJobNotifications.push(id);
+        this.instrumentation.incResolvedJobs(item.type);
+        if (info) {
+            const duration = this.msTimeSource() - info.startedAt;
+            this.instrumentation.recordJobDuration(item.type, duration);
+        }
+        try {
+            await this.database.setProvingJobResult(id, value);
+        } catch (saveErr) {
+            this.logger.error(`Failed to save proving job result id=${id}`, saveErr, {
+                provingJobId: id
+            });
+            throw saveErr;
+        }
+        return this.#getProvingJob(filter);
+    }
+    async cleanupPass() {
+        this.cleanupStaleJobs();
+        this.reEnqueueExpiredJobs();
+        const oldestEpochToKeep = this.oldestEpochToKeep();
+        if (oldestEpochToKeep > 0) {
+            await this.database.deleteAllProvingJobsOlderThanEpoch(oldestEpochToKeep);
+            this.logger.trace(`Deleted all epochs older than ${oldestEpochToKeep}`);
+        }
+    }
+    cleanupStaleJobs() {
+        const jobIds = Array.from(this.jobsCache.keys());
+        const jobsToClean = [];
+        for (const id of jobIds){
+            const job = this.jobsCache.get(id);
+            if (this.isJobStale(job)) {
+                jobsToClean.push(id);
+            }
+        }
+        if (jobsToClean.length > 0) {
+            this.cleanUpProvingJobState(jobsToClean);
+            this.logger.info(`Cleaned up jobs=${jobsToClean.length}`);
+        }
+    }
+    reEnqueueExpiredJobs() {
+        const inProgressEntries = Array.from(this.inProgress.entries());
+        for (const [id, metadata] of inProgressEntries){
+            const item = this.jobsCache.get(id);
+            if (!item) {
+                this.logger.warn(`Proving job id=${id} not found. Removing it from the queue.`, {
+                    provingJobId: id
+                });
+                this.inProgress.delete(id);
+                continue;
+            }
+            const now = this.msTimeSource();
+            const msSinceLastUpdate = now - metadata.lastUpdatedAt;
+            if (msSinceLastUpdate >= this.jobTimeoutMs) {
+                this.logger.warn(`Proving job id=${id} timed out. Adding it back to the queue.`, {
+                    provingJobId: id
+                });
+                this.inProgress.delete(id);
+                this.enqueueJobInternal(item);
+                this.instrumentation.incTimedOutJobs(item.type);
+            }
+        }
+    }
+    enqueueJobInternal(job) {
+        if (!this.promises.has(job.id)) {
+            this.promises.set(job.id, promiseWithResolvers());
+        }
+        this.queues[job.type].put({
+            epochNumber: job.epochNumber,
+            id: job.id
+        });
+        this.enqueuedAt.set(job.id, new Timer());
+        this.epochHeight = Math.max(this.epochHeight, job.epochNumber);
+    }
+    isJobStale(job) {
+        return job.epochNumber < this.oldestEpochToKeep();
+    }
+    oldestEpochToKeep() {
+        return this.epochHeight - this.maxEpochsToKeepResultsFor;
+    }
+}
+_ts_decorate([
+    trackSpan('ProvingBroker.cleanupPass')
+], ProvingBroker.prototype, "cleanupPass", null);
+/**
+ * Compares two proving jobs and selects which one's more important
+ * @param a - A proving job
+ * @param b - Another proving job
+ * @returns A number indicating the relative priority of the two proving jobs
+ */ function provingJobComparator(a, b) {
+    if (a.epochNumber < b.epochNumber) {
+        return -1;
+    } else if (a.epochNumber > b.epochNumber) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+/**
+ * Compares two proofs and selects which one's more important.
+ * If some proofs does not exist in the priority array then it's considered the least important.
+ *
+ * @param a - A proof type
+ * @param b - Another proof type
+ * @returns A number indicating the relative priority of the two proof types
+ */ function proofTypeComparator(a, b) {
+    const indexOfA = PROOF_TYPES_IN_PRIORITY_ORDER.indexOf(a);
+    const indexOfB = PROOF_TYPES_IN_PRIORITY_ORDER.indexOf(b);
+    if (indexOfA === indexOfB) {
+        return 0;
+    } else if (indexOfA === -1) {
+        // a is some new proof that didn't get added to the array
+        // b is more important because we know about it
+        return 1;
+    } else if (indexOfB === -1) {
+        // the opposite of the previous if branch
+        return -1;
+    } else if (indexOfA < indexOfB) {
+        return -1;
+    } else {
+        return 1;
+    }
+}
+/**
+ * Relative priority of each proof type. Proofs higher up on the list are more important and should be prioritized
+ * over proofs lower on the list.
+ *
+ * The aim is that this will speed up block proving as the closer we get to a block's root proof the more likely it
+ * is to get picked up by agents
+ */ const PROOF_TYPES_IN_PRIORITY_ORDER = [
+    ProvingRequestType.BLOCK_ROOT_ROLLUP,
+    ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP,
+    ProvingRequestType.BLOCK_MERGE_ROLLUP,
+    ProvingRequestType.ROOT_ROLLUP,
+    ProvingRequestType.MERGE_ROLLUP,
+    ProvingRequestType.PUBLIC_BASE_ROLLUP,
+    ProvingRequestType.PRIVATE_BASE_ROLLUP,
+    ProvingRequestType.PUBLIC_VM,
+    ProvingRequestType.TUBE_PROOF,
+    ProvingRequestType.ROOT_PARITY,
+    ProvingRequestType.BASE_PARITY,
+    ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP
+];

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

@@ -0,0 +1,16 @@
+import { type ProofUri, type ProvingJob, type ProvingJobId, type ProvingJobSettledResult } from '@aztec/stdlib/interfaces/server';
+import type { ProvingBrokerDatabase } from '../proving_broker_database.js';
+export declare class InMemoryBrokerDatabase implements ProvingBrokerDatabase {
+    private jobs;
+    private results;
+    getProvingJob(id: ProvingJobId): ProvingJob | undefined;
+    getProvingJobResult(id: ProvingJobId): ProvingJobSettledResult | undefined;
+    addProvingJob(job: ProvingJob): Promise<void>;
+    setProvingJobResult(id: ProvingJobId, value: ProofUri): Promise<void>;
+    setProvingJobError(id: ProvingJobId, reason: string): Promise<void>;
+    deleteProvingJobs(ids: ProvingJobId[]): Promise<void>;
+    deleteAllProvingJobsOlderThanEpoch(epochNumber: number): Promise<void>;
+    allProvingJobs(): AsyncIterableIterator<[ProvingJob, ProvingJobSettledResult | undefined]>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=memory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/proving_broker/proving_broker_database/memory.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,uBAAuB,EAE7B,MAAM,iCAAiC,CAAC;AAEzC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAE3E,qBAAa,sBAAuB,YAAW,qBAAqB;IAClE,OAAO,CAAC,IAAI,CAAuC;IACnD,OAAO,CAAC,OAAO,CAAoD;IAEnE,aAAa,CAAC,EAAE,EAAE,YAAY,GAAG,UAAU,GAAG,SAAS;IAIvD,mBAAmB,CAAC,EAAE,EAAE,YAAY,GAAG,uBAAuB,GAAG,SAAS;IAI1E,aAAa,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAK7C,mBAAmB,CAAC,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAKrE,kBAAkB,CAAC,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKnE,iBAAiB,CAAC,GAAG,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAQrD,kCAAkC,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ/D,cAAc,IAAI,qBAAqB,CAAC,CAAC,UAAU,EAAE,uBAAuB,GAAG,SAAS,CAAC,CAAC;IAMjG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAGvB"}

package/dest/proving_broker/proving_broker_database/memory.js

@@ -0,0 +1,54 @@
+import { getEpochFromProvingJobId } from '@aztec/stdlib/interfaces/server';
+export class InMemoryBrokerDatabase {
+    jobs = new Map();
+    results = new Map();
+    getProvingJob(id) {
+        return this.jobs.get(id);
+    }
+    getProvingJobResult(id) {
+        return this.results.get(id);
+    }
+    addProvingJob(job) {
+        this.jobs.set(job.id, job);
+        return Promise.resolve();
+    }
+    setProvingJobResult(id, value) {
+        this.results.set(id, {
+            status: 'fulfilled',
+            value
+        });
+        return Promise.resolve();
+    }
+    setProvingJobError(id, reason) {
+        this.results.set(id, {
+            status: 'rejected',
+            reason
+        });
+        return Promise.resolve();
+    }
+    deleteProvingJobs(ids) {
+        for (const id of ids){
+            this.jobs.delete(id);
+            this.results.delete(id);
+        }
+        return Promise.resolve();
+    }
+    deleteAllProvingJobsOlderThanEpoch(epochNumber) {
+        const toDelete = [
+            ...Array.from(this.jobs.keys()).filter((x)=>getEpochFromProvingJobId(x) < epochNumber),
+            ...Array.from(this.results.keys()).filter((x)=>getEpochFromProvingJobId(x) < epochNumber)
+        ];
+        return this.deleteProvingJobs(toDelete);
+    }
+    async *allProvingJobs() {
+        for await (const item of this.jobs.values()){
+            yield [
+                item,
+                this.results.get(item.id)
+            ];
+        }
+    }
+    close() {
+        return Promise.resolve();
+    }
+}

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

@@ -0,0 +1,25 @@
+import { type Logger } from '@aztec/foundation/log';
+import { type ProofUri, ProvingJob, type ProvingJobId, ProvingJobSettledResult } from '@aztec/stdlib/interfaces/server';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import type { ProverBrokerConfig } from '../config.js';
+import type { ProvingBrokerDatabase } from '../proving_broker_database.js';
+export declare class KVBrokerDatabase implements ProvingBrokerDatabase {
+    private epochs;
+    private config;
+    private logger;
+    private metrics;
+    private batchQueue;
+    private constructor();
+    commitWrites(items: Array<ProvingJob | [ProvingJobId, ProvingJobSettledResult]>, epochNumber: number): Promise<void>;
+    private estimateSize;
+    static new(config: ProverBrokerConfig, client?: TelemetryClient, logger?: Logger): Promise<KVBrokerDatabase>;
+    private start;
+    close(): Promise<void>;
+    deleteAllProvingJobsOlderThanEpoch(epochNumber: number): Promise<void>;
+    addProvingJob(job: ProvingJob): Promise<void>;
+    allProvingJobs(): AsyncIterableIterator<[ProvingJob, ProvingJobSettledResult | undefined]>;
+    setProvingJobError(id: ProvingJobId, reason: string): Promise<void>;
+    setProvingJobResult(id: ProvingJobId, value: ProofUri): Promise<void>;
+    private getEpochDatabase;
+}
+//# sourceMappingURL=persisted.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"persisted.d.ts","sourceRoot":"","sources":["../../../src/proving_broker/proving_broker_database/persisted.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAIlE,OAAO,EACL,KAAK,QAAQ,EACb,UAAU,EACV,KAAK,YAAY,EACjB,uBAAuB,EAExB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAA2B,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAK5G,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAwD3E,qBAAa,gBAAiB,YAAW,qBAAqB;IAM1D,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,MAAM;IAEd,OAAO,CAAC,MAAM;IARhB,OAAO,CAAC,OAAO,CAAc;IAE7B,OAAO,CAAC,UAAU,CAA2E;IAE7F,OAAO;IAuBM,YAAY,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,GAAG,CAAC,YAAY,EAAE,uBAAuB,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM;YAQnG,YAAY;WASN,GAAG,CACrB,MAAM,EAAE,kBAAkB,EAC1B,MAAM,GAAE,eAAsC,EAC9C,MAAM,SAAwD;IAgChE,OAAO,CAAC,KAAK;IAIP,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAOtB,kCAAkC,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAa5E,aAAa,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAItC,cAAc,IAAI,qBAAqB,CAAC,CAAC,UAAU,EAAE,uBAAuB,GAAG,SAAS,CAAC,CAAC;IAOjG,kBAAkB,CAAC,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAInE,mBAAmB,CAAC,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;YAIvD,gBAAgB;CAoB/B"}