@aztec/prover-node 0.56.0 → 0.57.0

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 ProverCoordination,
   type WorldStateSynchronizer,
 } from '@aztec/circuit-types';
+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,7 +162,8 @@ 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();
@@ -76,69 +173,27 @@ export class 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,17 +215,25 @@ 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.`);
     }
 
+    // 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;
+
     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`);
     }
 
     // Fast forward world state to right before the target block and get a fork
-    this.log.verbose(`Creating proving job for block ${fromBlock}`);
+    this.log.verbose(`Creating proving job for epoch ${epochNumber} for block range ${fromBlock} to ${toBlock}`);
     const db = await this.worldState.syncImmediateAndFork(fromBlock - 1, true);
 
     // Create a processor using the forked world state
@@ -186,26 +249,36 @@ export class ProverNode {
       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(
+  protected doCreateEpochProvingJob(
+    epochNumber: bigint,
+    blocks: L2Block[],
     db: MerkleTreeOperations,
     publicProcessorFactory: PublicProcessorFactory,
     cleanUp: () => Promise<void>,
   ) {
-    return new BlockProvingJob(
-      this.prover.createBlockProver(db),
+    return new EpochProvingJob(
+      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.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"}

package/dest/job/block-proving-job.js

@@ -1,120 +0,0 @@
-import { EmptyTxValidator, PROVING_STATUS, } from '@aztec/circuit-types';
-import { createDebugLogger } from '@aztec/foundation/log';
-import { Timer } from '@aztec/foundation/timer';
-import * as crypto from 'node:crypto';
-/**
- * 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 class BlockProvingJob {
-    constructor(prover, publicProcessorFactory, publisher, l2BlockSource, l1ToL2MessageSource, txProvider, metrics, cleanUp = () => Promise.resolve()) {
-        this.prover = prover;
-        this.publicProcessorFactory = publicProcessorFactory;
-        this.publisher = publisher;
-        this.l2BlockSource = l2BlockSource;
-        this.l1ToL2MessageSource = l1ToL2MessageSource;
-        this.txProvider = txProvider;
-        this.metrics = metrics;
-        this.cleanUp = cleanUp;
-        this.state = 'initialized';
-        this.log = createDebugLogger('aztec:block-proving-job');
-        this.uuid = crypto.randomUUID();
-    }
-    getId() {
-        return this.uuid;
-    }
-    getState() {
-        return this.state;
-    }
-    async run(fromBlock, toBlock) {
-        if (fromBlock !== toBlock) {
-            throw new Error(`Block ranges are not yet supported`);
-        }
-        this.log.info(`Starting block proving job`, { fromBlock, toBlock, uuid: this.uuid });
-        this.state = 'processing';
-        const timer = new Timer();
-        try {
-            let historicalHeader = (await this.l2BlockSource.getBlock(fromBlock - 1))?.header;
-            for (let blockNumber = fromBlock; blockNumber <= toBlock; blockNumber++) {
-                const block = await this.getBlock(blockNumber);
-                const globalVariables = block.header.globalVariables;
-                const txHashes = block.body.txEffects.map(tx => tx.txHash);
-                const txCount = block.body.numberOfTxsIncludingPadded;
-                const l1ToL2Messages = await this.getL1ToL2Messages(block);
-                this.log.verbose(`Starting block processing`, {
-                    number: block.number,
-                    blockHash: block.hash().toString(),
-                    lastArchive: block.header.lastArchive.root,
-                    noteHashTreeRoot: block.header.state.partial.noteHashTree.root,
-                    nullifierTreeRoot: block.header.state.partial.nullifierTree.root,
-                    publicDataTreeRoot: block.header.state.partial.publicDataTree.root,
-                    historicalHeader: historicalHeader?.hash(),
-                    uuid: this.uuid,
-                    ...globalVariables,
-                });
-                // When we move to proving epochs, this should change into a startNewEpoch and be lifted outside the loop.
-                const provingTicket = await this.prover.startNewBlock(txCount, globalVariables, l1ToL2Messages);
-                const publicProcessor = this.publicProcessorFactory.create(historicalHeader, globalVariables);
-                const txs = await this.getTxs(txHashes);
-                await this.processTxs(publicProcessor, txs, txCount);
-                this.log.verbose(`Processed all txs for block`, {
-                    blockNumber: block.number,
-                    blockHash: block.hash().toString(),
-                    uuid: this.uuid,
-                });
-                await this.prover.setBlockCompleted();
-                // This should be moved outside the loop to match the creation of the proving ticket when we move to epochs.
-                this.state = 'awaiting-prover';
-                const result = await provingTicket.provingPromise;
-                if (result.status === PROVING_STATUS.FAILURE) {
-                    throw new Error(`Block proving failed: ${result.reason}`);
-                }
-                historicalHeader = block.header;
-            }
-            const { block, aggregationObject, proof } = await this.prover.finaliseBlock();
-            this.log.info(`Finalised proof for block range`, { fromBlock, toBlock, uuid: this.uuid });
-            this.state = 'publishing-proof';
-            await this.publisher.submitProof(block.header, block.archive.root, this.prover.getProverId(), aggregationObject, proof);
-            this.log.info(`Submitted proof for block range`, { fromBlock, toBlock, uuid: this.uuid });
-            this.state = 'completed';
-            this.metrics.recordProvingJob(timer);
-        }
-        catch (err) {
-            this.log.error(`Error running block prover job`, err, { uuid: this.uuid });
-            this.state = 'failed';
-        }
-        finally {
-            await this.cleanUp(this);
-        }
-    }
-    stop() {
-        this.prover.cancel();
-    }
-    async getBlock(blockNumber) {
-        const block = await this.l2BlockSource.getBlock(blockNumber);
-        if (!block) {
-            throw new Error(`Block ${blockNumber} not found in L2 block source`);
-        }
-        return block;
-    }
-    async getTxs(txHashes) {
-        const txs = await Promise.all(txHashes.map(txHash => this.txProvider.getTxByHash(txHash).then(tx => [txHash, tx])));
-        const notFound = txs.filter(([_, tx]) => !tx);
-        if (notFound.length) {
-            throw new Error(`Txs not found: ${notFound.map(([txHash]) => txHash.toString()).join(', ')}`);
-        }
-        return txs.map(([_, tx]) => tx);
-    }
-    getL1ToL2Messages(block) {
-        return this.l1ToL2MessageSource.getL1ToL2Messages(BigInt(block.number));
-    }
-    async processTxs(publicProcessor, txs, totalNumberOfTxs) {
-        const [processedTxs, failedTxs] = await publicProcessor.process(txs, totalNumberOfTxs, this.prover, new EmptyTxValidator());
-        if (failedTxs.length) {
-            throw new Error(`Failed to process txs: ${failedTxs.map(({ tx, error }) => `${tx.getTxHash()} (${error})`).join(', ')}`);
-        }
-        return processedTxs;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvY2stcHJvdmluZy1qb2IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvam9iL2Jsb2NrLXByb3Zpbmctam9iLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFFTCxnQkFBZ0IsRUFJaEIsY0FBYyxHQUtmLE1BQU0sc0JBQXNCLENBQUM7QUFDOUIsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDMUQsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBSWhELE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBSXRDOzs7O0dBSUc7QUFDSCxNQUFNLE9BQU8sZUFBZTtJQUsxQixZQUNVLE1BQW1CLEVBQ25CLHNCQUE4QyxFQUM5QyxTQUFzQixFQUN0QixhQUE0QixFQUM1QixtQkFBd0MsRUFDeEMsVUFBc0IsRUFDdEIsT0FBMEIsRUFDMUIsVUFBbUQsR0FBRyxFQUFFLENBQUMsT0FBTyxDQUFDLE9BQU8sRUFBRTtRQVAxRSxXQUFNLEdBQU4sTUFBTSxDQUFhO1FBQ25CLDJCQUFzQixHQUF0QixzQkFBc0IsQ0FBd0I7UUFDOUMsY0FBUyxHQUFULFNBQVMsQ0FBYTtRQUN0QixrQkFBYSxHQUFiLGFBQWEsQ0FBZTtRQUM1Qix3QkFBbUIsR0FBbkIsbUJBQW1CLENBQXFCO1FBQ3hDLGVBQVUsR0FBVixVQUFVLENBQVk7UUFDdEIsWUFBTyxHQUFQLE9BQU8sQ0FBbUI7UUFDMUIsWUFBTyxHQUFQLE9BQU8sQ0FBbUU7UUFaNUUsVUFBSyxHQUF5QixhQUFhLENBQUM7UUFDNUMsUUFBRyxHQUFHLGlCQUFpQixDQUFDLHlCQUF5QixDQUFDLENBQUM7UUFhekQsSUFBSSxDQUFDLElBQUksR0FBRyxNQUFNLENBQUMsVUFBVSxFQUFFLENBQUM7SUFDbEMsQ0FBQztJQUVNLEtBQUs7UUFDVixPQUFPLElBQUksQ0FBQyxJQUFJLENBQUM7SUFDbkIsQ0FBQztJQUVNLFFBQVE7UUFDYixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUM7SUFDcEIsQ0FBQztJQUVNLEtBQUssQ0FBQyxHQUFHLENBQUMsU0FBaUIsRUFBRSxPQUFlO1FBQ2pELElBQUksU0FBUyxLQUFLLE9BQU8sRUFBRSxDQUFDO1lBQzFCLE1BQU0sSUFBSSxLQUFLLENBQUMsb0NBQW9DLENBQUMsQ0FBQztRQUN4RCxDQUFDO1FBRUQsSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsNEJBQTRCLEVBQUUsRUFBRSxTQUFTLEVBQUUsT0FBTyxFQUFFLElBQUksRUFBRSxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQztRQUNyRixJQUFJLENBQUMsS0FBSyxHQUFHLFlBQVksQ0FBQztRQUMxQixNQUFNLEtBQUssR0FBRyxJQUFJLEtBQUssRUFBRSxDQUFDO1FBQzFCLElBQUksQ0FBQztZQUNILElBQUksZ0JBQWdCLEdBQUcsQ0FBQyxNQUFNLElBQUksQ0FBQyxhQUFhLENBQUMsUUFBUSxDQUFDLFNBQVMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLE1BQU0sQ0FBQztZQUNsRixLQUFLLElBQUksV0FBVyxHQUFHLFNBQVMsRUFBRSxXQUFXLElBQUksT0FBTyxFQUFFLFdBQVcsRUFBRSxFQUFFLENBQUM7Z0JBQ3hFLE1BQU0sS0FBSyxHQUFHLE1BQU0sSUFBSSxDQUFDLFFBQVEsQ0FBQyxXQUFXLENBQUMsQ0FBQztnQkFDL0MsTUFBTSxlQUFlLEdBQUcsS0FBSyxDQUFDLE1BQU0sQ0FBQyxlQUFlLENBQUM7Z0JBQ3JELE1BQU0sUUFBUSxHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsQ0FBQztnQkFDM0QsTUFBTSxPQUFPLEdBQUcsS0FBSyxDQUFDLElBQUksQ0FBQywwQkFBMEIsQ0FBQztnQkFDdEQsTUFBTSxjQUFjLEdBQUcsTUFBTSxJQUFJLENBQUMsaUJBQWlCLENBQUMsS0FBSyxDQUFDLENBQUM7Z0JBRTNELElBQUksQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLDJCQUEyQixFQUFFO29CQUM1QyxNQUFNLEVBQUUsS0FBSyxDQUFDLE1BQU07b0JBQ3BCLFNBQVMsRUFBRSxLQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsUUFBUSxFQUFFO29CQUNsQyxXQUFXLEVBQUUsS0FBSyxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsSUFBSTtvQkFDMUMsZ0JBQWdCLEVBQUUsS0FBSyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLFlBQVksQ0FBQyxJQUFJO29CQUM5RCxpQkFBaUIsRUFBRSxLQUFLLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsYUFBYSxDQUFDLElBQUk7b0JBQ2hFLGtCQUFrQixFQUFFLEtBQUssQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxjQUFjLENBQUMsSUFBSTtvQkFDbEUsZ0JBQWdCLEVBQUUsZ0JBQWdCLEVBQUUsSUFBSSxFQUFFO29CQUMxQyxJQUFJLEVBQUUsSUFBSSxDQUFDLElBQUk7b0JBQ2YsR0FBRyxlQUFlO2lCQUNuQixDQUFDLENBQUM7Z0JBRUgsMEdBQTBHO2dCQUMxRyxNQUFNLGFBQWEsR0FBRyxNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsYUFBYSxDQUFDLE9BQU8sRUFBRSxlQUFlLEVBQUUsY0FBYyxDQUFDLENBQUM7Z0JBRWhHLE1BQU0sZUFBZSxHQUFHLElBQUksQ0FBQyxzQkFBc0IsQ0FBQyxNQUFNLENBQUMsZ0JBQWdCLEVBQUUsZUFBZSxDQUFDLENBQUM7Z0JBRTlGLE1BQU0sR0FBRyxHQUFHLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQztnQkFDeEMsTUFBTSxJQUFJLENBQUMsVUFBVSxDQUFDLGVBQWUsRUFBRSxHQUFHLEVBQUUsT0FBTyxDQUFDLENBQUM7Z0JBRXJELElBQUksQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLDZCQUE2QixFQUFFO29CQUM5QyxXQUFXLEVBQUUsS0FBSyxDQUFDLE1BQU07b0JBQ3pCLFNBQVMsRUFBRSxLQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsUUFBUSxFQUFFO29CQUNsQyxJQUFJLEVBQUUsSUFBSSxDQUFDLElBQUk7aUJBQ2hCLENBQUMsQ0FBQztnQkFFSCxNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztnQkFFdEMsNEdBQTRHO2dCQUM1RyxJQUFJLENBQUMsS0FBSyxHQUFHLGlCQUFpQixDQUFDO2dCQUMvQixNQUFNLE1BQU0sR0FBRyxNQUFNLGFBQWEsQ0FBQyxjQUFjLENBQUM7Z0JBQ2xELElBQUksTUFBTSxDQUFDLE1BQU0sS0FBSyxjQUFjLENBQUMsT0FBTyxFQUFFLENBQUM7b0JBQzdDLE1BQU0sSUFBSSxLQUFLLENBQUMseUJBQXlCLE1BQU0sQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDO2dCQUM1RCxDQUFDO2dCQUVELGdCQUFnQixHQUFHLEtBQUssQ0FBQyxNQUFNLENBQUM7WUFDbEMsQ0FBQztZQUVELE1BQU0sRUFBRSxLQUFLLEVBQUUsaUJBQWlCLEVBQUUsS0FBSyxFQUFFLEdBQUcsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLGFBQWEsRUFBRSxDQUFDO1lBQzlFLElBQUksQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLGlDQUFpQyxFQUFFLEVBQUUsU0FBUyxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDLENBQUM7WUFFMUYsSUFBSSxDQUFDLEtBQUssR0FBRyxrQkFBa0IsQ0FBQztZQUNoQyxNQUFNLElBQUksQ0FBQyxTQUFTLENBQUMsV0FBVyxDQUM5QixLQUFLLENBQUMsTUFBTSxFQUNaLEtBQUssQ0FBQyxPQUFPLENBQUMsSUFBSSxFQUNsQixJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsRUFBRSxFQUN6QixpQkFBaUIsRUFDakIsS0FBSyxDQUNOLENBQUM7WUFDRixJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxpQ0FBaUMsRUFBRSxFQUFFLFNBQVMsRUFBRSxPQUFPLEVBQUUsSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDO1lBRTFGLElBQUksQ0FBQyxLQUFLLEdBQUcsV0FBVyxDQUFDO1lBQ3pCLElBQUksQ0FBQyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDdkMsQ0FBQztRQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7WUFDYixJQUFJLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxnQ0FBZ0MsRUFBRSxHQUFHLEVBQUUsRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDLENBQUM7WUFDM0UsSUFBSSxDQUFDLEtBQUssR0FBRyxRQUFRLENBQUM7UUFDeEIsQ0FBQztnQkFBUyxDQUFDO1lBQ1QsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQzNCLENBQUM7SUFDSCxDQUFDO0lBRU0sSUFBSTtRQUNULElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxFQUFFLENBQUM7SUFDdkIsQ0FBQztJQUVPLEtBQUssQ0FBQyxRQUFRLENBQUMsV0FBbUI7UUFDeEMsTUFBTSxLQUFLLEdBQUcsTUFBTSxJQUFJLENBQUMsYUFBYSxDQUFDLFFBQVEsQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUM3RCxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDWCxNQUFNLElBQUksS0FBSyxDQUFDLFNBQVMsV0FBVywrQkFBK0IsQ0FBQyxDQUFDO1FBQ3ZFLENBQUM7UUFDRCxPQUFPLEtBQUssQ0FBQztJQUNmLENBQUM7SUFFTyxLQUFLLENBQUMsTUFBTSxDQUFDLFFBQWtCO1FBQ3JDLE1BQU0sR0FBRyxHQUFHLE1BQU0sT0FBTyxDQUFDLEdBQUcsQ0FDM0IsUUFBUSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsV0FBVyxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBVSxDQUFDLENBQUMsQ0FDOUYsQ0FBQztRQUNGLE1BQU0sUUFBUSxHQUFHLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUM5QyxJQUFJLFFBQVEsQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUNwQixNQUFNLElBQUksS0FBSyxDQUFDLGtCQUFrQixRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsRUFBRSxFQUFFLENBQUMsTUFBTSxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUNoRyxDQUFDO1FBQ0QsT0FBTyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDLEVBQUcsQ0FBQyxDQUFDO0lBQ25DLENBQUM7SUFFTyxpQkFBaUIsQ0FBQyxLQUFjO1FBQ3RDLE9BQU8sSUFBSSxDQUFDLG1CQUFtQixDQUFDLGlCQUFpQixDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQztJQUMxRSxDQUFDO0lBRU8sS0FBSyxDQUFDLFVBQVUsQ0FDdEIsZUFBZ0MsRUFDaEMsR0FBUyxFQUNULGdCQUF3QjtRQUV4QixNQUFNLENBQUMsWUFBWSxFQUFFLFNBQVMsQ0FBQyxHQUFHLE1BQU0sZUFBZSxDQUFDLE9BQU8sQ0FDN0QsR0FBRyxFQUNILGdCQUFnQixFQUNoQixJQUFJLENBQUMsTUFBTSxFQUNYLElBQUksZ0JBQWdCLEVBQUUsQ0FDdkIsQ0FBQztRQUVGLElBQUksU0FBUyxDQUFDLE1BQU0sRUFBRSxDQUFDO1lBQ3JCLE1BQU0sSUFBSSxLQUFLLENBQ2IsMEJBQTBCLFNBQVMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFLEVBQUUsRUFBRSxLQUFLLEVBQUUsRUFBRSxFQUFFLENBQUMsR0FBRyxFQUFFLENBQUMsU0FBUyxFQUFFLEtBQUssS0FBSyxHQUFHLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FDeEcsQ0FBQztRQUNKLENBQUM7UUFFRCxPQUFPLFlBQVksQ0FBQztJQUN0QixDQUFDO0NBQ0YifQ==

package/dest/tx-provider/aztec-node-tx-provider.d.ts

@@ -1,8 +0,0 @@
-import { type AztecNode, type Tx, type TxHash, type TxProvider } from '@aztec/circuit-types';
-/** Implements TxProvider by querying an Aztec node for the txs. */
-export declare class AztecNodeTxProvider implements TxProvider {
-    private node;
-    constructor(node: AztecNode);
-    getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
-}
-//# sourceMappingURL=aztec-node-tx-provider.d.ts.map

package/dest/tx-provider/aztec-node-tx-provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"aztec-node-tx-provider.d.ts","sourceRoot":"","sources":["../../src/tx-provider/aztec-node-tx-provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,EAAE,EAAE,KAAK,MAAM,EAAE,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAE7F,mEAAmE;AACnE,qBAAa,mBAAoB,YAAW,UAAU;IACxC,OAAO,CAAC,IAAI;gBAAJ,IAAI,EAAE,SAAS;IAEnC,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC;CAGrD"}