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

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/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

@@ -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;
@@ -76,6 +77,11 @@ export class Clock implements IClock {
     return timeAt * 1000 - Date.now();
   }
 
+  /** Milliseconds elapsed from a specific slot to now */
+  msFromSlot(slot: Slot): number {
+    return Date.now() - (this.genesisTime * 1000 + this.config.SLOT_DURATION_MS * slot);
+  }
+
   /** Seconds elapsed from a specific slot to now */
   secFromSlot(slot: Slot): number {
     return Date.now() / 1000 - (this.genesisTime + this.config.SECONDS_PER_SLOT * slot);

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: true, // 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,