@lodestar/validator 1.43.0-dev.bc569affb9 → 1.43.0-dev.c5efeb6c90

package/src/services/ptc.ts

@@ -0,0 +1,131 @@
+import {ApiClient, routes} from "@lodestar/api";
+import {ChainForkConfig} from "@lodestar/config";
+import {isForkPostGloas} from "@lodestar/params";
+import {Slot, gloas} from "@lodestar/types";
+import {prettyBytes, sleep, toRootHex} from "@lodestar/utils";
+import {Metrics} from "../metrics.js";
+import {PubkeyHex} from "../types.js";
+import {IClock, LoggerVc} from "../util/index.js";
+import {ChainHeaderTracker} from "./chainHeaderTracker.js";
+import {ValidatorEventEmitter} from "./emitter.js";
+import {PtcDutiesService} from "./ptcDuties.js";
+import {SyncingStatusTracker} from "./syncingStatusTracker.js";
+import {ValidatorStore} from "./validatorStore.js";
+
+/**
+ * Service that sets up and handles validator Payload Timeliness Committee duties.
+ */
+export class PtcService {
+  private readonly dutiesService: PtcDutiesService;
+
+  constructor(
+    private readonly config: ChainForkConfig,
+    private readonly logger: LoggerVc,
+    private readonly api: ApiClient,
+    private readonly clock: IClock,
+    private readonly validatorStore: ValidatorStore,
+    private readonly emitter: ValidatorEventEmitter,
+    chainHeadTracker: ChainHeaderTracker,
+    syncingStatusTracker: SyncingStatusTracker,
+    private readonly metrics: Metrics | null
+  ) {
+    this.dutiesService = new PtcDutiesService(
+      config,
+      logger,
+      api,
+      clock,
+      validatorStore,
+      chainHeadTracker,
+      syncingStatusTracker,
+      metrics
+    );
+
+    clock.runEverySlot(this.runPtcTasks);
+  }
+
+  removeDutiesForKey(pubkey: PubkeyHex): void {
+    this.dutiesService.removeDutiesForKey(pubkey);
+  }
+
+  private runPtcTasks = async (slot: Slot, signal: AbortSignal): Promise<void> => {
+    const fork = this.config.getForkName(slot);
+    if (!isForkPostGloas(fork)) {
+      return;
+    }
+
+    const duties = this.dutiesService.getDutiesAtSlot(slot);
+    if (duties.length === 0) {
+      return;
+    }
+
+    const payloadAttestationDueMs = this.config.getSlotComponentDurationMs(this.config.PAYLOAD_ATTESTATION_DUE_BPS);
+    await Promise.race([
+      sleep(payloadAttestationDueMs - this.clock.msFromSlot(slot), signal),
+      this.emitter.waitForExecutionPayloadAvailableSlot(slot),
+    ]);
+
+    this.metrics?.ptcStepCallProducePayloadAttestation.observe(
+      this.clock.secFromSlot(slot) - payloadAttestationDueMs / 1000
+    );
+
+    try {
+      const payloadAttestationData = await this.producePayloadAttestationData(slot);
+      await this.signAndPublishPayloadAttestations(slot, payloadAttestationData, duties);
+    } catch (e) {
+      this.logger.error("Error on PTC routine", {slot}, e as Error);
+    }
+  };
+
+  private async producePayloadAttestationData(slot: Slot): Promise<gloas.PayloadAttestationData> {
+    return (await this.api.validator.producePayloadAttestationData({slot})).value();
+  }
+
+  private async signAndPublishPayloadAttestations(
+    slot: Slot,
+    payloadAttestationData: gloas.PayloadAttestationData,
+    duties: routes.validator.PtcDuty[]
+  ): Promise<void> {
+    const payloadAttestationMessages: gloas.PayloadAttestationMessage[] = [];
+    const beaconBlockRootHex = toRootHex(payloadAttestationData.beaconBlockRoot);
+
+    await Promise.all(
+      duties.map(async (duty) => {
+        const logCtxValidator = {slot, validatorIndex: duty.validatorIndex, beaconBlockRoot: beaconBlockRootHex};
+        try {
+          payloadAttestationMessages.push(
+            await this.validatorStore.signPayloadAttestation(
+              duty,
+              payloadAttestationData,
+              this.clock.getCurrentSlot(),
+              this.logger
+            )
+          );
+          this.logger.debug("Signed payload attestation message", logCtxValidator);
+        } catch (e) {
+          this.metrics?.ptcError.inc({error: "sign"});
+          this.logger.error("Error signing payload attestation message", logCtxValidator, e as Error);
+        }
+      })
+    );
+
+    this.metrics?.ptcStepCallPublishPayloadAttestation.observe(
+      this.clock.secFromSlot(slot) -
+        this.config.getSlotComponentDurationMs(this.config.PAYLOAD_ATTESTATION_DUE_BPS) / 1000
+    );
+
+    if (payloadAttestationMessages.length > 0) {
+      try {
+        (await this.api.beacon.submitPayloadAttestationMessages({payloadAttestationMessages})).assertOk();
+        this.logger.info("Published payload attestation messages", {
+          slot,
+          beaconBlockRoot: prettyBytes(beaconBlockRootHex),
+          count: payloadAttestationMessages.length,
+        });
+        this.metrics?.publishedPayloadAttestations.inc(payloadAttestationMessages.length);
+      } catch (e) {
+        this.metrics?.ptcError.inc({error: "publish"});
+        this.logger.error("Error publishing payload attestation messages", {slot}, e as Error);
+      }
+    }
+  }
+}

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,8 @@ import {
   DOMAIN_BEACON_BUILDER,
   DOMAIN_BEACON_PROPOSER,
   DOMAIN_CONTRIBUTION_AND_PROOF,
+  DOMAIN_PROPOSER_PREFERENCES,
+  DOMAIN_PTC_ATTESTER,
   DOMAIN_RANDAO,
   DOMAIN_SELECTION_PROOF,
   DOMAIN_SYNC_COMMITTEE,
@@ -668,6 +670,77 @@ 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 signProposerPreferences(
+    duty: routes.validator.ProposerDuty,
+    dependentRoot: Uint8Array,
+    feeRecipient: ExecutionAddress,
+    gasLimit: number,
+    currentSlot: Slot
+  ): Promise<gloas.SignedProposerPreferences> {
+    if (duty.slot <= currentSlot) {
+      throw Error(`Not signing proposer preferences for past slot ${duty.slot} (current ${currentSlot})`);
+    }
+
+    this.assertDoppelgangerSafe(duty.pubkey);
+
+    const message: gloas.ProposerPreferences = {
+      dependentRoot,
+      proposalSlot: duty.slot,
+      validatorIndex: duty.validatorIndex,
+      feeRecipient: fromHex(feeRecipient),
+      gasLimit,
+    };
+
+    const signingSlot = duty.slot;
+    const domain = this.config.getDomain(signingSlot, DOMAIN_PROPOSER_PREFERENCES);
+    const signingRoot = computeSigningRoot(ssz.gloas.ProposerPreferences, message, domain);
+
+    const signableMessage: SignableMessage = {
+      type: SignableMessageType.PROPOSER_PREFERENCES,
+      data: message,
+    };
+
+    return {
+      message,
+      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);
@@ -852,6 +925,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,8 @@ 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",
+  PROPOSER_PREFERENCES = "PROPOSER_PREFERENCES",
 }
 
 const AggregationSlotType = new ContainerType({
@@ -83,7 +85,9 @@ 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}
+  | {type: SignableMessageType.PROPOSER_PREFERENCES; data: gloas.ProposerPreferences};
 
 const requiresForkInfo: Record<SignableMessageType, boolean> = {
   [SignableMessageType.AGGREGATION_SLOT]: true,
@@ -99,6 +103,8 @@ 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,
+  [SignableMessageType.PROPOSER_PREFERENCES]: true,
 };
 
 type Web3SignerSerializedRequest = {
@@ -273,6 +279,12 @@ 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)};
+
+    case SignableMessageType.PROPOSER_PREFERENCES:
+      return {proposer_preferences: ssz.gloas.ProposerPreferences.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

@@ -9,12 +9,15 @@ import {Metrics} from "./metrics.js";
 import {MetaDataRepository} from "./repositories/metaDataRepository.js";
 import {AttestationService} from "./services/attestation.js";
 import {BlockProposingService} from "./services/block.js";
+import {BlockDutiesService} from "./services/blockDuties.js";
 import {ChainHeaderTracker} from "./services/chainHeaderTracker.js";
 import {DoppelgangerService} from "./services/doppelgangerService.js";
 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 {ProposerPreferencesService} from "./services/proposerPreferences.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 +33,7 @@ export type ValidatorModules = {
   slashingProtection: ISlashingProtection;
   blockProposingService: BlockProposingService;
   attestationService: AttestationService;
+  ptcService: PtcService;
   syncCommitteeService: SyncCommitteeService;
   config: BeaconConfig;
   api: ApiClient;
@@ -84,6 +88,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 +107,7 @@ export class Validator {
     slashingProtection,
     blockProposingService,
     attestationService,
+    ptcService,
     syncCommitteeService,
     config,
     api,
@@ -118,6 +124,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,13 +232,32 @@ 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, {
-      broadcastValidation: opts.broadcastValidation ?? defaultOptions.broadcastValidation,
-      blindedLocal: opts.blindedLocal ?? defaultOptions.blindedLocal,
-    });
+    const blockDutiesService = new BlockDutiesService(
+      config,
+      loggerVc,
+      api,
+      clock,
+      validatorStore,
+      chainHeaderTracker,
+      metrics
+    );
+
+    const blockProposingService = new BlockProposingService(
+      config,
+      loggerVc,
+      api,
+      clock,
+      validatorStore,
+      blockDutiesService,
+      metrics,
+      {
+        broadcastValidation: opts.broadcastValidation ?? defaultOptions.broadcastValidation,
+        blindedLocal: opts.blindedLocal ?? defaultOptions.blindedLocal,
+      }
+    );
 
     const attestationService = new AttestationService(
       loggerVc,
@@ -249,6 +275,18 @@ export class Validator {
       }
     );
 
+    const ptcService = new PtcService(
+      config,
+      loggerVc,
+      api,
+      clock,
+      validatorStore,
+      emitter,
+      chainHeaderTracker,
+      syncingStatusTracker,
+      metrics
+    );
+
     const syncCommitteeService = new SyncCommitteeService(
       config,
       loggerVc,
@@ -265,6 +303,8 @@ export class Validator {
       }
     );
 
+    new ProposerPreferencesService(config, loggerVc, api, clock, validatorStore, blockDutiesService, metrics);
+
     return new Validator({
       opts,
       genesis,
@@ -272,6 +312,7 @@ export class Validator {
       slashingProtection,
       blockProposingService,
       attestationService,
+      ptcService,
       syncCommitteeService,
       config,
       api,
@@ -338,6 +379,7 @@ export class Validator {
   removeDutiesForKey(pubkey: PubkeyHex): void {
     this.blockProposingService.removeDutiesForKey(pubkey);
     this.attestationService.removeDutiesForKey(pubkey);
+    this.ptcService.removeDutiesForKey(pubkey);
     this.syncCommitteeService.removeDutiesForKey(pubkey);
   }