@lodestar/validator 1.50.0-rc.0 → 1.51.0-dev.13ce72c336

package/src/slashingProtection/index.ts

@@ -1,8 +1,8 @@
 import {GENESIS_EPOCH} from "@lodestar/params";
 import {BLSPubkey, Epoch, Root} from "@lodestar/types";
-import {Logger, toPubkeyHex} from "@lodestar/utils";
+import {Logger, defer, toPubkeyHex} from "@lodestar/utils";
 import {uniqueVectorArr} from "../slashingProtection/utils.js";
-import {LodestarValidatorDatabaseController} from "../types.js";
+import {LodestarValidatorDatabaseController, PubkeyHex} from "../types.js";
 import {
   AttestationByTargetRepository,
   AttestationLowerBoundRepository,
@@ -34,6 +34,8 @@ export type {ISlashingProtection, InterchangeFormatVersion, SlashingProtectionBl
 export class SlashingProtection implements ISlashingProtection {
   private blockService: SlashingProtectionBlockService;
   private attestationService: SlashingProtectionAttestationService;
+  private readonly importing = new Map<PubkeyHex, Promise<void>>();
+  private lastImport: Promise<void> | null = null;
 
   constructor(protected db: LodestarValidatorDatabaseController) {
     const blockBySlotRepository = new BlockBySlotRepository(db);
@@ -51,10 +53,26 @@ export class SlashingProtection implements ISlashingProtection {
   }
 
   async checkAndInsertBlockProposal(pubKey: BLSPubkey, block: SlashingProtectionBlock): Promise<void> {
+    if (this.importing.size !== 0) {
+      const pubkeyHex = toPubkeyHex(pubKey);
+      let importing = this.importing.get(pubkeyHex);
+      while (importing !== undefined) {
+        await importing;
+        importing = this.importing.get(pubkeyHex);
+      }
+    }
     await this.blockService.checkAndInsertBlockProposal(pubKey, block);
   }
 
   async checkAndInsertAttestation(pubKey: BLSPubkey, attestation: SlashingProtectionAttestation): Promise<void> {
+    if (this.importing.size !== 0) {
+      const pubkeyHex = toPubkeyHex(pubKey);
+      let importing = this.importing.get(pubkeyHex);
+      while (importing !== undefined) {
+        await importing;
+        importing = this.importing.get(pubkeyHex);
+      }
+    }
     await this.attestationService.checkAndInsertAttestation(pubKey, attestation);
   }
 
@@ -84,10 +102,36 @@ export class SlashingProtection implements ISlashingProtection {
         }
       }
     }
-    for (const validator of data) {
-      logger?.info("Importing slashing protection", {pubkey: toPubkeyHex(validator.pubkey)});
-      await this.blockService.importBlocks(validator.pubkey, validator.signedBlocks);
-      await this.attestationService.importAttestations(validator.pubkey, validator.signedAttestations);
+
+    // Checks for keys in the file wait for the whole import, a key that is already signing must not sign against
+    // a history the import is still extending. Imports run one after another so a later one cannot release a key early.
+    const pubkeyHexes = data.map((validator) => toPubkeyHex(validator.pubkey));
+    const previous = this.lastImport;
+    const {promise, resolve} = defer<void>();
+    this.lastImport = promise;
+    for (const pubkeyHex of pubkeyHexes) {
+      this.importing.set(pubkeyHex, promise);
+    }
+
+    try {
+      if (previous !== null) {
+        await previous;
+      }
+      for (const validator of data) {
+        logger?.info("Importing slashing protection", {pubkey: toPubkeyHex(validator.pubkey)});
+        await this.blockService.importBlocks(validator.pubkey, validator.signedBlocks);
+        await this.attestationService.importAttestations(validator.pubkey, validator.signedAttestations);
+      }
+    } finally {
+      resolve();
+      if (this.lastImport === promise) {
+        this.lastImport = null;
+      }
+      for (const pubkeyHex of pubkeyHexes) {
+        if (this.importing.get(pubkeyHex) === promise) {
+          this.importing.delete(pubkeyHex);
+        }
+      }
     }
   }
 

package/src/util/externalSignerClient.ts

@@ -1,6 +1,6 @@
 import {ContainerType, ValueOf} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
-import {ForkName, ForkPostGloas, ForkPreBellatrix, ForkSeq, isForkPostDeneb} from "@lodestar/params";
+import {ForkName, ForkPostGloas, ForkSeq, isForkPostDeneb} from "@lodestar/params";
 import {blindedOrFullBlockToHeader, computeEpochAtSlot} from "@lodestar/state-transition";
 import {
   AggregateAndProof,
@@ -78,7 +78,7 @@ export type SignableMessage =
   | {type: SignableMessageType.AGGREGATE_AND_PROOF; data: phase0.AggregateAndProof}
   | {type: SignableMessageType.AGGREGATE_AND_PROOF_V2; data: AggregateAndProof}
   | {type: SignableMessageType.ATTESTATION; data: phase0.AttestationData}
-  | {type: SignableMessageType.BLOCK_V2; data: BeaconBlock<ForkPreBellatrix> | BlindedBeaconBlock}
+  | {type: SignableMessageType.BLOCK_V2; data: BeaconBlock | BlindedBeaconBlock}
   | {type: SignableMessageType.DEPOSIT; data: ValueOf<typeof DepositType>}
   | {type: SignableMessageType.RANDAO_REVEAL; data: {epoch: Epoch}}
   | {type: SignableMessageType.VOLUNTARY_EXIT; data: phase0.VoluntaryExit}

package/src/validator.ts

@@ -6,7 +6,14 @@ import {
   assertEqualParams,
   createBeaconConfig,
 } from "@lodestar/config";
-import {Clock, ClockOptions, IClock, computeEpochAtSlot, getCurrentSlot} from "@lodestar/state-transition";
+import {
+  Clock,
+  ClockOptions,
+  IClock,
+  computeEpochAtSlot,
+  getCurrentSlot,
+  getSlotDurations,
+} from "@lodestar/state-transition";
 import {BLSPubkey, phase0, ssz} from "@lodestar/types";
 import {Genesis} from "@lodestar/types/phase0";
 import {Logger, prettyGweiToEth, toPrintableUrl, toRootHex} from "@lodestar/utils";
@@ -202,7 +209,9 @@ export class Validator {
           globalInit: {
             signal: controller.signal,
             ...globalInit,
-            timeoutMs: globalInit?.timeoutMs ?? config.SLOT_DURATION_MS,
+            timeoutMs:
+              globalInit?.timeoutMs ??
+              Math.min(...getSlotDurations(config).map(([, slotDurationMs]) => slotDurationMs)),
           },
         },
         {config, logger, metrics: metrics?.restApiClient}
@@ -366,7 +375,8 @@ export class Validator {
         urls: urls.map(toPrintableUrl).toString(),
         requestWireFormat: globalInit?.requestWireFormat ?? defaultInit.requestWireFormat,
         responseWireFormat: globalInit?.responseWireFormat ?? defaultInit.responseWireFormat,
-        requestTimeoutMs: globalInit?.timeoutMs ?? config.SLOT_DURATION_MS,
+        requestTimeoutMs:
+          globalInit?.timeoutMs ?? Math.min(...getSlotDurations(config).map(([, slotDurationMs]) => slotDurationMs)),
       });
     } else {
       api = clientOrUrls;