@aztec/prover-client 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/dest/prover-client/server-epoch-prover.d.ts

@@ -1,31 +0,0 @@
-import type { BatchedBlob, FinalBlobBatchingChallenges } from '@aztec/blob-lib';
-import type { Fr } from '@aztec/foundation/fields';
-import type { EthAddress } from '@aztec/stdlib/block';
-import type { EpochProver } from '@aztec/stdlib/interfaces/server';
-import type { Proof } from '@aztec/stdlib/proofs';
-import type { CheckpointConstantData, RootRollupPublicInputs } from '@aztec/stdlib/rollup';
-import type { BlockHeader, ProcessedTx, Tx } from '@aztec/stdlib/tx';
-import type { UInt64 } from '@aztec/stdlib/types';
-import type { ProvingOrchestrator } from '../orchestrator/orchestrator.js';
-import type { BrokerCircuitProverFacade } from '../proving_broker/broker_prover_facade.js';
-/** Encapsulates the proving orchestrator and the broker facade */
-export declare class ServerEpochProver implements EpochProver {
-    private facade;
-    private orchestrator;
-    constructor(facade: BrokerCircuitProverFacade, orchestrator: ProvingOrchestrator);
-    startNewEpoch(epochNumber: number, totalNumCheckpoints: number, finalBlobBatchingChallenges: FinalBlobBatchingChallenges): void;
-    startNewCheckpoint(checkpointIndex: number, constants: CheckpointConstantData, l1ToL2Messages: Fr[], totalNumBlocks: number, totalNumBlobFields: number, headerOfLastBlockInPreviousCheckpoint: BlockHeader): Promise<void>;
-    startChonkVerifierCircuits(txs: Tx[]): Promise<void>;
-    setBlockCompleted(blockNumber: number, expectedBlockHeader?: BlockHeader): Promise<BlockHeader>;
-    finalizeEpoch(): Promise<{
-        publicInputs: RootRollupPublicInputs;
-        proof: Proof;
-        batchedBlobInputs: BatchedBlob;
-    }>;
-    cancel(): void;
-    getProverId(): EthAddress;
-    stop(): Promise<void>;
-    startNewBlock(blockNumber: number, timestamp: UInt64, totalNumTxs: number): Promise<void>;
-    addTxs(txs: ProcessedTx[]): Promise<void>;
-}
-//# sourceMappingURL=server-epoch-prover.d.ts.map

package/dest/prover-client/server-epoch-prover.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server-epoch-prover.d.ts","sourceRoot":"","sources":["../../src/prover-client/server-epoch-prover.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AAChF,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAC3F,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AACrE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AAE3F,kEAAkE;AAClE,qBAAa,iBAAkB,YAAW,WAAW;IAEjD,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,YAAY;gBADZ,MAAM,EAAE,yBAAyB,EACjC,YAAY,EAAE,mBAAmB;IAG3C,aAAa,CACX,WAAW,EAAE,MAAM,EACnB,mBAAmB,EAAE,MAAM,EAC3B,2BAA2B,EAAE,2BAA2B,GACvD,IAAI;IAIP,kBAAkB,CAChB,eAAe,EAAE,MAAM,EACvB,SAAS,EAAE,sBAAsB,EACjC,cAAc,EAAE,EAAE,EAAE,EACpB,cAAc,EAAE,MAAM,EACtB,kBAAkB,EAAE,MAAM,EAC1B,qCAAqC,EAAE,WAAW,GACjD,OAAO,CAAC,IAAI,CAAC;IAUhB,0BAA0B,CAAC,GAAG,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAGpD,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,mBAAmB,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAG/F,aAAa,IAAI,OAAO,CAAC;QAAE,YAAY,EAAE,sBAAsB,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC;QAAC,iBAAiB,EAAE,WAAW,CAAA;KAAE,CAAC;IAGhH,MAAM,IAAI,IAAI;IAGd,WAAW,IAAI,UAAU;IAGnB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAGzF,MAAM,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAG1C"}

package/dest/prover-client/server-epoch-prover.js

