@lodestar/validator 1.35.0-rc.0 → 1.35.0-rc.2

package/src/services/attestation.ts

@@ -1,6 +1,6 @@
 import {ApiClient, routes} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
-import {ForkSeq} from "@lodestar/params";
+import {ForkName, isForkPostElectra} from "@lodestar/params";
 import {computeEpochAtSlot, isAggregatorFromCommitteeLength} from "@lodestar/state-transition";
 import {BLSSignature, SignedAggregateAndProof, SingleAttestation, Slot, phase0, ssz} from "@lodestar/types";
 import {prettyBytes, sleep, toRootHex} from "@lodestar/utils";
@@ -73,6 +73,7 @@ export class AttestationService {
     if (duties.length === 0) {
       return;
     }
+    const fork = this.config.getForkName(slot);
 
     if (this.opts?.distributedAggregationSelection) {
       // Validator in distributed cluster only has a key share, not the full private key.
@@ -81,16 +82,20 @@ export class AttestationService {
       // 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(duties, slot, signal).catch((e) =>
+      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) one-third of the slot has transpired (SECONDS_PER_SLOT / 3 seconds after the start of slot) -- whichever comes first.
-    await Promise.race([sleep(this.clock.msToSlot(slot + 1 / 3), signal), this.emitter.waitForBlockSlot(slot)]);
-    this.metrics?.attesterStepCallProduceAttestation.observe(this.clock.secFromSlot(slot + 1 / 3));
+    // (b) ATTESTATION_DUE_BPS of the slot has transpired -- whichever comes first.
+    const attestationDueMs = this.config.getAttestationDueMs(fork);
+    await Promise.race([
+      sleep(attestationDueMs - this.clock.msFromSlot(slot), signal),
+      this.emitter.waitForBlockSlot(slot),
+    ]);
+    this.metrics?.attesterStepCallProduceAttestation.observe(this.clock.secFromSlot(slot) - attestationDueMs / 1000);
 
     // Beacon node's endpoint produceAttestationData return data is not dependent on committeeIndex.
     // Produce a single attestation for all committees and submit unaggregated attestations in one go.
@@ -99,22 +104,25 @@ export class AttestationService {
       const attestationNoCommittee = await this.produceAttestation(0, slot);
 
       // Step 1. Mutate, and sign `Attestation` for each validator. Then publish all `Attestations` in one go
-      await this.signAndPublishAttestations(slot, attestationNoCommittee, duties);
+      await this.signAndPublishAttestations(fork, slot, attestationNoCommittee, duties);
 
       // Step 2. after all attestations are submitted, make an aggregate.
-      // First, wait until the `aggregation_production_instant` (2/3rds of the way through the slot)
-      await sleep(this.clock.msToSlot(slot + 2 / 3), signal);
-      this.metrics?.attesterStepCallProduceAggregate.observe(this.clock.secFromSlot(slot + 2 / 3));
+      // First, wait until the `aggregation_production_instant` (AGGREGATE_DUE_BPS of the way through the slot)
+      const aggregateDueMs = this.config.getAggregateDueMs(fork);
+      await sleep(aggregateDueMs - this.clock.msFromSlot(slot), signal);
+      this.metrics?.attesterStepCallProduceAggregate.observe(this.clock.secFromSlot(slot) - aggregateDueMs / 1000);
 
       const dutiesByCommitteeIndex = groupAttDutiesByCommitteeIndex(duties);
-      const isPostElectra = this.config.getForkSeq(slot) >= ForkSeq.electra;
 
       // Then download, sign and publish a `SignedAggregateAndProof` for each
       // validator that is elected to aggregate for this `slot` and `committeeIndex`.
       await Promise.all(
         Array.from(dutiesByCommitteeIndex.entries()).map(([index, dutiesSameCommittee]) => {
-          const attestationData: phase0.AttestationData = {...attestationNoCommittee, index: isPostElectra ? 0 : index};
-          return this.produceAndPublishAggregates(attestationData, index, dutiesSameCommittee);
+          const attestationData: phase0.AttestationData = {
+            ...attestationNoCommittee,
+            index: isForkPostElectra(fork) ? 0 : index,
+          };
+          return this.produceAndPublishAggregates(fork, attestationData, index, dutiesSameCommittee);
         })
       );
     } catch (e) {
@@ -138,6 +146,7 @@ export class AttestationService {
    * validator and the list of individually-signed `Attestation` objects is returned to the BN.
    */
   private async signAndPublishAttestations(
+    fork: ForkName,
     slot: Slot,
     attestationNoCommittee: phase0.AttestationData,
     duties: AttDutyAndProof[]
@@ -145,11 +154,10 @@ export class AttestationService {
     const signedAttestations: SingleAttestation[] = [];
     const headRootHex = toRootHex(attestationNoCommittee.beaconBlockRoot);
     const currentEpoch = computeEpochAtSlot(slot);
-    const isPostElectra = this.config.getForkSeq(slot) >= ForkSeq.electra;
 
     await Promise.all(
       duties.map(async ({duty}) => {
-        const index = isPostElectra ? 0 : duty.committeeIndex;
+        const index = isForkPostElectra(fork) ? 0 : duty.committeeIndex;
         const attestationData: phase0.AttestationData = {...attestationNoCommittee, index};
         const logCtxValidator = {slot, index, head: headRootHex, validatorIndex: duty.validatorIndex};
 
@@ -163,20 +171,21 @@ export class AttestationService {
       })
     );
 
-    // signAndPublishAttestations() may be called before the 1/3 cutoff time if the block was received early.
+    // signAndPublishAttestations() may be called before the ATTESTATION_DUE_BPS cutoff time if the block was received early.
     // If we produced the block or we got the block sooner than our peers, our attestations can be dropped because
     // they reach our peers before the block. To prevent that, we wait 2 extra seconds AFTER block arrival, but
-    // never beyond the 1/3 cutoff time.
+    // never beyond the ATTESTATION_DUE_BPS cutoff time.
     // https://github.com/status-im/nimbus-eth2/blob/7b64c1dce4392731a4a59ee3a36caef2e0a8357a/beacon_chain/validators/validator_duties.nim#L1123
-    const msToOneThirdSlot = this.clock.msToSlot(slot + 1 / 3);
-    // submitting attestations asap to avoid busy time at around 1/3 of slot
+    const attestationDueMs = this.config.getAttestationDueMs(fork);
+    const msToCutoffTime = attestationDueMs - this.clock.msFromSlot(slot);
+    // submitting attestations asap to avoid busy time at around ATTESTATION_DUE_BPS of slot
     const afterBlockDelayMs =
       1000 *
       this.clock.secondsPerSlot *
       (this.opts?.afterBlockDelaySlotFraction ?? DEFAULT_AFTER_BLOCK_DELAY_SLOT_FRACTION);
-    await sleep(Math.min(msToOneThirdSlot, afterBlockDelayMs));
+    await sleep(Math.min(msToCutoffTime, afterBlockDelayMs));
 
-    this.metrics?.attesterStepCallPublishAttestation.observe(this.clock.secFromSlot(slot + 1 / 3));
+    this.metrics?.attesterStepCallPublishAttestation.observe(this.clock.secFromSlot(slot) - attestationDueMs / 1000);
 
     // Step 2. Publish all `Attestations` in one go
     try {
@@ -205,6 +214,7 @@ export class AttestationService {
    * returned to the BN.
    */
   private async produceAndPublishAggregates(
+    fork: ForkName,
     attestation: phase0.AttestationData,
     committeeIndex: number,
     duties: AttDutyAndProof[]
@@ -246,7 +256,9 @@ export class AttestationService {
       })
     );
 
-    this.metrics?.attesterStepCallPublishAggregate.observe(this.clock.secFromSlot(attestation.slot + 2 / 3));
+    this.metrics?.attesterStepCallPublishAggregate.observe(
+      this.clock.secFromSlot(attestation.slot) - this.config.getAggregateDueMs(fork) / 1000
+    );
 
     if (signedAggregateAndProofs.length > 0) {
       try {
@@ -274,6 +286,7 @@ export class AttestationService {
    * See https://docs.google.com/document/d/1q9jOTPcYQa-3L8luRvQJ-M0eegtba4Nmon3dpO79TMk/mobilebasic
    */
   private async runDistributedAggregationSelectionTasks(
+    fork: ForkName,
     duties: AttDutyAndProof[],
     slot: number,
     signal: AbortSignal
@@ -290,16 +303,16 @@ export class AttestationService {
 
     const res = await Promise.race([
       this.api.validator.submitBeaconCommitteeSelections({selections: partialSelections}),
-      // Exit attestation aggregation flow if there is no response after 1/3 of slot as
+      // 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.clock.msToSlot(slot + 1 / 3), signal),
+      sleep(this.config.getAttestationDueMs(fork) - this.clock.msFromSlot(slot), signal),
     ]);
 
     if (!res) {
-      throw new Error("Failed to receive combined selection proofs before 1/3 of slot");
+      throw new Error("Failed to receive combined selection proofs before ATTESTATION_DUE_BPS of the slot");
     }
 
     const combinedSelections = res.value();

package/src/services/attestationDuties.ts

@@ -134,6 +134,7 @@ export class AttestationDutiesService {
       return;
     }
 
+    // TODO GLOAS: re-evaluate this timing
     // during the 1 / 3 of epoch, last block of epoch may come
     await sleep(this.clock.msToSlot(slot + 1 / 3), signal);
 

package/src/services/blockDuties.ts

@@ -1,5 +1,5 @@
 import {ApiClient, routes} from "@lodestar/api";
-import {ChainConfig} from "@lodestar/config";
+import {ChainForkConfig} from "@lodestar/config";
 import {computeEpochAtSlot, computeStartSlotAtEpoch} from "@lodestar/state-transition";
 import {BLSPubkey, Epoch, RootHex, Slot} from "@lodestar/types";
 import {sleep, toPubkeyHex} from "@lodestar/utils";
@@ -9,10 +9,11 @@ import {IClock, LoggerVc, differenceHex} from "../util/index.js";
 import {ValidatorStore} from "./validatorStore.js";
 
 /** This polls block duties 1s before the next epoch */
-// TODO: change to 6 to do it 2s before the next epoch
+// TODO: change to 8333 (5/6 of slot) to do it 2s before the next epoch
 // once we have some improvement on epoch transition time
 // see https://github.com/ChainSafe/lodestar/issues/5792#issuecomment-1647457442
-const BLOCK_DUTIES_LOOKAHEAD_FACTOR = 12;
+// TODO GLOAS: re-evaluate timing
+const BLOCK_DUTIES_LOOKAHEAD_BPS = 9167;
 /** Only retain `HISTORICAL_DUTIES_EPOCHS` duties prior to the current epoch */
 const HISTORICAL_DUTIES_EPOCHS = 2;
 // Re-declaring to not have to depend on `lodestar-params` just for this 0
@@ -30,7 +31,7 @@ export class BlockDutiesService {
   private readonly proposers = new Map<Epoch, BlockDutyAtEpoch>();
 
   constructor(
-    private readonly config: ChainConfig,
+    private readonly config: ChainForkConfig,
     private readonly logger: LoggerVc,
     private readonly api: ApiClient,
     private readonly clock: IClock,
@@ -169,7 +170,8 @@ export class BlockDutiesService {
    */
   private async pollBeaconProposersNextEpoch(currentSlot: Slot, nextEpoch: Epoch, signal: AbortSignal): Promise<void> {
     const nextSlot = currentSlot + 1;
-    const lookAheadMs = (this.config.SECONDS_PER_SLOT * 1000) / BLOCK_DUTIES_LOOKAHEAD_FACTOR;
+    const lookAheadMs =
+      this.config.SLOT_DURATION_MS - this.config.getSlotComponentDurationMs(BLOCK_DUTIES_LOOKAHEAD_BPS);
     await sleep(this.clock.msToSlot(nextSlot) - lookAheadMs, signal);
     this.logger.debug("Polling proposers for next epoch", {nextEpoch, nextSlot});
     // Poll proposers for the next epoch

package/src/services/externalSignerSync.ts

@@ -68,7 +68,7 @@ export function pollExternalSignerPubkeys(
     fetchExternalSignerPubkeys,
     externalSigner.fetchInterval ??
       // Once per epoch by default
-      SLOTS_PER_EPOCH * config.SECONDS_PER_SLOT * 1000
+      SLOTS_PER_EPOCH * config.SLOT_DURATION_MS
   );
   signal.addEventListener("abort", () => clearInterval(interval), {once: true});
 }

package/src/services/syncCommittee.ts

@@ -1,6 +1,7 @@
 import {ApiClient, routes} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
-import {computeEpochAtSlot, isSyncCommitteeAggregator} from "@lodestar/state-transition";
+import {ForkName, isForkPostAltair} from "@lodestar/params";
+import {isSyncCommitteeAggregator} from "@lodestar/state-transition";
 import {BLSSignature, CommitteeIndex, Root, Slot, altair} from "@lodestar/types";
 import {sleep} from "@lodestar/utils";
 import {Metrics} from "../metrics.js";
@@ -58,9 +59,11 @@ export class SyncCommitteeService {
   }
 
   private runSyncCommitteeTasks = async (slot: Slot, signal: AbortSignal): Promise<void> => {
+    const fork = this.config.getForkName(slot);
+
     try {
       // Before altair fork no need to check duties
-      if (computeEpochAtSlot(slot) < this.config.ALTAIR_FORK_EPOCH) {
+      if (!isForkPostAltair(fork)) {
         return;
       }
 
@@ -77,25 +80,32 @@ export class SyncCommitteeService {
         // 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(dutiesAtSlot, slot, signal).catch((e) =>
+        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 1/3 of slot
+      // especially with lodestar, it's very busy at ATTESTATION_DUE_BPS of the slot
       // see https://github.com/ChainSafe/lodestar/issues/4608
-      await Promise.race([sleep(this.clock.msToSlot(slot + 1 / 3), signal), this.emitter.waitForBlockSlot(slot)]);
-      this.metrics?.syncCommitteeStepCallProduceMessage.observe(this.clock.secFromSlot(slot + 1 / 3));
+      const syncMessageDueMs = this.config.getSyncMessageDueMs(fork);
+      await Promise.race([
+        sleep(syncMessageDueMs - this.clock.msFromSlot(slot), signal),
+        this.emitter.waitForBlockSlot(slot),
+      ]);
+      this.metrics?.syncCommitteeStepCallProduceMessage.observe(this.clock.secFromSlot(slot) - syncMessageDueMs / 1000);
 
       // Step 1. Download, sign and publish an `SyncCommitteeMessage` for each validator.
       //         Differs from AttestationService, `SyncCommitteeMessage` are equal for all
-      const beaconBlockRoot = await this.produceAndPublishSyncCommittees(slot, dutiesAtSlot);
+      const beaconBlockRoot = await this.produceAndPublishSyncCommittees(fork, slot, dutiesAtSlot);
 
       // Step 2. If an attestation was produced, make an aggregate.
-      // First, wait until the `aggregation_production_instant` (2/3rds of the way though the slot)
-      await sleep(this.clock.msToSlot(slot + 2 / 3), signal);
-      this.metrics?.syncCommitteeStepCallProduceAggregate.observe(this.clock.secFromSlot(slot + 2 / 3));
+      // First, wait until the `CONTRIBUTION_DUE_BPS` of the slot
+      const syncContributionDueMs = this.config.getSyncContributionDueMs(fork);
+      await sleep(syncContributionDueMs - this.clock.msFromSlot(slot), signal);
+      this.metrics?.syncCommitteeStepCallProduceAggregate.observe(
+        this.clock.secFromSlot(slot) - syncContributionDueMs / 1000
+      );
 
       // await for all so if the Beacon node is overloaded it auto-throttles
       // TODO: This approach is conservative to reduce the node's load, review
@@ -105,9 +115,11 @@ export class SyncCommitteeService {
           if (duties.length === 0) return;
           // Then download, sign and publish a `SignedAggregateAndProof` for each
           // validator that is elected to aggregate for this `slot` and `subcommitteeIndex`.
-          await this.produceAndPublishAggregates(slot, subcommitteeIndex, beaconBlockRoot, duties).catch((e: Error) => {
-            this.logger.error("Error on SyncCommitteeContribution", {slot, index: subcommitteeIndex}, e);
-          });
+          await this.produceAndPublishAggregates(fork, slot, subcommitteeIndex, beaconBlockRoot, duties).catch(
+            (e: Error) => {
+              this.logger.error("Error on SyncCommitteeContribution", {slot, index: subcommitteeIndex}, e);
+            }
+          );
         })
       );
     } catch (e) {
@@ -124,7 +136,11 @@ export class SyncCommitteeService {
    * Only one `SyncCommittee` is downloaded from the BN. It is then signed by each
    * validator and the list of individually-signed `SyncCommittee` objects is returned to the BN.
    */
-  private async produceAndPublishSyncCommittees(slot: Slot, duties: SyncDutyAndProofs[]): Promise<Root> {
+  private async produceAndPublishSyncCommittees(
+    fork: ForkName,
+    slot: Slot,
+    duties: SyncDutyAndProofs[]
+  ): Promise<Root> {
     const logCtx = {slot};
 
     // /eth/v1/beacon/blocks/:blockId/root -> at slot -1
@@ -156,14 +172,15 @@ export class SyncCommitteeService {
     // by default we want to submit SyncCommitteeSignature asap after we receive block
     // provide a delay option just in case any client implementation validate the existence of block in
     // SyncCommitteeSignature gossip validation.
-    const msToOneThirdSlot = this.clock.msToSlot(slot + 1 / 3);
+    const syncMessageDueMs = this.config.getSyncMessageDueMs(fork);
+    const msToCutoffTime = syncMessageDueMs - this.clock.msFromSlot(slot);
     const afterBlockDelayMs = 1000 * this.clock.secondsPerSlot * (this.opts?.scAfterBlockDelaySlotFraction ?? 0);
-    const toDelayMs = Math.min(msToOneThirdSlot, afterBlockDelayMs);
+    const toDelayMs = Math.min(msToCutoffTime, afterBlockDelayMs);
     if (toDelayMs > 0) {
       await sleep(toDelayMs);
     }
 
-    this.metrics?.syncCommitteeStepCallPublishMessage.observe(this.clock.secFromSlot(slot + 1 / 3));
+    this.metrics?.syncCommitteeStepCallPublishMessage.observe(this.clock.secFromSlot(slot) - syncMessageDueMs / 1000);
 
     if (signatures.length > 0) {
       try {
@@ -189,6 +206,7 @@ export class SyncCommitteeService {
    * returned to the BN.
    */
   private async produceAndPublishAggregates(
+    fork: ForkName,
     slot: Slot,
     subcommitteeIndex: CommitteeIndex,
     beaconBlockRoot: Root,
@@ -223,7 +241,9 @@ export class SyncCommitteeService {
       })
     );
 
-    this.metrics?.syncCommitteeStepCallPublishAggregate.observe(this.clock.secFromSlot(slot + 2 / 3));
+    this.metrics?.syncCommitteeStepCallPublishAggregate.observe(
+      this.clock.secFromSlot(slot) - this.config.getSyncContributionDueMs(fork) / 1000
+    );
 
     if (signedContributions.length > 0) {
       try {
@@ -248,6 +268,7 @@ export class SyncCommitteeService {
    * See https://docs.google.com/document/d/1q9jOTPcYQa-3L8luRvQJ-M0eegtba4Nmon3dpO79TMk/mobilebasic
    */
   private async runDistributedAggregationSelectionTasks(
+    fork: ForkName,
     duties: SyncDutyAndProofs[],
     slot: number,
     signal: AbortSignal
@@ -270,18 +291,18 @@ export class SyncCommitteeService {
 
     const res = await Promise.race([
       this.api.validator.submitSyncCommitteeSelections({selections: partialSelections}),
-      // Exit sync committee contributions flow if there is no response after 2/3 of slot.
-      // This is in contrast to attestations aggregations flow which is already exited at 1/3 of the slot
+      // 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.clock.msToSlot(slot + 2 / 3), signal),
+      sleep(this.config.getSyncContributionDueMs(fork) - this.clock.msFromSlot(slot), signal),
     ]);
 
     if (!res) {
-      throw new Error("Failed to receive combined selection proofs before 2/3 of slot");
+      throw new Error("Failed to receive combined selection proofs before CONTRIBUTION_DUE_BPS of the slot");
     }
 
     const combinedSelections = res.value();

package/src/util/clock.ts

@@ -1,6 +1,6 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {GENESIS_SLOT, SLOTS_PER_EPOCH} from "@lodestar/params";
-import {computeEpochAtSlot, getCurrentSlot} from "@lodestar/state-transition";
+import {computeEpochAtSlot, computeTimeAtSlot, getCurrentSlot} from "@lodestar/state-transition";
 import {Epoch, Slot, TimeSeconds} from "@lodestar/types";
 import {ErrorAborted, Logger, isErrorAborted, sleep} from "@lodestar/utils";
 
@@ -16,6 +16,7 @@ export interface IClock {
   runEverySlot(fn: (slot: Slot, signal: AbortSignal) => Promise<void>): void;
   runEveryEpoch(fn: (epoch: Epoch, signal: AbortSignal) => Promise<void>): void;
   msToSlot(slot: Slot): number;
+  msFromSlot(slot: Slot): number;
   secFromSlot(slot: Slot): number;
   getCurrentSlot(): Slot;
   getCurrentEpoch(): Epoch;
@@ -35,7 +36,7 @@ export class Clock implements IClock {
 
   constructor(config: ChainForkConfig, logger: Logger, opts: {genesisTime: number}) {
     this.genesisTime = opts.genesisTime;
-    this.secondsPerSlot = config.SECONDS_PER_SLOT;
+    this.secondsPerSlot = config.SLOT_DURATION_MS / 1000;
     this.config = config;
     this.logger = logger;
   }
@@ -72,13 +73,17 @@ export class Clock implements IClock {
 
   /** Milliseconds from now to a specific slot */
   msToSlot(slot: Slot): number {
-    const timeAt = this.genesisTime + this.config.SECONDS_PER_SLOT * slot;
-    return timeAt * 1000 - Date.now();
+    return computeTimeAtSlot(this.config, slot, this.genesisTime) * 1000 - Date.now();
+  }
+
+  /** Milliseconds elapsed from a specific slot to now */
+  msFromSlot(slot: Slot): number {
+    return Date.now() - computeTimeAtSlot(this.config, slot, this.genesisTime) * 1000;
   }
 
   /** Seconds elapsed from a specific slot to now */
   secFromSlot(slot: Slot): number {
-    return Date.now() / 1000 - (this.genesisTime + this.config.SECONDS_PER_SLOT * slot);
+    return Date.now() / 1000 - computeTimeAtSlot(this.config, slot, this.genesisTime);
   }
 
   /**
@@ -106,7 +111,7 @@ export class Clock implements IClock {
         if (timeItem === TimeItem.Slot) {
           if (nextSlot > slot + 1) {
             // It's not very likely that we skip more than one slot as HTTP timeout is set
-            // to SECONDS_PER_SLOT so we will fail task before skipping another slot.
+            // to SLOT_DURATION_MS so we will fail task before skipping another slot.
             this.logger.warn("Skipped slot due to task taking more than one slot to run", {
               skippedSlot: slot + 1,
             });
@@ -126,7 +131,7 @@ export class Clock implements IClock {
   }
 
   private timeUntilNext(timeItem: TimeItem): number {
-    const milliSecondsPerSlot = this.config.SECONDS_PER_SLOT * 1000;
+    const milliSecondsPerSlot = this.config.SLOT_DURATION_MS;
     const msFromGenesis = Date.now() - this.genesisTime * 1000;
 
     if (timeItem === TimeItem.Slot) {
@@ -148,7 +153,7 @@ export class Clock implements IClock {
  */
 export function getCurrentSlotAround(config: ChainForkConfig, genesisTime: TimeSeconds): Slot {
   const diffInSeconds = Date.now() / 1000 - genesisTime;
-  const slotsSinceGenesis = Math.round(diffInSeconds / config.SECONDS_PER_SLOT);
+  const slotsSinceGenesis = Math.round((diffInSeconds * 1000) / config.SLOT_DURATION_MS);
   return GENESIS_SLOT + slotsSinceGenesis;
 }
 

package/src/util/params.ts

@@ -146,11 +146,18 @@ function getSpecCriticalParams(localConfig: ChainConfig): Record<keyof ConfigWit
     GLOAS_FORK_EPOCH: gloasForkRelevant,
 
     // Time parameters
-    SECONDS_PER_SLOT: true,
+    SECONDS_PER_SLOT: false, // Deprecated
+    SLOT_DURATION_MS: true,
     SECONDS_PER_ETH1_BLOCK: false, // Legacy
     MIN_VALIDATOR_WITHDRAWABILITY_DELAY: true,
     SHARD_COMMITTEE_PERIOD: true,
     ETH1_FOLLOW_DISTANCE: true,
+    PROPOSER_REORG_CUTOFF_BPS: true,
+    ATTESTATION_DUE_BPS: true,
+    AGGREGATE_DUE_BPS: true,
+    // Altair
+    SYNC_MESSAGE_DUE_BPS: altairForkRelevant,
+    CONTRIBUTION_DUE_BPS: altairForkRelevant,
 
     // Validator cycle
     INACTIVITY_SCORE_BIAS: true,

package/src/validator.ts

@@ -178,7 +178,7 @@ export class Validator {
           urls: typeof clientOrUrls === "string" ? [clientOrUrls] : clientOrUrls,
           // Validator would need the beacon to respond within the slot
           // See https://github.com/ChainSafe/lodestar/issues/5315 for rationale
-          globalInit: {timeoutMs: config.SECONDS_PER_SLOT * 1000, signal: controller.signal, ...globalInit},
+          globalInit: {timeoutMs: config.SLOT_DURATION_MS, signal: controller.signal, ...globalInit},
         },
         {config, logger, metrics: metrics?.restApiClient}
       );