@aztec/prover-client 0.0.1-commit.2f68f620 → 0.0.1-commit.3100065

package/src/proving_broker/proving_broker.ts

@@ -272,15 +272,40 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
 
   async #enqueueProvingJob(job: ProvingJob): Promise<ProvingJobStatus> {
     // We return the job status at the start of this call
-    const jobStatus = this.#getProvingJobStatus(job.id);
+    let 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.resultsCache.get(job.id)?.status === 'aborted') {
+        // The producer is re-requesting a job it previously cancelled: revive it rather than
+        // returning the cached abort, clearing the aborted state in memory and in the database so the
+        // revival survives a restart.
+        //
+        // Concurrency model: `jobsCache` is the enqueue lock. Every path that puts a job on the queue
+        // populates `jobsCache` *synchronously, before its first await* (see the "New proving job"
+        // block below), so a second concurrent enqueue of the same id observes the entry at the top
+        // of this method and takes a cached, no-op branch instead of enqueuing a duplicate. The revive
+        // must keep holding that lock: we tear down the settled state and re-set `jobsCache` in a
+        // 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.)
+        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);
+        await this.database.deleteProvingJobResult(job.id);
+        jobStatus = this.#getProvingJobStatus(job.id);
+      } 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;
+      }
     }
 
     if (this.isJobStale(job)) {
@@ -306,15 +331,35 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
   }
 
   async #cancelProvingJob(id: ProvingJobId): Promise<void> {
-    if (!this.jobsCache.has(id)) {
+    const job = this.jobsCache.get(id);
+    if (!job) {
       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, undefined, true);
+    // Leave jobs that have already settled (completed or failed) alone: those results are terminal.
+    if (this.resultsCache.has(id)) {
+      return;
+    }
+
+    this.logger.info(`Cancelling job id=${id}`, { provingJobId: id });
+    this.inProgress.delete(id);
+
+    // Record the cancellation as its own settled state and persist it, so it survives a restart and
+    // 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.completedJobNotifications.push(id);
+    this.instrumentation.incAbortedJobs(job.type);
+
+    try {
+      await this.database.setProvingJobAborted(id);
+    } catch (saveErr) {
+      this.logger.error(`Failed to save proving job aborted status id=${id}`, saveErr, { provingJobId: id });
+      throw saveErr;
     }
   }
 
@@ -401,7 +446,6 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
     err: string,
     retry = false,
     filter?: ProvingJobFilter,
