@aztec/prover-client 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2 → 0.76.0

package/dest/prover-agent/index.js

@@ -1,3 +0,0 @@
-export * from './prover-agent.js';
-export * from './memory-proving-queue.js';
-export * from './rpc.js';

package/dest/prover-agent/memory-proving-queue.js

@@ -1,249 +0,0 @@
-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 { ProvingRequestType } from '@aztec/circuit-types';
-import { randomBytes } from '@aztec/foundation/crypto';
-import { AbortError, TimeoutError } from '@aztec/foundation/error';
-import { createLogger } from '@aztec/foundation/log';
-import { RunningPromise, promiseWithResolvers } from '@aztec/foundation/promise';
-import { PriorityMemoryQueue } from '@aztec/foundation/queue';
-import { trackSpan } from '@aztec/telemetry-client';
-import { InlineProofStore } from '../proving_broker/proof_store/index.js';
-import { ProvingQueueMetrics } from './queue_metrics.js';
-const MAX_RETRIES = 3;
-const defaultIdGenerator = ()=>randomBytes(4).toString('hex');
-const defaultTimeSource = ()=>Date.now();
-/**
- * A helper class that sits in between services that need proofs created and agents that can create them.
- * The queue accumulates jobs and provides them to agents prioritized by block number.
- */ export class MemoryProvingQueue {
-    jobTimeoutMs;
-    generateId;
-    timeSource;
-    proofStore;
-    log;
-    queue;
-    jobsInProgress;
-    runningPromise;
-    metrics;
-    tracer;
-    constructor(client, /** Timeout the job if an agent doesn't report back in this time */ jobTimeoutMs = 60 * 1000, /** How often to check for timed out jobs */ pollingIntervalMs = 1000, generateId = defaultIdGenerator, timeSource = defaultTimeSource, proofStore = new InlineProofStore()){
-        this.jobTimeoutMs = jobTimeoutMs;
-        this.generateId = generateId;
-        this.timeSource = timeSource;
-        this.proofStore = proofStore;
-        this.log = createLogger('prover-client:prover-pool:queue');
-        this.queue = new PriorityMemoryQueue((a, b)=>(a.epochNumber ?? 0) - (b.epochNumber ?? 0));
-        this.jobsInProgress = new Map();
-        this.tracer = client.getTracer('MemoryProvingQueue');
-        this.metrics = new ProvingQueueMetrics(client, 'MemoryProvingQueue');
-        this.runningPromise = new RunningPromise(this.poll.bind(this), this.log, pollingIntervalMs);
-    }
-    start() {
-        if (this.runningPromise.isRunning()) {
-            this.log.warn('Proving queue is already running');
-            return;
-        }
-        this.runningPromise.start();
-        this.log.info('Proving queue started');
-    }
-    async stop() {
-        if (!this.runningPromise.isRunning()) {
-            this.log.warn('Proving queue is already stopped');
-            return;
-        }
-        await this.runningPromise.stop();
-        this.log.info('Proving queue stopped');
-    }
-    async getProvingJob({ timeoutSec = 1 } = {}) {
-        if (!this.runningPromise.isRunning()) {
-            throw new Error('Proving queue is not running. Start the queue before getting jobs.');
-        }
-        try {
-            const job = await this.queue.get(timeoutSec);
-            if (!job) {
-                return undefined;
-            }
-            if (job.signal?.aborted) {
-                return undefined;
-            }
-            job.heartbeat = this.timeSource();
-            this.jobsInProgress.set(job.id, job);
-            return {
-                id: job.id,
-                type: job.type,
-                inputsUri: job.inputsUri,
-                epochNumber: job.epochNumber
-            };
-        } catch (err) {
-            if (err instanceof TimeoutError) {
-                return undefined;
-            }
-            throw err;
-        }
-    }
-    resolveProvingJob(jobId, result) {
-        if (!this.runningPromise.isRunning()) {
-            throw new Error('Proving queue is not running.');
-        }
-        const job = this.jobsInProgress.get(jobId);
-        if (!job) {
-            this.log.warn(`Job id=${jobId} not found. Can't resolve`);
-            return Promise.resolve();
-        }
-        this.jobsInProgress.delete(jobId);
-        if (!job.signal?.aborted) {
-            job.resolve(result);
-        }
-        return Promise.resolve();
-    }
-    rejectProvingJob(jobId, reason) {
-        if (!this.runningPromise.isRunning()) {
-            throw new Error('Proving queue is not running.');
-        }
-        const job = this.jobsInProgress.get(jobId);
-        if (!job) {
-            this.log.warn(`Job id=${jobId} not found. Can't reject`);
-            return Promise.resolve();
-        }
-        this.jobsInProgress.delete(jobId);
-        if (job.signal?.aborted) {
-            return Promise.resolve();
-        }
-        // every job should be retried with the exception of the public VM since its in development and can fail
-        if (job.attempts < MAX_RETRIES && job.type !== ProvingRequestType.PUBLIC_VM) {
-            job.attempts++;
-            this.log.warn(`Job id=${job.id} type=${ProvingRequestType[job.type]} failed with error: ${reason}. Retry ${job.attempts}/${MAX_RETRIES}`);
-            this.queue.put(job);
-        } else {
-            const logFn = job.type === ProvingRequestType.PUBLIC_VM && !process.env.AVM_PROVING_STRICT ? this.log.warn : this.log.error;
-            logFn(`Job id=${job.id} type=${ProvingRequestType[job.type]} failed with error: ${reason}`);
-            job.reject(new Error(reason));
-        }
-        return Promise.resolve();
-    }
-    heartbeat(jobId) {
-        if (!this.runningPromise.isRunning()) {
-            throw new Error('Proving queue is not running.');
-        }
-        const job = this.jobsInProgress.get(jobId);
-        if (job) {
-            job.heartbeat = this.timeSource();
-        }
-        return Promise.resolve();
-    }
-    isJobRunning(jobId) {
-        return this.jobsInProgress.has(jobId);
-    }
-    poll() {
-        const now = this.timeSource();
-        this.metrics.recordQueueSize(this.queue.length());
-        for (const job of this.jobsInProgress.values()){
-            if (job.signal?.aborted) {
-                this.jobsInProgress.delete(job.id);
-                continue;
-            }
-            if (job.heartbeat + this.jobTimeoutMs < now) {
-                this.log.warn(`Job ${job.id} type=${ProvingRequestType[job.type]} has timed out`);
-                this.jobsInProgress.delete(job.id);
-                job.heartbeat = 0;
-                this.queue.put(job);
-            }
-        }
-    }
-    async enqueue(type, inputs, signal, epochNumber) {
-        if (!this.runningPromise.isRunning()) {
-            return Promise.reject(new Error('Proving queue is not running.'));
-        }
-        const { promise, resolve, reject } = promiseWithResolvers();
-        const id = this.generateId();
-        const inputsUri = await this.proofStore.saveProofInput(id, type, inputs);
-        const item = {
-            id,
-            type,
-            inputsUri,
-            signal,
-            promise,
-            resolve,
-            reject,
-            attempts: 1,
-            heartbeat: 0,
-            epochNumber: epochNumber ?? 0
-        };
-        if (signal) {
-            signal.addEventListener('abort', ()=>reject(new AbortError('Operation has been aborted')));
-        }
-        this.log.debug(`Adding id=${item.id} type=${ProvingRequestType[type]} proving job to queue depth=${this.queue.length()}`);
-        if (!this.queue.put(item)) {
-            throw new Error();
-        }
-        return promise.then(({ result })=>result);
-    }
-    getTubeProof(inputs, signal, epochNumber) {
-        return this.enqueue(ProvingRequestType.TUBE_PROOF, inputs, signal, epochNumber);
-    }
-    /**
-   * Creates a proof for the given input.
-   * @param input - Input to the circuit.
-   */ getBaseParityProof(inputs, signal, epochNumber) {
-        return this.enqueue(ProvingRequestType.BASE_PARITY, inputs, signal, epochNumber);
-    }
-    /**
-   * Creates a proof for the given input.
-   * @param input - Input to the circuit.
-   */ getRootParityProof(inputs, signal, epochNumber) {
-        return this.enqueue(ProvingRequestType.ROOT_PARITY, inputs, signal, epochNumber);
-    }
-    getPrivateBaseRollupProof(inputs, signal, epochNumber) {
-        return this.enqueue(ProvingRequestType.PRIVATE_BASE_ROLLUP, inputs, signal, epochNumber);
-    }
-    getPublicBaseRollupProof(inputs, signal, epochNumber) {
-        return this.enqueue(ProvingRequestType.PUBLIC_BASE_ROLLUP, inputs, signal, epochNumber);
-    }
-    /**
-   * Creates a proof for the given input.
-   * @param input - Input to the circuit.
-   */ getMergeRollupProof(inputs, signal, epochNumber) {
-        return this.enqueue(ProvingRequestType.MERGE_ROLLUP, inputs, signal, epochNumber);
-    }
-    /**
-   * Creates a proof for the given input.
-   * @param input - Input to the circuit.
-   */ getBlockRootRollupProof(inputs, signal, epochNumber) {
-        return this.enqueue(ProvingRequestType.BLOCK_ROOT_ROLLUP, inputs, signal, epochNumber);
-    }
-    getSingleTxBlockRootRollupProof(inputs, signal, epochNumber) {
-        return this.enqueue(ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP, inputs, signal, epochNumber);
-    }
-    getEmptyBlockRootRollupProof(inputs, signal, epochNumber) {
-        return this.enqueue(ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP, inputs, signal, epochNumber);
-    }
-    /**
-   * Creates a proof for the given input.
-   * @param input - Input to the circuit.
-   */ getBlockMergeRollupProof(inputs, signal, epochNumber) {
-        return this.enqueue(ProvingRequestType.BLOCK_MERGE_ROLLUP, inputs, signal, epochNumber);
-    }
-    /**
-   * Creates a proof for the given input.
-   * @param input - Input to the circuit.
-   */ getRootRollupProof(inputs, signal, epochNumber) {
-        return this.enqueue(ProvingRequestType.ROOT_ROLLUP, inputs, signal, epochNumber);
-    }
-    /**
-   * Creates an AVM proof.
-   */ getAvmProof(inputs, signal, epochNumber) {
-        return this.enqueue(ProvingRequestType.PUBLIC_VM, inputs, signal, epochNumber);
-    }
-    /**
-   * Verifies a circuit proof
-   */ verifyProof() {
-        return Promise.reject('not implemented');
-    }
-}
-_ts_decorate([
-    trackSpan('MemoryProvingQueue.poll')
-], MemoryProvingQueue.prototype, "poll", null);

