@aztec/prover-node 0.56.0 → 0.58.0

package/src/bond/escrow-contract.ts

@@ -0,0 +1,63 @@
+import { EthAddress } from '@aztec/circuits.js';
+import { IProofCommitmentEscrowAbi } from '@aztec/l1-artifacts';
+
+import {
+  type Chain,
+  type Client,
+  type GetContractReturnType,
+  type HttpTransport,
+  type PrivateKeyAccount,
+  type PublicActions,
+  type PublicRpcSchema,
+  type WalletActions,
+  type WalletClient,
+  type WalletRpcSchema,
+  getContract,
+} from 'viem';
+
+export class EscrowContract {
+  private escrow: GetContractReturnType<
+    typeof IProofCommitmentEscrowAbi,
+    WalletClient<HttpTransport, Chain, PrivateKeyAccount>
+  >;
+
+  constructor(
+    private readonly client: Client<
+      HttpTransport,
+      Chain,
+      PrivateKeyAccount,
+      [...WalletRpcSchema, ...PublicRpcSchema],
+      PublicActions<HttpTransport, Chain> & WalletActions<Chain, PrivateKeyAccount>
+    >,
+    address: EthAddress,
+  ) {
+    this.escrow = getContract({ address: address.toString(), abi: IProofCommitmentEscrowAbi, client });
+  }
+
+  /** Returns the deposit of the publisher sender address on the proof commitment escrow contract. */
+  public async getProverDeposit() {
+    return await this.escrow.read.deposits([this.getSenderAddress().toString()]);
+  }
+
+  /**
+   * Deposits the given amount of tokens into the proof commitment escrow contract. Returns once the tx is mined.
+   * @param amount - The amount to deposit.
+   */
+  public async depositProverBond(amount: bigint) {
+    const hash = await this.escrow.write.deposit([amount]);
+    await this.client.waitForTransactionReceipt({ hash });
+  }
+
+  /** Returns the sender address for the client. */
+  public getSenderAddress(): EthAddress {
+    return EthAddress.fromString(this.client.account.address);
+  }
+
+  public getEscrowAddress(): EthAddress {
+    return EthAddress.fromString(this.escrow.address);
+  }
+
+  public async getTokenAddress(): Promise<EthAddress> {
+    return EthAddress.fromString(await this.escrow.read.token());
+  }
+}

package/src/bond/factory.ts

@@ -0,0 +1,48 @@
+import { EthAddress } from '@aztec/circuits.js';
+import { compact } from '@aztec/foundation/collection';
+import { type RollupAbi } from '@aztec/l1-artifacts';
+
+import {
+  type Chain,
+  type Client,
+  type GetContractReturnType,
+  type HttpTransport,
+  type PrivateKeyAccount,
+  type PublicActions,
+  type PublicClient,
+  type PublicRpcSchema,
+  type WalletActions,
+  type WalletRpcSchema,
+} from 'viem';
+
+import { BondManager } from './bond-manager.js';
+import { type ProverBondManagerConfig, getProverBondManagerConfigFromEnv } from './config.js';
+import { EscrowContract } from './escrow-contract.js';
+import { TokenContract } from './token-contract.js';
+
+export async function createBondManager(
+  rollupContract: GetContractReturnType<typeof RollupAbi, PublicClient>,
+  client: Client<
+    HttpTransport,
+    Chain,
+    PrivateKeyAccount,
+    [...WalletRpcSchema, ...PublicRpcSchema],
+    PublicActions<HttpTransport, Chain> & WalletActions<Chain, PrivateKeyAccount>
+  >,
+  overrides: Partial<ProverBondManagerConfig> = {},
+) {
+  const config = { ...getProverBondManagerConfigFromEnv(), ...compact(overrides) };
+  const { proverMinimumEscrowAmount: minimumStake, proverTargetEscrowAmount: maybeTargetStake } = config;
+  const targetStake = maybeTargetStake ?? minimumStake * 2n;
+
+  const escrowContractAddress = EthAddress.fromString(await rollupContract.read.PROOF_COMMITMENT_ESCROW());
+  const escrow = new EscrowContract(client, escrowContractAddress);
+
+  const tokenContractAddress = await escrow.getTokenAddress();
+  const token = new TokenContract(client, tokenContractAddress);
+
+  // Ensure the prover has enough balance to cover escrow and try to mint otherwise if on a dev environment
+  await token.ensureBalance(targetStake * 2n);
+
+  return new BondManager(token, escrow, minimumStake, targetStake);
+}

