@aztec/prover-node 0.56.0 → 0.58.0

package/src/monitors/epoch-monitor.ts

@@ -0,0 +1,48 @@
+import { type L2BlockSource } from '@aztec/circuit-types';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+
+export interface EpochMonitorHandler {
+  handleInitialEpochSync(epochNumber: bigint): Promise<void>;
+  handleEpochCompleted(epochNumber: bigint): Promise<void>;
+}
+
+export class EpochMonitor {
+  private runningPromise: RunningPromise;
+  private log = createDebugLogger('aztec:prover-node:epoch-monitor');
+
+  private handler: EpochMonitorHandler | undefined;
+
+  private latestEpochNumber: bigint | undefined;
+
+  constructor(private readonly l2BlockSource: L2BlockSource, private options: { pollingIntervalMs: number }) {
+    this.runningPromise = new RunningPromise(this.work.bind(this), this.options.pollingIntervalMs);
+  }
+
+  public start(handler: EpochMonitorHandler) {
+    this.handler = handler;
+    this.runningPromise.start();
+    this.log.info('Started EpochMonitor', this.options);
+  }
+
+  public async stop() {
+    await this.runningPromise.stop();
+    this.log.info('Stopped EpochMonitor');
+  }
+
+  public async work() {
+    if (!this.latestEpochNumber) {
+      const epochNumber = await this.l2BlockSource.getL2EpochNumber();
+      if (epochNumber > 0n) {
+        await this.handler?.handleInitialEpochSync(epochNumber - 1n);
+      }
+      this.latestEpochNumber = epochNumber;
+      return;
+    }
+
+    if (await this.l2BlockSource.isEpochComplete(this.latestEpochNumber)) {
+      await this.handler?.handleEpochCompleted(this.latestEpochNumber);
+      this.latestEpochNumber += 1n;
+    }
+  }
+}

package/src/monitors/index.ts

@@ -0,0 +1,2 @@
+export * from './claims-monitor.js';
+export * from './epoch-monitor.js';

package/src/prover-coordination/config.ts

@@ -0,0 +1,17 @@
+import { type ConfigMappingsType, getConfigFromMappings } from '@aztec/foundation/config';
+
+export type ProverCoordinationConfig = {
+  proverCoordinationNodeUrl: string | undefined;
+};
+
+export const proverCoordinationConfigMappings: ConfigMappingsType<ProverCoordinationConfig> = {
+  proverCoordinationNodeUrl: {
+    env: 'PROVER_COORDINATION_NODE_URL',
+    description: 'The URL of the tx provider node',
+    parseEnv: (val: string) => val,
+  },
+};
+
+export function getTxProviderConfigFromEnv(): ProverCoordinationConfig {
+  return getConfigFromMappings<ProverCoordinationConfig>(proverCoordinationConfigMappings);
+}

package/src/prover-coordination/factory.ts

@@ -0,0 +1,11 @@
+import { type ProverCoordination, createAztecNodeClient } from '@aztec/circuit-types';
+
+import { type ProverCoordinationConfig } from './config.js';
+
+export function createProverCoordination(config: ProverCoordinationConfig): ProverCoordination {
+  if (config.proverCoordinationNodeUrl) {
+    return createAztecNodeClient(config.proverCoordinationNodeUrl);
+  } else {
+    throw new Error(`Aztec Node URL for Tx Provider is not set.`);
+  }
+}

package/src/{tx-provider → prover-coordination}/index.ts

@@ -1,3 +1,2 @@
-export * from './aztec-node-tx-provider.js';
-export * from './factory.js';
 export * from './config.js';
+export * from './factory.js';

package/src/prover-node.ts

@@ -1,64 +1,160 @@
 import {
+  type EpochProofClaim,
+  type EpochProofQuote,
+  EpochProofQuotePayload,
+  type EpochProverManager,
   type L1ToL2MessageSource,
+  type L2Block,
   type L2BlockSource,
-  type MerkleTreeOperations,
-  type ProverClient,
-  type TxProvider,
+  type MerkleTreeWriteOperations,
+  type ProverCoordination,
   type WorldStateSynchronizer,
 } from '@aztec/circuit-types';
