@aztec/sequencer-client 0.0.1-commit.64b6bbb → 0.0.1-commit.684755437

package/src/sequencer/sequencer.ts

@@ -12,7 +12,7 @@ import type { DateProvider } from '@aztec/foundation/timer';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
 import type { P2P } from '@aztec/p2p';
 import type { SlasherClientInterface } from '@aztec/slasher';
-import type { L2Block, L2BlockSink, L2BlockSource, ValidateCheckpointResult } from '@aztec/stdlib/block';
+import type { BlockData, L2BlockSink, L2BlockSource, ValidateCheckpointResult } from '@aztec/stdlib/block';
 import type { Checkpoint } from '@aztec/stdlib/checkpoint';
 import { getSlotAtTimestamp, getSlotStartBuildTimestamp } from '@aztec/stdlib/epoch-helpers';
 import {
@@ -25,7 +25,7 @@ import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 import { pickFromSchema } from '@aztec/stdlib/schemas';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { Attributes, type TelemetryClient, type Tracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
-import { FullNodeCheckpointsBuilder, type ValidatorClient } from '@aztec/validator-client';
+import { FullNodeCheckpointsBuilder, NodeKeystoreAdapter, type ValidatorClient } from '@aztec/validator-client';
 
 import EventEmitter from 'node:events';
 
@@ -75,14 +75,6 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
   /** The maximum number of seconds that the sequencer can be into a slot to transition to a particular state. */
   protected timetable!: SequencerTimetable;
 
-  // This shouldn't be here as this gets re-created each time we build/propose a block.
-  // But we have a number of tests that abuse/rely on this class having a permanent publisher.
-  // As long as those tests only configure a single publisher they will continue to work.
-  // This will get re-assigned every time the sequencer goes to build a new block to a publisher that is valid
-  // for the block proposer.
-  // TODO(palla/mbps): Remove this field and fix tests
-  protected publisher: SequencerPublisher | undefined;
-
   /** Config for the sequencer */
   protected config: ResolvedSequencerConfig = DefaultSequencerConfig;
 
@@ -118,7 +110,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
   /** Updates sequencer config by the defined values and updates the timetable */
   public updateConfig(config: Partial<SequencerConfig>) {
     const filteredConfig = pickFromSchema(config, SequencerConfigSchema);
-    this.log.info(`Updated sequencer config`, omit(filteredConfig, 'txPublicSetupAllowList'));
+    this.log.info(`Updated sequencer config`, omit(filteredConfig, 'txPublicSetupAllowListExtend'));
     this.config = merge(this.config, filteredConfig);
     this.timetable = new SequencerTimetable(
       {
@@ -134,10 +126,9 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     );
   }
 
-  /** Initializes the sequencer (precomputes tables and creates a publisher). Takes about 3s. */
-  public async init() {
+  /** Initializes the sequencer (precomputes tables). Takes about 3s. */
+  public init() {
     getKzg();
-    this.publisher = (await this.publisherFactory.create(undefined)).publisher;
   }
 
   /** Starts the sequencer and moves to IDLE state. */
@@ -156,7 +147,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
   public async stop(): Promise<void> {
     this.log.info(`Stopping sequencer`);
     this.setState(SequencerState.STOPPING, undefined, { force: true });
-    this.publisher?.interrupt();
+    this.publisherFactory.interruptAll();
     await this.runningPromise?.stop();
     this.setState(SequencerState.STOPPED, undefined, { force: true });
     this.log.info('Stopped sequencer');
@@ -169,7 +160,6 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     } catch (err) {
       this.emit('checkpoint-error', { error: err as Error });
       if (err instanceof SequencerTooSlowError) {
-        // TODO(palla/mbps): Add missing states
         // Log as warn only if we had to abort halfway through the block proposal
         const logLvl = [SequencerState.INITIALIZING_CHECKPOINT, SequencerState.PROPOSER_CHECK].includes(
           err.proposedState,
@@ -310,12 +300,12 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     }
 
     // Check that the slot is not taken by a block already (should never happen, since only us can propose for this slot)
-    if (syncedTo.block && syncedTo.block.header.getSlot() >= slot) {
+    if (syncedTo.blockData && syncedTo.blockData.header.getSlot() >= slot) {
       this.log.warn(
         `Cannot propose block at next L2 slot ${slot} since that slot was taken by block ${syncedTo.blockNumber}`,
-        { ...logCtx, block: syncedTo.block.header.toInspect() },
+        { ...logCtx, block: syncedTo.blockData.header.toInspect() },
       );
-      this.metrics.recordBlockProposalPrecheckFailed('slot_already_taken');
+      this.metrics.recordCheckpointPrecheckFailed('slot_already_taken');
       return undefined;
     }
 
@@ -326,7 +316,6 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     const proposerForPublisher = this.config.fishermanMode ? undefined : proposer;
     const { attestorAddress, publisher } = await this.publisherFactory.create(proposerForPublisher);
     this.log.verbose(`Created publisher at address ${publisher.getSenderAddress()} for attestor ${attestorAddress}`);
-    this.publisher = publisher;
 
     // In fisherman mode, set the actual proposer's address for simulations
     if (this.config.fishermanMode && proposer) {
@@ -351,7 +340,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
         logCtx,
       );
       this.emit('proposer-rollup-check-failed', { reason: 'Rollup contract check failed', slot });
-      this.metrics.recordBlockProposalPrecheckFailed('rollup_contract_check_failed');
+      this.metrics.recordCheckpointPrecheckFailed('rollup_contract_check_failed');
       return undefined;
     }
 
@@ -361,7 +350,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
         { ...logCtx, rollup: canProposeCheck, expectedSlot: slot },
       );
       this.emit('proposer-rollup-check-failed', { reason: 'Slot mismatch', slot });
-      this.metrics.recordBlockProposalPrecheckFailed('slot_mismatch');
+      this.metrics.recordCheckpointPrecheckFailed('slot_mismatch');
       return undefined;
     }
 
@@ -371,7 +360,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
         { ...logCtx, rollup: canProposeCheck, expectedSlot: slot },
       );
       this.emit('proposer-rollup-check-failed', { reason: 'Block mismatch', slot });
-      this.metrics.recordBlockProposalPrecheckFailed('block_number_mismatch');
+      this.metrics.recordCheckpointPrecheckFailed('block_number_mismatch');
       return undefined;
     }
 
@@ -433,6 +422,13 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     );
   }
 
