@aztec/validator-client 0.0.1-commit.1a99e26c → 0.0.1-commit.1bb068fb5

package/dest/validator.js

@@ -1,5 +1,6 @@
 import { getBlobsPerL1Block } from '@aztec/blob-lib';
-import { BlockNumber } from '@aztec/foundation/branded-types';
+import { validateFeeAssetPriceModifier } from '@aztec/ethereum/contracts';
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { TimeoutError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
@@ -8,7 +9,7 @@ import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider } from '@aztec/foundation/timer';
 import { AuthRequest, AuthResponse, BlockProposalValidator, ReqRespSubProtocol } from '@aztec/p2p';
 import { OffenseType, WANT_TO_SLASH_EVENT } from '@aztec/slasher';
-import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import { getEpochAtSlot, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import { accumulateCheckpointOutHashes } from '@aztec/stdlib/messaging';
 import { AttestationTimeoutError } from '@aztec/stdlib/validators';
 import { getTelemetryClient } from '@aztec/telemetry-client';
@@ -48,11 +49,12 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
     log;
     // Whether it has already registered handlers on the p2p client
     hasRegisteredHandlers;
-    // Used to check if we are sending the same proposal twice
-    previousProposal;
+    /** Tracks the last block proposal we created, to detect duplicate proposal attempts. */ lastProposedBlock;
+    /** Tracks the last checkpoint proposal we created. */ lastProposedCheckpoint;
     lastEpochForCommitteeUpdateLoop;
     epochCacheUpdateLoop;
     proposersOfInvalidBlocks;
+    /** Tracks the last checkpoint proposal we attested to, to prevent equivocation. */ lastAttestedProposal;
     constructor(keyStore, epochCache, p2pClient, blockProposalHandler, blockSource, checkpointsBuilder, worldState, l1ToL2MessageSource, config, blobClient, dateProvider = new DateProvider(), telemetry = getTelemetryClient(), log = createLogger('validator')){
         super(), this.keyStore = keyStore, this.epochCache = epochCache, this.p2pClient = p2pClient, this.blockProposalHandler = blockProposalHandler, this.blockSource = blockSource, this.checkpointsBuilder = checkpointsBuilder, this.worldState = worldState, this.l1ToL2MessageSource = l1ToL2MessageSource, this.config = config, this.blobClient = blobClient, this.dateProvider = dateProvider, this.hasRegisteredHandlers = false, this.proposersOfInvalidBlocks = new Set();
         // Create child logger with fisherman prefix if in fisherman mode
@@ -183,6 +185,14 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             // and processed separately via the block handler above.
             const checkpointHandler = (checkpoint, proposalSender)=>this.attestToCheckpointProposal(checkpoint, proposalSender);
             this.p2pClient.registerCheckpointProposalHandler(checkpointHandler);
+            // Duplicate proposal handler - triggers slashing for equivocation
+            this.p2pClient.registerDuplicateProposalCallback((info)=>{
+                this.handleDuplicateProposal(info);
+            });
+            // Duplicate attestation handler - triggers slashing for attestation equivocation
+            this.p2pClient.registerDuplicateAttestationCallback((info)=>{
+                this.handleDuplicateAttestation(info);
+            });
             const myAddresses = this.getValidatorAddresses();
             this.p2pClient.registerThisValidatorAddresses(myAddresses);
             await this.p2pClient.addReqRespSubProtocol(ReqRespSubProtocol.AUTH, this.handleAuthRequest.bind(this));
@@ -203,6 +213,14 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             this.log.warn(`Received block proposal with invalid signature for slot ${slotNumber}`);
             return false;
         }
+        // Ignore proposals from ourselves (may happen in HA setups)
+        if (this.getValidatorAddresses().some((addr)=>addr.equals(proposer))) {
+            this.log.warn(`Ignoring block proposal from self for slot ${slotNumber}`, {
+                proposer: proposer.toString(),
+                slotNumber
+            });
+            return false;
+        }
         // Check if we're in the committee (for metrics purposes)
         const inCommittee = await this.epochCache.filterInCommittee(slotNumber, this.getValidatorAddresses());
         const partOfCommittee = inCommittee.length > 0;
@@ -274,6 +292,19 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             this.log.warn(`Received checkpoint proposal with invalid signature for slot ${slotNumber}`);
             return undefined;
         }