package/src/bond/index.ts

@@ -0,0 +1,2 @@
+export { BondManager } from './bond-manager.js';
+export * from './factory.js';

package/src/bond/token-contract.ts

@@ -0,0 +1,85 @@
+import { EthAddress } from '@aztec/circuits.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { IERC20Abi, TestERC20Abi } from '@aztec/l1-artifacts';
+
+import {
+  type Chain,
+  type Client,
+  type GetContractReturnType,
+  type HttpTransport,
+  type PrivateKeyAccount,
+  type PublicActions,
+  type PublicRpcSchema,
+  type WalletActions,
+  type WalletClient,
+  type WalletRpcSchema,
+  getContract,
+} from 'viem';
+
+const MAX_ALLOWANCE = (1n << 256n) - 1n;
+const MIN_ALLOWANCE = 1n << 255n;
+
+export class TokenContract {
+  private token: GetContractReturnType<typeof IERC20Abi, WalletClient<HttpTransport, Chain, PrivateKeyAccount>>;
+  private logger = createDebugLogger('aztec:prover-node:token-contract');
+
+  constructor(
+    private readonly client: Client<
+      HttpTransport,
+      Chain,
+      PrivateKeyAccount,
+      [...WalletRpcSchema, ...PublicRpcSchema],
+      PublicActions<HttpTransport, Chain> & WalletActions<Chain, PrivateKeyAccount>
+    >,
+    address: EthAddress,
+  ) {
+    this.token = getContract({ address: address.toString(), abi: IERC20Abi, client });
+  }
+
+  /**
+   * Ensures the allowed address has near-maximum allowance, or sets it otherwise.
+   * Returns once allowance tx is mined successfully.
+   * @param allowed - Who to allow.
+   */
+  public async ensureAllowance(allowed: EthAddress) {
+    const allowance = await this.token.read.allowance([this.getSenderAddress().toString(), allowed.toString()]);
+    if (allowance < MIN_ALLOWANCE) {
+      this.logger.verbose(`Approving max allowance for ${allowed.toString()}`);
+      const hash = await this.token.write.approve([allowed.toString(), MAX_ALLOWANCE]);
+      await this.client.waitForTransactionReceipt({ hash });
+    }
+  }
+
+  /**
+   * Checks the sender address has enough balance.
+   * If it doesn't, it tries calling a `mint` method, available on testing environments.
+   * If it can't, it throws an error.
+   * @param amount - The balance to ensure.
+   */
+  public async ensureBalance(amount: bigint) {
+    const balance = await this.getBalance();
+    if (balance < amount) {
+      this.logger.verbose(`Balance ${balance} is below required ${amount}. Attempting mint.`);
+      const testToken = getContract({ address: this.token.address, abi: TestERC20Abi, client: this.client });
+      try {
+        await testToken.simulate.mint([this.getSenderAddress().toString(), amount - balance]);
+        const hash = await testToken.write.mint([this.getSenderAddress().toString(), amount - balance]);
+        await this.client.waitForTransactionReceipt({ hash });
+        this.logger.verbose(`Minted ${amount - balance} test tokens`);
+      } catch (err) {
+        this.logger.warn(`Error minting test tokens: ${err}`);
+        throw new Error(`Insufficient balance for ${this.getSenderAddress().toString()}: ${balance} < ${amount}`);
+      }
+    }
+  }
+
+  /** Returns the sender address. */
+  public getSenderAddress(): EthAddress {
+    return EthAddress.fromString(this.client.account.address);
+  }
+
+  /** Returns the balance of the sender. */
+  public async getBalance() {
+    return await this.token.read.balanceOf([this.getSenderAddress().toString()]);
+  }
+}

package/src/config.ts

@@ -1,7 +1,7 @@
 import { type ArchiverConfig, archiverConfigMappings, getArchiverConfigFromEnv } from '@aztec/archiver';
 import {
   type ConfigMappingsType,
-  booleanConfigHelper,
+  bigintConfigHelper,
   getConfigFromMappings,
   numberConfigHelper,
 } from '@aztec/foundation/config';
@@ -16,31 +16,62 @@ import {
 } from '@aztec/sequencer-client';
 import { type WorldStateConfig, getWorldStateConfigFromEnv, worldStateConfigMappings } from '@aztec/world-state';
 
