@lodestar/validator 1.43.0-dev.9c8becae00 → 1.43.0-dev.9f5db5b9c7

package/src/services/ptcDuties.ts

@@ -0,0 +1,246 @@
+import {ApiClient, routes} from "@lodestar/api";
+import {ChainForkConfig} from "@lodestar/config";
+import {SLOTS_PER_EPOCH, isForkPostGloas} from "@lodestar/params";
+import {computeEpochAtSlot, isStartSlotOfEpoch} from "@lodestar/state-transition";
+import {Epoch, RootHex, Slot, ValidatorIndex} from "@lodestar/types";
+import {toPubkeyHex} from "@lodestar/utils";
+import {Metrics} from "../metrics.js";
+import {PubkeyHex} from "../types.js";
+import {IClock, LoggerVc} from "../util/index.js";
+import {ChainHeaderTracker, HeadEventData} from "./chainHeaderTracker.js";
+import {SyncingStatusTracker} from "./syncingStatusTracker.js";
+import {ValidatorStore} from "./validatorStore.js";
+
+/** Only retain `HISTORICAL_DUTIES_EPOCHS` duties prior to the current epoch. */
+const HISTORICAL_DUTIES_EPOCHS = 2;
+
+type PtcDutiesAtEpoch = {dependentRoot: RootHex; dutiesByIndex: Map<ValidatorIndex, routes.validator.PtcDuty>};
+
+export class PtcDutiesService {
+  /** Maps a validator index to its PTC duty for each epoch. */
+  private readonly dutiesByIndexByEpoch = new Map<Epoch, PtcDutiesAtEpoch>();
+
+  constructor(
+    private readonly config: ChainForkConfig,
+    private readonly logger: LoggerVc,
+    private readonly api: ApiClient,
+    private readonly clock: IClock,
+    private readonly validatorStore: ValidatorStore,
+    chainHeadTracker: ChainHeaderTracker,
+    syncingStatusTracker: SyncingStatusTracker,
+    private readonly metrics: Metrics | null
+  ) {
+    clock.runEveryEpoch(this.runDutiesTasks);
+    chainHeadTracker.runOnNewHead(this.onNewHead);
+    syncingStatusTracker.runOnResynced(async (slot) => {
+      // Skip on first slot of epoch since tasks are already scheduled.
+      if (!isStartSlotOfEpoch(slot)) {
+        return this.runDutiesTasks(computeEpochAtSlot(slot));
+      }
+    });
+
+    if (metrics) {
+      metrics.ptcDutiesCount.addCollect(() => {
+        const currentSlot = this.clock.getCurrentSlot();
+        let duties = 0;
+        let nextDutySlot = null;
+        for (const [epoch, ptcDutiesAtEpoch] of this.dutiesByIndexByEpoch) {
+          duties += ptcDutiesAtEpoch.dutiesByIndex.size;
+
+          // Epochs are sorted, stop searching once a next duty slot is found.
+          if (epoch < this.clock.currentEpoch || nextDutySlot !== null) continue;
+
+          for (const duty of ptcDutiesAtEpoch.dutiesByIndex.values()) {
+            if (duty.slot > currentSlot && (nextDutySlot === null || duty.slot < nextDutySlot)) {
+              nextDutySlot = duty.slot;
+            }
+          }
+        }
+        metrics.ptcDutiesCount.set(duties);
+        metrics.ptcDutiesEpochCount.set(this.dutiesByIndexByEpoch.size);
+        if (nextDutySlot !== null) metrics.ptcDutiesNextSlot.set(nextDutySlot);
+      });
+    }
+  }
+
+  removeDutiesForKey(pubkey: PubkeyHex): void {
+    for (const [epoch, ptcDutiesAtEpoch] of this.dutiesByIndexByEpoch) {
+      for (const [validatorIndex, duty] of ptcDutiesAtEpoch.dutiesByIndex) {
+        if (toPubkeyHex(duty.pubkey) === pubkey) {
+          ptcDutiesAtEpoch.dutiesByIndex.delete(validatorIndex);
+          if (ptcDutiesAtEpoch.dutiesByIndex.size === 0) {
+            this.dutiesByIndexByEpoch.delete(epoch);
+          }
+        }
+      }
+    }
+  }
+
+  /** Returns all PTC duties for the given slot. */
+  getDutiesAtSlot(slot: Slot): routes.validator.PtcDuty[] {
+    const epoch = computeEpochAtSlot(slot);
+    const duties: routes.validator.PtcDuty[] = [];
+    const epochDuties = this.dutiesByIndexByEpoch.get(epoch);
+    if (epochDuties === undefined) {
+      return duties;
+    }
+
+    for (const duty of epochDuties.dutiesByIndex.values()) {
+      if (duty.slot === slot) {
+        duties.push(duty);
+      }
+    }
+
+    return duties;
+  }
+
+  private runDutiesTasks = async (epoch: Epoch): Promise<void> => {
+    const nextEpoch = epoch + 1;
+    if (!isForkPostGloas(this.config.getForkName(nextEpoch * SLOTS_PER_EPOCH))) {
+      return;
+    }
+
+    await Promise.all([
+      this.pollPtcDuties(epoch, this.validatorStore.getAllLocalIndices()).catch((e: Error) => {
+        this.logger.error("Error on poll PTC duties", {epoch}, e);
+      }),
+
+      this.validatorStore
+        .pollValidatorIndices()
+        .then((newIndices) => this.pollPtcDuties(epoch, newIndices))
+        .catch((e: Error) => {
+          this.logger.error("Error on poll indices and PTC duties", {epoch}, e);
+        }),
+    ]);
+
+    this.pruneOldDuties(epoch);
+  };
+
+  private async pollPtcDuties(currentEpoch: Epoch, indexArr: ValidatorIndex[]): Promise<void> {
+    const nextEpoch = currentEpoch + 1;
+
+    if (indexArr.length === 0) {
+      return;
+    }
+
+    for (const epoch of [currentEpoch, nextEpoch]) {
+      await this.pollPtcDutiesForEpoch(epoch, indexArr).catch((e: Error) => {
+        this.logger.error("Failed to download PTC duties", {epoch}, e);
+      });
+    }
+  }
+
+  private async pollPtcDutiesForEpoch(epoch: Epoch, indexArr: ValidatorIndex[]): Promise<void> {
+    if (epoch < 0) {
+      return;
+    }
+
+    if (!isForkPostGloas(this.config.getForkName(epoch * SLOTS_PER_EPOCH))) {
+      return;
+    }
+
+    const res = await this.api.validator.getPtcDuties({epoch, indices: indexArr});
+    const ptcDuties = res.value();
+    const {dependentRoot} = res.meta();
+    const relevantDuties = ptcDuties.filter((duty) => {
+      const pubkeyHex = toPubkeyHex(duty.pubkey);
+      return this.validatorStore.hasVotingPubkey(pubkeyHex) && this.validatorStore.isDoppelgangerSafe(pubkeyHex);
+    });
+
+    this.logger.debug("Downloaded PTC duties", {epoch, dependentRoot, count: relevantDuties.length});
+
+    const dutiesAtEpoch = this.dutiesByIndexByEpoch.get(epoch);
+    const priorDependentRoot = dutiesAtEpoch?.dependentRoot;
+    const dependentRootChanged = priorDependentRoot !== undefined && priorDependentRoot !== dependentRoot;
+
+    if (!priorDependentRoot || dependentRootChanged) {
+      const dutiesByIndex = new Map<ValidatorIndex, routes.validator.PtcDuty>();
+      for (const duty of relevantDuties) {
+        dutiesByIndex.set(duty.validatorIndex, duty);
+      }
+      this.dutiesByIndexByEpoch.set(epoch, {dependentRoot, dutiesByIndex});
+
+      if (priorDependentRoot && dependentRootChanged) {
+        this.metrics?.ptcDutiesReorg.inc();
+        this.logger.warn("PTC duties re-org. This may happen from time to time", {
+          priorDependentRoot,
+          dependentRoot,
+          epoch,
+        });
+      }
+    } else {
+      const existingDuties = dutiesAtEpoch.dutiesByIndex;
+      const existingDutiesCount = existingDuties.size;
+      const discoveredNewDuties = relevantDuties.length > existingDutiesCount;
+
+      if (discoveredNewDuties) {
+        for (const duty of relevantDuties) {
+          if (!existingDuties.has(duty.validatorIndex)) {
+            existingDuties.set(duty.validatorIndex, duty);
+          }
+        }
+
+        this.logger.debug("Discovered new PTC duties", {
+          epoch,
+          dependentRoot,
+          count: relevantDuties.length - existingDutiesCount,
+        });
+      }
+    }
+  }
+
+  private onNewHead = async ({
+    slot,
+    previousDutyDependentRoot,
+    currentDutyDependentRoot,
+  }: HeadEventData): Promise<void> => {
+    const currentEpoch = computeEpochAtSlot(slot);
+    const nextEpoch = currentEpoch + 1;
+
+    const nextEpochDependentRoot = this.dutiesByIndexByEpoch.get(nextEpoch)?.dependentRoot;
+    if (nextEpochDependentRoot && currentDutyDependentRoot !== nextEpochDependentRoot) {
+      this.logger.warn("Potential next epoch PTC duties reorg", {
+        slot,
+        dutyEpoch: nextEpoch,
+        priorDependentRoot: nextEpochDependentRoot,
+        newDependentRoot: currentDutyDependentRoot,
+      });
+      await this.handlePtcDutiesReorg(nextEpoch, slot, nextEpochDependentRoot, currentDutyDependentRoot);
+    }
+
+    const currentEpochDependentRoot = this.dutiesByIndexByEpoch.get(currentEpoch)?.dependentRoot;
+    if (currentEpochDependentRoot && currentEpochDependentRoot !== previousDutyDependentRoot) {
+      this.logger.warn("Potential current epoch PTC duties reorg", {
+        slot,
+        dutyEpoch: currentEpoch,
+        priorDependentRoot: currentEpochDependentRoot,
+        newDependentRoot: previousDutyDependentRoot,
+      });
+      await this.handlePtcDutiesReorg(currentEpoch, slot, currentEpochDependentRoot, previousDutyDependentRoot);
+    }
+  };
+
+  private async handlePtcDutiesReorg(
+    dutyEpoch: Epoch,
+    slot: Slot,
+    oldDependentRoot: RootHex,
+    newDependentRoot: RootHex
+  ): Promise<void> {
+    this.metrics?.ptcDutiesReorg.inc();
+    const logContext = {dutyEpoch, slot, oldDependentRoot, newDependentRoot};
+    this.logger.debug("Redownload PTC duties", logContext);
+
+    await this.pollPtcDutiesForEpoch(dutyEpoch, this.validatorStore.getAllLocalIndices()).catch((e: Error) => {
+      this.logger.error("Failed to redownload PTC duties when reorg happens", logContext, e);
+    });
+  }
+
+  /** Run once per epoch to prune duties map. */
+  private pruneOldDuties(currentEpoch: Epoch): void {
+    for (const epoch of this.dutiesByIndexByEpoch.keys()) {
+      if (epoch + HISTORICAL_DUTIES_EPOCHS < currentEpoch) {
+        this.dutiesByIndexByEpoch.delete(epoch);
+      }
+    }
+  }
+}