+        // Ignore proposals from ourselves (may happen in HA setups)
+        if (this.getValidatorAddresses().some((addr)=>addr.equals(proposer))) {
+            this.log.warn(`Ignoring block proposal from self for slot ${slotNumber}`, {
+                proposer: proposer.toString(),
+                slotNumber
+            });
+            return undefined;
+        }
+        // Validate fee asset price modifier is within allowed range
+        if (!validateFeeAssetPriceModifier(proposal.feeAssetPriceModifier)) {
+            this.log.warn(`Received checkpoint proposal with invalid feeAssetPriceModifier ${proposal.feeAssetPriceModifier} for slot ${slotNumber}`);
+            return undefined;
+        }
         // Check that I have any address in current committee before attesting
         const inCommittee = await this.epochCache.filterInCommittee(slotNumber, this.getValidatorAddresses());
         const partOfCommittee = inCommittee.length > 0;
@@ -337,11 +368,32 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             });
             return undefined;
         }
-        return this.createCheckpointAttestationsFromProposal(proposal, attestors);
+        return await this.createCheckpointAttestationsFromProposal(proposal, attestors);
+    }
+    /**
+   * Checks if we should attest to a slot based on equivocation prevention rules.
+   * @returns true if we should attest, false if we should skip
+   */ shouldAttestToSlot(slotNumber) {
+        // If attestToEquivocatedProposals is true, always allow
+        if (this.config.attestToEquivocatedProposals) {
+            return true;
+        }
+        // Check if incoming slot is strictly greater than last attested
+        if (this.lastAttestedProposal && slotNumber <= this.lastAttestedProposal.slotNumber) {
+            this.log.warn(`Refusing to process a proposal for slot ${slotNumber} given we already attested to a proposal for slot ${this.lastAttestedProposal.slotNumber}`);
+            return false;
+        }
+        return true;
     }
     async createCheckpointAttestationsFromProposal(proposal, attestors = []) {
+        // Equivocation check: must happen right before signing to minimize the race window
+        if (!this.shouldAttestToSlot(proposal.slotNumber)) {
+            return undefined;
+        }
         const attestations = await this.validationService.attestToCheckpointProposal(proposal, attestors);
-        await this.p2pClient.addCheckpointAttestations(attestations);
+        // Track the proposal we attested to (to prevent equivocation)
+        this.lastAttestedProposal = proposal;
+        await this.p2pClient.addOwnCheckpointAttestations(attestations);
         return attestations;
     }
     /**
@@ -349,7 +401,10 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
    * @returns Validation result with isValid flag and reason if invalid.
    */ async validateCheckpointProposal(proposal, proposalInfo) {
         const slot = proposal.slotNumber;
-        const timeoutSeconds = 10; // TODO(palla/mbps): This should map to the timetable settings
+        // Timeout block syncing at the start of the next slot
+        const config = this.checkpointsBuilder.getConfig();
+        const nextSlotTimestampSeconds = Number(getTimestampForSlot(SlotNumber(slot + 1), config));
+        const timeoutSeconds = Math.max(1, nextSlotTimestampSeconds - Math.floor(this.dateProvider.now() / 1000));
         // Wait for last block to sync by archive
         let lastBlockHeader;
         try {
@@ -408,7 +463,7 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
         const fork = await this.worldState.fork(parentBlockNumber);
         try {
             // Create checkpoint builder with all existing blocks
-            const checkpointBuilder = await this.checkpointsBuilder.openCheckpoint(checkpointNumber, constants, l1ToL2Messages, previousCheckpointOutHashes, fork, blocks, this.log.getBindings());
+            const checkpointBuilder = await this.checkpointsBuilder.openCheckpoint(checkpointNumber, constants, proposal.feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, fork, blocks, this.log.getBindings());
             // Complete the checkpoint to get computed values
             const computedCheckpoint = await checkpointBuilder.completeCheckpoint();
             // Compare checkpoint header with proposal
@@ -524,23 +579,75 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             }
         ]);
     }
