@lodestar/validator 1.50.1 → 1.51.0-dev.09763aa8d2

package/src/services/validatorStore.ts

@@ -1,8 +1,8 @@
-import {SecretKey} from "@chainsafe/lodestar-z/blst";
 import {BitArray} from "@chainsafe/ssz";
 import {routes} from "@lodestar/api";
 import {BuilderConfigData, BuilderEntryConfig} from "@lodestar/api/keymanager";
 import {BeaconConfig} from "@lodestar/config";
+import {SecretKey} from "@lodestar/native/blst";
 import {
   DOMAIN_AGGREGATE_AND_PROOF,
   DOMAIN_APPLICATION_BUILDER,
@@ -11,6 +11,7 @@ import {
   DOMAIN_BEACON_PROPOSER,
   DOMAIN_BUILDER_REQUEST_AUTH,
   DOMAIN_CONTRIBUTION_AND_PROOF,
+  DOMAIN_INCLUSION_LIST_COMMITTEE,
   DOMAIN_PROPOSER_PREFERENCES,
   DOMAIN_PTC_ATTESTER,
   DOMAIN_RANDAO,
@@ -46,6 +47,7 @@ import {
   altair,
   bellatrix,
   gloas,
+  heze,
   phase0,
   ssz,
 } from "@lodestar/types";
@@ -633,7 +635,8 @@ export class ValidatorStore {
   removeSigner(pubkeyHex: PubkeyHex): boolean {
     this.doppelgangerService?.unregisterValidator(pubkeyHex);
 
-    return this.indicesService.removeForKey(pubkeyHex) || this.validators.delete(pubkeyHex);
+    this.indicesService.removeForKey(pubkeyHex);
+    return this.validators.delete(pubkeyHex);
   }
 
   /** Return true if there is at least 1 pubkey registered */
@@ -809,6 +812,8 @@ export class ValidatorStore {
   ): Promise<SignedAggregateAndProof> {
     this.validateAttestationDuty(duty, aggregate.data);
 
+    this.assertDoppelgangerSafe(duty.pubkey);
+
     const aggregateAndProof: AggregateAndProof = {
       aggregate,
       aggregatorIndex: duty.validatorIndex,
@@ -929,8 +934,6 @@ export class ValidatorStore {
       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,
@@ -954,6 +957,38 @@ export class ValidatorStore {
     };
   }
 
+  async signInclusionList(
+    duty: routes.validator.InclusionListDuty,
+    inclusionList: heze.InclusionList
+  ): Promise<heze.SignedInclusionList> {
+    if (duty.slot !== inclusionList.slot) {
+      throw Error(
+        `Inconsistent duties during signing: duty.slot ${duty.slot} != inclusionList.slot ${inclusionList.slot}`
+      );
+    }
+    if (duty.validatorIndex !== inclusionList.validatorIndex) {
+      throw Error(
+        `Inconsistent duties during signing: duty.validatorIndex ${duty.validatorIndex} != inclusionList.validatorIndex ${inclusionList.validatorIndex}`
+      );
+    }
+
+    this.assertDoppelgangerSafe(duty.pubkey);
+
+    const signingSlot = inclusionList.slot;
+    const domain = this.config.getDomain(signingSlot, DOMAIN_INCLUSION_LIST_COMMITTEE);
+    const signingRoot = computeSigningRoot(ssz.heze.InclusionList, inclusionList, domain);
+
+    const signableMessage: SignableMessage = {
+      type: SignableMessageType.INCLUSION_LIST,
+      data: inclusionList,
+    };
+
+    return {
+      message: inclusionList,
+      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);
@@ -1214,6 +1249,11 @@ export class ValidatorStore {
     }
   }
 
+  /**
+   * Required before signing a message that is slashable or that the beacon node counts as validator
+   * liveness (see `validatorSeenAtEpoch`), otherwise doppelganger detection would flag our own messages.
+   * Skip it for anything else.
+   */
   private assertDoppelgangerSafe(pubKey: PubkeyHex | BLSPubkey): void {
     const pubkeyHex = typeof pubKey === "string" ? pubKey : toPubkeyHex(pubKey);
     if (!this.isDoppelgangerSafe(pubkeyHex)) {

package/src/slashingProtection/attestation/index.ts

@@ -1,10 +1,12 @@
 import {BLSPubkey, Epoch} from "@lodestar/types";
+import {defer, toPubkeyHex} from "@lodestar/utils";
 import {MinMaxSurround, SurroundAttestationError, SurroundAttestationErrorCode} from "../minMaxSurround/index.js";
 import {SlashingProtectionAttestation} from "../types.js";
 import {ZERO_ROOT, isEqualNonZeroRoot, isEqualRoot, minEpoch} from "../utils.js";
 import {AttestationByTargetRepository} from "./attestationByTargetRepository.js";
 import {AttestationLowerBoundRepository} from "./attestationLowerBoundRepository.js";
 import {InvalidAttestationError, InvalidAttestationErrorCode} from "./errors.js";
+
 export {
   AttestationByTargetRepository,
   AttestationLowerBoundRepository,
@@ -21,6 +23,7 @@ export class SlashingProtectionAttestationService {
   private attestationByTarget: AttestationByTargetRepository;
   private attestationLowerBound: AttestationLowerBoundRepository;
   private minMaxSurround: MinMaxSurround;
+  private readonly pendingAttestations = new Map<string, Promise<void>>();
 
   constructor(
     signedAttestationDb: AttestationByTargetRepository,
@@ -37,10 +40,25 @@ export class SlashingProtectionAttestationService {
    * This is the safe, externally-callable interface for checking attestations
    */
   async checkAndInsertAttestation(pubKey: BLSPubkey, attestation: SlashingProtectionAttestation): Promise<void> {
-    const safeStatus = await this.checkAttestation(pubKey, attestation);
+    const pubkeyHex = toPubkeyHex(pubKey);
+    const previous = this.pendingAttestations.get(pubkeyHex);
+    const {promise, resolve} = defer<void>();
+    this.pendingAttestations.set(pubkeyHex, promise);
+
+    try {
+      if (previous !== undefined) {
+        await previous;
+      }
+      const safeStatus = await this.checkAttestation(pubKey, attestation);
 
-    if (safeStatus !== SafeStatus.SAME_DATA) {
-      await this.insertAttestation(pubKey, attestation);
+      if (safeStatus !== SafeStatus.SAME_DATA) {
+        await this.insertAttestation(pubKey, attestation);
+      }
+    } finally {
+      resolve();
+      if (this.pendingAttestations.get(pubkeyHex) === promise) {
+        this.pendingAttestations.delete(pubkeyHex);
+      }
     }
 
     // TODO: Implement safe clean-up of stored attestations
@@ -164,55 +182,73 @@ export class SlashingProtectionAttestationService {
    * Interchange import / export functionality
    */
   async importAttestations(pubkey: BLSPubkey, attestations: SlashingProtectionAttestation[]): Promise<void> {
-    // Min-max surround misses a surround vote beyond its lookback, require the highest target attestation to
-    // have the highest source epoch as `checkAttestation` relies on it
-    let latestAtt = await this.attestationByTarget.getLatest(pubkey);
-    let maxSourceAtt = latestAtt;
-    for (const attestation of attestations) {
-      if (latestAtt === null || attestation.targetEpoch >= latestAtt.targetEpoch) {
-        latestAtt = attestation;
+    const pubkeyHex = toPubkeyHex(pubkey);
+    const previous = this.pendingAttestations.get(pubkeyHex);
+    const {promise, resolve} = defer<void>();
+    this.pendingAttestations.set(pubkeyHex, promise);
+
+    try {
+      if (previous !== undefined) {
+        await previous;
       }
-      if (maxSourceAtt === null || attestation.sourceEpoch > maxSourceAtt.sourceEpoch) {
-        maxSourceAtt = attestation;
+      // Min-max surround misses a surround vote beyond its lookback, require the highest target attestation to
+      // have the highest source epoch as `checkAttestation` relies on it
+      let latestAtt = await this.attestationByTarget.getLatest(pubkey);
+      let maxSourceAtt = latestAtt;
+      for (const attestation of attestations) {
+        if (latestAtt === null || attestation.targetEpoch >= latestAtt.targetEpoch) {
+          latestAtt = attestation;
+        }
+        if (maxSourceAtt === null || attestation.sourceEpoch > maxSourceAtt.sourceEpoch) {
+          maxSourceAtt = attestation;
+        }
       }
-    }
-    if (latestAtt && maxSourceAtt && latestAtt.sourceEpoch < maxSourceAtt.sourceEpoch) {
-      throw new InvalidAttestationError({
-        code: InvalidAttestationErrorCode.NEW_SURROUNDS_PREV,
-        attestation: latestAtt,
-        prev: maxSourceAtt,
-      });
-    }
-
-    // Never replace a recorded attestation with a different source or signing root, a zero root refuses any attestation
-    // with that target. The highest source epoch is kept as the latest attestation must have it, see above.
-    const attestationsByTarget = new Map<Epoch, SlashingProtectionAttestation>();
-    for (const attestation of attestations) {
-      const {sourceEpoch, targetEpoch, signingRoot} = attestation;
-      const prevAtt =
-        attestationsByTarget.get(targetEpoch) ?? (await this.attestationByTarget.get(pubkey, targetEpoch));
-      if (prevAtt === null || (prevAtt.sourceEpoch === sourceEpoch && isEqualRoot(prevAtt.signingRoot, signingRoot))) {
-        attestationsByTarget.set(targetEpoch, attestation);
-      } else {
-        attestationsByTarget.set(targetEpoch, {
-          sourceEpoch: Math.max(prevAtt.sourceEpoch, sourceEpoch),
-          targetEpoch,
-          signingRoot: ZERO_ROOT,
+      if (latestAtt && maxSourceAtt && latestAtt.sourceEpoch < maxSourceAtt.sourceEpoch) {
+        throw new InvalidAttestationError({
+          code: InvalidAttestationErrorCode.NEW_SURROUNDS_PREV,
+          attestation: latestAtt,
+          prev: maxSourceAtt,
         });
       }
-    }
-    await this.attestationByTarget.set(pubkey, Array.from(attestationsByTarget.values()));
 
-    // Pre-compute spans for all attestations
-    for (const attestation of attestations) {
-      await this.minMaxSurround.insertAttestation(pubkey, attestation);
-    }
+      // Never replace a recorded attestation with a different source or signing root, a zero root refuses any attestation
+      // with that target. The highest source epoch is kept as the latest attestation must have it, see above.
+      const attestationsByTarget = new Map<Epoch, SlashingProtectionAttestation>();
+      for (const attestation of attestations) {
+        const {sourceEpoch, targetEpoch, signingRoot} = attestation;
+        const prevAtt =
+          attestationsByTarget.get(targetEpoch) ?? (await this.attestationByTarget.get(pubkey, targetEpoch));
+        if (
+          prevAtt === null ||
+          (prevAtt.sourceEpoch === sourceEpoch && isEqualRoot(prevAtt.signingRoot, signingRoot))
+        ) {
+          attestationsByTarget.set(targetEpoch, attestation);
+        } else {
+          attestationsByTarget.set(targetEpoch, {
+            sourceEpoch: Math.max(prevAtt.sourceEpoch, sourceEpoch),
+            targetEpoch,
+            signingRoot: ZERO_ROOT,
+          });
+        }
+      }
+      await this.attestationByTarget.set(pubkey, Array.from(attestationsByTarget.values()));
+
+      // Pre-compute spans for all attestations
+      for (const attestation of attestations) {
+        await this.minMaxSurround.insertAttestation(pubkey, attestation);
+      }
 
-    // Pre-compute and store lower-bound
-    const minSourceEpoch = minEpoch(attestations.map((attestation) => attestation.sourceEpoch));
-    const minTargetEpoch = minEpoch(attestations.map((attestation) => attestation.targetEpoch));
-    if (minSourceEpoch != null && minTargetEpoch != null) {
-      await this.attestationLowerBound.set(pubkey, {minSourceEpoch, minTargetEpoch});
+      // Pre-compute and store lower-bound
+      const minSourceEpoch = minEpoch(attestations.map((attestation) => attestation.sourceEpoch));
+      const minTargetEpoch = minEpoch(attestations.map((attestation) => attestation.targetEpoch));
+      if (minSourceEpoch != null && minTargetEpoch != null) {
+        await this.attestationLowerBound.set(pubkey, {minSourceEpoch, minTargetEpoch});
+      }
+    } finally {
+      resolve();
+      if (this.pendingAttestations.get(pubkeyHex) === promise) {
+        this.pendingAttestations.delete(pubkeyHex);
+      }
     }
   }
 

package/src/slashingProtection/block/index.ts

@@ -4,6 +4,7 @@ import {SlashingProtectionBlock} from "../types.js";
 import {ZERO_ROOT, isEqualNonZeroRoot, isEqualRoot} from "../utils.js";
 import {BlockBySlotRepository} from "./blockBySlotRepository.js";
 import {InvalidBlockError, InvalidBlockErrorCode} from "./errors.js";
+
 export {BlockBySlotRepository, InvalidBlockError, InvalidBlockErrorCode};
 
 enum SafeStatus {

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,
@@ -26,7 +26,7 @@ export {InvalidAttestationError, InvalidAttestationErrorCode} from "./attestatio
 export {InvalidBlockError, InvalidBlockErrorCode} from "./block/index.js";
 export type {Interchange, InterchangeFormat} from "./interchange/index.js";
 export {InterchangeError, InterchangeErrorErrorCode} from "./interchange/index.js";
-export type {ISlashingProtection, InterchangeFormatVersion, SlashingProtectionBlock, SlashingProtectionAttestation};
+export type {ISlashingProtection, InterchangeFormatVersion, SlashingProtectionAttestation, SlashingProtectionBlock};
 /**
  * Handles slashing protection for validator proposer and attester duties as well as slashing protection
  * during a validator interchange import/export process.
@@ -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/slashingProtection/utils.ts

@@ -40,7 +40,7 @@ export function stringToNum(str: string): number {
 }
 
 export function minEpoch(epochs: Epoch[]): Epoch | null {
-  return epochs.length > 0 ? epochs.reduce((minEpoch, epoch) => (minEpoch < epoch ? minEpoch : epoch)) : null;
+  return epochs.length > 0 ? epochs.reduce((minEpoch, epoch) => Math.min(minEpoch, epoch)) : null;
 }
 
 export function uniqueVectorArr(buffers: Uint8Array[]): Uint8Array[] {

package/src/types.ts

@@ -1,5 +1,5 @@
-import {SecretKey} from "@chainsafe/lodestar-z/blst";
 import {DatabaseController} from "@lodestar/db";
+import {SecretKey} from "@lodestar/native/blst";
 import {BLSPubkey} from "@lodestar/types";
 
 export type GenesisInfo = {

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,
@@ -12,6 +12,7 @@ import {
   Slot,
   altair,
   gloas,
+  heze,
   phase0,
   ssz,
   sszTypesFor,
@@ -37,6 +38,7 @@ export enum SignableMessageType {
   PAYLOAD_ATTESTATION_MESSAGE = "PAYLOAD_ATTESTATION_MESSAGE",
   PROPOSER_PREFERENCES = "PROPOSER_PREFERENCES",
   BUILDER_REQUEST_AUTH = "BUILDER_REQUEST_AUTH",
+  INCLUSION_LIST = "INCLUSION_LIST",
 }
 
 const AggregationSlotType = new ContainerType({
@@ -78,7 +80,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}
@@ -89,7 +91,8 @@ export type SignableMessage =
   | {type: SignableMessageType.EXECUTION_PAYLOAD_ENVELOPE; data: gloas.ExecutionPayloadEnvelope}
   | {type: SignableMessageType.PAYLOAD_ATTESTATION_MESSAGE; data: gloas.PayloadAttestationData}
   | {type: SignableMessageType.PROPOSER_PREFERENCES; data: gloas.ProposerPreferences}
-  | {type: SignableMessageType.BUILDER_REQUEST_AUTH; data: gloas.BuilderRequestAuth};
+  | {type: SignableMessageType.BUILDER_REQUEST_AUTH; data: gloas.BuilderRequestAuth}
+  | {type: SignableMessageType.INCLUSION_LIST; data: heze.InclusionList};
 
 const requiresForkInfo: Record<SignableMessageType, boolean> = {
   [SignableMessageType.AGGREGATION_SLOT]: true,
@@ -108,6 +111,7 @@ const requiresForkInfo: Record<SignableMessageType, boolean> = {
   [SignableMessageType.PAYLOAD_ATTESTATION_MESSAGE]: true,
   [SignableMessageType.PROPOSER_PREFERENCES]: true,
   [SignableMessageType.BUILDER_REQUEST_AUTH]: false,
+  [SignableMessageType.INCLUSION_LIST]: true,
 };
 
 type Web3SignerSerializedRequest = {
@@ -319,6 +323,9 @@ function serializerSignableMessagePayload(config: BeaconConfig, payload: Signabl
         },
       };
     }
+
+    case SignableMessageType.INCLUSION_LIST:
+      return {inclusion_list: ssz.heze.InclusionList.toJson(payload.data)};
   }
 }
 

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";
@@ -20,6 +27,7 @@ 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 {InclusionListService} from "./services/inclusionList.js";
 import {IndicesService} from "./services/indices.js";
 import {pollBuilderValidatorRegistration, pollPrepareBeaconProposer} from "./services/prepareBeaconProposer.js";
 import {ProposalPreferencesService} from "./services/proposalPreferences.js";
@@ -46,6 +54,7 @@ export type ValidatorModules = {
   blockProposingService: BlockProposingService;
   attestationService: AttestationService;
   ptcService: PtcService;
+  inclusionListService: InclusionListService;
   syncCommitteeService: SyncCommitteeService;
   config: BeaconConfig;
   api: ApiClient;
@@ -102,6 +111,7 @@ export class Validator {
   private readonly blockProposingService: BlockProposingService;
   private readonly attestationService: AttestationService;
   private readonly ptcService: PtcService;
+  private readonly inclusionListService: InclusionListService;
   private readonly syncCommitteeService: SyncCommitteeService;
   private readonly config: BeaconConfig;
   private readonly api: ApiClient;
@@ -121,6 +131,7 @@ export class Validator {
     blockProposingService,
     attestationService,
     ptcService,
+    inclusionListService,
     syncCommitteeService,
     config,
     api,
@@ -138,6 +149,7 @@ export class Validator {
     this.blockProposingService = blockProposingService;
     this.attestationService = attestationService;
     this.ptcService = ptcService;
+    this.inclusionListService = inclusionListService;
     this.syncCommitteeService = syncCommitteeService;
     this.config = config;
     this.api = api;
@@ -202,7 +214,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}
@@ -303,6 +317,17 @@ export class Validator {
       metrics
     );
 
+    const inclusionListService = new InclusionListService(
+      config,
+      loggerVc,
+      api,
+      clock,
+      validatorStore,
+      chainHeaderTracker,
+      syncingStatusTracker,
+      emitter
+    );
+
     const syncCommitteeService = new SyncCommitteeService(
       config,
       loggerVc,
@@ -338,6 +363,7 @@ export class Validator {
       blockProposingService,
       attestationService,
       ptcService,
+      inclusionListService,
       syncCommitteeService,
       config,
       api,
@@ -366,7 +392,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;
@@ -423,6 +450,7 @@ export class Validator {
     this.blockProposingService.removeDutiesForKey(pubkey);
     this.attestationService.removeDutiesForKey(pubkey);
     this.ptcService.removeDutiesForKey(pubkey);
+    this.inclusionListService.removeDutiesForKey(pubkey);
     this.syncCommitteeService.removeDutiesForKey(pubkey);
   }