@lodestar/validator 1.39.0-dev.3bf4734ba9 → 1.39.0-dev.4263377242

package/src/services/attestation.ts

@@ -1,8 +1,8 @@
-import {ApiClient, routes} from "@lodestar/api";
+import {ApiClient} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
 import {ForkName, isForkPostElectra} from "@lodestar/params";
-import {computeEpochAtSlot, isAggregatorFromCommitteeLength} from "@lodestar/state-transition";
-import {BLSSignature, SignedAggregateAndProof, SingleAttestation, Slot, phase0, ssz} from "@lodestar/types";
+import {computeEpochAtSlot} from "@lodestar/state-transition";
+import {SignedAggregateAndProof, SingleAttestation, Slot, phase0, ssz} from "@lodestar/types";
 import {prettyBytes, sleep, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../metrics.js";
 import {PubkeyHex} from "../types.js";
@@ -75,18 +75,6 @@ export class AttestationService {
     }
     const fork = this.config.getForkName(slot);
 
-    if (this.opts?.distributedAggregationSelection) {
-      // Validator in distributed cluster only has a key share, not the full private key.
-      // The partial selection proofs must be exchanged for combined selection proofs by
-      // calling submitBeaconCommitteeSelections on the distributed validator middleware client.
-      // This will run in parallel to other attestation tasks but must be finished before starting
-      // attestation aggregation as it is required to correctly determine if validator is aggregator
-      // and to produce a AggregateAndProof that can be threshold aggregated by the middleware client.
-      this.runDistributedAggregationSelectionTasks(fork, duties, slot, signal).catch((e) =>
-        this.logger.error("Error on attestation aggregation selection", {slot}, e)
-      );
-    }
-
     // A validator should create and broadcast the attestation to the associated attestation subnet when either
     // (a) the validator has received a valid block from the expected block proposer for the assigned slot or
     // (b) ATTESTATION_DUE_BPS of the slot has transpired -- whichever comes first.
@@ -274,89 +262,4 @@ export class AttestationService {
       }
     }
   }
-
-  /**
-   * Performs additional attestation aggregation tasks required if validator is part of distributed cluster
-   *
-   * 1. Exchange partial for combined selection proofs
-   * 2. Determine validators that should aggregate attestations
-   * 3. Mutate duty objects to set selection proofs for aggregators
-   * 4. Resubscribe validators as aggregators on beacon committee subnets
-   *
-   * See https://docs.google.com/document/d/1q9jOTPcYQa-3L8luRvQJ-M0eegtba4Nmon3dpO79TMk/mobilebasic
-   */
-  private async runDistributedAggregationSelectionTasks(
-    fork: ForkName,
-    duties: AttDutyAndProof[],
-    slot: number,
-    signal: AbortSignal
-  ): Promise<void> {
-    const partialSelections: routes.validator.BeaconCommitteeSelection[] = duties.map(
-      ({duty, partialSelectionProof}) => ({
-        validatorIndex: duty.validatorIndex,
-        slot,
-        selectionProof: partialSelectionProof as BLSSignature,
-      })
-    );
-
-    this.logger.debug("Submitting partial beacon committee selection proofs", {slot, count: partialSelections.length});
-
-    const res = await Promise.race([
-      this.api.validator.submitBeaconCommitteeSelections({selections: partialSelections}),
-      // Exit attestation aggregation flow if there is no response after ATTESTATION_DUE_BPS of the slot as
-      // beacon node would likely not have enough time to prepare an aggregate attestation.
-      // Note that the aggregations flow is not explicitly exited but rather will be skipped
-      // due to the fact that calculation of `is_aggregator` in AttestationDutiesService is not done
-      // and selectionProof is set to null, meaning no validator will be considered an aggregator.
-      sleep(this.config.getAttestationDueMs(fork) - this.clock.msFromSlot(slot), signal),
-    ]);
-
-    if (!res) {
-      throw new Error("Failed to receive combined selection proofs before ATTESTATION_DUE_BPS of the slot");
-    }
-
-    const combinedSelections = res.value();
-    this.logger.debug("Received combined beacon committee selection proofs", {slot, count: combinedSelections.length});
-
-    const beaconCommitteeSubscriptions: routes.validator.BeaconCommitteeSubscription[] = [];
-
-    for (const dutyAndProof of duties) {
-      const {validatorIndex, committeeIndex, committeeLength, committeesAtSlot} = dutyAndProof.duty;
-      const logCtxValidator = {slot, index: committeeIndex, validatorIndex};
-
-      const combinedSelection = combinedSelections.find((s) => s.validatorIndex === validatorIndex && s.slot === slot);
-
-      if (!combinedSelection) {
-        this.logger.warn("Did not receive combined beacon committee selection proof", logCtxValidator);
-        continue;
-      }
-
-      const isAggregator = isAggregatorFromCommitteeLength(committeeLength, combinedSelection.selectionProof);
-
-      if (isAggregator) {
-        // Update selection proof by mutating duty object
-        dutyAndProof.selectionProof = combinedSelection.selectionProof;
-
-        // Only push subnet subscriptions with `isAggregator=true` as all validators
-        // with duties for slot are already subscribed to subnets with `isAggregator=false`.
-        beaconCommitteeSubscriptions.push({
-          validatorIndex,
-          committeesAtSlot,
-          committeeIndex,
-          slot,
-          isAggregator,
-        });
-        this.logger.debug("Resubscribing validator as aggregator on beacon committee subnet", logCtxValidator);
-      }
-    }
-
-    // If there are any subscriptions with aggregators, push them out to the beacon node.
-    if (beaconCommitteeSubscriptions.length > 0) {
-      (await this.api.validator.prepareBeaconCommitteeSubnet({subscriptions: beaconCommitteeSubscriptions})).assertOk();
-      this.logger.debug("Resubscribed validators as aggregators on beacon committee subnets", {
-        slot,
-        count: beaconCommitteeSubscriptions.length,
-      });
-    }
-  }
 }