+import { type ContractDataSource } from '@aztec/circuits.js';
+import { compact } from '@aztec/foundation/collection';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { RunningPromise } from '@aztec/foundation/running-promise';
 import { type L1Publisher } from '@aztec/sequencer-client';
 import { PublicProcessorFactory, type SimulationProvider } from '@aztec/simulator';
 import { type TelemetryClient } from '@aztec/telemetry-client';
-import { type ContractDataSource } from '@aztec/types/contracts';
 
-import { BlockProvingJob, type BlockProvingJobState } from './job/block-proving-job.js';
+import { type BondManager } from './bond/bond-manager.js';
+import { EpochProvingJob, type EpochProvingJobState } from './job/epoch-proving-job.js';
 import { ProverNodeMetrics } from './metrics.js';
+import { type ClaimsMonitor, type ClaimsMonitorHandler } from './monitors/claims-monitor.js';
+import { type EpochMonitor, type EpochMonitorHandler } from './monitors/epoch-monitor.js';
+import { type QuoteProvider } from './quote-provider/index.js';
+import { type QuoteSigner } from './quote-signer.js';
+
+export type ProverNodeOptions = {
+  pollingIntervalMs: number;
+  maxPendingJobs: number;
+};
 
 /**
  * An Aztec Prover Node is a standalone process that monitors the unfinalised chain on L1 for unproven blocks,
- * fetches their txs from a tx source in the p2p network or an external node, re-executes their public functions,
- * creates a rollup proof, and submits it to L1.
+ * submits bids for proving them, and monitors if they are accepted. If so, the prover node fetches the txs
+ * from a tx source in the p2p network or an external node, re-executes their public functions, creates a rollup
+ * proof for the epoch, and submits it to L1.
  */