@@ -1,40 +0,0 @@
-/** Encapsulates the proving orchestrator and the broker facade */ export class ServerEpochProver {
-    facade;
-    orchestrator;
-    constructor(facade, orchestrator){
-        this.facade = facade;
-        this.orchestrator = orchestrator;
-    }
-    startNewEpoch(epochNumber, totalNumCheckpoints, finalBlobBatchingChallenges) {
-        this.orchestrator.startNewEpoch(epochNumber, totalNumCheckpoints, finalBlobBatchingChallenges);
-        this.facade.start();
-    }
-    startNewCheckpoint(checkpointIndex, constants, l1ToL2Messages, totalNumBlocks, totalNumBlobFields, headerOfLastBlockInPreviousCheckpoint) {
-        return this.orchestrator.startNewCheckpoint(checkpointIndex, constants, l1ToL2Messages, totalNumBlocks, totalNumBlobFields, headerOfLastBlockInPreviousCheckpoint);
-    }
-    startChonkVerifierCircuits(txs) {
-        return this.orchestrator.startChonkVerifierCircuits(txs);
-    }
-    setBlockCompleted(blockNumber, expectedBlockHeader) {
-        return this.orchestrator.setBlockCompleted(blockNumber, expectedBlockHeader);
-    }
-    finalizeEpoch() {
-        return this.orchestrator.finalizeEpoch();
-    }
-    cancel() {
-        this.orchestrator.cancel();
-    }
-    getProverId() {
-        return this.orchestrator.getProverId();
-    }
-    async stop() {
-        await this.facade.stop();
-        await this.orchestrator.stop();
-    }
-    startNewBlock(blockNumber, timestamp, totalNumTxs) {
-        return this.orchestrator.startNewBlock(blockNumber, timestamp, totalNumTxs);
-    }
-    addTxs(txs) {
-        return this.orchestrator.addTxs(txs);
-    }
-}

package/dest/proving_broker/proof_store/gcs_proof_store.d.ts

@@ -1,14 +0,0 @@
-import { type ProofUri, type ProvingJobId, type ProvingJobInputs, type ProvingJobInputsMap, type ProvingJobResult, type ProvingJobResultsMap } from '@aztec/stdlib/interfaces/server';
-import { ProvingRequestType } from '@aztec/stdlib/proofs';
-import type { ProofStore } from './proof_store.js';
-export declare class GoogleCloudStorageProofStore implements ProofStore {
-    private readonly bucketName;
-    private readonly path;
-    private readonly storage;
-    constructor(bucketName: string, path: string);
-    saveProofInput<T extends ProvingRequestType>(id: ProvingJobId, type: T, inputs: ProvingJobInputsMap[T]): Promise<ProofUri>;
-    saveProofOutput<T extends ProvingRequestType>(_id: ProvingJobId, _type: T, _result: ProvingJobResultsMap[T]): Promise<ProofUri>;
-    getProofInput(uri: ProofUri): Promise<ProvingJobInputs>;
-    getProofOutput(_uri: ProofUri): Promise<ProvingJobResult>;
-}
-//# sourceMappingURL=gcs_proof_store.d.ts.map

package/dest/proving_broker/proof_store/gcs_proof_store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gcs_proof_store.d.ts","sourceRoot":"","sources":["../../../src/proving_broker/proof_store/gcs_proof_store.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EAE1B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAK1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAKnD,qBAAa,4BAA6B,YAAW,UAAU;IAI3D,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,IAAI;IAJvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;gBAGf,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM;IAKlB,cAAc,CAAC,CAAC,SAAS,kBAAkB,EACtD,EAAE,EAAE,YAAY,EAChB,IAAI,EAAE,CAAC,EACP,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAC7B,OAAO,CAAC,QAAQ,CAAC;IAOpB,eAAe,CAAC,CAAC,SAAS,kBAAkB,EAC1C,GAAG,EAAE,YAAY,EACjB,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,oBAAoB,CAAC,CAAC,CAAC,GAC/B,OAAO,CAAC,QAAQ,CAAC;IAIP,aAAa,CAAC,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAwBpE,cAAc,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAG1D"}

package/dest/proving_broker/proof_store/gcs_proof_store.js