package/src/services/attestationDuties.ts

@@ -204,6 +204,17 @@ export class AttestationDutiesService {
     for (const epoch of [currentEpoch, nextEpoch]) {
       const epochDuties = this.dutiesByIndexByEpoch.get(epoch)?.dutiesByIndex;
       if (epochDuties) {
+        if (this.opts?.distributedAggregationSelection) {
+          // Validator in distributed cluster only has a key share, not the full private key.
+          // The partial selection proofs must be exchanged for combined selection proofs by
+          // calling submitBeaconCommitteeSelections on the distributed validator middleware client.
+          // This is required to correctly determine if validator is aggregator and to produce
+          // a AggregateAndProof that can be threshold aggregated by the middleware client.
+          await this.runDistributedAggregationSelectionTasks(Array.from(epochDuties.values()), epoch).catch((e) =>
+            this.logger.debug("Error on attestation aggregation selection", {epoch}, e)
+          );
+        }
+
         for (const {duty, selectionProof} of epochDuties.values()) {
           if (indexSet.has(duty.validatorIndex)) {
             beaconCommitteeSubscriptions.push({
@@ -367,6 +378,12 @@ export class AttestationDutiesService {
     const epochDuties = this.dutiesByIndexByEpoch.get(dutyEpoch)?.dutiesByIndex;
 
     if (epochDuties) {
+      if (this.opts?.distributedAggregationSelection) {
+        await this.runDistributedAggregationSelectionTasks(Array.from(epochDuties.values()), dutyEpoch).catch((e) =>
+          this.logger.debug("Error on attestation aggregation selection after duties reorg", logContext, e)
+        );
+      }
+
       for (const {duty, selectionProof} of epochDuties.values()) {
         beaconCommitteeSubscriptions.push({
           validatorIndex: duty.validatorIndex,
@@ -403,8 +420,8 @@ export class AttestationDutiesService {
     if (this.opts?.distributedAggregationSelection) {
       // Validator in distributed cluster only has a key share, not the full private key.
       // Passing a partial selection proof to `is_aggregator` would produce incorrect result.
-      // AttestationService will exchange partial for combined selection proofs retrieved from
-      // distributed validator middleware client and determine aggregators at beginning of every slot.
+      // Before subscribing to beacon committee subnets, aggregators are determined by exchanging
+      // partial for combined selection proofs retrieved from distributed validator middleware client.
       return {duty, selectionProof: null, partialSelectionProof: selectionProof};
     }
 
@@ -427,4 +444,64 @@ export class AttestationDutiesService {
       }
     }
   }
+
+  /**
+   * Performs additional attestation aggregation tasks required if validator is part of distributed cluster
+   *
+   * 1. Exchange partial for combined selection proofs
+   * 2. Determine validators that should aggregate attestations
+   * 3. Mutate duty objects to set selection proofs for aggregators
+   */
+  private async runDistributedAggregationSelectionTasks(duties: AttDutyAndProof[], epoch: Epoch): Promise<void> {
+    if (duties.length === 0) {
+      return;
+    }
+
+    const partialSelections: routes.validator.BeaconCommitteeSelection[] = duties.map(
+      ({duty, partialSelectionProof}) => ({
+        validatorIndex: duty.validatorIndex,
+        slot: duty.slot,
+        selectionProof: partialSelectionProof as BLSSignature,
+      })
+    );
+
+    this.logger.debug("Submitting partial beacon committee selection proofs", {epoch, count: partialSelections.length});
+
+    const res = await this.api.validator.submitBeaconCommitteeSelections({selections: partialSelections});
+
+    const combinedSelections = new Map<ValidatorIndex, routes.validator.BeaconCommitteeSelection>();
+    for (const selection of res.value()) {
+      combinedSelections.set(selection.validatorIndex, selection);
+    }
+    this.logger.debug("Received combined beacon committee selection proofs", {epoch, count: combinedSelections.size});
+
+    for (const dutyAndProof of duties) {
+      const {slot, validatorIndex, committeeIndex, committeeLength} = dutyAndProof.duty;
+      const logCtxValidator = {slot, index: committeeIndex, validatorIndex};
+
+      const combinedSelection = combinedSelections.get(validatorIndex);
+
+      if (!combinedSelection) {
+        this.logger.debug("Did not receive combined beacon committee selection proof", logCtxValidator);
+        continue;
+      }
+
+      if (combinedSelection.slot !== slot) {
+        this.logger.debug("Received combined beacon committee selection proof for different slot", {
+          expected: slot,
+          actual: combinedSelection.slot,
+          index: committeeIndex,
+          validatorIndex,
+        });
+        continue;
+      }
+
+      const isAggregator = isAggregatorFromCommitteeLength(committeeLength, combinedSelection.selectionProof);
+
+      if (isAggregator) {
+        // Update selection proof by mutating duty object
+        dutyAndProof.selectionProof = combinedSelection.selectionProof;
+      }
+    }
+  }
 }

package/src/services/syncCommittee.ts

@@ -1,8 +1,7 @@
-import {ApiClient, routes} from "@lodestar/api";
+import {ApiClient} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
 import {ForkName, isForkPostAltair} from "@lodestar/params";
-import {isSyncCommitteeAggregator} from "@lodestar/state-transition";
-import {BLSSignature, CommitteeIndex, Root, Slot, altair} from "@lodestar/types";
+import {CommitteeIndex, Root, Slot, altair} from "@lodestar/types";
 import {sleep} from "@lodestar/utils";
 import {Metrics} from "../metrics.js";
 import {PubkeyHex} from "../types.js";
@@ -73,18 +72,6 @@ export class SyncCommitteeService {
         return;
       }
 
-      if (this.opts?.distributedAggregationSelection) {
-        // Validator in distributed cluster only has a key share, not the full private key.
-        // The partial selection proofs must be exchanged for combined selection proofs by
-        // calling submitSyncCommitteeSelections on the distributed validator middleware client.
-        // This will run in parallel to other sync committee tasks but must be finished before starting
-        // sync committee contributions as it is required to correctly determine if validator is aggregator
-        // and to produce a ContributionAndProof that can be threshold aggregated by the middleware client.
-        this.runDistributedAggregationSelectionTasks(fork, dutiesAtSlot, slot, signal).catch((e) =>
-          this.logger.error("Error on sync committee aggregation selection", {slot}, e)
-        );
-      }
-
       // unlike Attestation, SyncCommitteeSignature could be published asap
       // especially with lodestar, it's very busy at ATTESTATION_DUE_BPS of the slot
       // see https://github.com/ChainSafe/lodestar/issues/4608
@@ -257,82 +244,4 @@ export class SyncCommitteeService {
       }
     }
   }
-
-  /**
-   * Performs additional sync committee contribution tasks required if validator is part of distributed cluster
-   *
-   * 1. Exchange partial for combined selection proofs
-   * 2. Determine validators that should produce sync committee contribution
-   * 3. Mutate duty objects to set selection proofs for aggregators
-   *
-   * See https://docs.google.com/document/d/1q9jOTPcYQa-3L8luRvQJ-M0eegtba4Nmon3dpO79TMk/mobilebasic
-   */
-  private async runDistributedAggregationSelectionTasks(
-    fork: ForkName,
-    duties: SyncDutyAndProofs[],
-    slot: number,
-    signal: AbortSignal
-  ): Promise<void> {
-    const partialSelections: routes.validator.SyncCommitteeSelection[] = [];
-
-    for (const {duty, selectionProofs} of duties) {
-      const validatorSelections: routes.validator.SyncCommitteeSelection[] = selectionProofs.map(
-        ({subcommitteeIndex, partialSelectionProof}) => ({
-          validatorIndex: duty.validatorIndex,
-          slot,
-          subcommitteeIndex,
-          selectionProof: partialSelectionProof as BLSSignature,
-        })
-      );
-      partialSelections.push(...validatorSelections);
-    }
-
-    this.logger.debug("Submitting partial sync committee selection proofs", {slot, count: partialSelections.length});
-
-    const res = await Promise.race([
-      this.api.validator.submitSyncCommitteeSelections({selections: partialSelections}),
-      // Exit sync committee contributions flow if there is no response after CONTRIBUTION_DUE_BPS of the slot.
-      // This is in contrast to attestations aggregations flow which is already exited at ATTESTATION_DUE_BPS of the slot
-      // because for sync committee is not required to resubscribe to subnets as beacon node will assume
-      // validator always aggregates. This allows us to wait until we have to produce sync committee contributions.
-      // Note that the sync committee contributions flow is not explicitly exited but rather will be skipped
-      // due to the fact that calculation of `is_sync_committee_aggregator` in SyncCommitteeDutiesService is not done
-      // and selectionProof is set to null, meaning no validator will be considered an aggregator.
-      sleep(this.config.getSyncContributionDueMs(fork) - this.clock.msFromSlot(slot), signal),
-    ]);
-
-    if (!res) {
-      throw new Error("Failed to receive combined selection proofs before CONTRIBUTION_DUE_BPS of the slot");
-    }
-
-    const combinedSelections = res.value();
-    this.logger.debug("Received combined sync committee selection proofs", {slot, count: combinedSelections.length});
-
-    for (const dutyAndProofs of duties) {
-      const {validatorIndex, subnets} = dutyAndProofs.duty;
-
-      for (const subnet of subnets) {
-        const logCtxValidator = {slot, index: subnet, validatorIndex};
-
-        const combinedSelection = combinedSelections.find(
-          (s) => s.validatorIndex === validatorIndex && s.slot === slot && s.subcommitteeIndex === subnet
-        );
-
-        if (!combinedSelection) {
-          this.logger.warn("Did not receive combined sync committee selection proof", logCtxValidator);
-          continue;
-        }
-
-        const isAggregator = isSyncCommitteeAggregator(combinedSelection.selectionProof);
-
-        if (isAggregator) {
-          const selectionProofObject = dutyAndProofs.selectionProofs.find((p) => p.subcommitteeIndex === subnet);
-          if (selectionProofObject) {
-            // Update selection proof by mutating proof objects in duty object
-            selectionProofObject.selectionProof = combinedSelection.selectionProof;
-          }
-        }
-      }
-    }
-  }
 }

package/src/services/syncCommitteeDuties.ts

@@ -85,7 +85,7 @@ export class SyncCommitteeDutiesService {
     private readonly config: ChainForkConfig,
     private readonly logger: LoggerVc,
     private readonly api: ApiClient,
-    clock: IClock,
+    private readonly clock: IClock,
     private readonly validatorStore: ValidatorStore,
     syncingStatusTracker: SyncingStatusTracker,
     metrics: Metrics | null,
@@ -134,6 +134,18 @@ export class SyncCommitteeDutiesService {
           selectionProofs: await this.getSelectionProofs(slot, dutyAtPeriod.duty),
         });
       }
+
+      if (this.opts?.distributedAggregationSelection) {
+        // Validator in distributed cluster only has a key share, not the full private key.
+        // The partial selection proofs must be exchanged for combined selection proofs by
+        // calling submitSyncCommitteeSelections on the distributed validator middleware client.
+        // This will run in parallel to other sync committee tasks but must be finished before starting
+        // sync committee contributions as it is required to correctly determine if validator is aggregator
+        // and to produce a ContributionAndProof that can be threshold aggregated by the middleware client.
+        this.runDistributedAggregationSelectionTasks(duties, slot).catch((e) =>
+          this.logger.debug("Error on sync committee aggregation selection", {slot}, e)
+        );
+      }
     }
 
     return duties;
@@ -307,8 +319,8 @@ export class SyncCommitteeDutiesService {
       if (this.opts?.distributedAggregationSelection) {
         // Validator in distributed cluster only has a key share, not the full private key.
         // Passing a partial selection proof to `is_sync_committee_aggregator` would produce incorrect result.
-        // SyncCommitteeService will exchange partial for combined selection proofs retrieved from
-        // distributed validator middleware client and determine aggregators at beginning of every slot.
+        // For all duties in the slot, aggregators are determined by exchanging partial for combined selection
+        // proofs retrieved from distributed validator middleware client at beginning of every slot.
         dutiesAndProofs.push({
           selectionProof: null,
           partialSelectionProof: selectionProof,
@@ -334,4 +346,74 @@ export class SyncCommitteeDutiesService {
       }
     }
   }
+
+  /**
+   * Performs additional sync committee contribution tasks required if validator is part of distributed cluster
+   *
+   * 1. Exchange partial for combined selection proofs
+   * 2. Determine validators that should produce sync committee contribution
+   * 3. Mutate duty objects to set selection proofs for aggregators
+   */
+  private async runDistributedAggregationSelectionTasks(duties: SyncDutyAndProofs[], slot: number): Promise<void> {
+    if (duties.length === 0) {
+      return;
+    }
+
+    const partialSelections: routes.validator.SyncCommitteeSelection[] = [];
+
+    for (const {duty, selectionProofs} of duties) {
+      const validatorSelections: routes.validator.SyncCommitteeSelection[] = selectionProofs.map(
+        ({subcommitteeIndex, partialSelectionProof}) => ({
+          validatorIndex: duty.validatorIndex,
+          slot,
+          subcommitteeIndex,
+          selectionProof: partialSelectionProof as BLSSignature,
+        })
+      );
+      partialSelections.push(...validatorSelections);
+    }
+
+    this.logger.debug("Submitting partial sync committee selection proofs", {slot, count: partialSelections.length});
+
+    const res = await this.api.validator.submitSyncCommitteeSelections(
+      {selections: partialSelections},
+      {
+        // Exit sync committee contributions flow if there is no response until CONTRIBUTION_DUE_BPS of the slot.
+        // Note that the sync committee contributions flow is not explicitly exited but rather will be skipped
+        // due to the fact that calculation of `is_sync_committee_aggregator` in SyncCommitteeDutiesService is not done
+        // and selectionProof is set to null, meaning no validator will be considered an aggregator.
+        timeoutMs: this.config.getSyncContributionDueMs(this.config.getForkName(slot)) - this.clock.msFromSlot(slot),
+      }
+    );
+
+    const combinedSelections = res.value();
+    this.logger.debug("Received combined sync committee selection proofs", {slot, count: combinedSelections.length});
+
+    for (const dutyAndProofs of duties) {
+      const {validatorIndex, subnets} = dutyAndProofs.duty;
+
+      for (const subnet of subnets) {
+        const logCtxValidator = {slot, index: subnet, validatorIndex};
+
+        const combinedSelection = combinedSelections.find(
+          (s) => s.validatorIndex === validatorIndex && s.slot === slot && s.subcommitteeIndex === subnet
+        );
+
+        if (!combinedSelection) {
+          this.logger.debug("Did not receive combined sync committee selection proof", logCtxValidator);
+          continue;
+        }
+
+        const isAggregator = isSyncCommitteeAggregator(combinedSelection.selectionProof);
+
+        if (isAggregator) {
+          const selectionProofObject = dutyAndProofs.selectionProofs.find((p) => p.subcommitteeIndex === subnet);
+          if (selectionProofObject) {
+            // Update selection proof by mutating proof objects in duty object
+            selectionProofObject.selectionProof = combinedSelection.selectionProof;
+          }
+        }
+      }
+    }
+  }
 }

package/src/services/validatorStore.ts

@@ -53,7 +53,7 @@ import {DoppelgangerService} from "./doppelgangerService.js";
 import {IndicesService} from "./indices.js";
 
 type BLSPubkeyMaybeHex = BLSPubkey | PubkeyHex;
-type Eth1Address = string;
+type ExecutionAddress = string;
 
 export enum SignerType {
   Local,
@@ -74,7 +74,7 @@ export type SignerRemote = {
 type DefaultProposerConfig = {
   graffiti?: string;
   strictFeeRecipientCheck: boolean;
-  feeRecipient: Eth1Address;
+  feeRecipient: ExecutionAddress;
   builder: {
     gasLimit: number;
     selection: routes.validator.BuilderSelection;
@@ -85,7 +85,7 @@ type DefaultProposerConfig = {
 export type ProposerConfig = {
   graffiti?: string;
   strictFeeRecipientCheck?: boolean;
-  feeRecipient?: Eth1Address;
+  feeRecipient?: ExecutionAddress;
   builder?: {
     gasLimit?: number;
     selection?: routes.validator.BuilderSelection;
@@ -219,7 +219,7 @@ export class ValidatorStore {
       : this.indicesService.pollValidatorIndices(Array.from(this.validators.keys()));
   }
 
-  getFeeRecipient(pubkeyHex: PubkeyHex): Eth1Address {
+  getFeeRecipient(pubkeyHex: PubkeyHex): ExecutionAddress {
     const validatorData = this.validators.get(pubkeyHex);
     if (validatorData === undefined) {
       throw Error(`Validator pubkey ${pubkeyHex} not known`);
@@ -227,12 +227,12 @@ export class ValidatorStore {
     return validatorData.feeRecipient ?? this.defaultProposerConfig.feeRecipient;
   }
 
-  getFeeRecipientByIndex(index: ValidatorIndex): Eth1Address {
+  getFeeRecipientByIndex(index: ValidatorIndex): ExecutionAddress {
     const pubkey = this.indicesService.index2pubkey.get(index);
     return pubkey ? this.getFeeRecipient(pubkey) : this.defaultProposerConfig.feeRecipient;
   }
 
-  setFeeRecipient(pubkeyHex: PubkeyHex, feeRecipient: Eth1Address): void {
+  setFeeRecipient(pubkeyHex: PubkeyHex, feeRecipient: ExecutionAddress): void {
     const validatorData = this.validators.get(pubkeyHex);
     if (validatorData === undefined) {
       throw Error(`Validator pubkey ${pubkeyHex} not known`);
@@ -696,7 +696,7 @@ export class ValidatorStore {
 
   async signValidatorRegistration(
     pubkeyMaybeHex: BLSPubkeyMaybeHex,
-    regAttributes: {feeRecipient: Eth1Address; gasLimit: number},
+    regAttributes: {feeRecipient: ExecutionAddress; gasLimit: number},
     _slot: Slot
   ): Promise<bellatrix.SignedValidatorRegistrationV1> {
     const pubkey = typeof pubkeyMaybeHex === "string" ? fromHex(pubkeyMaybeHex) : pubkeyMaybeHex;
@@ -727,7 +727,7 @@ export class ValidatorStore {
 
   async getValidatorRegistration(
     pubkeyMaybeHex: BLSPubkeyMaybeHex,
-    regAttributes: {feeRecipient: Eth1Address; gasLimit: number},
+    regAttributes: {feeRecipient: ExecutionAddress; gasLimit: number},
     slot: Slot
   ): Promise<bellatrix.SignedValidatorRegistrationV1> {
     const pubkeyHex = typeof pubkeyMaybeHex === "string" ? pubkeyMaybeHex : toPubkeyHex(pubkeyMaybeHex);

package/src/util/externalSignerClient.ts

@@ -1,6 +1,6 @@
 import {ContainerType, ValueOf} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
-import {ForkPreBellatrix, ForkSeq} from "@lodestar/params";
+import {ForkName, ForkPreBellatrix, ForkSeq, isForkPostDeneb} from "@lodestar/params";
 import {blindedOrFullBlockToHeader, computeEpochAtSlot} from "@lodestar/state-transition";
 import {
   AggregateAndProof,
@@ -11,7 +11,6 @@ import {
   RootHex,
   Slot,
   altair,
-  capella,
   phase0,
   ssz,
   sszTypesFor,
@@ -33,7 +32,6 @@ export enum SignableMessageType {
   SYNC_COMMITTEE_SELECTION_PROOF = "SYNC_COMMITTEE_SELECTION_PROOF",
   SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF = "SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF",
   VALIDATOR_REGISTRATION = "VALIDATOR_REGISTRATION",
-  BLS_TO_EXECUTION_CHANGE = "BLS_TO_EXECUTION_CHANGE",
 }
 
 const AggregationSlotType = new ContainerType({
@@ -82,8 +80,7 @@ export type SignableMessage =
   | {type: SignableMessageType.SYNC_COMMITTEE_MESSAGE; data: ValueOf<typeof SyncCommitteeMessageType>}
   | {type: SignableMessageType.SYNC_COMMITTEE_SELECTION_PROOF; data: ValueOf<typeof SyncAggregatorSelectionDataType>}
   | {type: SignableMessageType.SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF; data: altair.ContributionAndProof}
-  | {type: SignableMessageType.VALIDATOR_REGISTRATION; data: ValidatorRegistrationV1}
-  | {type: SignableMessageType.BLS_TO_EXECUTION_CHANGE; data: capella.BLSToExecutionChange};
+  | {type: SignableMessageType.VALIDATOR_REGISTRATION; data: ValidatorRegistrationV1};
 
 const requiresForkInfo: Record<SignableMessageType, boolean> = {
   [SignableMessageType.AGGREGATION_SLOT]: true,
@@ -98,7 +95,6 @@ const requiresForkInfo: Record<SignableMessageType, boolean> = {
   [SignableMessageType.SYNC_COMMITTEE_SELECTION_PROOF]: true,
   [SignableMessageType.SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF]: true,
   [SignableMessageType.VALIDATOR_REGISTRATION]: false,
-  [SignableMessageType.BLS_TO_EXECUTION_CHANGE]: true,
 };
 
 type Web3SignerSerializedRequest = {
@@ -147,12 +143,12 @@ export async function externalSignerPostSignature(
   requestObj.signingRoot = toRootHex(signingRoot);
 
   if (requiresForkInfo[signableMessage.type]) {
-    const forkInfo = config.getForkInfo(signingSlot);
+    const forkInfo = getForkInfoForSigning(config, signingSlot, signableMessage.type);
     requestObj.fork_info = {
       fork: {
         previous_version: toHex(forkInfo.prevVersion),
         current_version: toHex(forkInfo.version),
-        epoch: String(computeEpochAtSlot(signingSlot)),
+        epoch: String(forkInfo.epoch),
       },
       genesis_validators_root: toRootHex(config.genesisValidatorsRoot),
     };
@@ -270,8 +266,30 @@ function serializerSignableMessagePayload(config: BeaconConfig, payload: Signabl
 
     case SignableMessageType.VALIDATOR_REGISTRATION:
       return {validator_registration: ssz.bellatrix.ValidatorRegistrationV1.toJson(payload.data)};
+  }
+}
 
-    case SignableMessageType.BLS_TO_EXECUTION_CHANGE:
-      return {BLS_TO_EXECUTION_CHANGE: ssz.capella.BLSToExecutionChange.toJson(payload.data)};
+function getForkInfoForSigning(
+  config: BeaconConfig,
+  signingSlot: Slot,
+  messageType: SignableMessageType
+): {version: Uint8Array; prevVersion: Uint8Array; epoch: number} {
+  const forkInfo = config.getForkInfo(signingSlot);
+
+  if (messageType === SignableMessageType.VOLUNTARY_EXIT && isForkPostDeneb(forkInfo.name)) {
+    // Always uses Capella fork post-Deneb (EIP-7044)
+    const capellaFork = config.forks[ForkName.capella];
+    return {
+      version: capellaFork.version,
+      prevVersion: capellaFork.prevVersion,
+      epoch: capellaFork.epoch,
+    };
   }
+
+  // Use the fork at the signing slot by default
+  return {
+    version: forkInfo.version,
+    prevVersion: forkInfo.prevVersion,
+    epoch: computeEpochAtSlot(signingSlot),
+  };
 }