+    /**
+   * Handle detection of a duplicate proposal (equivocation).
+   * Emits a slash event when a proposer sends multiple proposals for the same position.
+   */ handleDuplicateProposal(info) {
+        const { slot, proposer, type } = info;
+        this.log.warn(`Triggering slash event for duplicate ${type} proposal from ${proposer.toString()} at slot ${slot}`, {
+            proposer: proposer.toString(),
+            slot,
+            type
+        });
+        // Emit slash event
+        this.emit(WANT_TO_SLASH_EVENT, [
+            {
+                validator: proposer,
+                amount: this.config.slashDuplicateProposalPenalty,
+                offenseType: OffenseType.DUPLICATE_PROPOSAL,
+                epochOrSlot: BigInt(slot)
+            }
+        ]);
+    }
+    /**
+   * Handle detection of a duplicate attestation (equivocation).
+   * Emits a slash event when an attester signs attestations for different proposals at the same slot.
+   */ handleDuplicateAttestation(info) {
+        const { slot, attester } = info;
+        this.log.warn(`Triggering slash event for duplicate attestation from ${attester.toString()} at slot ${slot}`, {
+            attester: attester.toString(),
+            slot
+        });
+        this.emit(WANT_TO_SLASH_EVENT, [
+            {
+                validator: attester,
+                amount: this.config.slashDuplicateAttestationPenalty,
+                offenseType: OffenseType.DUPLICATE_ATTESTATION,
+                epochOrSlot: BigInt(slot)
+            }
+        ]);
+    }
     async createBlockProposal(blockHeader, indexWithinCheckpoint, inHash, archive, txs, proposerAddress, options = {}) {
-        // TODO(palla/mbps): Prevent double proposals properly
-        // if (this.previousProposal?.slotNumber === blockHeader.globalVariables.slotNumber) {
-        //   this.log.verbose(`Already made a proposal for the same slot, skipping proposal`);
-        //   return Promise.resolve(undefined);
-        // }
+        // Validate that we're not creating a proposal for an older or equal position
+        if (this.lastProposedBlock) {
+            const lastSlot = this.lastProposedBlock.slotNumber;
+            const lastIndex = this.lastProposedBlock.indexWithinCheckpoint;
+            const newSlot = blockHeader.globalVariables.slotNumber;
+            if (newSlot < lastSlot || newSlot === lastSlot && indexWithinCheckpoint <= lastIndex) {
+                throw new Error(`Cannot create block proposal for slot ${newSlot} index ${indexWithinCheckpoint}: ` + `already proposed block for slot ${lastSlot} index ${lastIndex}`);
+            }
+        }
         this.log.info(`Assembling block proposal for block ${blockHeader.globalVariables.blockNumber} slot ${blockHeader.globalVariables.slotNumber}`);
         const newProposal = await this.validationService.createBlockProposal(blockHeader, indexWithinCheckpoint, inHash, archive, txs, proposerAddress, {
             ...options,
             broadcastInvalidBlockProposal: this.config.broadcastInvalidBlockProposal
         });
-        this.previousProposal = newProposal;
+        this.lastProposedBlock = newProposal;
         return newProposal;
     }
-    async createCheckpointProposal(checkpointHeader, archive, lastBlockInfo, proposerAddress, options = {}) {
+    async createCheckpointProposal(checkpointHeader, archive, feeAssetPriceModifier, lastBlockInfo, proposerAddress, options = {}) {
+        // Validate that we're not creating a proposal for an older or equal slot
+        if (this.lastProposedCheckpoint) {
+            const lastSlot = this.lastProposedCheckpoint.slotNumber;
+            const newSlot = checkpointHeader.slotNumber;
+            if (newSlot <= lastSlot) {
+                throw new Error(`Cannot create checkpoint proposal for slot ${newSlot}: ` + `already proposed checkpoint for slot ${lastSlot}`);
+            }
+        }
         this.log.info(`Assembling checkpoint proposal for slot ${checkpointHeader.slotNumber}`);
-        return await this.validationService.createCheckpointProposal(checkpointHeader, archive, lastBlockInfo, proposerAddress, options);
+        const newProposal = await this.validationService.createCheckpointProposal(checkpointHeader, archive, feeAssetPriceModifier, lastBlockInfo, proposerAddress, options);
+        this.lastProposedCheckpoint = newProposal;
+        return newProposal;
     }
     async broadcastBlockProposal(proposal) {
         await this.p2pClient.broadcastProposal(proposal);
@@ -555,6 +662,9 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             inCommittee
         });
         const attestations = await this.createCheckpointAttestationsFromProposal(proposal, inCommittee);
