@lodestar/validator 1.51.0-dev.4fa9ea1184 → 1.51.0-dev.5e25b73306

package/src/services/inclusionList.ts

@@ -0,0 +1,140 @@
+import {ApiClient, routes} from "@lodestar/api";
+import {ChainForkConfig} from "@lodestar/config";
+import {IClock} from "@lodestar/state-transition";
+import {Slot, bellatrix, heze} from "@lodestar/types";
+import {sleep} from "@lodestar/utils";
+import {PubkeyHex} from "../types.js";
+import {LoggerVc} from "../util/index.js";
+import {ChainHeaderTracker} from "./chainHeaderTracker.js";
+import {ExecutionPayloadImportedEventData, ValidatorEvent, ValidatorEventEmitter} from "./emitter.js";
+import {InclusionListDutiesService} from "./inclusionListDuties.js";
+import {SyncingStatusTracker} from "./syncingStatusTracker.js";
+import {ValidatorStore} from "./validatorStore.js";
+
+export class InclusionListService {
+  private readonly dutiesService: InclusionListDutiesService;
+
+  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 emitter: ValidatorEventEmitter
+  ) {
+    this.dutiesService = new InclusionListDutiesService(
+      config,
+      logger,
+      api,
+      clock,
+      validatorStore,
+      chainHeadTracker,
+      syncingStatusTracker
+    );
+
+    // At most every slot, check existing duties from InclusionListDutiesService and run tasks
+    clock.runEverySlot(this.runInclusionListTasks);
+  }
+
+  removeDutiesForKey(pubkey: PubkeyHex): void {
+    this.dutiesService.removeDutiesForKey(pubkey);
+  }
+
+  private runInclusionListTasks = async (slot: Slot, signal: AbortSignal): Promise<void> => {
+    if (this.dutiesService.getDutiesAtSlot(slot).length === 0) {
+      return;
+    }
+    // Spec: broadcast by get_inclusion_list_due_ms(). Wait until the beacon node imported the slot's payload,
+    // emitted once the execution client verified it and the fork choice update was queued, so the list is built
+    // from a mempool without that payload's transactions. Fall back to the deadline for empty or late slots.
+    const dueMs = Math.max(
+      0,
+      this.config.getInclusionListDueMs(this.config.getForkName(slot)) - this.clock.msFromSlot(slot)
+    );
+    // Publish ahead of the deadline so the list still counts as timely for peers
+    const beforeDueMs = 1000;
+    let resolvePayloadImported = (): void => {};
+    const payloadImported = new Promise<void>((resolve) => {
+      resolvePayloadImported = resolve;
+    });
+    const onPayloadImported = (payload: ExecutionPayloadImportedEventData): void => {
+      if (payload.slot === slot) {
+        resolvePayloadImported();
+      }
+    };
+    this.emitter.on(ValidatorEvent.executionPayloadImported, onPayloadImported);
+    try {
+      await Promise.race([sleep(Math.max(0, dueMs - beforeDueMs), signal), payloadImported]);
+    } finally {
+      this.emitter.off(ValidatorEvent.executionPayloadImported, onPayloadImported);
+    }
+
+    const inclusionListTransactions = await this.produceInclusionList(slot);
+
+    // Empty lists are ignored by gossip validation (consensus-specs#5576)
+    if (inclusionListTransactions.length === 0) {
+      this.logger.debug("Produced inclusion list has no transactions, skipping publish", {slot});
+      return;
+    }
+
+    // Read the duties after the wait, a reorg handled meanwhile may have changed the dependent root
+    const duties = this.dutiesService.getDutiesAtSlot(slot);
+    if (duties.length === 0) {
+      return;
+    }
+
+    await this.signAndPublishInclusionList(inclusionListTransactions, duties);
+  };
+
+  private async produceInclusionList(slot: Slot): Promise<bellatrix.Transactions> {
+    return (await this.api.validator.produceInclusionList({slot})).value();
+  }
+
+  /** One inclusion list per slot, signed by every validator on duty */
+  private async signAndPublishInclusionList(
+    inclusionListTransactions: bellatrix.Transactions,
+    duties: routes.validator.InclusionListDutyList
+  ) {
+    const signedInclusionLists: heze.SignedInclusionList[] = [];
+
+    await Promise.all(
+      duties.map(async (duty) => {
+        const inclusionList: heze.InclusionList = {
+          slot: duty.slot,
+          validatorIndex: duty.validatorIndex,
+          dependentRoot: duty.dependentRoot,
+          transactions: inclusionListTransactions,
+        };
+        try {
+          signedInclusionLists.push(await this.validatorStore.signInclusionList(duty, inclusionList));
+        } catch (e) {
+          this.logger.error(
+            "Error signing inclusion list",
+            {slot: duty.slot, validatorIndex: duty.validatorIndex},
+            e as Error
+          );
+        }
+      })
+    );
+
+    for (const signedInclusionList of signedInclusionLists) {
+      const {slot, validatorIndex, transactions} = signedInclusionList.message;
+      try {
+        (await this.api.validator.publishInclusionList({signedInclusionList})).assertOk();
+        this.logger.info("Published inclusionList", {
+          slot,
+          validatorIndex,
+          transactions: transactions.length,
+        });
+      } catch (e) {
+        this.logger.error(
+          "Error publishing inclusionList",
+          {slot, validatorIndex, transactions: transactions.length},
+          e as Error
+        );
+      }
+    }
+  }
+}

