@aztec/prover-client 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/src/proving_broker/proving_broker_database.ts

@@ -22,6 +22,20 @@ export interface ProvingBrokerDatabase {
    */
   allProvingJobs(): AsyncIterableIterator<[ProvingJob, ProvingJobSettledResult | undefined]>;
 
+  /**
+   * Reads a single job's inputs URI by id, or undefined if the job is unknown. The broker keeps only
+   * job metadata in memory and reads the (large) inputs from here on demand when dispatching to an agent.
+   * @param id - The ID of the proof request
+   */
+  getProvingJobInputs(id: ProvingJobId): Promise<ProofUri | undefined>;
+
+  /**
+   * Reads a single job's settled result by id, or undefined if not settled. The broker keeps only the
+   * settled status in memory and reads the (large) fulfilled proof from here on demand.
+   * @param id - The ID of the proof request
+   */
+  getProvingJobResult(id: ProvingJobId): Promise<ProvingJobSettledResult | undefined>;
+
   /**
    * Saves the result of a proof request
    * @param id - The ID of the proof request to save the result for
@@ -38,6 +52,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/proving_broker/rpc.ts

@@ -18,6 +18,16 @@ 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, 1, 1, 2, 4];
@@ -83,10 +93,12 @@ export function createProvingJobBrokerClient(
   url: string,
   versions: Partial<ComponentsVersions>,
   fetch = makeTracedFetch(proverBrokerBackoff, false),
+  maxRequestBodySize = PROVER_BROKER_MAX_REQUEST_BODY_SIZE,
 ): ProvingJobBroker {
   return createSafeJsonRpcClient(url, ProvingJobBrokerSchema, {
     namespaceMethods: 'proverBroker',
     fetch,
+    maxRequestBodySize,
     onResponse: getVersioningResponseHandler(versions),
   });
 }
@@ -95,10 +107,12 @@ export function createProvingJobProducerClient(
   url: string,
   versions: Partial<ComponentsVersions>,
   fetch = makeTracedFetch(proverBrokerBackoff, false),
+  maxRequestBodySize = PROVER_BROKER_MAX_REQUEST_BODY_SIZE,
 ): ProvingJobProducer {
   return createSafeJsonRpcClient(url, ProvingJobProducerSchema, {
     namespaceMethods: 'provingJobProducer',
     fetch,
+    maxRequestBodySize,
     onResponse: getVersioningResponseHandler(versions),
   });
 }
@@ -107,10 +121,12 @@ export function createProvingJobConsumerClient(
   url: string,
   versions: Partial<ComponentsVersions>,
   fetch = makeTracedFetch(proverBrokerBackoff, false),
+  maxRequestBodySize = PROVER_BROKER_MAX_REQUEST_BODY_SIZE,
 ): ProvingJobConsumer {
   return createSafeJsonRpcClient(url, ProvingJobConsumerSchema, {
     namespaceMethods: 'provingJobConsumer',
     fetch,
+    maxRequestBodySize,
     onResponse: getVersioningResponseHandler(versions),
   });
 }

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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"}