-    aborted = false,
   ): Promise<GetProvingJobResponse | undefined> {
     const info = this.inProgress.get(id);
     const item = this.jobsCache.get(id);
@@ -462,11 +506,7 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr
     this.promises.get(id)!.resolve(result);
     this.completedJobNotifications.push(id);
 
-    if (aborted) {
-      this.instrumentation.incAbortedJobs(item.type);
-    } else {
-      this.instrumentation.incRejectedJobs(item.type);
-    }
+    this.instrumentation.incRejectedJobs(item.type);
     if (info) {
       const duration = this.msTimeSource() - info.startedAt;
       this.instrumentation.recordJobDuration(item.type, duration);

package/src/proving_broker/proving_broker_database/memory.ts

@@ -36,6 +36,16 @@ export class InMemoryBrokerDatabase implements ProvingBrokerDatabase {
     return Promise.resolve();
   }
 
+  setProvingJobAborted(id: ProvingJobId): Promise<void> {
+    this.results.set(id, { status: 'aborted' });
+    return Promise.resolve();
+  }
+
+  deleteProvingJobResult(id: ProvingJobId): Promise<void> {
+    this.results.delete(id);
+    return Promise.resolve();
+  }
+
   deleteProvingJobs(ids: ProvingJobId[]): Promise<void> {
     for (const id of ids) {
       this.jobs.delete(id);

package/src/proving_broker/proving_broker_database/persisted.ts

@@ -41,7 +41,11 @@ class SingleEpochDatabase {
     return this.store.estimateSize();
   }
 
-  async batchWrite(jobs: ProvingJob[], results: Array<[ProvingJobId, ProvingJobSettledResult]>) {
+  async batchWrite(
+    jobs: ProvingJob[],
+    results: Array<[ProvingJobId, ProvingJobSettledResult]>,
+    deletedResults: ProvingJobId[] = [],
+  ) {
     await this.store.transactionAsync(async () => {
       for (const job of jobs) {
         await this.jobs.set(job.id, jsonStringify(job));
@@ -49,6 +53,11 @@ class SingleEpochDatabase {
       for (const [id, result] of results) {
         await this.jobResults.set(id, jsonStringify(result));
       }
+      // Deletes are applied after sets so that, if a set and a delete for the same id land in one
+      // batch (e.g. an abort immediately followed by a revive's result-delete), the delete wins.
+      for (const id of deletedResults) {
+        await this.jobResults.delete(id);
+      }
     });
   }
 
@@ -66,6 +75,11 @@ class SingleEpochDatabase {
     await this.jobResults.set(id, jsonStringify(result));
   }
 
+  async setProvingJobAborted(id: ProvingJobId): Promise<void> {
+    const result: ProvingJobSettledResult = { status: 'aborted' };
+    await this.jobResults.set(id, jsonStringify(result));
+  }
+
   async setProvingJobResult(id: ProvingJobId, value: ProofUri): Promise<void> {
     const result: ProvingJobSettledResult = { status: 'fulfilled', value };
     await this.jobResults.set(id, jsonStringify(result));
@@ -80,10 +94,19 @@ class SingleEpochDatabase {
   }
 }
 
+/**
+ * An item queued for a batched write. A {@link ProvingJob} adds/updates a job; a `[id, result]`
+ * tuple sets a job's settled result; a `[id, undefined]` tuple deletes a job's result. Deletes ride
+ * the same queue as writes so they stay FIFO-ordered against them: a revive's result-delete must
+ * land after the abort that preceded it, otherwise a still-queued abort could flush later and
+ * resurrect the cancelled state on disk.
+ */
+type BrokerWrite = ProvingJob | [ProvingJobId, ProvingJobSettledResult | undefined];
+
 export class KVBrokerDatabase implements ProvingBrokerDatabase {
   private metrics: LmdbMetrics;
 
-  private batchQueue: BatchQueue<ProvingJob | [ProvingJobId, ProvingJobSettledResult], number>;
+  private batchQueue: BatchQueue<BrokerWrite, number>;
 
   public readonly tracer: Tracer;
 
@@ -112,12 +135,16 @@ export class KVBrokerDatabase implements ProvingBrokerDatabase {
   }
 
   // exposed for testing
-  public async commitWrites(items: Array<ProvingJob | [ProvingJobId, ProvingJobSettledResult]>, epochNumber: number) {
+  public async commitWrites(items: Array<BrokerWrite>, epochNumber: number) {
     const jobsToAdd = items.filter((item): item is ProvingJob => 'id' in item);
-    const resultsToAdd = items.filter((item): item is [ProvingJobId, ProvingJobSettledResult] => Array.isArray(item));
+    const resultOps = items.filter((item): item is [ProvingJobId, ProvingJobSettledResult | undefined] =>
+      Array.isArray(item),
+    );
+    const resultsToSet = resultOps.filter((op): op is [ProvingJobId, ProvingJobSettledResult] => op[1] !== undefined);
+    const resultsToDelete = resultOps.filter(op => op[1] === undefined).map(([id]) => id);
 
     const db = await this.getEpochDatabase(EpochNumber(epochNumber));
-    await db.batchWrite(jobsToAdd, resultsToAdd);
+    await db.batchWrite(jobsToAdd, resultsToSet, resultsToDelete);
   }
 
   private async estimateSize() {
@@ -207,6 +234,14 @@ export class KVBrokerDatabase implements ProvingBrokerDatabase {
     return this.batchQueue.put([id, { status: 'rejected', reason }], getEpochFromProvingJobId(id));
   }
 
+  setProvingJobAborted(id: ProvingJobId): Promise<void> {
+    return this.batchQueue.put([id, { status: 'aborted' }], getEpochFromProvingJobId(id));
+  }
+
+  deleteProvingJobResult(id: ProvingJobId): Promise<void> {
+    return this.batchQueue.put([id, undefined], getEpochFromProvingJobId(id));
+  }
+
   setProvingJobResult(id: ProvingJobId, value: ProofUri): Promise<void> {
     return this.batchQueue.put([id, { status: 'fulfilled', value }], getEpochFromProvingJobId(id));
   }

package/src/proving_broker/proving_broker_database.ts

@@ -38,6 +38,22 @@ export interface ProvingBrokerDatabase {
    */
   setProvingJobError(id: ProvingJobId, err: string): Promise<void>;
 
+  /**
+   * Records that a proof request was cancelled. Unlike a result or error this is not terminal:
+   * re-enqueuing the same job id revives it, so the aborted state can survive a restart without
+   * permanently blocking the proof.
+   * @param id - The ID of the cancelled proof request
+   */
+  setProvingJobAborted(id: ProvingJobId): Promise<void>;
+
+  /**
+   * Clears any stored result for a proof request, returning it to the pending state while keeping
+   * the job itself. Used when reviving an aborted job so the revival is persisted and a restart
+   * cannot resurrect the stale aborted state.
+   * @param id - The ID of the proof request whose result should be cleared
+   */
+  deleteProvingJobResult(id: ProvingJobId): Promise<void>;
+
   /**
    * Closes the database
    */

package/src/test/epoch_settlement.ts

@@ -0,0 +1,82 @@
+import type { RollupCheatCodes } from '@aztec/ethereum/test';
+import type { CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { Logger } from '@aztec/foundation/log';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import { computeEpochOutHash } from '@aztec/stdlib/messaging';
+
+/** Arguments for {@link settleEpochOutbox}. */
+export type SettleEpochOutboxArgs = {
+  /** Cheat codes used to write the computed out hash directly into the L1 Outbox storage. */
+  rollupCheatCodes: RollupCheatCodes;
+  /** Source of checkpointed L2 blocks for the epoch being settled. */
+  l2BlockSource: L2BlockSource;
+  /** Epoch to settle. */
+  epoch: EpochNumber;
+  /**
+   * When set, only checkpoints up to and including this number are covered. Used to settle a partial
+   * epoch (the AZIP-14 Outbox keeps one root per `numCheckpointsInEpoch`, so a prefix of an epoch can
+   * be settled and consumed before the epoch completes). When omitted, every checkpointed block in the
+   * epoch is covered.
+   */
+  maxCheckpoint?: CheckpointNumber;
+  log: Logger;
+};
+
+/**
+ * Computes the epoch out hash over the checkpointed blocks of an epoch (optionally only up to
+ * `maxCheckpoint`) and writes it into the L1 Outbox via cheat codes. This is the synthetic,
+ * no-prover equivalent of an epoch root proof landing on L1: it makes the L2-to-L1 messages in the
+ * covered checkpoints consumable. It does NOT advance the rollup's proven tip — callers
+ * `markAsProven` separately so a single prove call can settle multiple epochs before marking proven.
+ *
+ * Used by the test-only proving drivers: the `AutomineSequencer`'s auto-settle loop and the standalone
+ * `EpochTestSettler`. Lives here (rather than in either consumer) so both share one implementation.
+ *
+ * @returns The last checkpoint number covered by the settled range, or `undefined` if the epoch has
+ * no checkpointed blocks (within the `maxCheckpoint` bound).
+ */
+export async function settleEpochOutbox({
+  rollupCheatCodes,
+  l2BlockSource,
+  epoch,
+  maxCheckpoint,
+  log,
+}: SettleEpochOutboxArgs): Promise<CheckpointNumber | undefined> {
+  let blocks = await l2BlockSource.getBlocks({ epoch, onlyCheckpointed: true });
+  if (maxCheckpoint !== undefined) {
+    blocks = blocks.filter(block => block.checkpointNumber <= maxCheckpoint);
+  }
+  if (blocks.length === 0) {
+    return undefined;
+  }
+
+  log.info(
+    `Settling epoch ${epoch}${maxCheckpoint !== undefined ? ` up to checkpoint ${maxCheckpoint}` : ''} with blocks ${blocks[0]?.header.getBlockNumber()} to ${blocks.at(-1)?.header.getBlockNumber()}`,
+    { epoch, maxCheckpoint, blocks: blocks.map(block => block.toBlockInfo()) },
+  );
+
+  const messagesInEpoch: Fr[][][][] = [];
+  // Undefined (not SlotNumber.ZERO) so a first checkpointed block at slot 0 still opens checkpoint 0.
+  let previousSlotNumber: SlotNumber | undefined;
+  let checkpointIndex = -1;
+
+  for (const block of blocks) {
+    const slotNumber = block.header.globalVariables.slotNumber;
+    if (slotNumber !== previousSlotNumber) {
+      checkpointIndex++;
+      messagesInEpoch[checkpointIndex] = [];
+      previousSlotNumber = slotNumber;
+    }
+    messagesInEpoch[checkpointIndex].push(block.body.txEffects.map(txEffect => txEffect.l2ToL1Msgs));
+  }
+
+  const outHash = computeEpochOutHash(messagesInEpoch);
+  if (!outHash.isZero()) {
+    await rollupCheatCodes.insertOutbox(epoch, messagesInEpoch.length, outHash.toBigInt());
+  } else {
+    log.info(`No L2 to L1 messages in epoch ${epoch}`, { epoch });
+  }
+
+  return blocks.at(-1)?.checkpointNumber;
+}

package/src/test/index.ts

@@ -0,0 +1 @@
+export { settleEpochOutbox, type SettleEpochOutboxArgs } from './epoch_settlement.js';

package/src/test/mock_prover.ts

@@ -1,5 +1,5 @@
 import {
-  AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
+  AVM_V2_PROOF_LENGTH_IN_FIELDS,
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
@@ -104,7 +104,7 @@ export class MockProver implements ServerCircuitProver {
   constructor() {}
 
   getAvmProof(_inputs: AvmCircuitInputs, _signal?: AbortSignal, _epochNumber?: number) {
-    return Promise.resolve(makeEmptyRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED));
+    return Promise.resolve(makeEmptyRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS));
   }
 
   getBaseParityProof(_inputs: ParityBasePrivateInputs, _signal?: AbortSignal, _epochNumber?: number) {

package/dest/orchestrator/epoch-proving-context.d.ts

@@ -1,51 +0,0 @@
-import type { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
-import type { EpochNumber } from '@aztec/foundation/branded-types';
-import { type LoggerBindings } from '@aztec/foundation/log';
-import type { PublicInputsAndRecursiveProof, ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
-import type { PublicChonkVerifierPrivateInputs, PublicChonkVerifierPublicInputs } from '@aztec/stdlib/rollup';
-/**
- * Result of a chonk-verifier proof, cached per tx hash on `EpochProvingContext`.
- */
-export type ChonkVerifierProofResult = PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>;
-/**
- * Per-epoch state shared across every `CheckpointSubTreeOrchestrator` constructed for
- * the same epoch. Owns the chonk-verifier proof cache so a tx whose checkpoint is
- * reorged out and re-appears in a replacement checkpoint does not have to re-prove
- * its chonk circuit.
- *
- * The context's chonk-verifier broker jobs are deliberately submitted **outside** the
- * sub-tree's deferred-proving queue. The sub-tree's `cancel()` therefore does not abort
- * them — by design, because their result is tx-scoped, not sub-tree-scoped, and a
- * replacement sub-tree should be able to consume the cached proof.
- *
- * Callers (`EpochProvingJob`, or unit tests) construct one context per epoch and pass
- * it into every sub-tree they create. `stop()` aborts every in-flight chonk job.
- */
-export declare class EpochProvingContext {
-    private readonly prover;
-    readonly epochNumber: EpochNumber;
-    private readonly cache;
-    /** Abort controllers for in-flight chonk jobs, keyed by tx hash. */
-    private readonly pending;
-    private readonly log;
-    private stopped;
-    constructor(prover: ServerCircuitProver, epochNumber: EpochNumber, bindings?: LoggerBindings);
-    /**
-     * Returns the cached chonk-verifier proof promise for the given tx hash, or
-     * `undefined` if none has been enqueued yet. Non-mutating.
-     */
-    getCached(txHash: string): Promise<ChonkVerifierProofResult> | undefined;
-    /**
-     * Enqueues a chonk-verifier proof for the given tx hash, returning the promise (or
-     * the already-cached one if already enqueued). The promise resolves when the broker
-     * delivers the result; on rejection (including `stop()`), the cache entry is removed
-     * so a subsequent caller can re-enqueue.
-     */
-    enqueue(txHash: string, inputs: PublicChonkVerifierPrivateInputs): Promise<ChonkVerifierProofResult>;
-    /**
-     * Aborts every in-flight chonk-verifier broker job and clears the cache. Called by
-     * the owning `EpochProvingJob` when the job stops.
-     */
-    stop(): void;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXBvY2gtcHJvdmluZy1jb250ZXh0LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvb3JjaGVzdHJhdG9yL2Vwb2NoLXByb3ZpbmctY29udGV4dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSx5Q0FBeUMsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ2xGLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ25FLE9BQU8sRUFBZSxLQUFLLGNBQWMsRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQUN2RixPQUFPLEtBQUssRUFBRSw2QkFBNkIsRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQzFHLE9BQU8sS0FBSyxFQUFFLGdDQUFnQyxFQUFFLCtCQUErQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFOUc7O0dBRUc7QUFDSCxNQUFNLE1BQU0sd0JBQXdCLEdBQUcsNkJBQTZCLENBQ2xFLCtCQUErQixFQUMvQixPQUFPLHlDQUF5QyxDQUNqRCxDQUFDO0FBRUY7Ozs7Ozs7Ozs7Ozs7R0FhRztBQUNILHFCQUFhLG1CQUFtQjtJQVE1QixPQUFPLENBQUMsUUFBUSxDQUFDLE1BQU07YUFDUCxXQUFXLEVBQUUsV0FBVztJQVIxQyxPQUFPLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBd0Q7SUFDOUUsb0VBQW9FO0lBQ3BFLE9BQU8sQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFzQztJQUM5RCxPQUFPLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBUztJQUM3QixPQUFPLENBQUMsT0FBTyxDQUFTO0lBRXhCLFlBQ21CLE1BQU0sRUFBRSxtQkFBbUIsRUFDNUIsV0FBVyxFQUFFLFdBQVcsRUFDeEMsUUFBUSxDQUFDLEVBQUUsY0FBYyxFQUcxQjtJQUVEOzs7T0FHRztJQUNJLFNBQVMsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyx3QkFBd0IsQ0FBQyxHQUFHLFNBQVMsQ0FFOUU7SUFFRDs7Ozs7T0FLRztJQUNJLE9BQU8sQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxnQ0FBZ0MsR0FBRyxPQUFPLENBQUMsd0JBQXdCLENBQUMsQ0E2QjFHO0lBRUQ7OztPQUdHO0lBQ0ksSUFBSSxTQU9WO0NBQ0YifQ==

package/dest/orchestrator/epoch-proving-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"epoch-proving-context.d.ts","sourceRoot":"","sources":["../../src/orchestrator/epoch-proving-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yCAAyC,EAAE,MAAM,kBAAkB,CAAC;AAClF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AACvF,OAAO,KAAK,EAAE,6BAA6B,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAC1G,OAAO,KAAK,EAAE,gCAAgC,EAAE,+BAA+B,EAAE,MAAM,sBAAsB,CAAC;AAE9G;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,6BAA6B,CAClE,+BAA+B,EAC/B,OAAO,yCAAyC,CACjD,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,qBAAa,mBAAmB;IAQ5B,OAAO,CAAC,QAAQ,CAAC,MAAM;aACP,WAAW,EAAE,WAAW;IAR1C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAwD;IAC9E,oEAAoE;IACpE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;IAC9D,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,OAAO,CAAS;IAExB,YACmB,MAAM,EAAE,mBAAmB,EAC5B,WAAW,EAAE,WAAW,EACxC,QAAQ,CAAC,EAAE,cAAc,EAG1B;IAED;;;OAGG;IACI,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,wBAAwB,CAAC,GAAG,SAAS,CAE9E;IAED;;;;;OAKG;IACI,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,gCAAgC,GAAG,OAAO,CAAC,wBAAwB,CAAC,CA6B1G;IAED;;;OAGG;IACI,IAAI,SAOV;CACF"}

package/dest/orchestrator/epoch-proving-context.js

@@ -1,81 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-/**
- * Per-epoch state shared across every `CheckpointSubTreeOrchestrator` constructed for
- * the same epoch. Owns the chonk-verifier proof cache so a tx whose checkpoint is
- * reorged out and re-appears in a replacement checkpoint does not have to re-prove
- * its chonk circuit.
- *
- * The context's chonk-verifier broker jobs are deliberately submitted **outside** the
- * sub-tree's deferred-proving queue. The sub-tree's `cancel()` therefore does not abort
- * them — by design, because their result is tx-scoped, not sub-tree-scoped, and a
- * replacement sub-tree should be able to consume the cached proof.
- *
- * Callers (`EpochProvingJob`, or unit tests) construct one context per epoch and pass
- * it into every sub-tree they create. `stop()` aborts every in-flight chonk job.
- */ export class EpochProvingContext {
-    prover;
-    epochNumber;
-    cache;
-    /** Abort controllers for in-flight chonk jobs, keyed by tx hash. */ pending;
-    log;
-    stopped;
-    constructor(prover, epochNumber, bindings){
-        this.prover = prover;
-        this.epochNumber = epochNumber;
-        this.cache = new Map();
-        this.pending = new Map();
-        this.stopped = false;
-        this.log = createLogger('prover-client:epoch-proving-context', bindings);
-    }
-    /**
-   * Returns the cached chonk-verifier proof promise for the given tx hash, or
-   * `undefined` if none has been enqueued yet. Non-mutating.
-   */ getCached(txHash) {
-        return this.cache.get(txHash);
-    }
-    /**
-   * Enqueues a chonk-verifier proof for the given tx hash, returning the promise (or
-   * the already-cached one if already enqueued). The promise resolves when the broker
-   * delivers the result; on rejection (including `stop()`), the cache entry is removed
-   * so a subsequent caller can re-enqueue.
-   */ enqueue(txHash, inputs) {
-        if (this.stopped) {
-            return Promise.reject(new Error('EpochProvingContext is stopped'));
-        }
-        const cached = this.cache.get(txHash);
-        if (cached) {
-            return cached;
-        }
-        const controller = new AbortController();
-        this.pending.set(txHash, controller);
-        this.log.debug(`Enqueueing chonk-verifier circuit`, {
-            txHash,
-            epochNumber: this.epochNumber
-        });
-        const promise = this.prover.getPublicChonkVerifierProof(inputs, controller.signal, this.epochNumber).finally(()=>this.pending.delete(txHash));
-        // Self-clean on rejection so a future caller can re-enqueue. Mark the rejection
-        // path as observed to silence unhandled-rejection warnings when no consumer
-        // awaits the promise (e.g. when the only `.then` chain belonged to a cancelled
-        // sub-tree's tx-proving state).
-        promise.catch((err)=>{
-            this.cache.delete(txHash);
-            this.log.debug(`Chonk-verifier proof failed; evicted from cache`, {
-                txHash,
-                error: `${err}`
-            });
-        });
-        this.cache.set(txHash, promise);
-        return promise;
-    }
-    /**
-   * Aborts every in-flight chonk-verifier broker job and clears the cache. Called by
-   * the owning `EpochProvingJob` when the job stops.
-   */ stop() {
-        this.stopped = true;
-        for (const controller of this.pending.values()){
-            controller.abort();
-        }
-        this.pending.clear();
-        this.cache.clear();
-    }
-}

package/dest/orchestrator/epoch-proving-state.d.ts

@@ -1,75 +0,0 @@
-import { BatchedBlob, type FinalBlobBatchingChallenges } from '@aztec/blob-lib';
-import { type ARCHIVE_HEIGHT, type L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
-import { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import type { Tuple } from '@aztec/foundation/serialize';
-import { type TreeNodeLocation } from '@aztec/foundation/trees';
-import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
-import type { Proof } from '@aztec/stdlib/proofs';
-import { CheckpointConstantData, CheckpointMergeRollupPrivateInputs, CheckpointPaddingRollupPrivateInputs, CheckpointRollupPublicInputs, PublicChonkVerifierPublicInputs, RootRollupPrivateInputs, type RootRollupPublicInputs } from '@aztec/stdlib/rollup';
-import { AppendOnlyTreeSnapshot, type MerkleTreeId } from '@aztec/stdlib/trees';
-import type { BlockHeader } from '@aztec/stdlib/tx';
-import { CheckpointProvingState } from './checkpoint-proving-state.js';
-export type TreeSnapshots = Map<MerkleTreeId, AppendOnlyTreeSnapshot>;
-export type ProvingResult = {
-    status: 'success';
-} | {
-    status: 'failure';
-    reason: string;
-};
-/**
- * The current state of the proving schedule for an epoch.
- * Contains the raw inputs and intermediate state to generate every constituent proof in the tree.
- * Carries an identifier so we can identify if the proving state is discarded and a new one started.
- * Captures resolve and reject callbacks to provide a promise base interface to the consumer of our proving.
- */
-export declare class EpochProvingState {
-    #private;
-    readonly epochNumber: EpochNumber;
-    readonly totalNumCheckpoints: number;
-    private readonly finalBlobBatchingChallenges;
-    private onCheckpointBlobAccumulatorSet;
-    private completionCallback;
-    private rejectionCallback;
-    private checkpointProofs;
-    private checkpointPaddingProof;
-    private rootRollupProof;
-    private checkpoints;
-    private startBlobAccumulator;
-    private endBlobAccumulator;
-    private finalBatchedBlob;
-    private provingStateLifecycle;
-    readonly cachedChonkVerifierProofs: Map<string, Promise<PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, 480>>>;
-    constructor(epochNumber: EpochNumber, totalNumCheckpoints: number, finalBlobBatchingChallenges: FinalBlobBatchingChallenges, onCheckpointBlobAccumulatorSet: (checkpoint: CheckpointProvingState) => Promise<void>, completionCallback: (result: ProvingResult) => void, rejectionCallback: (reason: string) => void);
-    startNewCheckpoint(checkpointIndex: number, constants: CheckpointConstantData, totalNumBlocks: number, previousBlockHeader: BlockHeader, lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, l1ToL2Messages: Fr[], lastL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, lastL1ToL2MessageSubtreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH>, newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, newL1ToL2MessageSubtreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH>): CheckpointProvingState;
-    getCheckpointProvingState(index: number): CheckpointProvingState | undefined;
-    getCheckpointProvingStateByBlockNumber(blockNumber: BlockNumber): CheckpointProvingState | undefined;
-    getBlockProvingStateByBlockNumber(blockNumber: BlockNumber): import("./block-proving-state.js").BlockProvingState | undefined;
-    verifyState(): boolean;
-    isAcceptingCheckpoints(): boolean;
-    setCheckpointRootRollupProof(checkpointIndex: number, provingOutput: PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): TreeNodeLocation;
-    tryStartProvingCheckpointMerge(location: TreeNodeLocation): boolean;
-    setCheckpointMergeRollupProof(location: TreeNodeLocation, provingOutput: PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
-    tryStartProvingRootRollup(): boolean;
-    setRootRollupProof(provingOutput: PublicInputsAndRecursiveProof<RootRollupPublicInputs>): void;
-    tryStartProvingPaddingCheckpoint(): boolean;
-    setCheckpointPaddingProof(provingOutput: PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
-    accumulateCheckpointOutHashes(): Promise<void>;
-    setBlobAccumulators(): Promise<void>;
-    finalizeBatchedBlob(): Promise<void>;
-    getParentLocation(location: TreeNodeLocation): TreeNodeLocation;
-    getCheckpointMergeRollupInputs(mergeLocation: TreeNodeLocation): CheckpointMergeRollupPrivateInputs;
-    getRootRollupInputs(): RootRollupPrivateInputs;
-    getPaddingCheckpointInputs(): CheckpointPaddingRollupPrivateInputs;
-    getEpochProofResult(): {
-        proof: Proof;
-        publicInputs: RootRollupPublicInputs;
-        batchedBlobInputs: BatchedBlob;
-    };
-    isReadyForCheckpointMerge(location: TreeNodeLocation): boolean;
-    isReadyForRootRollup(): boolean;
-    cancel(): void;
-    reject(reason: string): void;
-    resolve(result: ProvingResult): void;
-}
-//# sourceMappingURL=data:application/json;base64,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

package/dest/orchestrator/epoch-proving-state.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"epoch-proving-state.d.ts","sourceRoot":"","sources":["../../src/orchestrator/epoch-proving-state.ts"],"names":[],"mappings":"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"}