@@ -1,52 +0,0 @@
-import { getProvingJobInputClassFor } from '@aztec/stdlib/interfaces/server';
-import { ProvingRequestType } from '@aztec/stdlib/proofs';
-import { Storage } from '@google-cloud/storage';
-import { join } from 'path';
-const INPUTS_PATH = 'inputs';
-// REFACTOR(#13067): Use the stdlib/file-store instead of referencing google-cloud-storage directly.
-export class GoogleCloudStorageProofStore {
-    bucketName;
-    path;
-    storage;
-    constructor(bucketName, path){
-        this.bucketName = bucketName;
-        this.path = path;
-        this.storage = new Storage();
-    }
-    async saveProofInput(id, type, inputs) {
-        const path = join(this.path, INPUTS_PATH, ProvingRequestType[type], id);
-        const file = this.storage.bucket(this.bucketName).file(path);
-        await file.save(inputs.toBuffer());
-        return file.cloudStorageURI.toString();
-    }
-    saveProofOutput(_id, _type, _result) {
-        throw new Error('Not implemented');
-    }
-    async getProofInput(uri) {
-        try {
-            const url = new URL(uri);
-            const bucket = this.storage.bucket(url.host);
-            const path = url.pathname.replace(/^\/+/, '');
-            const file = bucket.file(path);
-            if (!await file.exists()) {
-                throw new Error(`File at ${uri} does not exist`);
-            }
-            const typeString = path.split('/').at(-2);
-            const type = typeString ? ProvingRequestType[typeString] : undefined;
-            if (type === undefined) {
-                throw new Error(`Unrecognized proof type ${type} in path ${path}`);
-            }
-            const contents = await file.download();
-            const inputs = getProvingJobInputClassFor(type).fromBuffer(contents[0]);
-            return {
-                inputs,
-                type
-            };
-        } catch (err) {
-            throw new Error(`Error getting proof input at ${uri}: ${err}`);
-        }
-    }
-    getProofOutput(_uri) {
-        throw new Error('Not implemented');
-    }
-}

package/dest/proving_broker/proving_agent_instrumentation.d.ts

@@ -1,8 +0,0 @@
-import type { Timer } from '@aztec/foundation/timer';
-import { type TelemetryClient } from '@aztec/telemetry-client';
-export declare class ProvingAgentInstrumentation {
-    private idleTime;
-    constructor(client: TelemetryClient, name?: string);
-    recordIdleTime(msOrTimer: Timer | number): void;
-}
-//# sourceMappingURL=proving_agent_instrumentation.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"proving_agent_instrumentation.d.ts","sourceRoot":"","sources":["../../src/proving_broker/proving_agent_instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAA2B,KAAK,eAAe,EAAa,MAAM,yBAAyB,CAAC;AAEnG,qBAAa,2BAA2B;IACtC,OAAO,CAAC,QAAQ,CAAY;gBAEhB,MAAM,EAAE,eAAe,EAAE,IAAI,SAAiB;IAU1D,cAAc,CAAC,SAAS,EAAE,KAAK,GAAG,MAAM;CAIzC"}

package/dest/proving_broker/proving_agent_instrumentation.js

@@ -1,16 +0,0 @@
-import { Metrics, ValueType } from '@aztec/telemetry-client';
-export class ProvingAgentInstrumentation {
-    idleTime;
-    constructor(client, name = 'ProvingAgent'){
-        const meter = client.getMeter(name);
-        this.idleTime = meter.createHistogram(Metrics.PROVING_AGENT_IDLE, {
-            description: 'Records how long an agent was idle',
-            unit: 's',
-            valueType: ValueType.DOUBLE
-        });
-    }
-    recordIdleTime(msOrTimer) {
-        const duration = typeof msOrTimer === 'number' ? msOrTimer : msOrTimer.ms();
-        this.idleTime.record(duration / 1000);
-    }
-}

package/src/block-factory/index.ts

@@ -1 +0,0 @@
-export * from './light.js';

package/src/block-factory/light.ts

