@lodestar/validator 1.39.0-dev.aceb5b7416 → 1.39.0-dev.ad129ced66

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/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),
+  };
 }