-export class ProverNode {
+export class ProverNode implements ClaimsMonitorHandler, EpochMonitorHandler {
   private log = createDebugLogger('aztec:prover-node');
-  private runningPromise: RunningPromise | undefined;
-  private latestBlockWeAreProving: number | undefined;
-  private jobs: Map<string, BlockProvingJob> = new Map();
-  private options: { pollingIntervalMs: number; disableAutomaticProving: boolean; maxPendingJobs: number };
+
+  private latestEpochWeAreProving: bigint | undefined;
+  private jobs: Map<string, EpochProvingJob> = new Map();
+  private options: ProverNodeOptions;
   private metrics: ProverNodeMetrics;
 
   constructor(
-    private prover: ProverClient,
-    private publisher: L1Publisher,
-    private l2BlockSource: L2BlockSource,
-    private l1ToL2MessageSource: L1ToL2MessageSource,
-    private contractDataSource: ContractDataSource,
-    private worldState: WorldStateSynchronizer,
-    private txProvider: TxProvider,
-    private simulator: SimulationProvider,
-    private telemetryClient: TelemetryClient,
-    options: { pollingIntervalMs?: number; disableAutomaticProving?: boolean; maxPendingJobs?: number } = {},
+    private readonly prover: EpochProverManager,
+    private readonly publisher: L1Publisher,
+    private readonly l2BlockSource: L2BlockSource,
+    private readonly l1ToL2MessageSource: L1ToL2MessageSource,
+    private readonly contractDataSource: ContractDataSource,
+    private readonly worldState: WorldStateSynchronizer,
+    private readonly coordination: ProverCoordination,
+    private readonly simulator: SimulationProvider,
+    private readonly quoteProvider: QuoteProvider,
+    private readonly quoteSigner: QuoteSigner,
+    private readonly claimsMonitor: ClaimsMonitor,
+    private readonly epochsMonitor: EpochMonitor,
+    private readonly bondManager: BondManager,
+    private readonly telemetryClient: TelemetryClient,
+    options: Partial<ProverNodeOptions> = {},
   ) {
     this.options = {
       pollingIntervalMs: 1_000,
-      disableAutomaticProving: false,
       maxPendingJobs: 100,
-      ...options,
+      ...compact(options),
     };
 
     this.metrics = new ProverNodeMetrics(telemetryClient, 'ProverNode');
   }
 
+  async handleClaim(proofClaim: EpochProofClaim): Promise<void> {
+    if (proofClaim.epochToProve === this.latestEpochWeAreProving) {
+      this.log.verbose(`Already proving claim for epoch ${proofClaim.epochToProve}`);
+      return;
+    }
+
+    try {
+      await this.startProof(proofClaim.epochToProve);
+      this.latestEpochWeAreProving = proofClaim.epochToProve;
+    } catch (err) {
+      this.log.error(`Error handling claim for epoch ${proofClaim.epochToProve}`, err);
+    }
+
+    try {
+      // Staked amounts are lowered after a claim, so this is a good time for doing a top-up if needed
+      await this.bondManager.ensureBond();
+    } catch (err) {
+      this.log.error(`Error ensuring prover bond after handling claim for epoch ${proofClaim.epochToProve}`, err);
+    }
+  }
+
+  /**
+   * Handles the epoch number to prove when the prover node starts by checking if there
+   * is an existing claim for it. If not, it creates and sends a quote for it.
+   * @param epochNumber - The epoch immediately before the current one when the prover node starts.
+   */
+  async handleInitialEpochSync(epochNumber: bigint): Promise<void> {
+    try {
+      const claim = await this.publisher.getProofClaim();
+      if (!claim || claim.epochToProve < epochNumber) {
+        await this.handleEpochCompleted(epochNumber);
+      } else if (claim && claim.bondProvider.equals(this.publisher.getSenderAddress())) {
+        const lastEpochProven = await this.l2BlockSource.getProvenL2EpochNumber();
+        if (lastEpochProven === undefined || lastEpochProven < claim.epochToProve) {
+          await this.handleClaim(claim);
+        }
+      }
+    } catch (err) {
+      this.log.error(`Error handling initial epoch sync`, err);
+    }
+  }
+
+  /**
+   * Handles an epoch being completed by sending a quote for proving it.
+   * @param epochNumber - The epoch number that was just completed.
+   */
+  async handleEpochCompleted(epochNumber: bigint): Promise<void> {
+    try {
+      // Construct a quote for the epoch
+      const blocks = await this.l2BlockSource.getBlocksForEpoch(epochNumber);
+      const partialQuote = await this.quoteProvider.getQuote(Number(epochNumber), blocks);
+      if (!partialQuote) {
+        this.log.verbose(`No quote produced for epoch ${epochNumber}`);
+        return;
+      }
+
+      // Ensure we have deposited enough funds for sending this quote
+      await this.bondManager.ensureBond(partialQuote.bondAmount);
+
+      // Assemble and sign full quote
+      const quote = EpochProofQuotePayload.from({
+        ...partialQuote,
+        epochToProve: BigInt(epochNumber),
+        prover: this.publisher.getSenderAddress(),
+        validUntilSlot: partialQuote.validUntilSlot ?? BigInt(Number.MAX_SAFE_INTEGER), // Should we constrain this?
+      });
+      const signed = await this.quoteSigner.sign(quote);
+
+      // Send it to the coordinator
+      await this.sendEpochProofQuote(signed);
+    } catch (err) {
+      this.log.error(`Error handling epoch completed`, err);
+    }
+  }
+
   /**
-   * Starts the prover node so it periodically checks for unproven blocks in the unfinalised chain from L1 and proves them.
-   * This may change once we implement a prover coordination mechanism.
+   * Starts the prover node so it periodically checks for unproven epochs in the unfinalised chain from L1 and sends
+   * quotes for them, as well as monitors the claims for the epochs it has sent quotes for and starts proving jobs.
+   * This method returns once the prover node has deposited an initial bond into the escrow contract.
    */
-  start() {
-    this.runningPromise = new RunningPromise(this.work.bind(this), this.options.pollingIntervalMs);
-    this.runningPromise.start();
-    this.log.info('Started ProverNode');
+  async start() {
+    await this.bondManager.ensureBond();
+    this.epochsMonitor.start(this);
+    this.claimsMonitor.start(this);
+    this.log.info('Started ProverNode', this.options);
   }
 
   /**
@@ -66,79 +162,38 @@ export class ProverNode {
    */
   async stop() {
     this.log.info('Stopping ProverNode');
-    await this.runningPromise?.stop();
+    await this.epochsMonitor.stop();
+    await this.claimsMonitor.stop();
     await this.prover.stop();
     await this.l2BlockSource.stop();
     this.publisher.interrupt();
-    this.jobs.forEach(job => job.stop());
+    await Promise.all(Array.from(this.jobs.values()).map(job => job.stop()));
     await this.worldState.stop();
     this.log.info('Stopped ProverNode');
   }
 
   /**
-   * Single iteration of recurring work. This method is called periodically by the running promise.
-   * Checks whether there are new blocks to prove, proves them, and submits them.
+   * Sends an epoch proof quote to the coordinator.
    */
-  protected async work() {
-    try {
-      if (this.options.disableAutomaticProving) {
-        return;
-      }
-
-      if (!this.checkMaximumPendingJobs()) {
-        this.log.debug(`Maximum pending proving jobs reached. Skipping work.`, {
-          maxPendingJobs: this.options.maxPendingJobs,
-          pendingJobs: this.jobs.size,
-        });
-        return;
-      }
-
-      const [latestBlockNumber, latestProvenBlockNumber] = await Promise.all([
-        this.l2BlockSource.getBlockNumber(),
-        this.l2BlockSource.getProvenBlockNumber(),
-      ]);
-
-      // Consider both the latest block we are proving and the last block proven on the chain
-      const latestBlockBeingProven = this.latestBlockWeAreProving ?? 0;
-      const latestProven = Math.max(latestBlockBeingProven, latestProvenBlockNumber);
-      if (latestProven >= latestBlockNumber) {
-        this.log.debug(`No new blocks to prove`, {
-          latestBlockNumber,
-          latestProvenBlockNumber,
-          latestBlockBeingProven,
-        });
-        return;
-      }
-
-      const fromBlock = latestProven + 1;
-      const toBlock = fromBlock; // We only prove one block at a time for now
-
-      try {
-        await this.startProof(fromBlock, toBlock);
-      } finally {
-        // If we fail to create a proving job for the given block, skip it instead of getting stuck on it.
-        this.log.verbose(`Setting ${toBlock} as latest block we are proving`);
-        this.latestBlockWeAreProving = toBlock;
-      }
-    } catch (err) {
-      this.log.error(`Error in prover node work`, err);
-    }
+  public sendEpochProofQuote(quote: EpochProofQuote): Promise<void> {
+    this.log.info(`Sending quote for epoch`, quote.toViemArgs().quote);
+    return this.coordination.addEpochProofQuote(quote);
   }
 
   /**
    * Creates a proof for a block range. Returns once the proof has been submitted to L1.
    */
-  public async prove(fromBlock: number, toBlock: number) {
-    const job = await this.createProvingJob(fromBlock);
-    return job.run(fromBlock, toBlock);
+  public async prove(epochNumber: number | bigint) {
+    const job = await this.createProvingJob(BigInt(epochNumber));
+    return job.run();
   }
 
   /**
    * Starts a proving process and returns immediately.
    */
-  public async startProof(fromBlock: number, toBlock: number) {
-    const job = await this.createProvingJob(fromBlock);
-    void job.run(fromBlock, toBlock);
+  public async startProof(epochNumber: number | bigint) {
+    const job = await this.createProvingJob(BigInt(epochNumber));
+    void job.run().catch(err => this.log.error(`Error proving epoch ${epochNumber}`, err));
   }
 
   /**
@@ -151,7 +206,7 @@ export class ProverNode {
   /**
    * Returns an array of jobs being processed.
    */
-  public getJobs(): { uuid: string; status: BlockProvingJobState }[] {
+  public getJobs(): { uuid: string; status: EpochProvingJobState }[] {
     return Array.from(this.jobs.entries()).map(([uuid, job]) => ({ uuid, status: job.getState() }));
   }
 
@@ -160,52 +215,67 @@ export class ProverNode {
     return maxPendingJobs === 0 || this.jobs.size < maxPendingJobs;
   }
 
-  private async createProvingJob(fromBlock: number) {
+  private async createProvingJob(epochNumber: bigint) {
     if (!this.checkMaximumPendingJobs()) {
       throw new Error(`Maximum pending proving jobs ${this.options.maxPendingJobs} reached. Cannot create new job.`);
     }
 
-    if ((await this.worldState.status()).syncedToL2Block >= fromBlock) {
-      throw new Error(`Cannot create proving job for block ${fromBlock} as it is behind the current world state`);
+    // Gather blocks for this epoch
+    const blocks = await this.l2BlockSource.getBlocksForEpoch(epochNumber);
+    if (blocks.length === 0) {
+      throw new Error(`No blocks found for epoch ${epochNumber}`);
     }
+    const fromBlock = blocks[0].number;
+    const toBlock = blocks.at(-1)!.number;
 
     // Fast forward world state to right before the target block and get a fork
-    this.log.verbose(`Creating proving job for block ${fromBlock}`);
-    const db = await this.worldState.syncImmediateAndFork(fromBlock - 1, true);
+    this.log.verbose(`Creating proving job for epoch ${epochNumber} for block range ${fromBlock} to ${toBlock}`);
+    await this.worldState.syncImmediate(fromBlock - 1);
+    const db = await this.worldState.fork(fromBlock - 1);
 
     // Create a processor using the forked world state
     const publicProcessorFactory = new PublicProcessorFactory(
-      db,
       this.contractDataSource,
       this.simulator,
       this.telemetryClient,
     );
 
     const cleanUp = async () => {
-      await db.delete();
+      await db.close();
       this.jobs.delete(job.getId());
     };
 
-    const job = this.doCreateBlockProvingJob(db, publicProcessorFactory, cleanUp);
+    const job = this.doCreateEpochProvingJob(epochNumber, blocks, db, publicProcessorFactory, cleanUp);
     this.jobs.set(job.getId(), job);
     return job;
   }
 
   /** Extracted for testing purposes. */
-  protected doCreateBlockProvingJob(
-    db: MerkleTreeOperations,
+  protected doCreateEpochProvingJob(
+    epochNumber: bigint,
+    blocks: L2Block[],
+    db: MerkleTreeWriteOperations,
     publicProcessorFactory: PublicProcessorFactory,
     cleanUp: () => Promise<void>,
   ) {
-    return new BlockProvingJob(
-      this.prover.createBlockProver(db),
+    return new EpochProvingJob(
+      db,
+      epochNumber,
+      blocks,
+      this.prover.createEpochProver(db),
       publicProcessorFactory,
       this.publisher,
       this.l2BlockSource,
       this.l1ToL2MessageSource,
-      this.txProvider,
+      this.coordination,
       this.metrics,
       cleanUp,
     );
   }
+
+  /** Extracted for testing purposes. */
+  protected async triggerMonitors() {
+    await this.epochsMonitor.work();
+    await this.claimsMonitor.work();
+  }
 }

package/src/quote-provider/http.ts

@@ -0,0 +1,47 @@
+import { type L2Block } from '@aztec/circuit-types';
+
+import { type QuoteProvider, type QuoteProviderResult } from './index.js';
+import { getTotalFees, getTxCount } from './utils.js';
+
+export class HttpQuoteProvider implements QuoteProvider {
+  constructor(private readonly url: string) {}
+
+  public async getQuote(epochNumber: number, epoch: L2Block[]): Promise<QuoteProviderResult | undefined> {
+    const payload: HttpQuoteRequestPayload = {
+      epochNumber,
+      fromBlock: epoch[0].number,
+      toBlock: epoch.at(-1)!.number,
+      totalFees: getTotalFees(epoch).toString(),
+      txCount: getTxCount(epoch),
+    };
+
+    const response = await fetch(this.url, {
+      method: 'POST',
+      body: JSON.stringify(payload),
+      headers: { 'content-type': 'application/json' },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch quote: ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    if (!data.basisPointFee || !data.bondAmount) {
+      throw new Error(`Missing required fields in response: ${JSON.stringify(data)}`);
+    }
+
+    const basisPointFee = Number(data.basisPointFee);
+    const bondAmount = BigInt(data.bondAmount);
+    const validUntilSlot = data.validUntilSlot ? BigInt(data.validUntilSlot) : undefined;
+
+    return { basisPointFee, bondAmount, validUntilSlot };
+  }
+}
+
+export type HttpQuoteRequestPayload = {
+  epochNumber: number;
+  fromBlock: number;
+  toBlock: number;
+  totalFees: string;
+  txCount: number;
+};

package/src/quote-provider/index.ts

@@ -0,0 +1,8 @@
+import { type EpochProofQuotePayload, type L2Block } from '@aztec/circuit-types';
+
+export type QuoteProviderResult = Pick<EpochProofQuotePayload, 'basisPointFee' | 'bondAmount'> &
+  Partial<Pick<EpochProofQuotePayload, 'validUntilSlot'>>;
+
+export interface QuoteProvider {
+  getQuote(epochNumber: number, epoch: L2Block[]): Promise<QuoteProviderResult | undefined>;
+}

package/src/quote-provider/simple.ts

@@ -0,0 +1,15 @@
+import { type EpochProofQuotePayload, type L2Block } from '@aztec/circuit-types';
+
+import { type QuoteProvider } from './index.js';
+
+export class SimpleQuoteProvider implements QuoteProvider {
+  constructor(public readonly basisPointFee: number, public readonly bondAmount: bigint) {}
+
+  getQuote(
+    _epochNumber: number,
+    _epoch: L2Block[],
+  ): Promise<Pick<EpochProofQuotePayload, 'basisPointFee' | 'bondAmount'>> {
+    const { basisPointFee, bondAmount } = this;
+    return Promise.resolve({ basisPointFee, bondAmount });
+  }
+}

package/src/quote-provider/utils.ts

@@ -0,0 +1,10 @@
+import { type L2Block } from '@aztec/circuit-types';
+import { Fr } from '@aztec/circuits.js';
+
+export function getTotalFees(epoch: L2Block[]) {
+  return epoch.reduce((total, block) => total.add(block.header.totalFees), Fr.ZERO).toBigInt();
+}
+
+export function getTxCount(epoch: L2Block[]) {
+  return epoch.reduce((total, block) => total + block.body.txEffects.length, 0);
+}

package/src/quote-signer.ts

@@ -0,0 +1,24 @@
+import { EpochProofQuote, type EpochProofQuotePayload } from '@aztec/circuit-types';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { Secp256k1Signer } from '@aztec/foundation/crypto';
+import { type RollupAbi } from '@aztec/l1-artifacts';
+
+import { type GetContractReturnType, type PublicClient } from 'viem';
+
+export class QuoteSigner {
+  constructor(
+    private readonly signer: Secp256k1Signer,
+    private readonly quoteToDigest: (payload: EpochProofQuotePayload) => Promise<Buffer32>,
+  ) {}
+
+  static new(privateKey: Buffer32, rollupContract: GetContractReturnType<typeof RollupAbi, PublicClient>): QuoteSigner {
+    const quoteToDigest = (payload: EpochProofQuotePayload) =>
+      rollupContract.read.quoteToDigest([payload.toViemArgs()]).then(Buffer32.fromString);
+    return new QuoteSigner(new Secp256k1Signer(privateKey), quoteToDigest);
+  }
+
+  public async sign(payload: EpochProofQuotePayload) {
+    const digest = await this.quoteToDigest(payload);
+    return EpochProofQuote.new(digest, payload, this.signer);
+  }
+}

package/dest/job/block-proving-job.d.ts

@@ -1,33 +0,0 @@
-import { type BlockProver, type L1ToL2MessageSource, type L2BlockSource, type TxProvider } from '@aztec/circuit-types';
-import { type L1Publisher } from '@aztec/sequencer-client';
-import { type PublicProcessorFactory } from '@aztec/simulator';
-import { type ProverNodeMetrics } from '../metrics.js';
-/**
- * Job that grabs a range of blocks from the unfinalised chain from L1, gets their txs given their hashes,
- * re-executes their public calls, generates a rollup proof, and submits it to L1. This job will update the
- * world state as part of public call execution via the public processor.
- */
-export declare class BlockProvingJob {
-    private prover;
-    private publicProcessorFactory;
-    private publisher;
-    private l2BlockSource;
-    private l1ToL2MessageSource;
-    private txProvider;
-    private metrics;
-    private cleanUp;
-    private state;
-    private log;
-    private uuid;
-    constructor(prover: BlockProver, publicProcessorFactory: PublicProcessorFactory, publisher: L1Publisher, l2BlockSource: L2BlockSource, l1ToL2MessageSource: L1ToL2MessageSource, txProvider: TxProvider, metrics: ProverNodeMetrics, cleanUp?: (job: BlockProvingJob) => Promise<void>);
-    getId(): string;
-    getState(): BlockProvingJobState;
-    run(fromBlock: number, toBlock: number): Promise<void>;
-    stop(): void;
-    private getBlock;
-    private getTxs;
-    private getL1ToL2Messages;
-    private processTxs;
-}
-export type BlockProvingJobState = 'initialized' | 'processing' | 'awaiting-prover' | 'publishing-proof' | 'completed' | 'failed';
-//# sourceMappingURL=block-proving-job.d.ts.map

package/dest/job/block-proving-job.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"block-proving-job.d.ts","sourceRoot":"","sources":["../../src/job/block-proving-job.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,mBAAmB,EAExB,KAAK,aAAa,EAKlB,KAAK,UAAU,EAChB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAwB,KAAK,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAIrF,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEvD;;;;GAIG;AACH,qBAAa,eAAe;IAMxB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,sBAAsB;IAC9B,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,OAAO;IAZjB,OAAO,CAAC,KAAK,CAAuC;IACpD,OAAO,CAAC,GAAG,CAAgD;IAC3D,OAAO,CAAC,IAAI,CAAS;gBAGX,MAAM,EAAE,WAAW,EACnB,sBAAsB,EAAE,sBAAsB,EAC9C,SAAS,EAAE,WAAW,EACtB,aAAa,EAAE,aAAa,EAC5B,mBAAmB,EAAE,mBAAmB,EACxC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,iBAAiB,EAC1B,OAAO,GAAE,CAAC,GAAG,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAA2B;IAK7E,KAAK,IAAI,MAAM;IAIf,QAAQ,IAAI,oBAAoB;IAI1B,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IA8E5C,IAAI;YAIG,QAAQ;YAQR,MAAM;IAWpB,OAAO,CAAC,iBAAiB;YAIX,UAAU;CAoBzB;AAED,MAAM,MAAM,oBAAoB,GAC5B,aAAa,GACb,YAAY,GACZ,iBAAiB,GACjB,kBAAkB,GAClB,WAAW,GACX,QAAQ,CAAC"}