package/dest/prover-agent/prover-agent.js

@@ -1,201 +0,0 @@
-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 { ProvingRequestType, makeProvingRequestResult } from '@aztec/circuit-types';
-import { createLogger } from '@aztec/foundation/log';
-import { RunningPromise } from '@aztec/foundation/running-promise';
-import { elapsed } from '@aztec/foundation/timer';
-import { Attributes, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
-import { InlineProofStore } from '../proving_broker/proof_store/index.js';
-const PRINT_THRESHOLD_NS = 6e10; // 60 seconds
-/**
- * A helper class that encapsulates a circuit prover and connects it to a job source.
- */ export class ProverAgent {
-    circuitProver;
-    maxConcurrency;
-    pollIntervalMs;
-    log;
-    inFlightPromises;
-    runningPromise;
-    proofInputsDatabase;
-    tracer;
-    constructor(/** The prover implementation to defer jobs to */ circuitProver, /** How many proving jobs this agent can handle in parallel */ maxConcurrency = 1, /** How long to wait between jobs */ pollIntervalMs = 100, /** Telemetry client */ telemetry = getTelemetryClient(), /** Logger */ log = createLogger('prover-client:prover-agent')){
-        this.circuitProver = circuitProver;
-        this.maxConcurrency = maxConcurrency;
-        this.pollIntervalMs = pollIntervalMs;
-        this.log = log;
-        this.inFlightPromises = new Map();
-        this.proofInputsDatabase = new InlineProofStore();
-        this.tracer = telemetry.getTracer('ProverAgent');
-    }
-    setMaxConcurrency(maxConcurrency) {
-        if (maxConcurrency < 1) {
-            throw new Error('Concurrency must be at least 1');
-        }
-        this.maxConcurrency = maxConcurrency;
-        return Promise.resolve();
-    }
-    setCircuitProver(circuitProver) {
-        this.circuitProver = circuitProver;
-    }
-    isRunning() {
-        return Promise.resolve(this.#isRunning());
-    }
-    #isRunning() {
-        return this.runningPromise?.isRunning() ?? false;
-    }
-    getCurrentJobs() {
-        return Promise.resolve(Array.from(this.inFlightPromises.values()).map(({ id, type })=>({
-                id,
-                type: ProvingRequestType[type]
-            })));
-    }
-    start(jobSource) {
-        if (this.runningPromise) {
-            throw new Error('Agent is already running');
-        }
-        let lastPrint = process.hrtime.bigint();
-        this.runningPromise = new RunningPromise(async ()=>{
-            for (const jobId of this.inFlightPromises.keys()){
-                await jobSource.heartbeat(jobId);
-            }
-            const now = process.hrtime.bigint();
-            if (now - lastPrint >= PRINT_THRESHOLD_NS) {
-                // only log if we're actually doing work
-                if (this.inFlightPromises.size > 0) {
-                    const jobs = Array.from(this.inFlightPromises.values()).map((job)=>`id=${job.id},type=${ProvingRequestType[job.type]}`).join(' ');
-                    this.log.info(`Agent is running with ${this.inFlightPromises.size} in-flight jobs: ${jobs}`);
-                }
-                lastPrint = now;
-            }
-            while(this.inFlightPromises.size < this.maxConcurrency){
-                try {
-                    const job = await jobSource.getProvingJob();
-                    if (!job) {
-                        // job source is fully drained, sleep for a bit and try again
-                        return;
-                    }
-                    try {
-                        const promise = this.work(jobSource, job).finally(()=>this.inFlightPromises.delete(job.id));
-                        this.inFlightPromises.set(job.id, {
-                            id: job.id,
-                            type: job.type,
-                            promise
-                        });
-                    } catch (err) {
-                        this.log.warn(`Error processing job! type=${ProvingRequestType[job.type]}: ${err}. ${err.stack}`);
-                    }
-                } catch (err) {
-                    this.log.error(`Error fetching job`, err);
-                }
-            }
-        }, this.log, this.pollIntervalMs);
-        this.runningPromise.start();
-        this.log.info(`Agent started with concurrency=${this.maxConcurrency}`);
-    }
-    async stop() {
-        if (!this.runningPromise?.isRunning()) {
-            return;
-        }
-        await this.runningPromise.stop();
-        this.runningPromise = undefined;
-        this.log.info('Agent stopped');
-    }
-    async work(jobSource, job) {
-        try {
-            this.log.debug(`Picked up proving job ${job.id} ${ProvingRequestType[job.type]}`, {
-                jobId: job.id,
-                jobType: ProvingRequestType[job.type]
-            });
-            const type = job.type;
-            const inputs = await this.proofInputsDatabase.getProofInput(job.inputsUri);
-            const [time, result] = await elapsed(this.getProof(inputs));
-            if (this.#isRunning()) {
-                this.log.verbose(`Processed proving job id=${job.id} type=${ProvingRequestType[type]} duration=${time}ms`);
-                await jobSource.resolveProvingJob(job.id, makeProvingRequestResult(type, result));
-            } else {
-                this.log.verbose(`Dropping proving job id=${job.id} type=${ProvingRequestType[job.type]} duration=${time}ms: agent stopped`);
-            }
-        } catch (err) {
-            const type = ProvingRequestType[job.type];
-            if (this.#isRunning()) {
-                if (job.type === ProvingRequestType.PUBLIC_VM && !process.env.AVM_PROVING_STRICT) {
-                    this.log.warn(`Expected error processing VM proving job id=${job.id} type=${type}: ${err}`);
-                } else {
-                    this.log.error(`Error processing proving job id=${job.id} type=${type}: ${err}`, err);
-                }
-                const reason = err?.message ?? String(err);
-                await jobSource.rejectProvingJob(job.id, reason);
-            } else {
-                this.log.verbose(`Dropping proving job id=${job.id} type=${type}: agent stopped: ${err.stack || err}`);
-            }
-        }
-    }
-    getProof(request) {
-        const { type, inputs } = request;
-        switch(type){
-            case ProvingRequestType.PUBLIC_VM:
-                {
-                    return this.circuitProver.getAvmProof(inputs);
-                }
-            case ProvingRequestType.PRIVATE_BASE_ROLLUP:
-                {
-                    return this.circuitProver.getPrivateBaseRollupProof(inputs);
-                }
-            case ProvingRequestType.PUBLIC_BASE_ROLLUP:
-                {
-                    return this.circuitProver.getPublicBaseRollupProof(inputs);
-                }
-            case ProvingRequestType.MERGE_ROLLUP:
-                {
-                    return this.circuitProver.getMergeRollupProof(inputs);
-                }
-            case ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP:
-                {
-                    return this.circuitProver.getEmptyBlockRootRollupProof(inputs);
-                }
-            case ProvingRequestType.BLOCK_ROOT_ROLLUP:
-                {
-                    return this.circuitProver.getBlockRootRollupProof(inputs);
-                }
-            case ProvingRequestType.SINGLE_TX_BLOCK_ROOT_ROLLUP:
-                {
-                    return this.circuitProver.getSingleTxBlockRootRollupProof(inputs);
-                }
-            case ProvingRequestType.BLOCK_MERGE_ROLLUP:
-                {
-                    return this.circuitProver.getBlockMergeRollupProof(inputs);
-                }
-            case ProvingRequestType.ROOT_ROLLUP:
-                {
-                    return this.circuitProver.getRootRollupProof(inputs);
-                }
-            case ProvingRequestType.BASE_PARITY:
-                {
-                    return this.circuitProver.getBaseParityProof(inputs);
-                }
-            case ProvingRequestType.ROOT_PARITY:
-                {
-                    return this.circuitProver.getRootParityProof(inputs);
-                }
-            case ProvingRequestType.TUBE_PROOF:
-                {
-                    return this.circuitProver.getTubeProof(inputs);
-                }
-            default:
-                {
-                    const _exhaustive = type;
-                    return Promise.reject(new Error(`Invalid proof request type: ${type}`));
-                }
-        }
-    }
-}
-_ts_decorate([
-    trackSpan('ProverAgent.work', (_jobSoure, job)=>({
-            [Attributes.PROVING_JOB_ID]: job.id,
-            [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[job.type]
-        }))
-], ProverAgent.prototype, "work", null);

package/dest/prover-agent/proving-error.js

@@ -1,8 +0,0 @@
-export class ProvingError extends Error {
-    toString() {
-        return this.message;
-    }
-    static fromString(message) {
-        return new ProvingError(message);
-    }
-}

package/dest/prover-agent/queue_metrics.js

@@ -1,24 +0,0 @@
-import { ProvingRequestType } from '@aztec/circuit-types';
-import { Attributes, Metrics } from '@aztec/telemetry-client';
-export class ProvingQueueMetrics {
-    jobSize;
-    queueSize;
-    constructor(client, name = 'ProvingQueueMetrics'){
-        const meter = client.getMeter(name);
-        this.jobSize = meter.createHistogram(Metrics.PROVING_QUEUE_JOB_SIZE, {
-            description: 'Size of proving job',
-            unit: 'by'
-        });
-        this.queueSize = meter.createGauge(Metrics.PROVING_QUEUE_SIZE, {
-            description: 'Size of proving queue'
-        });
-    }
-    recordNewJob(type, size) {
-        this.jobSize.record(size, {
-            [Attributes.PROVING_JOB_TYPE]: ProvingRequestType[type]
-        });
-    }
-    recordQueueSize(size) {
-        this.queueSize.record(size);
-    }
-}

package/dest/prover-agent/rpc.js

@@ -1,20 +0,0 @@
-import { ProverAgentApiSchema, ProvingJobSourceSchema } from '@aztec/circuit-types';
-import { createSafeJsonRpcClient } from '@aztec/foundation/json-rpc/client';
-import { createTracedJsonRpcServer, makeTracedFetch } from '@aztec/telemetry-client';
-export function createProvingJobSourceServer(queue) {
-    return createTracedJsonRpcServer(queue, ProvingJobSourceSchema);
-}
-export function createProvingJobSourceClient(url, fetch = makeTracedFetch([
-    1,
-    2,
-    3
-], false)) {
-    return createSafeJsonRpcClient(url, ProvingJobSourceSchema, false, 'provingJobSource', fetch);
-}
-/**
- * Wrap a ProverAgent instance with a JSON RPC HTTP server.
- * @param agent - The Prover Agent
- * @returns An JSON-RPC HTTP server
- */ export function createProverAgentRpcServer(agent) {
-    return createTracedJsonRpcServer(agent, ProverAgentApiSchema);
-}

package/src/prover-agent/index.ts

@@ -1,3 +0,0 @@
-export * from './prover-agent.js';
-export * from './memory-proving-queue.js';
-export * from './rpc.js';