-import { type TxProviderConfig, getTxProviderConfigFromEnv, txProviderConfigMappings } from './tx-provider/config.js';
+import { type ProverBondManagerConfig, proverBondManagerConfigMappings } from './bond/config.js';
+import {
+  type ProverCoordinationConfig,
+  getTxProviderConfigFromEnv,
+  proverCoordinationConfigMappings,
+} from './prover-coordination/config.js';
 
 export type ProverNodeConfig = ArchiverConfig &
   ProverClientConfig &
   WorldStateConfig &
   PublisherConfig &
   TxSenderConfig &
-  TxProviderConfig & {
-    proverNodeDisableAutomaticProving?: boolean;
-    proverNodeMaxPendingJobs?: number;
+  ProverCoordinationConfig &
+  ProverBondManagerConfig &
+  QuoteProviderConfig & {
+    proverNodeMaxPendingJobs: number;
+    proverNodePollingIntervalMs: number;
   };
 
+export type QuoteProviderConfig = {
+  quoteProviderBasisPointFee: number;
+  quoteProviderBondAmount: bigint;
+  quoteProviderUrl?: string;
+};
+
 const specificProverNodeConfigMappings: ConfigMappingsType<
-  Pick<ProverNodeConfig, 'proverNodeDisableAutomaticProving' | 'proverNodeMaxPendingJobs'>
+  Pick<ProverNodeConfig, 'proverNodePollingIntervalMs' | 'proverNodeMaxPendingJobs'>
 > = {
-  proverNodeDisableAutomaticProving: {
-    env: 'PROVER_NODE_DISABLE_AUTOMATIC_PROVING',
-    description: 'Whether to disable automatic proving of pending blocks seen on L1',
-    ...booleanConfigHelper(false),
-  },
   proverNodeMaxPendingJobs: {
     env: 'PROVER_NODE_MAX_PENDING_JOBS',
     description: 'The maximum number of pending jobs for the prover node',
+    ...numberConfigHelper(10),
+  },
+  proverNodePollingIntervalMs: {
+    env: 'PROVER_NODE_POLLING_INTERVAL_MS',
+    description: 'The interval in milliseconds to poll for new jobs',
+    ...numberConfigHelper(1000),
+  },
+};
+
+const quoteProviderConfigMappings: ConfigMappingsType<QuoteProviderConfig> = {
+  quoteProviderBasisPointFee: {
+    env: 'QUOTE_PROVIDER_BASIS_POINT_FEE',
+    description: 'The basis point fee to charge for providing quotes',
     ...numberConfigHelper(100),
   },
+  quoteProviderBondAmount: {
+    env: 'QUOTE_PROVIDER_BOND_AMOUNT',
+    description: 'The bond amount to charge for providing quotes',
+    ...bigintConfigHelper(1000n),
+  },
+  quoteProviderUrl: {
+    env: 'QUOTE_PROVIDER_URL',
+    description:
+      'The URL of the remote quote provider. Overrides QUOTE_PROVIDER_BASIS_POINT_FEE and QUOTE_PROVIDER_BOND_AMOUNT.',
+  },
 };
 
 export const proverNodeConfigMappings: ConfigMappingsType<ProverNodeConfig> = {
@@ -49,7 +80,9 @@ export const proverNodeConfigMappings: ConfigMappingsType<ProverNodeConfig> = {
   ...worldStateConfigMappings,
   ...getPublisherConfigMappings('PROVER'),
   ...getTxSenderConfigMappings('PROVER'),
-  ...txProviderConfigMappings,
+  ...proverCoordinationConfigMappings,
+  ...quoteProviderConfigMappings,
+  ...proverBondManagerConfigMappings,
   ...specificProverNodeConfigMappings,
 };
 
@@ -61,6 +94,8 @@ export function getProverNodeConfigFromEnv(): ProverNodeConfig {
     ...getPublisherConfigFromEnv('PROVER'),
     ...getTxSenderConfigFromEnv('PROVER'),
     ...getTxProviderConfigFromEnv(),
+    ...getConfigFromMappings(quoteProviderConfigMappings),
     ...getConfigFromMappings(specificProverNodeConfigMappings),
+    ...getConfigFromMappings(proverBondManagerConfigMappings),
   };
 }

package/src/factory.ts

@@ -1,6 +1,9 @@
 import { type Archiver, createArchiver } from '@aztec/archiver';
 import { type AztecNode } from '@aztec/circuit-types';
+import { createEthereumChain } from '@aztec/ethereum';
+import { Buffer32 } from '@aztec/foundation/buffer';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
+import { RollupAbi } from '@aztec/l1-artifacts';
 import { createProverClient } from '@aztec/prover-client';
 import { L1Publisher } from '@aztec/sequencer-client';
 import { createSimulationProvider } from '@aztec/simulator';
@@ -8,10 +11,17 @@ import { type TelemetryClient } from '@aztec/telemetry-client';
 import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 import { createWorldStateSynchronizer } from '@aztec/world-state';
 
-import { type ProverNodeConfig } from './config.js';
+import { createPublicClient, getAddress, getContract, http } from 'viem';
+
+import { createBondManager } from './bond/factory.js';
+import { type ProverNodeConfig, type QuoteProviderConfig } from './config.js';
+import { ClaimsMonitor } from './monitors/claims-monitor.js';
+import { EpochMonitor } from './monitors/epoch-monitor.js';
+import { createProverCoordination } from './prover-coordination/factory.js';
 import { ProverNode } from './prover-node.js';
-import { AztecNodeTxProvider } from './tx-provider/aztec-node-tx-provider.js';
-import { createTxProvider } from './tx-provider/factory.js';
+import { HttpQuoteProvider } from './quote-provider/http.js';
+import { SimpleQuoteProvider } from './quote-provider/simple.js';
+import { QuoteSigner } from './quote-signer.js';
 
 /** Creates a new prover node given a config. */
 export async function createProverNode(
@@ -39,9 +49,21 @@ export async function createProverNode(
   // REFACTOR: Move publisher out of sequencer package and into an L1-related package
   const publisher = new L1Publisher(config, telemetry);
 
-  const txProvider = deps.aztecNodeTxProvider
-    ? new AztecNodeTxProvider(deps.aztecNodeTxProvider)
-    : createTxProvider(config);
+  const txProvider = deps.aztecNodeTxProvider ? deps.aztecNodeTxProvider : createProverCoordination(config);
+  const quoteProvider = createQuoteProvider(config);
+  const quoteSigner = createQuoteSigner(config);
+
+  const proverNodeConfig = {
+    maxPendingJobs: config.proverNodeMaxPendingJobs,
+    pollingIntervalMs: config.proverNodePollingIntervalMs,
+  };
+
+  const claimsMonitor = new ClaimsMonitor(publisher, proverNodeConfig);
+  const epochMonitor = new EpochMonitor(archiver, proverNodeConfig);
+
+  const rollupContract = publisher.getRollupContract();
+  const walletClient = publisher.getClient();
+  const bondManager = await createBondManager(rollupContract, walletClient, config);
 
   return new ProverNode(
     prover!,
@@ -52,10 +74,29 @@ export async function createProverNode(
     worldStateSynchronizer,
     txProvider,
     simulationProvider,
+    quoteProvider,
+    quoteSigner,
+    claimsMonitor,
+    epochMonitor,
+    bondManager,
     telemetry,
-    {
-      disableAutomaticProving: config.proverNodeDisableAutomaticProving,
-      maxPendingJobs: config.proverNodeMaxPendingJobs,
-    },
+    proverNodeConfig,
   );
 }
+
+function createQuoteProvider(config: QuoteProviderConfig) {
+  return config.quoteProviderUrl
+    ? new HttpQuoteProvider(config.quoteProviderUrl)
+    : new SimpleQuoteProvider(config.quoteProviderBasisPointFee, config.quoteProviderBondAmount);
+}
+
+function createQuoteSigner(config: ProverNodeConfig) {
+  // REFACTOR: We need a package that just returns an instance of a rollup contract ready to use
+  const { l1RpcUrl: rpcUrl, l1ChainId: chainId, l1Contracts } = config;
+  const chain = createEthereumChain(rpcUrl, chainId);
+  const client = createPublicClient({ chain: chain.chainInfo, transport: http(chain.rpcUrl) });
+  const address = getAddress(l1Contracts.rollupAddress.toString());
+  const rollupContract = getContract({ address, abi: RollupAbi, client });
+  const privateKey = config.publisherPrivateKey;
+  return QuoteSigner.new(Buffer32.fromString(privateKey), rollupContract);
+}

package/src/job/{block-proving-job.ts → epoch-proving-job.ts}

@@ -1,16 +1,17 @@
 import {
-  type BlockProver,
   EmptyTxValidator,
+  type EpochProver,
   type L1ToL2MessageSource,
   type L2Block,
   type L2BlockSource,
-  PROVING_STATUS,
+  type MerkleTreeWriteOperations,
   type ProcessedTx,
+  type ProverCoordination,
   type Tx,
   type TxHash,
-  type TxProvider,
 } from '@aztec/circuit-types';
 import { createDebugLogger } from '@aztec/foundation/log';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { Timer } from '@aztec/foundation/timer';
 import { type L1Publisher } from '@aztec/sequencer-client';
 import { type PublicProcessor, type PublicProcessorFactory } from '@aztec/simulator';
@@ -24,20 +25,25 @@ import { type ProverNodeMetrics } from '../metrics.js';
  * 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 {
-  private state: BlockProvingJobState = 'initialized';
-  private log = createDebugLogger('aztec:block-proving-job');
+export class EpochProvingJob {
+  private state: EpochProvingJobState = 'initialized';
+  private log = createDebugLogger('aztec:epoch-proving-job');
   private uuid: string;
 
+  private runPromise: Promise<void> | undefined;
+
   constructor(
-    private prover: BlockProver,
+    private db: MerkleTreeWriteOperations,
+    private epochNumber: bigint,
+    private blocks: L2Block[],
+    private prover: EpochProver,
     private publicProcessorFactory: PublicProcessorFactory,
     private publisher: L1Publisher,
     private l2BlockSource: L2BlockSource,
     private l1ToL2MessageSource: L1ToL2MessageSource,
-    private txProvider: TxProvider,
+    private coordination: ProverCoordination,
     private metrics: ProverNodeMetrics,
-    private cleanUp: (job: BlockProvingJob) => Promise<void> = () => Promise.resolve(),
+    private cleanUp: (job: EpochProvingJob) => Promise<void> = () => Promise.resolve(),
   ) {
     this.uuid = crypto.randomUUID();
   }
@@ -46,26 +52,39 @@ export class BlockProvingJob {
     return this.uuid;
   }
 
-  public getState(): BlockProvingJobState {
+  public getState(): EpochProvingJobState {
     return this.state;
   }
 
-  public async run(fromBlock: number, toBlock: number) {
-    if (fromBlock !== toBlock) {
-      throw new Error(`Block ranges are not yet supported`);
-    }
-
-    this.log.info(`Starting block proving job`, { fromBlock, toBlock, uuid: this.uuid });
+  /**
+   * Proves the given epoch and submits the proof to L1.
+   */
+  public async run() {
+    const epochNumber = Number(this.epochNumber);
+    const epochSize = this.blocks.length;
+    this.log.info(`Starting epoch proving job`, { epochSize, epochNumber, uuid: this.uuid });
     this.state = 'processing';
     const timer = new Timer();
+
+    const { promise, resolve } = promiseWithResolvers<void>();
+    this.runPromise = promise;
+
     try {
-      let historicalHeader = (await this.l2BlockSource.getBlock(fromBlock - 1))?.header;
-      for (let blockNumber = fromBlock; blockNumber <= toBlock; blockNumber++) {
-        const block = await this.getBlock(blockNumber);
+      this.prover.startNewEpoch(epochNumber, epochSize);
+
+      // Get the genesis header if the first block of the epoch is the first block of the chain
+      let previousHeader =
+        this.blocks[0].number === 1
+          ? this.db.getInitialHeader()
+          : await this.l2BlockSource.getBlockHeader(this.blocks[0].number - 1);
+
+      for (const block of this.blocks) {
+        // Gather all data to prove this block
         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);
+        const txs = await this.getTxs(txHashes);
 
         this.log.verbose(`Starting block processing`, {
           number: block.number,
@@ -74,75 +93,58 @@ export class BlockProvingJob {
           noteHashTreeRoot: block.header.state.partial.noteHashTree.root,
           nullifierTreeRoot: block.header.state.partial.nullifierTree.root,
           publicDataTreeRoot: block.header.state.partial.publicDataTree.root,
-          historicalHeader: historicalHeader?.hash(),
+          previousHeader: previousHeader?.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);
+        // Start block proving
+        await this.prover.startNewBlock(txCount, globalVariables, l1ToL2Messages);
 
-        const publicProcessor = this.publicProcessorFactory.create(historicalHeader, globalVariables);
-
-        const txs = await this.getTxs(txHashes);
+        // Process public fns
+        const publicProcessor = this.publicProcessorFactory.create(this.db, previousHeader, globalVariables);
         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;
+        // Mark block as completed and update archive tree
+        await this.prover.setBlockCompleted(block.header);
+        previousHeader = 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 = 'awaiting-prover';
+      const { publicInputs, proof } = await this.prover.finaliseEpoch();
+      this.log.info(`Finalised proof for epoch`, { epochNumber, 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 });
+      const [fromBlock, toBlock] = [this.blocks[0].number, this.blocks.at(-1)!.number];
+      await this.publisher.submitEpochProof({ fromBlock, toBlock, epochNumber, publicInputs, proof });
+      this.log.info(`Submitted proof for epoch`, { epochNumber, 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.log.error(`Error running epoch prover job`, err, { uuid: this.uuid });
       this.state = 'failed';
     } finally {
       await this.cleanUp(this);
+      resolve();
     }
   }
 
-  public stop() {
+  public async stop() {
     this.prover.cancel();
-  }
-
-  private async getBlock(blockNumber: number): Promise<L2Block> {
-    const block = await this.l2BlockSource.getBlock(blockNumber);
-    if (!block) {
-      throw new Error(`Block ${blockNumber} not found in L2 block source`);
+    if (this.runPromise) {
+      await this.runPromise;
     }
-    return block;
   }
 
   private async getTxs(txHashes: TxHash[]): Promise<Tx[]> {
     const txs = await Promise.all(
-      txHashes.map(txHash => this.txProvider.getTxByHash(txHash).then(tx => [txHash, tx] as const)),
+      txHashes.map(txHash => this.coordination.getTxByHash(txHash).then(tx => [txHash, tx] as const)),
     );
     const notFound = txs.filter(([_, tx]) => !tx);
     if (notFound.length) {
@@ -177,7 +179,7 @@ export class BlockProvingJob {
   }
 }
 
-export type BlockProvingJobState =
+export type EpochProvingJobState =
   | 'initialized'
   | 'processing'
   | 'awaiting-prover'

package/src/monitors/claims-monitor.ts

@@ -0,0 +1,52 @@
+import { type EpochProofClaim } from '@aztec/circuit-types';
+import { type EthAddress } from '@aztec/circuits.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { type L1Publisher } from '@aztec/sequencer-client';
+
+export interface ClaimsMonitorHandler {
+  handleClaim(proofClaim: EpochProofClaim): Promise<void>;
+}
+
+export class ClaimsMonitor {
+  private runningPromise: RunningPromise;
+  private log = createDebugLogger('aztec:prover-node:claims-monitor');
+
+  private handler: ClaimsMonitorHandler | undefined;
+  private lastClaimEpochNumber: bigint | undefined;
+
+  constructor(private readonly l1Publisher: L1Publisher, private options: { pollingIntervalMs: number }) {
+    this.runningPromise = new RunningPromise(this.work.bind(this), this.options.pollingIntervalMs);
+  }
+
+  public start(handler: ClaimsMonitorHandler) {
+    this.handler = handler;
+    this.runningPromise.start();
+    this.log.info(`Started ClaimsMonitor with prover address ${this.getProverAddress().toString()}`, this.options);
+  }
+
+  public async stop() {
+    this.log.verbose('Stopping ClaimsMonitor');
+    await this.runningPromise.stop();
+    this.log.info('Stopped ClaimsMonitor');
+  }
+
+  public async work() {
+    const proofClaim = await this.l1Publisher.getProofClaim();
+    if (!proofClaim) {
+      return;
+    }
+
+    if (this.lastClaimEpochNumber === undefined || proofClaim.epochToProve > this.lastClaimEpochNumber) {
+      this.log.verbose(`Found new claim for epoch ${proofClaim.epochToProve} by ${proofClaim.bondProvider.toString()}`);
+      if (proofClaim.bondProvider.equals(this.getProverAddress())) {
+        await this.handler?.handleClaim(proofClaim);
+      }
+      this.lastClaimEpochNumber = proofClaim.epochToProve;
+    }
+  }
+
+  protected getProverAddress(): EthAddress {
+    return this.l1Publisher.getSenderAddress();
+  }
+}