package/src/services/inclusionListDuties.ts

@@ -0,0 +1,306 @@
+import {ApiClient, routes} from "@lodestar/api";
+import {ChainForkConfig} from "@lodestar/config";
+import {SLOTS_PER_EPOCH} from "@lodestar/params";
+import {IClock, computeEpochAtSlot, isStartSlotOfEpoch} from "@lodestar/state-transition";
+import {Epoch, RootHex, Slot, ValidatorIndex} from "@lodestar/types";
+import {sleep, toPubkeyHex} from "@lodestar/utils";
+import {PubkeyHex} from "../types.js";
+import {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 InclusionListDuty = routes.validator.InclusionListDuty;
+// To assist with readability
+type InclusionListDutiesAtEpoch = {dependentRoot: RootHex; dutiesByIndex: Map<ValidatorIndex, InclusionListDuty>};
+
+/**
+ * Similar to AttestationDutiesService but
+ *   - No generating and caching selection proof
+ *   - No handling and maintaining subnet subscription
+ */
+export class InclusionListDutiesService {
+  /** Maps a validator index to its duty for each epoch */
+  private readonly dutiesByIndexByEpoch = new Map<Epoch, InclusionListDutiesAtEpoch>();
+  /**
+   * We may receive new dependentRoot of an epoch but it's not the last slot of epoch
+   * so we have to wait for getting close to the next epoch to redownload new inclusionListDuties.
+   */
+  private readonly pendingDependentRootByEpoch = new Map<Epoch, RootHex>();
+
+  constructor(
+    private readonly config: ChainForkConfig,
+    private readonly logger: LoggerVc,
+    private readonly api: ApiClient,
+    private clock: IClock,
+    private readonly validatorStore: ValidatorStore,
+    chainHeadTracker: ChainHeaderTracker,
+    syncingStatusTracker: SyncingStatusTracker
+  ) {
+    // Running this task every epoch is safe since a re-org of two epochs is very unlikely
+    clock.runEveryEpoch(this.runDutiesTasks);
+    clock.runEverySlot(this.prepareForNextEpoch);
+    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));
+      }
+    });
+  }
+
+  removeDutiesForKey(pubkey: PubkeyHex): void {
+    for (const [epoch, dutiesAtEpoch] of this.dutiesByIndexByEpoch) {
+      for (const [vIndex, duty] of dutiesAtEpoch.dutiesByIndex) {
+        if (toPubkeyHex(duty.pubkey) === pubkey) {
+          dutiesAtEpoch.dutiesByIndex.delete(vIndex);
+          if (dutiesAtEpoch.dutiesByIndex.size === 0) {
+            this.dutiesByIndexByEpoch.delete(epoch);
+          }
+        }
+      }
+    }
+  }
+
+  /** Returns all `ValidatorDuty` for the given `slot` */
+  getDutiesAtSlot(slot: Slot): InclusionListDuty[] {
+    const epoch = computeEpochAtSlot(slot);
+    const duties: InclusionListDuty[] = [];
+    const epochDuties = this.dutiesByIndexByEpoch.get(epoch);
+    if (epochDuties === undefined) {
+      return duties;
+    }
+
+    for (const validatorDuty of epochDuties.dutiesByIndex.values()) {
+      if (validatorDuty.slot === slot) {
+        duties.push(validatorDuty);
+      }
+    }
+
+    return duties;
+  }
+
+  /**
+   * If a reorg dependent root comes at a slot other than last slot of epoch
+   * just update this.pendingDependentRootByEpoch() and process here
+   */
+  private prepareForNextEpoch = async (slot: Slot, signal: AbortSignal): Promise<void> => {
+    // only interested in last slot of epoch
+    if ((slot + 1) % SLOTS_PER_EPOCH !== 0) {
+      return;
+    }
+
+    // during the 1 / 3 of epoch, last block of epoch may come
+    await sleep(this.clock.msToSlot(slot + 1 / 3), signal);
+
+    const nextEpoch = computeEpochAtSlot(slot) + 1;
+    const dependentRoot = this.dutiesByIndexByEpoch.get(nextEpoch)?.dependentRoot;
+    const pendingDependentRoot = this.pendingDependentRootByEpoch.get(nextEpoch);
+    if (dependentRoot && pendingDependentRoot && dependentRoot !== pendingDependentRoot) {
+      // this happens when pendingDependentRoot is not the last block of an epoch
+      this.logger.info("Redownload inclusion list duties when it's close to epoch boundary", {nextEpoch, slot});
+      await this.handleInclusionListDutiesReorg(nextEpoch, slot, dependentRoot, pendingDependentRoot);
+    }
+  };
+
+  private runDutiesTasks = async (epoch: Epoch): Promise<void> => {
+    // pollInclusionListCommittee also polls epoch + 1, so start one epoch before the fork
+    if (epoch + 1 < this.config.HEZE_FORK_EPOCH) {
+      return;
+    }
+
+    await Promise.all([
+      // Run pollInclusionListCommittee immediately for all known local indices
+      this.pollInclusionListCommittee(epoch, this.validatorStore.getAllLocalIndices()).catch((e: Error) => {
+        this.logger.error("Error on poll inclusion list committee", {epoch}, e);
+      }),
+
+      // At the same time fetch any remaining unknown validator indices, then poll duties for those newIndices only
+      this.validatorStore
+        .pollValidatorIndices()
+        .then((newIndices) => this.pollInclusionListCommittee(epoch, newIndices))
+        .catch((e: Error) => {
+          this.logger.error("Error on poll indices and inclusion list committee", {epoch}, e);
+        }),
+    ]);
+
+    // After both, prune
+    this.pruneOldDuties(epoch);
+  };
+
+  private async pollInclusionListCommittee(currentEpoch: Epoch, indexArr: ValidatorIndex[]): Promise<void> {
+    const nextEpoch = currentEpoch + 1;
+
+    // No need to bother the BN if we don't have any validators.
+    if (indexArr.length === 0) {
+      return;
+    }
+
+    for (const epoch of [currentEpoch, nextEpoch]) {
+      // Download the duties and update the duties for the current and next epoch.
+      await this.pollInclusionListCommitteeForEpoch(epoch, indexArr).catch((e: Error) => {
+        this.logger.error("Failed to download inclusion list duties", {epoch}, e);
+      });
+    }
+  }
+
+  /**
+   * For the given `indexArr`, download the duties for the given `epoch` and store them in duties.
+   */
+  private async pollInclusionListCommitteeForEpoch(epoch: Epoch, indexArr: ValidatorIndex[]): Promise<void> {
+    // Don't fetch duties for epochs before genesis. However, should fetch epoch 0 duties at epoch -1
+    if (epoch < 0) {
+      return;
+    }
+
+    // Inclusion list committees only exist post-heze; the beacon node rejects earlier epochs
+    if (epoch < this.config.HEZE_FORK_EPOCH) {
+      return;
+    }
+
+    const res = await this.api.validator.getInclusionListCommitteeDuties({epoch, indices: indexArr});
+    const inclusionListDuties = res.value();
+    const {dependentRoot} = res.meta();
+    const relevantDuties = inclusionListDuties.filter((duty) => {
+      const pubkeyHex = toPubkeyHex(duty.pubkey);
+      return this.validatorStore.hasVotingPubkey(pubkeyHex) && this.validatorStore.isDoppelgangerSafe(pubkeyHex);
+    });
+
+    this.logger.debug("Downloaded inclusion list 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, InclusionListDuty>();
+      for (const duty of relevantDuties) {
+        dutiesByIndex.set(duty.validatorIndex, duty);
+      }
+      this.dutiesByIndexByEpoch.set(epoch, {dependentRoot, dutiesByIndex});
+
+      if (priorDependentRoot && dependentRootChanged) {
+        this.logger.warn("Inclusion list duties re-org. This may happen from time to time", {
+          priorDependentRoot: priorDependentRoot,
+          dependentRoot: dependentRoot,
+          epoch,
+        });
+      }
+    } else {
+      const existingDuties = dutiesAtEpoch.dutiesByIndex;
+      const existingDutiesCount = existingDuties.size;
+      for (const duty of relevantDuties) {
+        if (!existingDuties.has(duty.validatorIndex)) {
+          existingDuties.set(duty.validatorIndex, duty);
+        }
+      }
+
+      if (existingDuties.size > existingDutiesCount) {
+        this.logger.debug("Discovered new inclusion list duties", {
+          epoch,
+          dependentRoot,
+          count: existingDuties.size - existingDutiesCount,
+        });
+      }
+    }
+  }
+
+  private async handleInclusionListDutiesReorg(
+    dutyEpoch: Epoch,
+    slot: Slot,
+    oldDependentRoot: RootHex,
+    newDependentRoot: RootHex
+  ): Promise<void> {
+    const logContext = {dutyEpoch, slot, oldDependentRoot, newDependentRoot};
+    this.logger.debug("Redownload inclusion list duties", logContext);
+
+    await this.pollInclusionListCommitteeForEpoch(dutyEpoch, this.validatorStore.getAllLocalIndices())
+      .then(() => {
+        this.pendingDependentRootByEpoch.delete(dutyEpoch);
+      })
+      .catch((e: Error) => {
+        this.logger.error("Failed to redownload inclusion list duties when reorg happens", logContext, e);
+      });
+  }
+
+  /**
+   * inclusion list duties may be reorged due to 2 scenarios:
+   *   1. node is syncing (for nextEpoch duties)
+   *   2. node is reorged
+   * previousDutyDependentRoot = get_block_root_at_slot(state, compute_start_slot_at_epoch(epoch - 1) - 1)
+   *   => dependent root of current epoch
+   * currentDutyDependentRoot = get_block_root_at_slot(state, compute_start_slot_at_epoch(epoch) - 1)
+   *   => dependent root of next epoch
+   */
+  private onNewHead = async ({
+    slot,
+    head,
+    previousDutyDependentRoot,
+    currentDutyDependentRoot,
+  }: HeadEventData): Promise<void> => {
+    const currentEpoch = computeEpochAtSlot(slot);
+    const nextEpoch = currentEpoch + 1;
+    const nextTwoEpoch = currentEpoch + 2;
+    const nextTwoEpochDependentRoot = this.dutiesByIndexByEpoch.get(currentEpoch + 2)?.dependentRoot;
+
+    // this may happen ONLY when node is syncing
+    // it's safe to get inclusion list duties at epoch n + 1 thanks to nextEpochShuffling cache
+    // but it's an issue to request inclusion list duties for epoch n + 2 as dependent root keeps changing while node is syncing
+    // see https://github.com/ChainSafe/lodestar/issues/3211
+    if (nextTwoEpochDependentRoot && head !== nextTwoEpochDependentRoot) {
+      // last slot of epoch, we're sure it's the correct dependent root
+      if ((slot + 1) % SLOTS_PER_EPOCH === 0) {
+        this.logger.info("Next 2 epoch inclusion list duties reorg", {slot, dutyEpoch: nextTwoEpoch, head});
+        await this.handleInclusionListDutiesReorg(nextTwoEpoch, slot, nextTwoEpochDependentRoot, head);
+      } else {
+        this.logger.debug("Potential next 2 epoch inclusion list duties reorg", {slot, dutyEpoch: nextTwoEpoch, head});
+        // node may send adjacent onHead events while it's syncing
+        // wait for getting close to next epoch to make sure the dependRoot
+        this.pendingDependentRootByEpoch.set(nextTwoEpoch, head);
+      }
+    }
+
+    // dependent root for next epoch changed
+    const nextEpochDependentRoot = this.dutiesByIndexByEpoch.get(nextEpoch)?.dependentRoot;
+    if (nextEpochDependentRoot && currentDutyDependentRoot !== nextEpochDependentRoot) {
+      this.logger.warn("Potential next epoch inclusion list duties reorg", {
+        slot,
+        dutyEpoch: nextEpoch,
+        priorDependentRoot: nextEpochDependentRoot,
+        newDependentRoot: currentDutyDependentRoot,
+      });
+      await this.handleInclusionListDutiesReorg(nextEpoch, slot, nextEpochDependentRoot, currentDutyDependentRoot);
+    }
+
+    // dependent root for current epoch changed
+    const currentEpochDependentRoot = this.dutiesByIndexByEpoch.get(currentEpoch)?.dependentRoot;
+    if (currentEpochDependentRoot && currentEpochDependentRoot !== previousDutyDependentRoot) {
+      this.logger.warn("Potential current epoch inclusion list duties reorg", {
+        slot,
+        dutyEpoch: currentEpoch,
+        priorDependentRoot: currentEpochDependentRoot,
+        newDependentRoot: previousDutyDependentRoot,
+      });
+      await this.handleInclusionListDutiesReorg(
+        currentEpoch,
+        slot,
+        currentEpochDependentRoot,
+        previousDutyDependentRoot
+      );
+    }
+  };
+
+  /** Run once per epoch to prune duties map */
+  private pruneOldDuties(currentEpoch: Epoch): void {
+    for (const byEpochMap of [this.dutiesByIndexByEpoch, this.pendingDependentRootByEpoch]) {
+      for (const epoch of byEpochMap.keys()) {
+        if (epoch + HISTORICAL_DUTIES_EPOCHS < currentEpoch) {
+          byEpochMap.delete(epoch);
+        }
+      }
+    }
+  }
+}

package/src/services/validatorStore.ts

@@ -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";
@@ -954,6 +956,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 +1248,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/util/externalSignerClient.ts

@@ -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({
@@ -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

@@ -27,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";
@@ -53,6 +54,7 @@ export type ValidatorModules = {
   blockProposingService: BlockProposingService;
   attestationService: AttestationService;
   ptcService: PtcService;
+  inclusionListService: InclusionListService;
   syncCommitteeService: SyncCommitteeService;
   config: BeaconConfig;
   api: ApiClient;
@@ -109,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;
@@ -128,6 +131,7 @@ export class Validator {
     blockProposingService,
     attestationService,
     ptcService,
+    inclusionListService,
     syncCommitteeService,
     config,
     api,
@@ -145,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;
@@ -312,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,
@@ -347,6 +363,7 @@ export class Validator {
       blockProposingService,
       attestationService,
       ptcService,
+      inclusionListService,
       syncCommitteeService,
       config,
       api,
@@ -433,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);
   }