@aztec/prover-client 0.0.1-commit.3100065 → 0.0.1-commit.330febf

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

@@ -1 +1 @@
-{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../../src/proving_broker/rpc.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EAEvB,KAAK,kBAAkB,EAExB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,KAAK,YAAY,EAAY,MAAM,uBAAuB,CAAC;AACpE,OAAO,EAAE,KAAK,kBAAkB,EAAgC,MAAM,0BAA0B,CAAC;AAKjG,qFAAqF;AACrF,wBAAiB,mBAAmB,qCAMnC;AAWD,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,kBAAkB,CAKrE,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,kBAAkB,CAiBrE,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,gBAAgB,CAGjE,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,qBAAqB,CAK3E,CAAC;AAEF,eAAO,MAAM,+BAA+B,EAAE,YAAY,CAAC,gBAAgB,GAAG,qBAAqB,CAGlG,CAAC;AAEF,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,EACrC,KAAK;;;;;EAA8C,GAClD,gBAAgB,CAMlB;AAED,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,EACrC,KAAK;;;;;EAA8C,GAClD,kBAAkB,CAMpB;AAED,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,EACrC,KAAK;;;;;EAA8C,GAClD,kBAAkB,CAMpB"}
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../../src/proving_broker/rpc.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EAEvB,KAAK,kBAAkB,EAExB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,KAAK,YAAY,EAAY,MAAM,uBAAuB,CAAC;AACpE,OAAO,EAAE,KAAK,kBAAkB,EAAgC,MAAM,0BAA0B,CAAC;AAKjG;;;;;;;GAOG;AACH,eAAO,MAAM,mCAAmC,QAAmB,CAAC;AAEpE,qFAAqF;AACrF,wBAAiB,mBAAmB,qCAMnC;AAWD,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,kBAAkB,CAKrE,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,kBAAkB,CAiBrE,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,gBAAgB,CAGjE,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,qBAAqB,CAK3E,CAAC;AAEF,eAAO,MAAM,+BAA+B,EAAE,YAAY,CAAC,gBAAgB,GAAG,qBAAqB,CAGlG,CAAC;AAEF,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,EACrC,KAAK;;;;;EAA8C,EACnD,kBAAkB,SAAsC,GACvD,gBAAgB,CAOlB;AAED,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,EACrC,KAAK;;;;;EAA8C,EACnD,kBAAkB,SAAsC,GACvD,kBAAkB,CAOpB;AAED,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,OAAO,CAAC,kBAAkB,CAAC,EACrC,KAAK;;;;;EAA8C,EACnD,kBAAkB,SAAsC,GACvD,kBAAkB,CAOpB"}

package/dest/proving_broker/rpc.js

@@ -6,6 +6,14 @@ import { optional } from '@aztec/stdlib/schemas';
 import { getVersioningResponseHandler } from '@aztec/stdlib/versioning';
 import { makeTracedFetch } from '@aztec/telemetry-client';
 import { z } from 'zod';
+/**
+ * Max JSON-RPC request body the broker clients will send.
+ *
+ * Job inputs and proof results travel inline as `data:` URIs on this path, so a single call is routinely larger than
+ * the 1 mb the generic JSON-RPC client allows — that default sizes batches of small node requests against the node
+ * server's own default. An AVM (`PUBLIC_VM`) result is around 1.3 mb today. This value must stay at or below the
+ * broker server's `RPC_MAX_BODY_SIZE`, which deployments set to 50mb.
+ */ export const PROVER_BROKER_MAX_REQUEST_BODY_SIZE = 50 * 1024 * 1024;
 /** Indefinite backoff for broker communication: 1, 1, 1, 2, 4, 4, 4, ... seconds. */ export function* proverBrokerBackoff() {
     const v = [
         1,
@@ -104,24 +112,27 @@ export const ProvingJobBrokerSchemaWithDebug = {
     ...ProvingJobBrokerSchema,
     ...ProvingJobBrokerDebugSchema
 };
-export function createProvingJobBrokerClient(url, versions, fetch = makeTracedFetch(proverBrokerBackoff, false)) {
+export function createProvingJobBrokerClient(url, versions, fetch = makeTracedFetch(proverBrokerBackoff, false), maxRequestBodySize = PROVER_BROKER_MAX_REQUEST_BODY_SIZE) {
     return createSafeJsonRpcClient(url, ProvingJobBrokerSchema, {
         namespaceMethods: 'proverBroker',
         fetch,
+        maxRequestBodySize,
         onResponse: getVersioningResponseHandler(versions)
     });
 }
-export function createProvingJobProducerClient(url, versions, fetch = makeTracedFetch(proverBrokerBackoff, false)) {
+export function createProvingJobProducerClient(url, versions, fetch = makeTracedFetch(proverBrokerBackoff, false), maxRequestBodySize = PROVER_BROKER_MAX_REQUEST_BODY_SIZE) {
     return createSafeJsonRpcClient(url, ProvingJobProducerSchema, {
         namespaceMethods: 'provingJobProducer',
         fetch,
+        maxRequestBodySize,
         onResponse: getVersioningResponseHandler(versions)
     });
 }
-export function createProvingJobConsumerClient(url, versions, fetch = makeTracedFetch(proverBrokerBackoff, false)) {
+export function createProvingJobConsumerClient(url, versions, fetch = makeTracedFetch(proverBrokerBackoff, false), maxRequestBodySize = PROVER_BROKER_MAX_REQUEST_BODY_SIZE) {
     return createSafeJsonRpcClient(url, ProvingJobConsumerSchema, {
         namespaceMethods: 'provingJobConsumer',
         fetch,
+        maxRequestBodySize,
         onResponse: getVersioningResponseHandler(versions)
     });
 }

package/dest/test/mock_prover.d.ts

@@ -19,7 +19,7 @@ export declare class TestBroker implements ProvingJobProducer {
 }
 export declare class MockProver implements ServerCircuitProver {
     constructor();
-    getAvmProof(_inputs: AvmCircuitInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<import("@aztec/stdlib/proofs").RecursiveProof<15516>>;
+    getAvmProof(_inputs: AvmCircuitInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<import("@aztec/stdlib/proofs").RecursiveProof<14532>>;
     getBaseParityProof(_inputs: ParityBasePrivateInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<import("@aztec/stdlib/parity").ParityPublicInputs, 410>>;
     getRootParityProof(_inputs: ParityRootPrivateInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<import("@aztec/stdlib/parity").ParityPublicInputs, 410>>;
     getPublicChonkVerifierProof(_inputs: PublicChonkVerifierPrivateInputs, _signal?: AbortSignal, _epochNumber?: number): Promise<PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/prover-client",
-  "version": "0.0.1-commit.3100065",
+  "version": "0.0.1-commit.330febf",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -69,19 +69,19 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb-prover": "0.0.1-commit.3100065",
-    "@aztec/blob-lib": "0.0.1-commit.3100065",
-    "@aztec/constants": "0.0.1-commit.3100065",
-    "@aztec/ethereum": "0.0.1-commit.3100065",
-    "@aztec/foundation": "0.0.1-commit.3100065",
-    "@aztec/kv-store": "0.0.1-commit.3100065",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.3100065",
-    "@aztec/noir-types": "0.0.1-commit.3100065",
-    "@aztec/protocol-contracts": "0.0.1-commit.3100065",
-    "@aztec/simulator": "0.0.1-commit.3100065",
-    "@aztec/stdlib": "0.0.1-commit.3100065",
-    "@aztec/telemetry-client": "0.0.1-commit.3100065",
-    "@aztec/world-state": "0.0.1-commit.3100065",
+    "@aztec/bb-prover": "0.0.1-commit.330febf",
+    "@aztec/blob-lib": "0.0.1-commit.330febf",
+    "@aztec/constants": "0.0.1-commit.330febf",
+    "@aztec/ethereum": "0.0.1-commit.330febf",
+    "@aztec/foundation": "0.0.1-commit.330febf",
+    "@aztec/kv-store": "0.0.1-commit.330febf",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.330febf",
+    "@aztec/noir-types": "6.0.0-nightly.20260807",
+    "@aztec/protocol-contracts": "0.0.1-commit.330febf",
+    "@aztec/simulator": "0.0.1-commit.330febf",
+    "@aztec/stdlib": "0.0.1-commit.330febf",
+    "@aztec/telemetry-client": "0.0.1-commit.330febf",
+    "@aztec/world-state": "0.0.1-commit.330febf",
     "@iarna/toml": "^2.2.5",
     "commander": "^12.1.0",
     "lodash.chunk": "^4.2.0",
@@ -90,7 +90,7 @@
     "zod": "^4"
   },
   "devDependencies": {
-    "@aztec/noir-contracts.js": "0.0.1-commit.3100065",
+    "@aztec/noir-contracts.js": "0.0.1-commit.330febf",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",

package/src/mocks/fixtures.ts

@@ -17,12 +17,10 @@ import { promises as fs } from 'fs';
 import path from 'path';
 
 const {
-  BB_RELEASE_DIR = 'cpp/build/bin',
   TEMP_DIR = '/tmp',
   BB_BINARY_PATH = '',
   BB_WORKING_DIRECTORY = '',
   BB_SKIP_CLEANUP = '',
-  NOIR_RELEASE_DIR = 'noir-repo/target/release',
   ACVM_BINARY_PATH = '',
   ACVM_WORKING_DIRECTORY = '',
 } = process.env;
@@ -32,7 +30,7 @@ export const getEnvironmentConfig = async (logger: Logger) => {
   try {
     const expectedBBPath = BB_BINARY_PATH
       ? BB_BINARY_PATH
-      : `${path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../barretenberg/', BB_RELEASE_DIR)}/bb-avm`;
+      : `${path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../labs-aztec-toolchain/bin')}/bb-avm`;
     await fs.access(expectedBBPath, fs.constants.R_OK);
     const tempWorkingDirectory = `${TEMP_DIR}/${randomBytes(4).toString('hex')}`;
     const bbWorkingDirectory = BB_WORKING_DIRECTORY ? BB_WORKING_DIRECTORY : `${tempWorkingDirectory}/bb`;
@@ -41,7 +39,7 @@ export const getEnvironmentConfig = async (logger: Logger) => {
 
     const expectedAcvmPath = ACVM_BINARY_PATH
       ? ACVM_BINARY_PATH
-      : `${path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../noir/', NOIR_RELEASE_DIR)}/acvm`;
+      : `${path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../labs-aztec-toolchain/bin')}/acvm`;
     await fs.access(expectedAcvmPath, fs.constants.R_OK);
     const acvmWorkingDirectory = ACVM_WORKING_DIRECTORY ? ACVM_WORKING_DIRECTORY : `${tempWorkingDirectory}/acvm`;
     await fs.mkdir(acvmWorkingDirectory, { recursive: true });

package/src/mocks/test_context.ts

@@ -95,7 +95,7 @@ export class TestContext {
     };
 
     // Separated dbs for public processor and prover - see public_processor for context
-    const ws = await NativeWorldStateService.tmp(/*rollupAddress=*/ undefined, /*cleanupTmpDir=*/ true, genesis);
+    const ws = await NativeWorldStateService.tmp(/*cleanupTmpDir=*/ true, genesis);
 
     let localProver: ServerCircuitProver;
     const config = await getEnvironmentConfig(logger);
@@ -136,6 +136,7 @@ export class TestContext {
   async cleanup() {
     await this.brokerProverFacade.stop();
     await this.broker.stop();
+    await this.worldState.close();
     for (const dir of this.directoriesToCleanup.filter(x => x !== '')) {
       try {
         await fs.rm(dir, { recursive: true, force: true, maxRetries: 3 });

package/src/proving_broker/broker_prover_facade.ts

@@ -145,7 +145,14 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver {
 
     try {
       const inputsUri = await this.proofStore.saveProofInput(id, type, inputs);
-      job.inputsUri = inputsUri;
+      // 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 });

package/src/proving_broker/proving_broker.ts

@@ -33,6 +33,23 @@ type InProgressMetadata = {
 
 type EnqueuedProvingJob = Pick<ProvingJob, 'id' | 'epochNumber'>;
 
+/** In-memory scheduling metadata for a job. The large `inputsUri` is deliberately excluded — it lives
+ * in the database and is read on demand when dispatching to an agent. */
+type ProvingJobMetadata = Pick<ProvingJob, 'id' | 'type' | 'epochNumber'>;
+
+/** Settled state kept in memory: the status plus the small payloads (rejected reason, aborted). The
+ * large fulfilled proof `value` is NOT kept here — it lives in the database (read on demand) and,
+ * transiently, in `pendingResults` while its database write is in flight. */
+type SettledRecord = { status: 'fulfilled' } | { status: 'rejected'; reason: string } | { status: 'aborted' };
+
+function toJobMetadata(job: ProvingJob): ProvingJobMetadata {
+  return { id: job.id, type: job.type, epochNumber: job.epochNumber };
+}
+
+function toSettledRecord(result: ProvingJobSettledResult): SettledRecord {
+  return result.status === 'fulfilled' ? { status: 'fulfilled' } : result;
+}
+
 /**
  * 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.
@@ -69,11 +86,17 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
     [ProvingRequestType.PARITY_ROOT]: new PriorityMemoryQueue<EnqueuedProvingJob>(provingJobComparator),
   };
 
-  // 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
-  private jobsCache = new Map<ProvingJobId, ProvingJob>();
-  // as above, but for results
-  private resultsCache = new Map<ProvingJobId, ProvingJobSettledResult>();
+  // Scheduling metadata for every known job (id, type, epochNumber). The large `inputsUri` is NOT held
+  // here — it lives in the database and is read on demand when a job is dispatched to an agent.
+  private jobsCache = new Map<ProvingJobId, ProvingJobMetadata>();
+  // Settled status for every settled job. The large fulfilled proof `value` is NOT held here — it lives
+  // in the database (read on demand in getProvingJobStatus) and, transiently, in `pendingResults` while
+  // its database write is in flight. Small payloads (rejected reason, aborted) are kept inline.
+  private resultsCache = new Map<ProvingJobId, SettledRecord>();
+  // Transient hold of a fulfilled result's full value, from the moment it settles until its database
+  // write commits, so status reads are read-your-writes without retaining every proof. Evicted once the
+  // value is durable in the database; kept only if that write failed (preserving the result in memory).
+  private pendingResults = new Map<ProvingJobId, ProvingJobSettledResult>();
 
   // tracks when each job was enqueued
   private enqueuedAt = new Map<ProvingJobId, Timer>();
@@ -87,8 +110,9 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
   // keep track of which proving job has been retried
   private retries = new Map<ProvingJobId, number>();
 
-  // a map of promises that will be resolved when a job is settled
-  private promises = new Map<ProvingJobId, PromiseWithResolvers<ProvingJobSettledResult>>();
+  // a map of promises that are resolved when a job settles. Carries no payload (settled status/results
+  // are read from resultsCache/pendingResults/DB) so it never pins a proof value in memory.
+  private promises = new Map<ProvingJobId, PromiseWithResolvers<void>>();
 
   private cleanupPromise: RunningPromise;
   private msTimeSource = () => Date.now();
@@ -175,12 +199,12 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
         status: result ? result.status : 'pending',
       });
 
-      this.jobsCache.set(item.id, item);
+      this.jobsCache.set(item.id, toJobMetadata(item));
       this.promises.set(item.id, promiseWithResolvers());
 
       if (result) {
-        this.promises.get(item.id)!.resolve(result);
-        this.resultsCache.set(item.id, result);
+        this.promises.get(item.id)!.resolve();
+        this.resultsCache.set(item.id, toSettledRecord(result));
       } else {
         this.enqueueJobInternal(item);
       }
@@ -211,7 +235,7 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
   }
 
   public getProvingJobStatus(id: ProvingJobId): Promise<ProvingJobStatus> {
-    return Promise.resolve(this.#getProvingJobStatus(id));
+    return this.#getProvingJobStatus(id);
   }
 
   public getCompletedJobs(ids: ProvingJobId[]): Promise<ProvingJobId[]> {
@@ -219,7 +243,7 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
   }
 
   public getProvingJob(filter?: ProvingJobFilter): Promise<GetProvingJobResponse | undefined> {
-    return Promise.resolve(this.#getProvingJob(filter));
+    return this.#getProvingJob(filter);
   }
 
   public reportProvingJobSuccess(
@@ -244,7 +268,7 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
     startedAt: number,
     filter?: ProvingJobFilter,
   ): Promise<{ job: ProvingJob; time: number } | undefined> {
-    return Promise.resolve(this.#reportProvingJobProgress(id, startedAt, filter));
+    return this.#reportProvingJobProgress(id, startedAt, filter);
   }
 
   public async replayProvingJob(
@@ -263,7 +287,7 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
     this.cleanUpProvingJobState([jobId]);
 
     const job: ProvingJob = { id: jobId, type, epochNumber, inputsUri };
-    this.jobsCache.set(jobId, job);
+    this.jobsCache.set(jobId, toJobMetadata(job));
     await this.database.addProvingJob(job);
     this.enqueueJobInternal(job);
 
@@ -271,11 +295,17 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
   }
 
   async #enqueueProvingJob(job: ProvingJob): Promise<ProvingJobStatus> {
-    // We return the job status at the start of this call
-    let jobStatus = this.#getProvingJobStatus(job.id);
+    // The status returned to the caller reflects the job's state at the start of this call: `not-found`
+    // for a brand-new job (it did not exist yet), or the cached status for one already known. Crucially
+    // this must NOT `await` before the synchronous `jobsCache`/`resultsCache` gate below, or the
+    // enqueue/revive lock would no longer hold. So the not-found default is set synchronously here and
+    // the cached branch computes the real status (which may read the DB) only when it returns.
+    let jobStatus: ProvingJobStatus = { status: 'not-found' };
     if (this.jobsCache.has(job.id)) {
       const existing = this.jobsCache.get(job.id);
-      assert.deepStrictEqual(job, existing, 'Duplicate proving job ID');
+      // Identity check is metadata-only: `inputsUri` now lives in the database, not memory, and job ids
+      // are content-addressed (same id ⇒ same inputs), so a mismatch shows up in id/type/epochNumber.
+      assert.deepStrictEqual(toJobMetadata(job), existing, 'Duplicate proving job ID');
 
       if (this.resultsCache.get(job.id)?.status === 'aborted') {
         // The producer is re-requesting a job it previously cancelled: revive it rather than
@@ -290,21 +320,26 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
         // single synchronous span (no await in between), and only then await the database. Because a
         // concurrent re-request can only interleave at that await — by which point `jobsCache` is
         // populated again and the aborted result is gone — it falls into the cached branch and no-ops,
-        // so the job is enqueued exactly once. (`cleanUpProvingJobState` also drops the promise, which
-        // was resolved with the abort, so `enqueueJobInternal` below mints a fresh one for the retry.)
+        // so the job is enqueued exactly once. (`cleanUpProvingJobState` also drops the promise, so
+        // `enqueueJobInternal` below mints a fresh one for the retry.) This holds unchanged with the
+        // slimmer caches: `jobsCache` (now metadata) and `resultsCache` (now settled status) are still
+        // synchronous in-memory maps, so the tear-down + re-set span still contains no await.
         this.logger.info(`Reviving aborted proving job id=${job.id} epochNumber=${job.epochNumber}`, {
           provingJobId: job.id,
         });
         this.cleanUpProvingJobState([job.id]);
-        this.jobsCache.set(job.id, job);
+        this.jobsCache.set(job.id, toJobMetadata(job));
         await this.database.deleteProvingJobResult(job.id);
-        jobStatus = this.#getProvingJobStatus(job.id);
+        // The job is re-set in the cache and about to be re-enqueued below: its start status is in-queue.
+        jobStatus = { status: 'in-queue' };
       } else {
         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;
+        // Return the job's current status. This reads the fulfilled proof value from the DB when needed;
+        // the await is fine here because this branch does not enqueue, so it is outside the lock span.
+        return await this.#getProvingJobStatus(job.id);
       }
     }
 
@@ -318,7 +353,7 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
     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);
+      this.jobsCache.set(job.id, toJobMetadata(job));
       await this.database.addProvingJob(job);
       this.enqueueJobInternal(job);
       this.instrumentation.incTotalJobs(job.type);
@@ -349,9 +384,8 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
     // notifies the current waiter. Unlike a completion or failure this is not terminal: re-enqueuing
     // the same job id revives it (see #enqueueProvingJob), so the abort never permanently blocks the
     // proof.
-    const result: ProvingJobSettledResult = { status: 'aborted' };
-    this.resultsCache.set(id, result);
-    this.promises.get(id)?.resolve(result);
+    this.resultsCache.set(id, { status: 'aborted' });
+    this.promises.get(id)?.resolve();
     this.completedJobNotifications.push(id);
     this.instrumentation.incAbortedJobs(job.type);
 
@@ -369,10 +403,11 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
       this.jobsCache.delete(id);
       const deferred = this.promises.get(id);
       if (deferred) {
-        deferred.resolve({ status: 'rejected', reason: 'Proving job cleaned up' });
+        deferred.resolve();
       }
       this.promises.delete(id);
       this.resultsCache.delete(id);
+      this.pendingResults.delete(id);
       this.inProgress.delete(id);
       this.retries.delete(id);
       this.enqueuedAt.delete(id);
@@ -380,20 +415,31 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
     this.completedJobNotifications = this.completedJobNotifications.filter(id => !idsToClean.has(id));
   }
 
-  #getProvingJobStatus(id: ProvingJobId): ProvingJobStatus {
-    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' };
+  async #getProvingJobStatus(id: ProvingJobId): Promise<ProvingJobStatus> {
+    const settled = this.resultsCache.get(id);
+    if (settled) {
+      if (settled.status !== 'fulfilled') {
+        // rejected/aborted carry their (small) payload inline.
+        return settled;
+      }
+      // A fulfilled job's proof value is not held in memory: serve it from the transient hold if its
+      // database write is still in flight, otherwise read it back from the database.
+      const full = this.pendingResults.get(id) ?? (await this.database.getProvingJobResult(id));
+      if (full?.status === 'fulfilled') {
+        return full;
       }
+      // Settled as fulfilled but the value is nowhere to be found — should not happen (it is held in
+      // pendingResults until its DB write commits). Report not-found rather than a torn result.
+      this.logger.error(`Fulfilled proving job id=${id} has no retrievable result value`, { provingJobId: id });
+      return { status: 'not-found' };
+    }
 
-      return { status: this.inProgress.has(id) ? 'in-progress' : 'in-queue' };
+    // 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: ProvingJobId[]): Promise<ProvingJobId[]> {
@@ -403,7 +449,9 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
     return Promise.resolve(notifications.concat(completedJobs));
   }
 
-  #getProvingJob(filter: ProvingJobFilter = { allowList: [] }): { job: ProvingJob; time: number } | undefined {
+  async #getProvingJob(
+    filter: ProvingJobFilter = { allowList: [] },
+  ): Promise<{ job: ProvingJob; time: number } | undefined> {
     const allowedProofs: ProvingRequestType[] =
       Array.isArray(filter.allowList) && filter.allowList.length > 0
         ? [...filter.allowList]
@@ -418,21 +466,40 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
       // 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 meta = this.jobsCache.get(enqueuedJob.id);
+        if (meta && !this.inProgress.has(enqueuedJob.id) && !this.resultsCache.has(enqueuedJob.id)) {
           const time = this.msTimeSource();
-          this.inProgress.set(job.id, {
-            id: job.id,
+          // Claim the job synchronously (before the await below) so a concurrent dispatch can't re-pick
+          // it. The same id can sit in a queue more than once (an abort leaves a stale entry that a
+          // later revive re-enqueues alongside), so this in-progress claim — not the queue pop — is what
+          // dedups those copies across concurrently-polling agents. It must be set before the await.
+          this.inProgress.set(meta.id, {
+            id: meta.id,
             startedAt: time,
             lastUpdatedAt: time,
           });
-          const enqueuedAt = this.enqueuedAt.get(job.id);
-          if (enqueuedAt) {
-            this.instrumentation.recordJobWait(job.type, enqueuedAt);
-            // we can clear this flag now.
-            this.enqueuedAt.delete(job.id);
+
+          // The large inputs are not kept in memory; read them from the database. They were durably
+          // persisted (addProvingJob's write commits) before the job became dispatchable, so this hits.
+          const inputsUri = await this.database.getProvingJobInputs(meta.id);
+          if (!inputsUri) {
+            // The job was cleaned up (or its inputs lost) after we claimed it — release the claim and
+            // keep draining the queue for another candidate. Nothing else was mutated yet, so there is
+            // no wait metric or enqueued-at timer to unwind.
+            this.inProgress.delete(meta.id);
+            this.logger.warn(`No inputs found for proving job id=${meta.id}; skipping dispatch`, {
+              provingJobId: meta.id,
+            });
+            continue;
           }
 
+          // The dispatch is now committed: record the queue wait and clear the enqueued-at timer.
+          const enqueuedAt = this.enqueuedAt.get(meta.id);
+          if (enqueuedAt) {
+            this.instrumentation.recordJobWait(meta.type, enqueuedAt);
+            this.enqueuedAt.delete(meta.id);
+          }
+          const job: ProvingJob = { id: meta.id, type: meta.type, epochNumber: meta.epochNumber, inputsUri };
           return { job, time };
         }
       }
@@ -499,11 +566,10 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
       },
     );
 
-    // 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: ProvingJobSettledResult = { status: 'rejected', reason: String(err) };
-    this.resultsCache.set(id, result);
-    this.promises.get(id)!.resolve(result);
+    // save the (small) rejection reason to the cache and notify clients of the job status. The reason
+    // is kept in memory, so status reads work even if the database write below fails.
+    this.resultsCache.set(id, { status: 'rejected', reason: String(err) });
+    this.promises.get(id)!.resolve();
     this.completedJobNotifications.push(id);
 
     this.instrumentation.incRejectedJobs(item.type);
@@ -525,20 +591,20 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
     return this.#getProvingJob(filter);
   }
 
-  #reportProvingJobProgress(
+  async #reportProvingJobProgress(
     id: ProvingJobId,
     startedAt: number,
     filter?: ProvingJobFilter,
-  ): { job: ProvingJob; time: number } | undefined {
+  ): Promise<{ job: ProvingJob; time: number } | undefined> {
     const job = this.jobsCache.get(id);
     if (!job) {
       this.logger.warn(`Proving job id=${id} does not exist`, { provingJobId: id });
-      return this.#getProvingJob(filter);
+      return await 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);
+      return await this.#getProvingJob(filter);
     }
 
     const metadata = this.inProgress.get(id);
@@ -578,7 +644,7 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
       { provingJobId: id },
     );
 
-    return this.#getProvingJob(filter);
+    return await this.#getProvingJob(filter);
   }
 
   async #reportProvingJobSuccess(
@@ -612,12 +678,12 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
       { 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: ProvingJobSettledResult = { status: 'fulfilled', value };
-    this.resultsCache.set(id, result);
-    this.promises.get(id)!.resolve(result);
+    // Mark settled synchronously (the gate that makes concurrent settles no-op, unchanged from before),
+    // holding only the status in resultsCache. The large proof value is kept transiently in
+    // pendingResults so status reads are read-your-writes until the database write below commits.
+    this.resultsCache.set(id, { status: 'fulfilled' });
+    this.pendingResults.set(id, { status: 'fulfilled', value });
+    this.promises.get(id)!.resolve();
     this.completedJobNotifications.push(id);
 
     this.instrumentation.incResolvedJobs(item.type);
@@ -628,7 +694,11 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
 
     try {
       await this.database.setProvingJobResult(id, value);
+      // The value is durable in the database now; drop the transient in-memory copy.
+      this.pendingResults.delete(id);
     } catch (saveErr) {
+      // Keep the value in pendingResults so status/result reads still succeed despite the failed write —
+      // this preserves the previous "works even if the database breaks" behaviour for this edge.
       this.logger.error(`Failed to save proving job result id=${id}`, saveErr, {
         provingJobId: id,
       });
@@ -692,9 +762,8 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
           this.logger.error(`Proving job id=${id} timed out after ${retries + 1} attempts. Marking as failed.`, {
             provingJobId: id,
           });
-          const result: ProvingJobSettledResult = { status: 'rejected', reason: 'Timed out' };
-          this.resultsCache.set(id, result);
-          this.promises.get(id)?.resolve(result);
+          this.resultsCache.set(id, { status: 'rejected', reason: 'Timed out' });
+          this.promises.get(id)?.resolve();
           this.completedJobNotifications.push(id);
           this.instrumentation.incRejectedJobs(item.type);
         }
@@ -702,7 +771,7 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
     }
   }
 
-  private enqueueJobInternal(job: ProvingJob): void {
+  private enqueueJobInternal(job: ProvingJobMetadata): void {
     if (!this.promises.has(job.id)) {
       this.promises.set(job.id, promiseWithResolvers());
     }
@@ -714,7 +783,7 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
     this.epochHeight = Math.max(this.epochHeight, job.epochNumber);
   }
 
-  private isJobStale(job: ProvingJob) {
+  private isJobStale(job: ProvingJobMetadata) {
     return job.epochNumber < this.oldestEpochToKeep();
   }
 

package/src/proving_broker/proving_broker_database/memory.ts

@@ -17,8 +17,12 @@ export class InMemoryBrokerDatabase implements ProvingBrokerDatabase {
     return this.jobs.get(id);
   }
 
-  getProvingJobResult(id: ProvingJobId): ProvingJobSettledResult | undefined {
-    return this.results.get(id);
+  getProvingJobInputs(id: ProvingJobId): Promise<ProofUri | undefined> {
+    return Promise.resolve(this.jobs.get(id)?.inputsUri);
+  }
+
+  getProvingJobResult(id: ProvingJobId): Promise<ProvingJobSettledResult | undefined> {
+    return Promise.resolve(this.results.get(id));
   }
 
   addProvingJob(job: ProvingJob): Promise<void> {