@@ -1,140 +0,0 @@
-import { SpongeBlob } from '@aztec/blob-lib';
-import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import { L2Block } from '@aztec/stdlib/block';
-import type { IBlockFactory, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
-import type { GlobalVariables, ProcessedTx } from '@aztec/stdlib/tx';
-import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
-
-import {
-  buildHeaderAndBodyFromTxs,
-  getTreeSnapshot,
-  insertSideEffectsAndBuildBaseRollupHints,
-} from '../orchestrator/block-building-helpers.js';
-
-/**
- * Builds a block and its header from a set of processed tx without running any circuits.
- *
- * NOTE: the onus is ON THE CALLER to update the db that is passed in with the notes hashes, nullifiers, etc
- * PRIOR to calling `buildBlock`.
- *
- * Why? Because if you are, e.g. building a block in practice from TxObjects, you are using the
- * PublicProcessor which will do this for you as it processes transactions.
- *
- * If you haven't already inserted the side effects, e.g. because you are in a testing context, you can use the helper
- * function `buildBlockWithCleanDB`, which calls `insertSideEffectsAndBuildBaseRollupHints` for you.
- */
-export class LightweightBlockFactory implements IBlockFactory {
-  private globalVariables?: GlobalVariables;
-  private l1ToL2Messages?: Fr[];
-  private startSpongeBlob?: SpongeBlob;
-  private txs: ProcessedTx[] | undefined;
-
-  private readonly logger = createLogger('lightweight-block-factory');
-
-  constructor(
-    private db: MerkleTreeWriteOperations,
-    private telemetry: TelemetryClient = getTelemetryClient(),
-  ) {}
-
-  async startNewBlock(
-    globalVariables: GlobalVariables,
-    l1ToL2Messages: Fr[],
-    // Must be provided to generate the correct spongeBlobHash for the block header if there's more than one block in the checkpoint.
-    startSpongeBlob?: SpongeBlob,
-    // Only insert l1 to l2 messages for the first block in a checkpoint.
-    isFirstBlock = true,
-  ): Promise<void> {
-    this.logger.debug('Starting new block', { globalVariables: globalVariables.toInspect(), l1ToL2Messages });
-    this.globalVariables = globalVariables;
-    this.l1ToL2Messages = isFirstBlock
-      ? padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP)
-      : [];
-    this.startSpongeBlob = startSpongeBlob;
-    this.txs = undefined;
-    // Update L1 to L2 tree
-    await this.db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, this.l1ToL2Messages!);
-  }
-
-  addTxs(txs: ProcessedTx[]): Promise<void> {
-    // Most times, `addTxs` is only called once per block.
-    // So avoid copies.
-    if (this.txs === undefined) {
-      this.txs = txs;
-    } else {
-      this.txs.push(...txs);
-    }
-    return Promise.resolve();
-  }
-
-  setBlockCompleted(): Promise<L2Block> {
-    return this.buildBlock();
-  }
-
-  private async buildBlock(): Promise<L2Block> {
-    const { header, body } = await buildHeaderAndBodyFromTxs(
-      this.txs ?? [],
-      this.globalVariables!,
-      this.l1ToL2Messages!,
-      this.db,
-      this.startSpongeBlob,
-    );
-
-    header.state.validate();
-
-    const blockHeader = header.toBlockHeader();
-    await this.db.updateArchive(blockHeader);
-    const newArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.db);
-
-    const block = new L2Block(newArchive, header, body);
-
-    this.logger.debug(`Built block ${block.number}`, {
-      globalVariables: this.globalVariables?.toInspect(),
-      archiveRoot: newArchive.root.toString(),
-      stateReference: header.state.toInspect(),
-      blockHash: (await block.hash()).toString(),
-      txs: block.body.txEffects.map(tx => tx.txHash.toString()),
-    });
-
-    return block;
-  }
-}
-
-/**
- * Inserts the processed transactions into the DB, then creates a block.
- * @param db - A db fork to use for block building which WILL BE MODIFIED.
- */
-export async function buildBlockWithCleanDB(
-  txs: ProcessedTx[],
-  globalVariables: GlobalVariables,
-  l1ToL2Messages: Fr[],
-  db: MerkleTreeWriteOperations,
-  startSpongeBlob?: SpongeBlob,
-  isFirstBlock = true,
-  telemetry: TelemetryClient = getTelemetryClient(),
-) {
-  const lastArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
-  const builder = new LightweightBlockFactory(db, telemetry);
-  await builder.startNewBlock(globalVariables, l1ToL2Messages, startSpongeBlob, isFirstBlock);
-  const l1ToL2MessageTree = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
-
-  for (const tx of txs) {
-    // startSpongeBlob and proverId are only used for constructing private inputs of the base rollup.
-    // Their values don't matter here because we are not using the return private inputs to build the block.
-    const proverId = Fr.ZERO;
-    await insertSideEffectsAndBuildBaseRollupHints(
-      tx,
-      lastArchive,
-      l1ToL2MessageTree,
-      startSpongeBlob?.clone() ?? SpongeBlob.empty(),
-      proverId,
-      db,
-    );
-  }
-  await builder.addTxs(txs);
-
-  return await builder.setBlockCompleted();
-}