+  /**
+   * Returns the current sequencer state.
+   */
+  public getState(): SequencerState {
+    return this.state;
+  }
+
   /**
    * Internal helper for setting the sequencer state and checks if we have enough time left in the slot to transition to the new state.
    * @param proposedState - The new state to transition to.
@@ -533,18 +529,18 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
       };
     }
 
-    const block = await this.l2BlockSource.getL2Block(blockNumber);
-    if (!block) {
+    const blockData = await this.l2BlockSource.getBlockData(blockNumber);
+    if (!blockData) {
       // this shouldn't really happen because a moment ago we checked that all components were in sync
-      this.log.error(`Failed to get L2 block ${blockNumber} from the archiver with all components in sync`);
+      this.log.error(`Failed to get L2 block data ${blockNumber} from the archiver with all components in sync`);
       return undefined;
     }
 
     return {
-      block,
-      blockNumber: block.number,
-      checkpointNumber: block.checkpointNumber,
-      archive: block.archive.root,
+      blockData,
+      blockNumber: blockData.header.getBlockNumber(),
+      checkpointNumber: blockData.checkpointNumber,
+      archive: blockData.archive.root,
       l1Timestamp,
       pendingChainValidationStatus,
     };
@@ -867,6 +863,11 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
     return this.validatorClient?.getValidatorAddresses();
   }
 
+  /** Updates the publisher factory's node keystore adapter after a keystore reload. */
+  public updatePublisherNodeKeyStore(adapter: NodeKeystoreAdapter): void {
+    this.publisherFactory.updateNodeKeyStore(adapter);
+  }
+
   public getConfig() {
     return this.config;
   }
