@aztec/prover-node 3.0.0-nightly.20251201.2 → 3.0.0-nightly.20251203

package/src/prover-node-publisher.ts

@@ -2,7 +2,7 @@ import { BatchedBlob, getEthBlobEvaluationInputs } from '@aztec/blob-lib';
 import { AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
 import type { L1TxUtils, RollupContract, ViemCommitteeAttestation } from '@aztec/ethereum';
 import { makeTuple } from '@aztec/foundation/array';
-import { EpochNumber } from '@aztec/foundation/branded-types';
+import { CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { areArraysEqual } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
@@ -87,15 +87,15 @@ export class ProverNodePublisher {
 
   public async submitEpochProof(args: {
     epochNumber: EpochNumber;
-    fromBlock: number;
-    toBlock: number;
+    fromCheckpoint: CheckpointNumber;
+    toCheckpoint: CheckpointNumber;
     publicInputs: RootRollupPublicInputs;
     proof: Proof;
     batchedBlobInputs: BatchedBlob;
     attestations: ViemCommitteeAttestation[];
   }): Promise<boolean> {
-    const { epochNumber, fromBlock, toBlock } = args;
-    const ctx = { epochNumber, fromBlock, toBlock };
+    const { epochNumber, fromCheckpoint, toCheckpoint } = args;
+    const ctx = { epochNumber, fromCheckpoint, toCheckpoint };
 
     if (!this.interrupted) {
       const timer = new Timer();
@@ -139,44 +139,48 @@ export class ProverNodePublisher {
       this.log.error(`Rollup.submitEpochProof tx status failed ${txReceipt.transactionHash}`, undefined, ctx);
     }
 
-    this.log.verbose('L2 block data syncing interrupted', ctx);
+    this.log.verbose('Checkpoint data syncing interrupted', ctx);
     return false;
   }
 
   private async validateEpochProofSubmission(args: {
-    fromBlock: number;
-    toBlock: number;
+    fromCheckpoint: CheckpointNumber;
+    toCheckpoint: CheckpointNumber;
     publicInputs: RootRollupPublicInputs;
     proof: Proof;
     batchedBlobInputs: BatchedBlob;
     attestations: ViemCommitteeAttestation[];
   }) {
-    const { fromBlock, toBlock, publicInputs, batchedBlobInputs } = args;
+    const { fromCheckpoint, toCheckpoint, publicInputs, batchedBlobInputs } = args;
 
-    // Check that the block numbers match the expected epoch to be proven
+    // Check that the checkpoint numbers match the expected epoch to be proven
     const { pending, proven } = await this.rollupContract.getTips();
-    // Don't publish if proven is beyond our toBlock, pointless to do so
-    if (proven > BigInt(toBlock)) {
-      throw new Error(`Cannot submit epoch proof for ${fromBlock}-${toBlock} as proven block is ${proven}`);
+    // Don't publish if proven is beyond our toCheckpoint, pointless to do so
+    if (proven > BigInt(toCheckpoint)) {
+      throw new Error(
+        `Cannot submit epoch proof for ${fromCheckpoint}-${toCheckpoint} as proven checkpoint is ${proven}`,
+      );
     }
-    // toBlock can't be greater than pending
-    if (toBlock > pending) {
-      throw new Error(`Cannot submit epoch proof for ${fromBlock}-${toBlock} as pending block is ${pending}`);
+    // toCheckpoint can't be greater than pending
+    if (toCheckpoint > pending) {
+      throw new Error(
+        `Cannot submit epoch proof for ${fromCheckpoint}-${toCheckpoint} as pending checkpoint is ${pending}`,
+      );
     }
 
-    // Check the archive for the immediate block before the epoch
-    const blockLog = await this.rollupContract.getCheckpoint(BigInt(fromBlock - 1));
-    if (publicInputs.previousArchiveRoot.toString() !== blockLog.archive) {
+    // Check the archive for the immediate checkpoint before the epoch
+    const checkpointLog = await this.rollupContract.getCheckpoint(CheckpointNumber(fromCheckpoint - 1));
+    if (publicInputs.previousArchiveRoot.toString() !== checkpointLog.archive) {
       throw new Error(
-        `Previous archive root mismatch: ${publicInputs.previousArchiveRoot.toString()} !== ${blockLog.archive}`,
+        `Previous archive root mismatch: ${publicInputs.previousArchiveRoot.toString()} !== ${checkpointLog.archive}`,
       );
     }
 
-    // Check the archive for the last block in the epoch
-    const endBlockLog = await this.rollupContract.getCheckpoint(BigInt(toBlock));
-    if (publicInputs.endArchiveRoot.toString() !== endBlockLog.archive) {
+    // Check the archive for the last checkpoint in the epoch
+    const endCheckpointLog = await this.rollupContract.getCheckpoint(toCheckpoint);
+    if (publicInputs.endArchiveRoot.toString() !== endCheckpointLog.archive) {
       throw new Error(
-        `End archive root mismatch: ${publicInputs.endArchiveRoot.toString()} !== ${endBlockLog.archive}`,
+        `End archive root mismatch: ${publicInputs.endArchiveRoot.toString()} !== ${endCheckpointLog.archive}`,
       );
     }
 
@@ -203,8 +207,8 @@ export class ProverNodePublisher {
   }
 
   private async sendSubmitEpochProofTx(args: {
-    fromBlock: number;
-    toBlock: number;
+    fromCheckpoint: CheckpointNumber;
+    toCheckpoint: CheckpointNumber;
     publicInputs: RootRollupPublicInputs;
     proof: Proof;
     batchedBlobInputs: BatchedBlob;
@@ -214,8 +218,8 @@ export class ProverNodePublisher {
 
     this.log.info(`Submitting epoch proof to L1 rollup contract`, {
       proofSize: args.proof.withoutPublicInputs().length,
-      fromBlock: args.fromBlock,
-      toBlock: args.toBlock,
+      fromCheckpoint: args.fromCheckpoint,
+      toCheckpoint: args.toCheckpoint,
     });
     const data = encodeFunctionData({
       abi: RollupAbi,
@@ -244,16 +248,16 @@ export class ProverNodePublisher {
   }
 
   private getEpochProofPublicInputsArgs(args: {
-    fromBlock: number;
-    toBlock: number;
+    fromCheckpoint: CheckpointNumber;
+    toCheckpoint: CheckpointNumber;
     publicInputs: RootRollupPublicInputs;
     batchedBlobInputs: BatchedBlob;
     attestations: ViemCommitteeAttestation[];
   }) {
     // Returns arguments for EpochProofLib.sol -> getEpochProofPublicInputs()
     return [
-      BigInt(args.fromBlock) /*_start*/,
-      BigInt(args.toBlock) /*_end*/,
+      BigInt(args.fromCheckpoint) /*_start*/,
+      BigInt(args.toCheckpoint) /*_end*/,
       {
         previousArchive: args.publicInputs.previousArchiveRoot.toString(),
         endArchive: args.publicInputs.endArchiveRoot.toString(),
@@ -269,8 +273,8 @@ export class ProverNodePublisher {
   }
 
   private getSubmitEpochProofArgs(args: {
-    fromBlock: number;
-    toBlock: number;
+    fromCheckpoint: CheckpointNumber;
+    toCheckpoint: CheckpointNumber;
     publicInputs: RootRollupPublicInputs;
     proof: Proof;
     batchedBlobInputs: BatchedBlob;

package/src/prover-node.ts

@@ -1,6 +1,6 @@
 import type { Archiver } from '@aztec/archiver';
 import type { RollupContract } from '@aztec/ethereum';
-import { EpochNumber } from '@aztec/foundation/branded-types';
+import { CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { assertRequired, compact, pick, sum } from '@aztec/foundation/collection';
 import { memoize } from '@aztec/foundation/decorators';
 import type { Fr } from '@aztec/foundation/fields';
@@ -9,7 +9,8 @@ import { DateProvider } from '@aztec/foundation/timer';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
 import type { P2PClient } from '@aztec/p2p';
 import { PublicProcessorFactory } from '@aztec/simulator/server';
-import type { L2Block, L2BlockSource } from '@aztec/stdlib/block';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { Checkpoint } from '@aztec/stdlib/checkpoint';
 import type { ChainConfig } from '@aztec/stdlib/config';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import { getProofSubmissionDeadlineTimestamp } from '@aztec/stdlib/epoch-helpers';
@@ -271,10 +272,13 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
 
     // Gather all data for this epoch
     const epochData = await this.gatherEpochData(epochNumber);
-
-    const fromBlock = epochData.blocks[0].number;
-    const toBlock = epochData.blocks.at(-1)!.number;
-    this.log.verbose(`Creating proving job for epoch ${epochNumber} for block range ${fromBlock} to ${toBlock}`);
+    const fromCheckpoint = epochData.checkpoints[0].number;
+    const toCheckpoint = epochData.checkpoints.at(-1)!.number;
+    const fromBlock = epochData.checkpoints[0].blocks[0].number;
+    const toBlock = epochData.checkpoints.at(-1)!.blocks.at(-1)!.number;
+    this.log.verbose(
+      `Creating proving job for epoch ${epochNumber} for checkpoint range ${fromCheckpoint} to ${toCheckpoint} and block range ${fromBlock} to ${toBlock}`,
+    );
 
     // Fast forward world state to right before the target block and get a fork
     await this.worldState.syncImmediate(toBlock);
@@ -289,7 +293,6 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
     // Set deadline for this job to run. It will abort if it takes too long.
     const deadlineTs = getProofSubmissionDeadlineTimestamp(epochNumber, await this.getL1Constants());
     const deadline = new Date(Number(deadlineTs) * 1000);
-
     const job = this.doCreateEpochProvingJob(epochData, deadline, publicProcessorFactory, this.publisher, opts);
     this.jobs.set(job.getId(), job);
     return job;
@@ -302,28 +305,30 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
 
   @trackSpan('ProverNode.gatherEpochData', epochNumber => ({ [Attributes.EPOCH_NUMBER]: epochNumber }))
   private async gatherEpochData(epochNumber: EpochNumber): Promise<EpochProvingJobData> {
-    const blocks = await this.gatherBlocks(epochNumber);
-    const txArray = await this.gatherTxs(epochNumber, blocks);
+    const checkpoints = await this.gatherCheckpoints(epochNumber);
+    const txArray = await this.gatherTxs(epochNumber, checkpoints);
     const txs = new Map<string, Tx>(txArray.map(tx => [tx.getTxHash().toString(), tx]));
-    const l1ToL2Messages = await this.gatherMessages(epochNumber, blocks);
-    const previousBlockHeader = await this.gatherPreviousBlockHeader(epochNumber, blocks[0]);
-    const [lastBlock] = await this.l2BlockSource.getPublishedBlocks(blocks.at(-1)!.number, 1);
-    const attestations = lastBlock?.attestations ?? [];
+    const l1ToL2Messages = await this.gatherMessages(epochNumber, checkpoints);
+    const [firstBlock] = checkpoints[0].blocks;
+    const previousBlockHeader = await this.gatherPreviousBlockHeader(epochNumber, firstBlock.number - 1);
+    const [lastPublishedCheckpoint] = await this.l2BlockSource.getPublishedCheckpoints(checkpoints.at(-1)!.number, 1);
+    const attestations = lastPublishedCheckpoint?.attestations ?? [];
 
-    return { blocks, txs, l1ToL2Messages, epochNumber, previousBlockHeader, attestations };
+    return { checkpoints, txs, l1ToL2Messages, epochNumber, previousBlockHeader, attestations };
   }
 
-  private async gatherBlocks(epochNumber: EpochNumber) {
-    const blocks = await this.l2BlockSource.getBlocksForEpoch(epochNumber);
-    if (blocks.length === 0) {
+  private async gatherCheckpoints(epochNumber: EpochNumber) {
+    const checkpoints = await this.l2BlockSource.getCheckpointsForEpoch(epochNumber);
+    if (checkpoints.length === 0) {
       throw new EmptyEpochError(epochNumber);
     }
-    return blocks;
+    return checkpoints;
   }
 
-  private async gatherTxs(epochNumber: EpochNumber, blocks: L2Block[]) {
+  private async gatherTxs(epochNumber: EpochNumber, checkpoints: Checkpoint[]) {
     const deadline = new Date(this.dateProvider.now() + this.config.txGatheringTimeoutMs);
     const txProvider = this.p2pClient.getTxProvider();
+    const blocks = checkpoints.flatMap(checkpoint => checkpoint.blocks);
     const txsByBlock = await Promise.all(blocks.map(block => txProvider.getTxsForBlock(block, { deadline })));
     const txs = txsByBlock.map(({ txs }) => txs).flat();
     const missingTxs = txsByBlock.map(({ missingTxs }) => missingTxs).flat();
@@ -336,25 +341,26 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
     throw new Error(`Txs not found for epoch ${epochNumber}: ${missingTxs.map(hash => hash.toString()).join(', ')}`);
   }
 
-  private async gatherMessages(epochNumber: EpochNumber, blocks: L2Block[]) {
-    const messages = await Promise.all(blocks.map(b => this.l1ToL2MessageSource.getL1ToL2Messages(b.number)));
+  private async gatherMessages(epochNumber: EpochNumber, checkpoints: Checkpoint[]) {
+    const messages = await Promise.all(
+      checkpoints.map(c => this.l1ToL2MessageSource.getL1ToL2MessagesForCheckpoint(c.number)),
+    );
     const messageCount = sum(messages.map(m => m.length));
     this.log.verbose(`Gathered all ${messageCount} messages for epoch ${epochNumber}`, { epochNumber });
-    const messagesByBlock: Record<number, Fr[]> = {};
-    for (let i = 0; i < blocks.length; i++) {
-      messagesByBlock[blocks[i].number] = messages[i];
+    const messagesByCheckpoint: Record<CheckpointNumber, Fr[]> = {};
+    for (let i = 0; i < checkpoints.length; i++) {
+      messagesByCheckpoint[checkpoints[i].number] = messages[i];
     }
-    return messagesByBlock;
+    return messagesByCheckpoint;
   }
 
-  private async gatherPreviousBlockHeader(epochNumber: EpochNumber, initialBlock: L2Block) {
-    const previousBlockNumber = initialBlock.number - 1;
+  private async gatherPreviousBlockHeader(epochNumber: EpochNumber, previousBlockNumber: number) {
     const header = await (previousBlockNumber === 0
       ? this.worldState.getCommitted().getInitialHeader()
       : this.l2BlockSource.getBlockHeader(previousBlockNumber));
 
     if (!header) {
-      throw new Error(`Previous block header ${initialBlock.number} not found for proving epoch ${epochNumber}`);
+      throw new Error(`Previous block header ${previousBlockNumber} not found for proving epoch ${epochNumber}`);
     }
 
     this.log.verbose(`Gathered previous block header ${header.getBlockNumber()} for epoch ${epochNumber}`);