+        if (!attestations) {
+            return [];
+        }
         // We broadcast our own attestations to our peers so, in case our block does not get mined on L1,
         // other nodes can see that our validators did attest to this block proposal, and do not slash us
         // due to inactivity for missed attestations.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/validator-client",
-  "version": "0.0.1-commit.1a99e26c",
+  "version": "0.0.1-commit.1bb068fb5",
   "main": "dest/index.js",
   "type": "module",
   "exports": {
@@ -64,30 +64,30 @@
     ]
   },
   "dependencies": {
-    "@aztec/blob-client": "0.0.1-commit.1a99e26c",
-    "@aztec/blob-lib": "0.0.1-commit.1a99e26c",
-    "@aztec/constants": "0.0.1-commit.1a99e26c",
-    "@aztec/epoch-cache": "0.0.1-commit.1a99e26c",
-    "@aztec/ethereum": "0.0.1-commit.1a99e26c",
-    "@aztec/foundation": "0.0.1-commit.1a99e26c",
-    "@aztec/node-keystore": "0.0.1-commit.1a99e26c",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.1a99e26c",
-    "@aztec/p2p": "0.0.1-commit.1a99e26c",
-    "@aztec/protocol-contracts": "0.0.1-commit.1a99e26c",
-    "@aztec/prover-client": "0.0.1-commit.1a99e26c",
-    "@aztec/simulator": "0.0.1-commit.1a99e26c",
-    "@aztec/slasher": "0.0.1-commit.1a99e26c",
-    "@aztec/stdlib": "0.0.1-commit.1a99e26c",
-    "@aztec/telemetry-client": "0.0.1-commit.1a99e26c",
-    "@aztec/validator-ha-signer": "0.0.1-commit.1a99e26c",
+    "@aztec/blob-client": "0.0.1-commit.1bb068fb5",
+    "@aztec/blob-lib": "0.0.1-commit.1bb068fb5",
+    "@aztec/constants": "0.0.1-commit.1bb068fb5",
+    "@aztec/epoch-cache": "0.0.1-commit.1bb068fb5",
+    "@aztec/ethereum": "0.0.1-commit.1bb068fb5",
+    "@aztec/foundation": "0.0.1-commit.1bb068fb5",
+    "@aztec/node-keystore": "0.0.1-commit.1bb068fb5",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.1bb068fb5",
+    "@aztec/p2p": "0.0.1-commit.1bb068fb5",
+    "@aztec/protocol-contracts": "0.0.1-commit.1bb068fb5",
+    "@aztec/prover-client": "0.0.1-commit.1bb068fb5",
+    "@aztec/simulator": "0.0.1-commit.1bb068fb5",
+    "@aztec/slasher": "0.0.1-commit.1bb068fb5",
+    "@aztec/stdlib": "0.0.1-commit.1bb068fb5",
+    "@aztec/telemetry-client": "0.0.1-commit.1bb068fb5",
+    "@aztec/validator-ha-signer": "0.0.1-commit.1bb068fb5",
     "koa": "^2.16.1",
     "koa-router": "^13.1.1",
     "tslib": "^2.4.0",
     "viem": "npm:@aztec/viem@2.38.2"
   },
   "devDependencies": {
-    "@aztec/archiver": "0.0.1-commit.1a99e26c",
-    "@aztec/world-state": "0.0.1-commit.1a99e26c",
+    "@aztec/archiver": "0.0.1-commit.1bb068fb5",
+    "@aztec/world-state": "0.0.1-commit.1bb068fb5",
     "@electric-sql/pglite": "^0.3.14",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",

package/src/block_proposal_handler.ts

@@ -491,6 +491,7 @@ export class BlockProposalHandler {
     const checkpointBuilder = await this.checkpointsBuilder.openCheckpoint(
       checkpointNumber,
       constants,
+      0n, // only takes effect in the following checkpoint.
       l1ToL2Messages,
       previousCheckpointOutHashes,
       fork,

package/src/checkpoint_builder.ts

@@ -3,7 +3,7 @@ import { merge, pick } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { bufferToHex } from '@aztec/foundation/string';
-import { DateProvider, Timer, elapsed } from '@aztec/foundation/timer';
+import { DateProvider, elapsed } from '@aztec/foundation/timer';
 import { getDefaultAllowedSetupFunctions } from '@aztec/p2p/msg_validators';
 import { LightweightCheckpointBuilder } from '@aztec/prover-client/light';
 import {
@@ -24,6 +24,7 @@ import {
   type ICheckpointBlockBuilder,
   type ICheckpointsBuilder,
   type MerkleTreeWriteOperations,
+  NoValidTxsError,
   type PublicProcessorLimits,
   type WorldStateSynchronizer,
 } from '@aztec/stdlib/interfaces/server';
@@ -36,11 +37,6 @@ import { createValidatorForBlockBuilding } from './tx_validator/tx_validator_fac
 // Re-export for backward compatibility
 export type { BuildBlockInCheckpointResult } from '@aztec/stdlib/interfaces/server';
 
-/** Result of building a block within a checkpoint. Extends the base interface with timer. */
-export interface BuildBlockInCheckpointResultWithTimer extends BuildBlockInCheckpointResult {
-  blockBuildingTimer: Timer;
-}
-
 /**
  * Builder for a single checkpoint. Handles building blocks within the checkpoint
  * and completing it.
@@ -75,8 +71,7 @@ export class CheckpointBuilder implements ICheckpointBlockBuilder {
     blockNumber: BlockNumber,
     timestamp: bigint,
     opts: PublicProcessorLimits & { expectedEndState?: StateReference } = {},
-  ): Promise<BuildBlockInCheckpointResultWithTimer> {
-    const blockBuildingTimer = new Timer();
+  ): Promise<BuildBlockInCheckpointResult> {
     const slot = this.checkpointBuilder.constants.slotNumber;
 
     this.log.verbose(`Building block ${blockNumber} for slot ${slot} within checkpoint`, {
@@ -103,6 +98,12 @@ export class CheckpointBuilder implements ICheckpointBlockBuilder {
       processor.process(pendingTxs, opts, validator),
     );
 
+    // Throw if we didn't collect a single valid tx and we're not allowed to build empty blocks
+    // (only the first block in a checkpoint can be empty)
+    if (processedTxs.length === 0 && this.checkpointBuilder.getBlockCount() > 0) {
+      throw new NoValidTxsError(failedTxs);
+    }
+
     // Add block to checkpoint
     const block = await this.checkpointBuilder.addBlock(globalVariables, processedTxs, {
       expectedEndState: opts.expectedEndState,
@@ -111,18 +112,21 @@ export class CheckpointBuilder implements ICheckpointBlockBuilder {
     // How much public gas was processed
     const publicGas = processedTxs.reduce((acc, tx) => acc.add(tx.gasUsed.publicGas), Gas.empty());
 
-    const res = {
+    this.log.debug('Built block within checkpoint', {
+      header: block.header.toInspect(),
+      processedTxs: processedTxs.map(tx => tx.hash.toString()),
+      failedTxs: failedTxs.map(tx => tx.tx.txHash.toString()),
+    });
+
+    return {
       block,
       publicGas,
       publicProcessorDuration,
       numTxs: processedTxs.length,
       failedTxs,
-      blockBuildingTimer,
       usedTxs,
       usedTxBlobFields,
     };
-    this.log.debug('Built block within checkpoint', res.block.header);
-    return res;
   }
 
   /** Completes the checkpoint and returns it. */
@@ -211,6 +215,7 @@ export class FullNodeCheckpointsBuilder implements ICheckpointsBuilder {
   async startCheckpoint(
     checkpointNumber: CheckpointNumber,
     constants: CheckpointGlobalVariables,
+    feeAssetPriceModifier: bigint,
     l1ToL2Messages: Fr[],
     previousCheckpointOutHashes: Fr[],
     fork: MerkleTreeWriteOperations,
@@ -225,6 +230,7 @@ export class FullNodeCheckpointsBuilder implements ICheckpointsBuilder {
       initialStateReference: stateReference.toInspect(),
       initialArchiveRoot: bufferToHex(archiveTree.root),
       constants,
+      feeAssetPriceModifier,
     });
 
     const lightweightBuilder = await LightweightCheckpointBuilder.startNewCheckpoint(
@@ -234,6 +240,7 @@ export class FullNodeCheckpointsBuilder implements ICheckpointsBuilder {
       previousCheckpointOutHashes,
       fork,
       bindings,
+      feeAssetPriceModifier,
     );
 
     return new CheckpointBuilder(
@@ -253,6 +260,7 @@ export class FullNodeCheckpointsBuilder implements ICheckpointsBuilder {
   async openCheckpoint(
     checkpointNumber: CheckpointNumber,
     constants: CheckpointGlobalVariables,
+    feeAssetPriceModifier: bigint,
     l1ToL2Messages: Fr[],
     previousCheckpointOutHashes: Fr[],
     fork: MerkleTreeWriteOperations,
@@ -266,6 +274,7 @@ export class FullNodeCheckpointsBuilder implements ICheckpointsBuilder {
       return this.startCheckpoint(
         checkpointNumber,
         constants,
+        feeAssetPriceModifier,
         l1ToL2Messages,
         previousCheckpointOutHashes,
         fork,
@@ -280,11 +289,13 @@ export class FullNodeCheckpointsBuilder implements ICheckpointsBuilder {
       initialStateReference: stateReference.toInspect(),
       initialArchiveRoot: bufferToHex(archiveTree.root),
       constants,
+      feeAssetPriceModifier,
     });
 
     const lightweightBuilder = await LightweightCheckpointBuilder.resumeCheckpoint(
       checkpointNumber,
       constants,
+      feeAssetPriceModifier,
       l1ToL2Messages,
       previousCheckpointOutHashes,
       fork,

package/src/config.ts

@@ -73,6 +73,10 @@ export const validatorClientConfigMappings: ConfigMappingsType<ValidatorClientCo
     description: 'Skip pushing re-executed blocks to archiver (default: false)',
     defaultValue: false,
   },
+  attestToEquivocatedProposals: {
+    description: 'Agree to attest to equivocated checkpoint proposals (for testing purposes only)',
+    ...booleanConfigHelper(false),
+  },
   ...validatorHASignerConfigMappings,
 };
 

package/src/duties/validation_service.ts

@@ -95,6 +95,7 @@ export class ValidationService {
   public createCheckpointProposal(
     checkpointHeader: CheckpointHeader,
     archive: Fr,
+    feeAssetPriceModifier: bigint,
     lastBlockInfo: CreateCheckpointProposalLastBlockData | undefined,
     proposerAttesterAddress: EthAddress | undefined,
     options: CheckpointProposalOptions,
@@ -119,7 +120,13 @@ export class ValidationService {
       txs: options.publishFullTxs ? lastBlockInfo.txs : undefined,
     };
 
-    return CheckpointProposal.createProposalFromSigner(checkpointHeader, archive, lastBlock, payloadSigner);
+    return CheckpointProposal.createProposalFromSigner(
+      checkpointHeader,
+      archive,
+      feeAssetPriceModifier,
+      lastBlock,
+      payloadSigner,
+    );
   }
 
   /**
@@ -137,7 +144,7 @@ export class ValidationService {
     attestors: EthAddress[],
   ): Promise<CheckpointAttestation[]> {
     // Create the attestation payload from the checkpoint proposal
-    const payload = new ConsensusPayload(proposal.checkpointHeader, proposal.archive);
+    const payload = new ConsensusPayload(proposal.checkpointHeader, proposal.archive, proposal.feeAssetPriceModifier);
     const buf = Buffer32.fromBuffer(
       keccak256(payload.getPayloadToSign(SignatureDomainSeparator.checkpointAttestation)),
     );

package/src/key_store/ha_key_store.ts

@@ -256,8 +256,8 @@ export class HAKeyStore implements ExtendedValidatorKeyStore {
   /**
    * Start the high-availability key store
    */
-  public start(): Promise<void> {
-    return Promise.resolve(this.haSigner.start());
+  public async start() {
+    await this.haSigner.start();
   }
 
   /**