@@ -877,7 +878,7 @@ export class Sequencer extends (EventEmitter as new () => TypedEventEmitter<Sequ
 }
 
 type SequencerSyncCheckResult = {
-  block?: L2Block;
+  blockData?: BlockData;
   checkpointNumber: CheckpointNumber;
   blockNumber: BlockNumber;
   archive: Fr;

package/src/sequencer/timetable.ts

@@ -1,4 +1,4 @@
-import { createLogger } from '@aztec/aztec.js/log';
+import type { Logger } from '@aztec/foundation/log';
 import {
   CHECKPOINT_ASSEMBLE_TIME,
   CHECKPOINT_INITIALIZATION_TIME,
@@ -80,7 +80,7 @@ export class SequencerTimetable {
       enforce: boolean;
     },
     private readonly metrics?: SequencerMetrics,
-    private readonly log = createLogger('sequencer:timetable'),
+    private readonly log?: Logger,
   ) {
     this.ethereumSlotDuration = opts.ethereumSlotDuration;
     this.aztecSlotDuration = opts.aztecSlotDuration;
@@ -132,7 +132,7 @@ export class SequencerTimetable {
     const initializeDeadline = this.aztecSlotDuration - minWorkToDo;
     this.initializeDeadline = initializeDeadline;
 
-    this.log.verbose(
+    this.log?.info(
       `Sequencer timetable initialized with ${this.maxNumberOfBlocks} blocks per slot (${this.enforce ? 'enforced' : 'not enforced'})`,
       {
         ethereumSlotDuration: this.ethereumSlotDuration,
@@ -206,7 +206,7 @@ export class SequencerTimetable {
     }
 
     this.metrics?.recordStateTransitionBufferMs(Math.floor(bufferSeconds * 1000), newState);
-    this.log.trace(`Enough time to transition to ${newState}`, { maxAllowedTime, secondsIntoSlot });
+    this.log?.trace(`Enough time to transition to ${newState}`, { maxAllowedTime, secondsIntoSlot });
   }
 
   /**
@@ -242,7 +242,7 @@ export class SequencerTimetable {
       const canStart = available >= this.minExecutionTime;
       const deadline = secondsIntoSlot + available;
 
-      this.log.verbose(
+      this.log?.verbose(
         `${canStart ? 'Can' : 'Cannot'} start single-block checkpoint at ${secondsIntoSlot}s into slot`,
         { secondsIntoSlot, maxAllowed, available, deadline },
       );
@@ -262,7 +262,7 @@ export class SequencerTimetable {
         // Found an available sub-slot! Is this the last one?
         const isLastBlock = subSlot === this.maxNumberOfBlocks;
 
-        this.log.verbose(
+        this.log?.verbose(
           `Can start ${isLastBlock ? 'last block' : 'block'} in sub-slot ${subSlot} with deadline ${deadline}s`,
           { secondsIntoSlot, deadline, timeUntilDeadline, subSlot, maxBlocks: this.maxNumberOfBlocks },
         );
@@ -272,7 +272,7 @@ export class SequencerTimetable {
     }
 
     // No sub-slots available with enough time
-    this.log.verbose(`No time left to start any more blocks`, {
+    this.log?.verbose(`No time left to start any more blocks`, {
       secondsIntoSlot,
       maxBlocks: this.maxNumberOfBlocks,
       initializationOffset: this.initializationOffset,

package/src/sequencer/types.ts

@@ -3,4 +3,7 @@ import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 export type SequencerRollupConstants = Pick<
   L1RollupConstants,
   'ethereumSlotDuration' | 'l1GenesisTime' | 'slotDuration'
->;
+> & {
+  /** Total L2 gas (mana) allowed per checkpoint. Fetched from L1 getManaLimit(). */
+  rollupManaLimit: number;
+};

package/src/test/index.ts

@@ -1,18 +1,16 @@
-import type { L1TxUtilsWithBlobs } from '@aztec/ethereum/l1-tx-utils-with-blobs';
+import type { L1TxUtils } from '@aztec/ethereum/l1-tx-utils';
 import type { PublisherManager } from '@aztec/ethereum/publisher-manager';
 import type { PublicProcessorFactory } from '@aztec/simulator/server';
 import type { FullNodeCheckpointsBuilder, ValidatorClient } from '@aztec/validator-client';
 
 import { SequencerClient } from '../client/sequencer-client.js';
 import type { SequencerPublisherFactory } from '../publisher/sequencer-publisher-factory.js';
-import type { SequencerPublisher } from '../publisher/sequencer-publisher.js';
 import { Sequencer } from '../sequencer/sequencer.js';
 import type { SequencerTimetable } from '../sequencer/timetable.js';
 
 class TestSequencer_ extends Sequencer {
   declare public publicProcessorFactory: PublicProcessorFactory;
   declare public timetable: SequencerTimetable;
-  declare public publisher: SequencerPublisher;
   declare public publisherFactory: SequencerPublisherFactory;
   declare public validatorClient: ValidatorClient;
   declare public checkpointsBuilder: FullNodeCheckpointsBuilder;
@@ -22,7 +20,7 @@ export type TestSequencer = TestSequencer_;
 
 class TestSequencerClient_ extends SequencerClient {
   declare public sequencer: TestSequencer;
-  declare public publisherManager: PublisherManager<L1TxUtilsWithBlobs>;
+  declare public publisherManager: PublisherManager<L1TxUtils>;
 }
 
 export type TestSequencerClient = TestSequencerClient_;

package/src/test/mock_checkpoint_builder.ts

@@ -1,8 +1,8 @@
-import { type BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { type BlockNumber, CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import { unfreeze } from '@aztec/foundation/types';
 import { L2Block } from '@aztec/stdlib/block';
 import { Checkpoint } from '@aztec/stdlib/checkpoint';
-import { Gas } from '@aztec/stdlib/gas';
 import type {
   FullNodeBlockBuilderConfig,
   ICheckpointBlockBuilder,
@@ -86,8 +86,10 @@ export class MockCheckpointBuilder implements ICheckpointBlockBuilder {
     let usedTxs: Tx[];
 
     if (this.blockProvider) {
-      // Dynamic mode: get block from provider
-      block = this.blockProvider();
+      // Dynamic mode: get block from provider, cloning to avoid shared references across multiple buildBlock calls
+      block = L2Block.fromBuffer(this.blockProvider().toBuffer());
+      block.header.globalVariables.blockNumber = blockNumber;
+      await block.header.recomputeHash();
       usedTxs = [];
       this.builtBlocks.push(block);
     } else {
@@ -113,81 +115,79 @@ export class MockCheckpointBuilder implements ICheckpointBlockBuilder {
 
     return {
       block,
-      publicGas: Gas.empty(),
       publicProcessorDuration: 0,
       numTxs: block?.body?.txEffects?.length ?? usedTxs.length,
       usedTxs,
       failedTxs: [],
-      usedTxBlobFields: block?.body?.txEffects?.reduce((sum, tx) => sum + tx.getNumBlobFields(), 0) ?? 0,
     };
   }
 
   completeCheckpoint(): Promise<Checkpoint> {
     this.completeCheckpointCalled = true;
     const allBlocks = this.blockProvider ? this.builtBlocks : this.blocks;
-    const lastBlock = allBlocks[allBlocks.length - 1];
-    // Create a CheckpointHeader from the last block's header for testing
-    const checkpointHeader = this.createCheckpointHeader(lastBlock);
-    return Promise.resolve(
-      new Checkpoint(
-        makeAppendOnlyTreeSnapshot(lastBlock.header.globalVariables.blockNumber + 1),
-        checkpointHeader,
-        allBlocks,
-        this.checkpointNumber,
-      ),
-    );
+    return this.buildCheckpoint(allBlocks);
   }
 
   getCheckpoint(): Promise<Checkpoint> {
     this.getCheckpointCalled = true;
     const builtBlocks = this.blockProvider ? this.builtBlocks : this.blocks.slice(0, this.blockIndex);
-    const lastBlock = builtBlocks[builtBlocks.length - 1];
-    if (!lastBlock) {
+    if (builtBlocks.length === 0) {
       throw new Error('No blocks built yet');
     }
-    // Create a CheckpointHeader from the last block's header for testing
-    const checkpointHeader = this.createCheckpointHeader(lastBlock);
-    return Promise.resolve(
-      new Checkpoint(
-        makeAppendOnlyTreeSnapshot(lastBlock.header.globalVariables.blockNumber + 1),
-        checkpointHeader,
-        builtBlocks,
-        this.checkpointNumber,
-      ),
-    );
+    return this.buildCheckpoint(builtBlocks);
   }
 
-  /**
-   * Creates a CheckpointHeader from a block's header for testing.
-   * This is a simplified version that creates a minimal CheckpointHeader.
-   */
-  private createCheckpointHeader(block: L2Block): CheckpointHeader {
-    const header = block.header;
-    const gv = header.globalVariables;
-    return CheckpointHeader.empty({
-      lastArchiveRoot: header.lastArchive.root,
-      blockHeadersHash: Fr.random(), // Use random for testing
+  /** Builds a structurally valid Checkpoint from a list of blocks, fixing up indexes and archive chaining. */
+  private async buildCheckpoint(blocks: L2Block[]): Promise<Checkpoint> {
+    // Fix up indexWithinCheckpoint and archive chaining so the checkpoint passes structural validation.
+    for (let i = 0; i < blocks.length; i++) {
+      blocks[i].indexWithinCheckpoint = IndexWithinCheckpoint(i);
+      if (i > 0) {
+        unfreeze(blocks[i].header).lastArchive = blocks[i - 1].archive;
+        await blocks[i].header.recomputeHash();
+      }
+    }
+
+    const firstBlock = blocks[0];
+    const lastBlock = blocks[blocks.length - 1];
+    const gv = firstBlock.header.globalVariables;
+
+    const checkpointHeader = CheckpointHeader.empty({
+      lastArchiveRoot: firstBlock.header.lastArchive.root,
+      blockHeadersHash: Fr.random(),
       slotNumber: gv.slotNumber,
       timestamp: gv.timestamp,
       coinbase: gv.coinbase,
       feeRecipient: gv.feeRecipient,
       gasFees: gv.gasFees,
-      totalManaUsed: header.totalManaUsed,
+      totalManaUsed: lastBlock.header.totalManaUsed,
     });
+
+    return new Checkpoint(
+      makeAppendOnlyTreeSnapshot(lastBlock.header.globalVariables.blockNumber + 1),
+      checkpointHeader,
+      blocks,
+      this.checkpointNumber,
+    );
   }
 
-  /** Reset for reuse in another test */
-  reset(): void {
-    this.blocks = [];
+  /** Resets per-checkpoint state (built blocks, consumed txs) while preserving config (blockProvider, seeded blocks). */
+  resetCheckpointState(): void {
     this.builtBlocks = [];
-    this.usedTxsPerBlock = [];
     this.blockIndex = 0;
-    this.buildBlockCalls = [];
     this.consumedTxHashes.clear();
     this.completeCheckpointCalled = false;
     this.getCheckpointCalled = false;
+  }
+
+  /** Reset for reuse in another test */
+  reset(): void {
+    this.blocks = [];
+    this.usedTxsPerBlock = [];
+    this.buildBlockCalls = [];
     this.errorOnBuild = undefined;
     this.blockProvider = undefined;
+    this.resetCheckpointState();
   }
 }
 
@@ -205,6 +205,7 @@ export class MockCheckpointsBuilder implements ICheckpointsBuilder {
     constants: CheckpointGlobalVariables;
     l1ToL2Messages: Fr[];
     previousCheckpointOutHashes: Fr[];
+    feeAssetPriceModifier: bigint;
   }> = [];
   public openCheckpointCalls: Array<{
     checkpointNumber: CheckpointNumber;
@@ -212,6 +213,7 @@ export class MockCheckpointsBuilder implements ICheckpointsBuilder {
     l1ToL2Messages: Fr[];
     previousCheckpointOutHashes: Fr[];
     existingBlocks: L2Block[];
+    feeAssetPriceModifier: bigint;
   }> = [];
   public updateConfigCalls: Array<Partial<FullNodeBlockBuilderConfig>> = [];
 
@@ -247,6 +249,7 @@ export class MockCheckpointsBuilder implements ICheckpointsBuilder {
       slotDuration: 24,
       l1ChainId: 1,
       rollupVersion: 1,
+      rollupManaLimit: 200_000_000,
     };
   }
 
@@ -257,15 +260,24 @@ export class MockCheckpointsBuilder implements ICheckpointsBuilder {
   startCheckpoint(
     checkpointNumber: CheckpointNumber,
     constants: CheckpointGlobalVariables,
+    feeAssetPriceModifier: bigint,
     l1ToL2Messages: Fr[],
     previousCheckpointOutHashes: Fr[],
     _fork: MerkleTreeWriteOperations,
   ): Promise<ICheckpointBlockBuilder> {
-    this.startCheckpointCalls.push({ checkpointNumber, constants, l1ToL2Messages, previousCheckpointOutHashes });
+    this.startCheckpointCalls.push({
+      checkpointNumber,
+      constants,
+      l1ToL2Messages,
+      previousCheckpointOutHashes,
+      feeAssetPriceModifier,
+    });
 
     if (!this.checkpointBuilder) {
       // Auto-create a builder if none was set
       this.checkpointBuilder = new MockCheckpointBuilder(constants, checkpointNumber);
+    } else {
+      this.checkpointBuilder.resetCheckpointState();
     }
 
     return Promise.resolve(this.checkpointBuilder);
@@ -274,6 +286,7 @@ export class MockCheckpointsBuilder implements ICheckpointsBuilder {
   openCheckpoint(
     checkpointNumber: CheckpointNumber,
     constants: CheckpointGlobalVariables,
+    feeAssetPriceModifier: bigint,
     l1ToL2Messages: Fr[],
     previousCheckpointOutHashes: Fr[],
     _fork: MerkleTreeWriteOperations,
@@ -285,6 +298,7 @@ export class MockCheckpointsBuilder implements ICheckpointsBuilder {
       l1ToL2Messages,
       previousCheckpointOutHashes,
       existingBlocks,
+      feeAssetPriceModifier,
     });
 
     if (!this.checkpointBuilder) {

package/src/test/utils.ts

@@ -56,6 +56,7 @@ export async function makeBlock(txs: Tx[], globalVariables: GlobalVariables): Pr
 export function mockPendingTxs(p2p: MockProxy<P2P>, txs: Tx[]): void {
   p2p.getPendingTxCount.mockResolvedValue(txs.length);
   p2p.iteratePendingTxs.mockImplementation(() => mockTxIterator(Promise.resolve(txs)));
+  p2p.iterateEligiblePendingTxs.mockImplementation(() => mockTxIterator(Promise.resolve(txs)));
 }
 
 /**
@@ -118,10 +119,11 @@ export function createCheckpointProposal(
   block: L2Block,
   checkpointSignature: Signature,
   blockSignature?: Signature,
+  feeAssetPriceModifier: bigint = 0n,
 ): CheckpointProposal {
   const txHashes = block.body.txEffects.map(tx => tx.txHash);
   const checkpointHeader = createCheckpointHeaderFromBlock(block);
-  return new CheckpointProposal(checkpointHeader, block.archive.root, checkpointSignature, {
+  return new CheckpointProposal(checkpointHeader, block.archive.root, feeAssetPriceModifier, checkpointSignature, {
     blockHeader: block.header,
     indexWithinCheckpoint: block.indexWithinCheckpoint,
     txHashes,
@@ -138,9 +140,10 @@ export function createCheckpointAttestation(
   block: L2Block,
   signature: Signature,
   sender: EthAddress,
+  feeAssetPriceModifier: bigint = 0n,
 ): CheckpointAttestation {
   const checkpointHeader = createCheckpointHeaderFromBlock(block);
-  const payload = new ConsensusPayload(checkpointHeader, block.archive.root);
+  const payload = new ConsensusPayload(checkpointHeader, block.archive.root, feeAssetPriceModifier);
   const attestation = new CheckpointAttestation(payload, signature, signature);
   // Set sender directly for testing (bypasses signature recovery)
   (attestation as any).sender = sender;