@aztec/prover-node 0.76.3 → 0.76.4-devnet-test-rc3

package/src/monitors/claims-monitor.ts

@@ -0,0 +1,69 @@
+import { type EpochProofClaim } from '@aztec/circuit-types';
+import { type EthAddress } from '@aztec/circuits.js';
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import {
+  type TelemetryClient,
+  type Traceable,
+  type Tracer,
+  getTelemetryClient,
+  trackSpan,
+} from '@aztec/telemetry-client';
+
+import { type ProverNodePublisher } from '../prover-node-publisher.js';
+
+export interface ClaimsMonitorHandler {
+  handleClaim(proofClaim: EpochProofClaim): Promise<void>;
+}
+
+export class ClaimsMonitor implements Traceable {
+  private runningPromise: RunningPromise;
+  private log = createLogger('prover-node:claims-monitor');
+
+  private handler: ClaimsMonitorHandler | undefined;
+  private lastClaimEpochNumber: bigint | undefined;
+
+  public readonly tracer: Tracer;
+
+  constructor(
+    private readonly l1Publisher: ProverNodePublisher,
+    private options: { pollingIntervalMs: number },
+    telemetry: TelemetryClient = getTelemetryClient(),
+  ) {
+    this.tracer = telemetry.getTracer('ClaimsMonitor');
+    this.runningPromise = new RunningPromise(this.work.bind(this), this.log, 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');
+  }
+
+  @trackSpan('ClaimsMonitor.work')
+  public async work() {
+    const proofClaim = await this.l1Publisher.getProofClaim();
+    if (!proofClaim) {
+      this.log.trace(`Found no proof claim`);
+      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();
+  }
+}

package/src/monitors/epoch-monitor.ts

@@ -10,6 +10,7 @@ import {
 } from '@aztec/telemetry-client';
 
 export interface EpochMonitorHandler {
+  handleInitialEpochSync(epochNumber: bigint): Promise<void>;
   handleEpochCompleted(epochNumber: bigint): Promise<void>;
 }
 
@@ -47,7 +48,7 @@ export class EpochMonitor implements Traceable {
     if (!this.latestEpochNumber) {
       const epochNumber = await this.l2BlockSource.getL2EpochNumber();
       if (epochNumber > 0n) {
-        await this.handler?.handleEpochCompleted(epochNumber - 1n);
+        await this.handler?.handleInitialEpochSync(epochNumber - 1n);
       }
       this.latestEpochNumber = epochNumber;
       return;

package/src/monitors/index.ts

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

package/src/prover-node-publisher.ts

@@ -85,6 +85,10 @@ export class ProverNodePublisher {
     return EthAddress.fromString(this.l1TxUtils.getSenderAddress());
   }
 
+  public getProofClaim() {
+    return this.rollupContract.getProofClaim();
+  }
+
   public async submitEpochProof(args: {
     epochNumber: number;
     fromBlock: number;
@@ -201,12 +205,11 @@ export class ProverNodePublisher {
 
     const txArgs = [
       {
-        start: argsArray[0],
-        end: argsArray[1],
-        args: argsArray[2],
-        fees: argsArray[3],
-        blobPublicInputs: argsArray[4],
-        aggregationObject: argsArray[5],
+        epochSize: argsArray[0],
+        args: argsArray[1],
+        fees: argsArray[2],
+        blobPublicInputs: argsArray[3],
+        aggregationObject: argsArray[4],
         proof: proofHex,
       },
     ] as const;
@@ -249,8 +252,7 @@ export class ProverNodePublisher {
     proof: Proof;
   }) {
     return [
-      BigInt(args.fromBlock),
-      BigInt(args.toBlock),
+      BigInt(args.toBlock - args.fromBlock + 1),
       [
         args.publicInputs.previousArchive.root.toString(),
         args.publicInputs.endArchive.root.toString(),

package/src/prover-node.ts

@@ -1,6 +1,8 @@
 import {
+  type EpochProofClaim,
+  type EpochProofQuote,
+  EpochProofQuotePayload,
   type EpochProverManager,
-  EpochProvingJobTerminalState,
   type L1ToL2MessageSource,
   type L2Block,
   type L2BlockSource,
@@ -32,10 +34,14 @@ import {
   trackSpan,
 } from '@aztec/telemetry-client';
 
+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 ProverNodePublisher } from './prover-node-publisher.js';
+import { type QuoteProvider } from './quote-provider/index.js';
+import { type QuoteSigner } from './quote-signer.js';
 
 export type ProverNodeOptions = {
   pollingIntervalMs: number;
@@ -52,7 +58,7 @@ export type ProverNodeOptions = {
  * 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 implements EpochMonitorHandler, ProverNodeApi, Traceable {
+export class ProverNode implements ClaimsMonitorHandler, EpochMonitorHandler, ProverNodeApi, Traceable {
   private log = createLogger('prover-node');
   private dateProvider = new DateProvider();
 
@@ -75,7 +81,11 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
     protected readonly contractDataSource: ContractDataSource,
     protected readonly worldState: WorldStateSynchronizer,
     protected readonly coordination: ProverCoordination & Maybe<Service>,
+    protected readonly quoteProvider: QuoteProvider,
+    protected readonly quoteSigner: QuoteSigner,
+    protected readonly claimsMonitor: ClaimsMonitor,
     protected readonly epochsMonitor: EpochMonitor,
+    protected readonly bondManager: BondManager,
     options: Partial<ProverNodeOptions> = {},
     protected readonly telemetryClient: TelemetryClient = getTelemetryClient(),
   ) {
@@ -102,23 +112,89 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
     return undefined;
   }
 
+  async handleClaim(proofClaim: EpochProofClaim): Promise<void> {
+    if (proofClaim.epochToProve === this.latestEpochWeAreProving) {
+      this.log.verbose(`Already proving claim for epoch ${proofClaim.epochToProve}`);
+      return;
+    }
+
+    const provenEpoch = await this.l2BlockSource.getProvenL2EpochNumber();
+    if (provenEpoch !== undefined && proofClaim.epochToProve <= provenEpoch) {
+      this.log.verbose(`Claim for epoch ${proofClaim.epochToProve} is already proven`);
+      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 an epoch being completed by starting a proof for it if there are no active jobs for it.
+   * 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) {
+        this.log.verbose(`Handling epoch ${epochNumber} completed as initial sync`);
+        await this.handleEpochCompleted(epochNumber);
+      }
+    } 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 {
-      this.log.debug('jobs', JSON.stringify(this.jobs, null, 2));
-      const activeJobs = await this.getActiveJobsForEpoch(epochNumber);
-      if (activeJobs.length > 0) {
-        this.log.info(`Not starting proof for ${epochNumber} since there are active jobs`);
+      // Gather data for the epoch
+      const epochData = await this.gatherEpochData(epochNumber);
+      const { blocks } = epochData;
+      this.cachedEpochData = { epochNumber, ...epochData };
+
+      // Construct a quote for the epoch
+      const partialQuote = await this.quoteProvider.getQuote(Number(epochNumber), blocks);
+      if (!partialQuote) {
+        this.log.info(`No quote produced for epoch ${epochNumber}`);
         return;
       }
-      // TODO: we probably want to skip starting a proof if we are too far into the current epoch
-      await this.startProof(epochNumber);
+
+      // 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
+      this.log.info(
+        `Sending quote for epoch ${epochNumber} with blocks ${blocks[0].number} to ${blocks.at(-1)!.number}`,
+        quote.toViemArgs(),
+      );
+      await this.doSendEpochProofQuote(signed);
     } catch (err) {
       if (err instanceof EmptyEpochError) {
-        this.log.info(`Not starting proof for ${epochNumber} since no blocks were found`);
+        this.log.info(`Not producing quote for ${epochNumber} since no blocks were found`);
       } else {
         this.log.error(`Error handling epoch completed`, err);
       }
@@ -126,12 +202,15 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
   }
 
   /**
-   * Starts the prover node so it periodically checks for unproven epochs in the unfinalised chain from L1 and
-   * starts proving jobs for them.
+   * 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() {
+  async start() {
     this.txFetcher.start();
+    await this.bondManager.ensureBond();
     this.epochsMonitor.start(this);
+    this.claimsMonitor.start(this);
     this.log.info('Started ProverNode', this.options);
   }
 
@@ -142,6 +221,7 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
     this.log.info('Stopping ProverNode');
     await this.txFetcher.stop();
     await this.epochsMonitor.stop();
+    await this.claimsMonitor.stop();
     await this.prover.stop();
     await tryStop(this.l2BlockSource);
     this.publisher.interrupt();
@@ -152,6 +232,16 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
     this.log.info('Stopped ProverNode');
   }
 
+  /** Sends an epoch proof quote to the coordinator. */
+  public sendEpochProofQuote(quote: EpochProofQuote): Promise<void> {
+    this.log.info(`Sending quote for epoch`, quote.toViemArgs().quote);
+    return this.doSendEpochProofQuote(quote);
+  }
+
+  private doSendEpochProofQuote(quote: EpochProofQuote) {
+    return this.coordination.addEpochProofQuote(quote);
+  }
+
   /**
    * Creates a proof for a block range. Returns once the proof has been submitted to L1.
    */
@@ -178,22 +268,8 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
   /**
    * Returns an array of jobs being processed.
    */
-  public getJobs(): Promise<{ uuid: string; status: EpochProvingJobState; epochNumber: number }[]> {
-    return Promise.resolve(
-      Array.from(this.jobs.entries()).map(([uuid, job]) => ({
-        uuid,
-        status: job.getState(),
-        epochNumber: Number(job.getEpochNumber()),
-      })),
-    );
-  }
-
-  protected async getActiveJobsForEpoch(
-    epochBigInt: bigint,
-  ): Promise<{ uuid: string; status: EpochProvingJobState }[]> {
-    const jobs = await this.getJobs();
-    const epochNumber = Number(epochBigInt);
-    return jobs.filter(job => job.epochNumber === epochNumber && !EpochProvingJobTerminalState.includes(job.status));
+  public getJobs(): Promise<{ uuid: string; status: EpochProvingJobState }[]> {
+    return Promise.resolve(Array.from(this.jobs.entries()).map(([uuid, job]) => ({ uuid, status: job.getState() })));
   }
 
   private checkMaximumPendingJobs() {
@@ -322,6 +398,7 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
   /** Extracted for testing purposes. */
   protected async triggerMonitors() {
     await this.epochsMonitor.work();
+    await this.claimsMonitor.work();
   }
 }
 

package/src/quote-provider/http.ts

@@ -0,0 +1,48 @@
+import { type L2Block } from '@aztec/circuit-types';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+
+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: jsonStringify(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 (basisPointFee | bondAmount) in response: ${jsonStringify(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);
+  }
+}