package/src/orchestrator/epoch-proving-state.ts

@@ -1,328 +0,0 @@
-import { BatchedBlob, BatchedBlobAccumulator, type FinalBlobBatchingChallenges } from '@aztec/blob-lib';
-import type {
-  ARCHIVE_HEIGHT,
-  L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
-  NESTED_RECURSIVE_PROOF_LENGTH,
-  NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-} from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/fields';
-import type { Tuple } from '@aztec/foundation/serialize';
-import { type TreeNodeLocation, UnbalancedTreeStore } 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 type { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
-import type { BlockHeader } from '@aztec/stdlib/tx';
-
-import { toProofData } from './block-building-helpers.js';
-import type { ProofState } from './block-proving-state.js';
-import { CheckpointProvingState } from './checkpoint-proving-state.js';
-
-export type TreeSnapshots = Map<MerkleTreeId, AppendOnlyTreeSnapshot>;
-
-enum PROVING_STATE_LIFECYCLE {
-  PROVING_STATE_CREATED,
-  PROVING_STATE_FULL,
-  PROVING_STATE_RESOLVED,
-  PROVING_STATE_REJECTED,
-}
-
-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 class EpochProvingState {
-  private checkpointProofs: UnbalancedTreeStore<
-    ProofState<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  >;
-  private checkpointPaddingProof:
-    | ProofState<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-    | undefined;
-  private rootRollupProof: ProofState<RootRollupPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH> | undefined;
-  private checkpoints: (CheckpointProvingState | undefined)[] = [];
-  private startBlobAccumulator: BatchedBlobAccumulator;
-  private endBlobAccumulator: BatchedBlobAccumulator | undefined;
-  private finalBatchedBlob: BatchedBlob | undefined;
-  private provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED;
-
-  // Map from tx hash to chonk verifier proof promise. Used when kickstarting chonk verifier proofs before tx processing.
-  public readonly cachedChonkVerifierProofs = new Map<
-    string,
-    Promise<
-      PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-    >
-  >();
-
-  constructor(
-    public readonly epochNumber: number,
-    public readonly totalNumCheckpoints: number,
-    private readonly finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
-    private onCheckpointBlobAccumulatorSet: (checkpoint: CheckpointProvingState) => void,
-    private completionCallback: (result: ProvingResult) => void,
-    private rejectionCallback: (reason: string) => void,
-  ) {
-    this.checkpointProofs = new UnbalancedTreeStore(totalNumCheckpoints);
-    this.startBlobAccumulator = BatchedBlobAccumulator.newWithChallenges(finalBlobBatchingChallenges);
-  }
-
-  // Adds a block to the proving state, returns its index
-  // Will update the proving life cycle if this is the last block
-  public startNewCheckpoint(
-    checkpointIndex: number,
-    constants: CheckpointConstantData,
-    totalNumBlocks: number,
-    totalNumBlobFields: 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 {
-    if (checkpointIndex >= this.totalNumCheckpoints) {
-      throw new Error(
-        `Unable to start a new checkpoint at index ${checkpointIndex}. Expected at most ${this.totalNumCheckpoints} checkpoints.`,
-      );
-    }
-
-    const checkpoint = new CheckpointProvingState(
-      checkpointIndex,
-      constants,
-      totalNumBlocks,
-      totalNumBlobFields,
-      this.finalBlobBatchingChallenges,
-      previousBlockHeader,
-      lastArchiveSiblingPath,
-      l1ToL2Messages,
-      lastL1ToL2MessageTreeSnapshot,
-      lastL1ToL2MessageSubtreeRootSiblingPath,
-      newL1ToL2MessageTreeSnapshot,
-      newL1ToL2MessageSubtreeRootSiblingPath,
-      this,
-      this.onCheckpointBlobAccumulatorSet,
-    );
-    this.checkpoints[checkpointIndex] = checkpoint;
-
-    if (this.checkpoints.filter(c => !!c).length === this.totalNumCheckpoints) {
-      this.provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_FULL;
-    }
-
-    return checkpoint;
-  }
-
-  public getCheckpointProvingState(index: number) {
-    return this.checkpoints[index];
-  }
-
-  public getCheckpointProvingStateByBlockNumber(blockNumber: number) {
-    return this.checkpoints.find(
-      c => c && blockNumber >= c.firstBlockNumber && blockNumber < c.firstBlockNumber + c.totalNumBlocks,
-    );
-  }
-
-  public getBlockProvingStateByBlockNumber(blockNumber: number) {
-    return this.getCheckpointProvingStateByBlockNumber(blockNumber)?.getBlockProvingStateByBlockNumber(blockNumber);
-  }
-
-  // Returns true if this proving state is still valid, false otherwise
-  public verifyState() {
-    return (
-      this.provingStateLifecycle === PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED ||
-      this.provingStateLifecycle === PROVING_STATE_LIFECYCLE.PROVING_STATE_FULL
-    );
-  }
-
-  // Returns true if we are still able to accept checkpoints, false otherwise.
-  public isAcceptingCheckpoints() {
-    return this.checkpoints.filter(c => !!c).length < this.totalNumCheckpoints;
-  }
-
-  public setCheckpointRootRollupProof(
-    checkpointIndex: number,
-    provingOutput: PublicInputsAndRecursiveProof<
-      CheckpointRollupPublicInputs,
-      typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
-    >,
-  ): TreeNodeLocation {
-    return this.checkpointProofs.setLeaf(checkpointIndex, { provingOutput });
-  }
-
-  public tryStartProvingCheckpointMerge(location: TreeNodeLocation) {
-    if (this.checkpointProofs.getNode(location)?.isProving) {
-      return false;
-    } else {
-      this.checkpointProofs.setNode(location, { isProving: true });
-      return true;
-    }
-  }
-
-  public setCheckpointMergeRollupProof(
-    location: TreeNodeLocation,
-    provingOutput: PublicInputsAndRecursiveProof<
-      CheckpointRollupPublicInputs,
-      typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
-    >,
-  ) {
-    this.checkpointProofs.setNode(location, { provingOutput });
-  }
-
-  public tryStartProvingRootRollup() {
-    if (this.rootRollupProof?.isProving) {
-      return false;
-    } else {
-      this.rootRollupProof = { isProving: true };
-      return true;
-    }
-  }
-
-  public setRootRollupProof(provingOutput: PublicInputsAndRecursiveProof<RootRollupPublicInputs>) {
-    this.rootRollupProof = { provingOutput };
-  }
-
-  public tryStartProvingPaddingCheckpoint() {
-    if (this.checkpointPaddingProof?.isProving) {
-      return false;
-    } else {
-      this.checkpointPaddingProof = { isProving: true };
-      return true;
-    }
-  }
-
-  public setCheckpointPaddingProof(
-    provingOutput: PublicInputsAndRecursiveProof<
-      CheckpointRollupPublicInputs,
-      typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
-    >,
-  ) {
-    this.checkpointPaddingProof = { provingOutput };
-  }
-
-  public async setBlobAccumulators() {
-    let previousAccumulator = this.startBlobAccumulator;
-    // Accumulate blobs as far as we can for this epoch.
-    for (let i = 0; i < this.totalNumCheckpoints; i++) {
-      const checkpoint = this.checkpoints[i];
-      if (!checkpoint) {
-        break;
-      }
-
-      const endAccumulator =
-        checkpoint.getEndBlobAccumulator() || (await checkpoint.accumulateBlobs(previousAccumulator));
-      if (!endAccumulator) {
-        break;
-      }
-
-      previousAccumulator = endAccumulator;
-
-      // If this is the last checkpoint, set the end blob accumulator.
-      if (i === this.totalNumCheckpoints - 1) {
-        this.endBlobAccumulator = endAccumulator;
-      }
-    }
-  }
-
-  public async finalizeBatchedBlob() {
-    if (!this.endBlobAccumulator) {
-      throw new Error('End blob accumulator not ready.');
-    }
-    this.finalBatchedBlob = await this.endBlobAccumulator.finalize(true /* verifyProof */);
-  }
-
-  public getParentLocation(location: TreeNodeLocation) {
-    return this.checkpointProofs.getParentLocation(location);
-  }
-
-  public getCheckpointMergeRollupInputs(mergeLocation: TreeNodeLocation) {
-    const [left, right] = this.checkpointProofs.getChildren(mergeLocation).map(c => c?.provingOutput);
-    if (!left || !right) {
-      throw new Error('At least one child is not ready for the checkpoint merge rollup.');
-    }
-
-    return new CheckpointMergeRollupPrivateInputs([toProofData(left), toProofData(right)]);
-  }
-
-  public getRootRollupInputs() {
-    const [left, right] = this.#getChildProofsForRoot();
-    if (!left || !right) {
-      throw new Error('At least one child is not ready for the root rollup.');
-    }
-
-    return RootRollupPrivateInputs.from({
-      previousRollups: [toProofData(left), toProofData(right)],
-    });
-  }
-
-  public getPaddingCheckpointInputs() {
-    return new CheckpointPaddingRollupPrivateInputs();
-  }
-
-  public getEpochProofResult(): { proof: Proof; publicInputs: RootRollupPublicInputs; batchedBlobInputs: BatchedBlob } {
-    const provingOutput = this.rootRollupProof?.provingOutput;
-
-    if (!provingOutput || !this.finalBatchedBlob) {
-      throw new Error('Unable to get epoch proof result. Root rollup is not ready.');
-    }
-
-    return {
-      proof: provingOutput.proof.binaryProof,
-      publicInputs: provingOutput.inputs,
-      batchedBlobInputs: this.finalBatchedBlob,
-    };
-  }
-
-  public isReadyForCheckpointMerge(location: TreeNodeLocation) {
-    return !!this.checkpointProofs.getSibling(location)?.provingOutput;
-  }
-
-  // Returns true if we have sufficient inputs to execute the block root rollup
-  public isReadyForRootRollup() {
-    const childProofs = this.#getChildProofsForRoot();
-    return childProofs.every(p => !!p);
-  }
-
-  // Attempts to reject the proving state promise with a reason of 'cancelled'
-  public cancel() {
-    this.reject('Proving cancelled');
-  }
-
-  // Attempts to reject the proving state promise with the given reason
-  // Does nothing if not in a valid state
-  public reject(reason: string) {
-    if (!this.verifyState()) {
-      return;
-    }
-    this.provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_REJECTED;
-    this.rejectionCallback(reason);
-  }
-
-  // Attempts to resolve the proving state promise with the given result
-  // Does nothing if not in a valid state
-  public resolve(result: ProvingResult) {
-    if (!this.verifyState()) {
-      return;
-    }
-    this.provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_RESOLVED;
-    this.completionCallback(result);
-  }
-
-  #getChildProofsForRoot() {
-    const rootLocation = { level: 0, index: 0 };
-    // If there's only 1 block, its block root proof will be stored at the root.
-    return this.totalNumCheckpoints === 1
-      ? [this.checkpointProofs.getNode(rootLocation)?.provingOutput, this.checkpointPaddingProof?.provingOutput]
-      : this.checkpointProofs.getChildren(rootLocation).map(c => c?.provingOutput);
-  }
-}