package/src/services/validatorStore.ts

@@ -9,6 +9,7 @@ import {
   DOMAIN_BEACON_BUILDER,
   DOMAIN_BEACON_PROPOSER,
   DOMAIN_CONTRIBUTION_AND_PROOF,
+  DOMAIN_PTC_ATTESTER,
   DOMAIN_RANDAO,
   DOMAIN_SELECTION_PROOF,
   DOMAIN_SYNC_COMMITTEE,
@@ -496,11 +497,13 @@ export class ValidatorStore {
     logger?: LoggerVc
   ): Promise<gloas.SignedExecutionPayloadEnvelope> {
     // Make sure the envelope slot is not higher than the current slot to avoid potential attacks.
-    if (envelope.slot > currentSlot) {
-      throw Error(`Not signing envelope with slot ${envelope.slot} greater than current slot ${currentSlot}`);
+    if (envelope.payload.slotNumber > currentSlot) {
+      throw Error(
+        `Not signing envelope with slot ${envelope.payload.slotNumber} greater than current slot ${currentSlot}`
+      );
     }
 
-    const signingSlot = envelope.slot;
+    const signingSlot = envelope.payload.slotNumber;
     const domain = this.config.getDomain(signingSlot, DOMAIN_BEACON_BUILDER);
     const signingRoot = computeSigningRoot(ssz.gloas.ExecutionPayloadEnvelope, envelope, domain);
 
@@ -666,6 +669,41 @@ export class ValidatorStore {
     };
   }
 
+  async signPayloadAttestation(
+    duty: routes.validator.PtcDuty,
+    data: gloas.PayloadAttestationData,
+    currentSlot: Slot,
+    logger?: LoggerVc
+  ): Promise<gloas.PayloadAttestationMessage> {
+    if (data.slot > currentSlot) {
+      throw Error(`Not signing payload attestation with slot ${data.slot} greater than current slot ${currentSlot}`);
+    }
+
+    this.assertDoppelgangerSafe(duty.pubkey);
+    this.validatePtcDuty(duty, data);
+
+    const signingSlot = data.slot;
+    const domain = this.config.getDomain(signingSlot, DOMAIN_PTC_ATTESTER);
+    const signingRoot = computeSigningRoot(ssz.gloas.PayloadAttestationData, data, domain);
+
+    logger?.debug("Signing payload attestation message", {
+      slot: signingSlot,
+      beaconBlockRoot: toRootHex(data.beaconBlockRoot),
+      signingRoot: toRootHex(signingRoot),
+    });
+
+    const signableMessage: SignableMessage = {
+      type: SignableMessageType.PAYLOAD_ATTESTATION,
+      data,
+    };
+
+    return {
+      validatorIndex: duty.validatorIndex,
+      data,
+      signature: await this.getSignature(duty.pubkey, signingRoot, signingSlot, signableMessage),
+    };
+  }
+
   async signAttestationSelectionProof(pubkey: BLSPubkeyMaybeHex, slot: Slot): Promise<BLSSignature> {
     const signingSlot = slot;
     const domain = this.config.getDomain(slot, DOMAIN_SELECTION_PROOF);
@@ -850,6 +888,12 @@ export class ValidatorStore {
     }
   }
 
+  private validatePtcDuty(duty: routes.validator.PtcDuty, data: gloas.PayloadAttestationData): void {
+    if (duty.slot !== data.slot) {
+      throw Error(`Inconsistent PTC duties during signing: duty.slot ${duty.slot} != data.slot ${data.slot}`);
+    }
+  }
+
   private assertDoppelgangerSafe(pubKey: PubkeyHex | BLSPubkey): void {
     const pubkeyHex = typeof pubKey === "string" ? pubKey : toPubkeyHex(pubKey);
     if (!this.isDoppelgangerSafe(pubkeyHex)) {

package/src/util/externalSignerClient.ts

@@ -34,6 +34,7 @@ export enum SignableMessageType {
   SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF = "SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF",
   VALIDATOR_REGISTRATION = "VALIDATOR_REGISTRATION",
   EXECUTION_PAYLOAD_ENVELOPE = "EXECUTION_PAYLOAD_ENVELOPE",
+  PAYLOAD_ATTESTATION = "PAYLOAD_ATTESTATION",
 }
 
 const AggregationSlotType = new ContainerType({
@@ -83,7 +84,8 @@ export type SignableMessage =
   | {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.EXECUTION_PAYLOAD_ENVELOPE; data: gloas.ExecutionPayloadEnvelope};
+  | {type: SignableMessageType.EXECUTION_PAYLOAD_ENVELOPE; data: gloas.ExecutionPayloadEnvelope}
+  | {type: SignableMessageType.PAYLOAD_ATTESTATION; data: gloas.PayloadAttestationData};
 
 const requiresForkInfo: Record<SignableMessageType, boolean> = {
   [SignableMessageType.AGGREGATION_SLOT]: true,
@@ -99,6 +101,7 @@ const requiresForkInfo: Record<SignableMessageType, boolean> = {
   [SignableMessageType.SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF]: true,
   [SignableMessageType.VALIDATOR_REGISTRATION]: false,
   [SignableMessageType.EXECUTION_PAYLOAD_ENVELOPE]: true,
+  [SignableMessageType.PAYLOAD_ATTESTATION]: true,
 };
 
 type Web3SignerSerializedRequest = {
@@ -273,6 +276,9 @@ function serializerSignableMessagePayload(config: BeaconConfig, payload: Signabl
 
     case SignableMessageType.EXECUTION_PAYLOAD_ENVELOPE:
       return {execution_payload_envelope: ssz.gloas.ExecutionPayloadEnvelope.toJson(payload.data)};
+
+    case SignableMessageType.PAYLOAD_ATTESTATION:
+      return {payload_attestation: ssz.gloas.PayloadAttestationData.toJson(payload.data)};
   }
 }
 

package/src/util/params.ts

@@ -327,5 +327,8 @@ function getSpecCriticalParams(localConfig: ChainConfig): Record<keyof ConfigWit
     BUILDER_PENDING_WITHDRAWALS_LIMIT: gloasForkRelevant,
     MAX_BUILDERS_PER_WITHDRAWALS_SWEEP: gloasForkRelevant,
     MIN_BUILDER_WITHDRAWABILITY_DELAY: gloasForkRelevant,
+    CHURN_LIMIT_QUOTIENT_GLOAS: gloasForkRelevant,
+    CONSOLIDATION_CHURN_LIMIT_QUOTIENT: gloasForkRelevant,
+    MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT_GLOAS: gloasForkRelevant,
   };
 }

package/src/validator.ts

@@ -15,6 +15,7 @@ import {ValidatorEventEmitter} from "./services/emitter.js";
 import {ExternalSignerOptions, pollExternalSignerPubkeys} from "./services/externalSignerSync.js";
 import {IndicesService} from "./services/indices.js";
 import {pollBuilderValidatorRegistration, pollPrepareBeaconProposer} from "./services/prepareBeaconProposer.js";
+import {PtcService} from "./services/ptc.js";
 import {SyncCommitteeService} from "./services/syncCommittee.js";
 import {SyncingStatusTracker} from "./services/syncingStatusTracker.js";
 import {Signer, ValidatorProposerConfig, ValidatorStore, defaultOptions} from "./services/validatorStore.js";
@@ -30,6 +31,7 @@ export type ValidatorModules = {
   slashingProtection: ISlashingProtection;
   blockProposingService: BlockProposingService;
   attestationService: AttestationService;
+  ptcService: PtcService;
   syncCommitteeService: SyncCommitteeService;
   config: BeaconConfig;
   api: ApiClient;
@@ -84,6 +86,7 @@ export class Validator {
   private readonly slashingProtection: ISlashingProtection;
   private readonly blockProposingService: BlockProposingService;
   private readonly attestationService: AttestationService;
+  private readonly ptcService: PtcService;
   private readonly syncCommitteeService: SyncCommitteeService;
   private readonly config: BeaconConfig;
   private readonly api: ApiClient;
@@ -102,6 +105,7 @@ export class Validator {
     slashingProtection,
     blockProposingService,
     attestationService,
+    ptcService,
     syncCommitteeService,
     config,
     api,
@@ -118,6 +122,7 @@ export class Validator {
     this.slashingProtection = slashingProtection;
     this.blockProposingService = blockProposingService;
     this.attestationService = attestationService;
+    this.ptcService = ptcService;
     this.syncCommitteeService = syncCommitteeService;
     this.config = config;
     this.api = api;
@@ -225,7 +230,7 @@ export class Validator {
     // We set infinity to prevent MaxListenersExceededWarning which get logged when listeners > 10
     emitter.setMaxListeners(Infinity);
 
-    const chainHeaderTracker = new ChainHeaderTracker(logger, api, emitter);
+    const chainHeaderTracker = new ChainHeaderTracker(config, logger, api, emitter);
     const syncingStatusTracker = new SyncingStatusTracker(logger, api, clock, metrics);
 
     const blockProposingService = new BlockProposingService(config, loggerVc, api, clock, validatorStore, metrics, {
@@ -249,6 +254,18 @@ export class Validator {
       }
     );
 
+    const ptcService = new PtcService(
+      config,
+      loggerVc,
+      api,
+      clock,
+      validatorStore,
+      emitter,
+      chainHeaderTracker,
+      syncingStatusTracker,
+      metrics
+    );
+
     const syncCommitteeService = new SyncCommitteeService(
       config,
       loggerVc,
@@ -272,6 +289,7 @@ export class Validator {
       slashingProtection,
       blockProposingService,
       attestationService,
+      ptcService,
       syncCommitteeService,
       config,
       api,
@@ -338,6 +356,7 @@ export class Validator {
   removeDutiesForKey(pubkey: PubkeyHex): void {
     this.blockProposingService.removeDutiesForKey(pubkey);
     this.attestationService.removeDutiesForKey(pubkey);
+    this.ptcService.removeDutiesForKey(pubkey);
     this.syncCommitteeService.removeDutiesForKey(pubkey);
   }