@lodestar/validator 1.35.0-dev.f80d2d52da → 1.35.0-dev.fd1dac853d

package/src/services/syncCommittee.ts

@@ -0,0 +1,338 @@
+import {ApiClient, routes} from "@lodestar/api";
+import {ChainForkConfig} from "@lodestar/config";
+import {ForkName, isForkPostAltair} from "@lodestar/params";
+import {isSyncCommitteeAggregator} from "@lodestar/state-transition";
+import {BLSSignature, CommitteeIndex, Root, Slot, altair} from "@lodestar/types";
+import {sleep} from "@lodestar/utils";
+import {Metrics} from "../metrics.js";
+import {PubkeyHex} from "../types.js";
+import {IClock, LoggerVc} from "../util/index.js";
+import {ChainHeaderTracker} from "./chainHeaderTracker.js";
+import {ValidatorEventEmitter} from "./emitter.js";
+import {SyncCommitteeDutiesService, SyncDutyAndProofs} from "./syncCommitteeDuties.js";
+import {SyncingStatusTracker} from "./syncingStatusTracker.js";
+import {SubcommitteeDuty, groupSyncDutiesBySubcommitteeIndex} from "./utils.js";
+import {ValidatorStore} from "./validatorStore.js";
+
+export type SyncCommitteeServiceOpts = {
+  scAfterBlockDelaySlotFraction?: number;
+  distributedAggregationSelection?: boolean;
+};
+
+/**
+ * Service that sets up and handles validator sync duties.
+ */
+export class SyncCommitteeService {
+  private readonly dutiesService: SyncCommitteeDutiesService;
+
+  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,
+    private readonly chainHeaderTracker: ChainHeaderTracker,
+    readonly syncingStatusTracker: SyncingStatusTracker,
+    private readonly metrics: Metrics | null,
+    private readonly opts?: SyncCommitteeServiceOpts
+  ) {
+    this.dutiesService = new SyncCommitteeDutiesService(
+      config,
+      logger,
+      api,
+      clock,
+      validatorStore,
+      syncingStatusTracker,
+      metrics,
+      {
+        distributedAggregationSelection: opts?.distributedAggregationSelection,
+      }
+    );
+
+    // At most every slot, check existing duties from SyncCommitteeDutiesService and run tasks
+    clock.runEverySlot(this.runSyncCommitteeTasks);
+  }
+
+  removeDutiesForKey(pubkey: PubkeyHex): void {
+    this.dutiesService.removeDutiesForKey(pubkey);
+  }
+
+  private runSyncCommitteeTasks = async (slot: Slot, signal: AbortSignal): Promise<void> => {
+    const fork = this.config.getForkName(slot);
+
+    try {
+      // Before altair fork no need to check duties
+      if (!isForkPostAltair(fork)) {
+        return;
+      }
+
+      // Fetch info first so a potential delay is absorbed by the sleep() below
+      const dutiesAtSlot = await this.dutiesService.getDutiesAtSlot(slot);
+      if (dutiesAtSlot.length === 0) {
+        return;
+      }
+
+      if (this.opts?.distributedAggregationSelection) {
+        // Validator in distributed cluster only has a key share, not the full private key.
+        // The partial selection proofs must be exchanged for combined selection proofs by
+        // calling submitSyncCommitteeSelections on the distributed validator middleware client.
+        // This will run in parallel to other sync committee tasks but must be finished before starting
+        // sync committee contributions as it is required to correctly determine if validator is aggregator
+        // and to produce a ContributionAndProof that can be threshold aggregated by the middleware client.
+        this.runDistributedAggregationSelectionTasks(fork, dutiesAtSlot, slot, signal).catch((e) =>
+          this.logger.error("Error on sync committee aggregation selection", {slot}, e)
+        );
+      }
+
+      // unlike Attestation, SyncCommitteeSignature could be published asap
+      // especially with lodestar, it's very busy at ATTESTATION_DUE_BPS of the slot
+      // see https://github.com/ChainSafe/lodestar/issues/4608
+      const syncMessageDueMs = this.config.getSyncMessageDueMs(fork);
+      await Promise.race([
+        sleep(syncMessageDueMs - this.clock.msFromSlot(slot), signal),
+        this.emitter.waitForBlockSlot(slot),
+      ]);
+      this.metrics?.syncCommitteeStepCallProduceMessage.observe(this.clock.secFromSlot(slot) - syncMessageDueMs / 1000);
+
+      // Step 1. Download, sign and publish an `SyncCommitteeMessage` for each validator.
+      //         Differs from AttestationService, `SyncCommitteeMessage` are equal for all
+      const beaconBlockRoot = await this.produceAndPublishSyncCommittees(fork, slot, dutiesAtSlot);
+
+      // Step 2. If an attestation was produced, make an aggregate.
+      // First, wait until the `CONTRIBUTION_DUE_BPS` of the slot
+      const syncContributionDueMs = this.config.getSyncContributionDueMs(fork);
+      await sleep(syncContributionDueMs - this.clock.msFromSlot(slot), signal);
+      this.metrics?.syncCommitteeStepCallProduceAggregate.observe(
+        this.clock.secFromSlot(slot) - syncContributionDueMs / 1000
+      );
+
+      // await for all so if the Beacon node is overloaded it auto-throttles
+      // TODO: This approach is conservative to reduce the node's load, review
+      const dutiesBySubcommitteeIndex = groupSyncDutiesBySubcommitteeIndex(dutiesAtSlot);
+      await Promise.all(
+        Array.from(dutiesBySubcommitteeIndex.entries()).map(async ([subcommitteeIndex, duties]) => {
+          if (duties.length === 0) return;
+          // Then download, sign and publish a `SignedAggregateAndProof` for each
+          // validator that is elected to aggregate for this `slot` and `subcommitteeIndex`.
+          await this.produceAndPublishAggregates(fork, slot, subcommitteeIndex, beaconBlockRoot, duties).catch(
+            (e: Error) => {
+              this.logger.error("Error on SyncCommitteeContribution", {slot, index: subcommitteeIndex}, e);
+            }
+          );
+        })
+      );
+    } catch (e) {
+      this.logger.error("Error on runSyncCommitteeTasks", {slot}, e as Error);
+    }
+  };
+
+  /**
+   * Performs the first step of the attesting process: downloading `SyncCommittee` objects,
+   * signing them and returning them to the validator.
+   *
+   * https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/altair/validator.md#sync-committee-messages
+   *
+   * Only one `SyncCommittee` is downloaded from the BN. It is then signed by each
+   * validator and the list of individually-signed `SyncCommittee` objects is returned to the BN.
+   */
+  private async produceAndPublishSyncCommittees(
+    fork: ForkName,
+    slot: Slot,
+    duties: SyncDutyAndProofs[]
+  ): Promise<Root> {
+    const logCtx = {slot};
+
+    // /eth/v1/beacon/blocks/:blockId/root -> at slot -1
+
+    // Produce one attestation data per slot and subcommitteeIndex
+    // Spec: the validator should prepare a SyncCommitteeMessage for the previous slot (slot - 1)
+    // as soon as they have determined the head block of slot - 1
+
+    const blockRoot: Uint8Array =
+      this.chainHeaderTracker.getCurrentChainHead(slot) ??
+      (await this.api.beacon.getBlockRoot({blockId: "head"})).value().root;
+
+    const signatures: altair.SyncCommitteeMessage[] = [];
+
+    await Promise.all(
+      duties.map(async ({duty}) => {
+        const logCtxValidator = {...logCtx, validatorIndex: duty.validatorIndex};
+        try {
+          signatures.push(
+            await this.validatorStore.signSyncCommitteeSignature(duty.pubkey, duty.validatorIndex, slot, blockRoot)
+          );
+          this.logger.debug("Signed SyncCommitteeMessage", logCtxValidator);
+        } catch (e) {
+          this.logger.error("Error signing SyncCommitteeMessage", logCtxValidator, e as Error);
+        }
+      })
+    );
+
+    // by default we want to submit SyncCommitteeSignature asap after we receive block
+    // provide a delay option just in case any client implementation validate the existence of block in
+    // SyncCommitteeSignature gossip validation.
+    const syncMessageDueMs = this.config.getSyncMessageDueMs(fork);
+    const msToCutoffTime = syncMessageDueMs - this.clock.msFromSlot(slot);
+    const afterBlockDelayMs = 1000 * this.clock.secondsPerSlot * (this.opts?.scAfterBlockDelaySlotFraction ?? 0);
+    const toDelayMs = Math.min(msToCutoffTime, afterBlockDelayMs);
+    if (toDelayMs > 0) {
+      await sleep(toDelayMs);
+    }
+
+    this.metrics?.syncCommitteeStepCallPublishMessage.observe(this.clock.secFromSlot(slot) - syncMessageDueMs / 1000);
+
+    if (signatures.length > 0) {
+      try {
+        (await this.api.beacon.submitPoolSyncCommitteeSignatures({signatures})).assertOk();
+        this.logger.info("Published SyncCommitteeMessage", {...logCtx, count: signatures.length});
+        this.metrics?.publishedSyncCommitteeMessage.inc(signatures.length);
+      } catch (e) {
+        this.logger.error("Error publishing SyncCommitteeMessage", logCtx, e as Error);
+      }
+    }
+
+    return blockRoot;
+  }
+
+  /**
+   * Performs the second step of the attesting process: downloading an aggregated `SyncCommittee`,
+   * converting it into a `SignedAggregateAndProof` and returning it to the BN.
+   *
+   * https://github.com/ethereum/consensus-specs/blob/v1.1.10/specs/altair/validator.md#sync-committee-contributions
+   *
+   * Only one aggregated `SyncCommittee` is downloaded from the BN. It is then signed
+   * by each validator and the list of individually-signed `SignedAggregateAndProof` objects is
+   * returned to the BN.
+   */
+  private async produceAndPublishAggregates(
+    fork: ForkName,
+    slot: Slot,
+    subcommitteeIndex: CommitteeIndex,
+    beaconBlockRoot: Root,
+    duties: SubcommitteeDuty[]
+  ): Promise<void> {
+    const logCtx = {slot, index: subcommitteeIndex};
+
+    // No validator is aggregator, skip
+    if (duties.every(({selectionProof}) => selectionProof === null)) {
+      return;
+    }
+
+    this.logger.verbose("Producing SyncCommitteeContribution", logCtx);
+    const res = await this.api.validator.produceSyncCommitteeContribution({slot, subcommitteeIndex, beaconBlockRoot});
+
+    const signedContributions: altair.SignedContributionAndProof[] = [];
+
+    await Promise.all(
+      duties.map(async ({duty, selectionProof}) => {
+        const logCtxValidator = {...logCtx, validatorIndex: duty.validatorIndex};
+        try {
+          // Produce signed contributions only for validators that are subscribed aggregators.
+          if (selectionProof !== null) {
+            signedContributions.push(
+              await this.validatorStore.signContributionAndProof(duty, selectionProof, res.value())
+            );
+            this.logger.debug("Signed SyncCommitteeContribution", logCtxValidator);
+          }
+        } catch (e) {
+          this.logger.error("Error signing SyncCommitteeContribution", logCtxValidator, e as Error);
+        }
+      })
+    );
+
+    this.metrics?.syncCommitteeStepCallPublishAggregate.observe(
+      this.clock.secFromSlot(slot) - this.config.getSyncContributionDueMs(fork) / 1000
+    );
+
+    if (signedContributions.length > 0) {
+      try {
+        (
+          await this.api.validator.publishContributionAndProofs({contributionAndProofs: signedContributions})
+        ).assertOk();
+        this.logger.info("Published SyncCommitteeContribution", {...logCtx, count: signedContributions.length});
+        this.metrics?.publishedSyncCommitteeContribution.inc(signedContributions.length);
+      } catch (e) {
+        this.logger.error("Error publishing SyncCommitteeContribution", logCtx, e as Error);
+      }
+    }
+  }
+
+  /**
+   * Performs additional sync committee contribution tasks required if validator is part of distributed cluster
+   *
+   * 1. Exchange partial for combined selection proofs
+   * 2. Determine validators that should produce sync committee contribution
+   * 3. Mutate duty objects to set selection proofs for aggregators
+   *
+   * See https://docs.google.com/document/d/1q9jOTPcYQa-3L8luRvQJ-M0eegtba4Nmon3dpO79TMk/mobilebasic
+   */
+  private async runDistributedAggregationSelectionTasks(
+    fork: ForkName,
+    duties: SyncDutyAndProofs[],
+    slot: number,
+    signal: AbortSignal
+  ): Promise<void> {
+    const partialSelections: routes.validator.SyncCommitteeSelection[] = [];
+
+    for (const {duty, selectionProofs} of duties) {
+      const validatorSelections: routes.validator.SyncCommitteeSelection[] = selectionProofs.map(
+        ({subcommitteeIndex, partialSelectionProof}) => ({
+          validatorIndex: duty.validatorIndex,
+          slot,
+          subcommitteeIndex,
+          selectionProof: partialSelectionProof as BLSSignature,
+        })
+      );
+      partialSelections.push(...validatorSelections);
+    }
+
+    this.logger.debug("Submitting partial sync committee selection proofs", {slot, count: partialSelections.length});
+
+    const res = await Promise.race([
+      this.api.validator.submitSyncCommitteeSelections({selections: partialSelections}),
+      // Exit sync committee contributions flow if there is no response after CONTRIBUTION_DUE_BPS of the slot.
+      // This is in contrast to attestations aggregations flow which is already exited at ATTESTATION_DUE_BPS of the slot
+      // because for sync committee is not required to resubscribe to subnets as beacon node will assume
+      // validator always aggregates. This allows us to wait until we have to produce sync committee contributions.
+      // Note that the sync committee contributions flow is not explicitly exited but rather will be skipped
+      // due to the fact that calculation of `is_sync_committee_aggregator` in SyncCommitteeDutiesService is not done
+      // and selectionProof is set to null, meaning no validator will be considered an aggregator.
+      sleep(this.config.getSyncContributionDueMs(fork) - this.clock.msFromSlot(slot), signal),
+    ]);
+
+    if (!res) {
+      throw new Error("Failed to receive combined selection proofs before CONTRIBUTION_DUE_BPS of the slot");
+    }
+
+    const combinedSelections = res.value();
+    this.logger.debug("Received combined sync committee selection proofs", {slot, count: combinedSelections.length});
+
+    for (const dutyAndProofs of duties) {
+      const {validatorIndex, subnets} = dutyAndProofs.duty;
+
+      for (const subnet of subnets) {
+        const logCtxValidator = {slot, index: subnet, validatorIndex};
+
+        const combinedSelection = combinedSelections.find(
+          (s) => s.validatorIndex === validatorIndex && s.slot === slot && s.subcommitteeIndex === subnet
+        );
+
+        if (!combinedSelection) {
+          this.logger.warn("Did not receive combined sync committee selection proof", logCtxValidator);
+          continue;
+        }
+
+        const isAggregator = isSyncCommitteeAggregator(combinedSelection.selectionProof);
+
+        if (isAggregator) {
+          const selectionProofObject = dutyAndProofs.selectionProofs.find((p) => p.subcommitteeIndex === subnet);
+          if (selectionProofObject) {
+            // Update selection proof by mutating proof objects in duty object
+            selectionProofObject.selectionProof = combinedSelection.selectionProof;
+          }
+        }
+      }
+    }
+  }
+}

package/src/services/syncCommitteeDuties.ts

@@ -0,0 +1,337 @@
+import {ApiClient, routes} from "@lodestar/api";
+import {ChainForkConfig} from "@lodestar/config";
+import {EPOCHS_PER_SYNC_COMMITTEE_PERIOD, SYNC_COMMITTEE_SUBNET_SIZE} from "@lodestar/params";
+import {
+  computeEpochAtSlot,
+  computeSyncPeriodAtEpoch,
+  computeSyncPeriodAtSlot,
+  isStartSlotOfEpoch,
+  isSyncCommitteeAggregator,
+} from "@lodestar/state-transition";
+import {BLSSignature, Epoch, Slot, SyncPeriod, 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 {SyncingStatusTracker} from "./syncingStatusTracker.js";
+import {syncCommitteeIndicesToSubnets} from "./utils.js";
+import {ValidatorStore} from "./validatorStore.js";
+
+/** Only retain `HISTORICAL_DUTIES_PERIODS` duties prior to the current periods. */
+const HISTORICAL_DUTIES_PERIODS = 2;
+/**
+ * Epochs prior to `ALTAIR_FORK_EPOCH` to start fetching duties
+ *
+ * UPDATE: Setting it to 0 from 1, because looking ahead caused an "Empty SyncCommitteeCache"
+ * error (https://github.com/ChainSafe/lodestar/issues/3752) as currently the lodestar
+ * beacon's pre-altair placeholder object SyncCommitteeCacheEmpty just throws on
+ * any getter.
+ * This can be updated back to 1, once SyncCommitteeCacheEmpty supports the duties
+ * look-ahead. It can also be later turned as a cli param to interface with another
+ * client's beacon, which supports look-ahead of duties.
+ */
+const ALTAIR_FORK_LOOKAHEAD_EPOCHS = 0;
+/** How many epochs prior from a subscription starting, ask the node to subscribe */
+const SUBSCRIPTIONS_LOOKAHEAD_EPOCHS = 2;
+
+export type SyncDutySubnet = {
+  pubkey: string;
+  /** Index of validator in validator registry. */
+  validatorIndex: ValidatorIndex;
+  /**
+   * The indices of the validator in the sync committee.
+   * The same validator can appear multiples in the sync committee. Given how sync messages are constructor, the
+   * validator client only cares in which subnets the validator is in, not the specific index.
+   */
+  subnets: number[];
+};
+
+export type SyncSelectionProof = {
+  /** This value is only set to not null if the proof indicates that the validator is an aggregator. */
+  selectionProof: BLSSignature | null;
+  /** This value will only be set if validator is part of distributed cluster and only has a key share */
+  partialSelectionProof?: BLSSignature;
+  subcommitteeIndex: number;
+};
+
+/** Neatly joins SyncDuty with the locally-generated `selectionProof`. */
+export type SyncDutyAndProofs = {
+  duty: SyncDutySubnet;
+  /**
+   * Array because the same validator can appear multiple times in the sync committee.
+   * `routes.validator.SyncDuty` `.validatorSyncCommitteeIndices` is an array for that reason.
+   * SelectionProof signs over slot + index in committee, so the length of `.selectionProofs` equals
+   * `.validatorSyncCommitteeIndices`.
+   */
+  selectionProofs: SyncSelectionProof[];
+};
+
+// To assist with readability
+type DutyAtPeriod = {duty: SyncDutySubnet};
+
+type SyncCommitteeDutiesServiceOpts = {
+  distributedAggregationSelection?: boolean;
+};
+
+/**
+ * Validators are part of a static long (~27h) sync committee, and part of static subnets.
+ * However, the isAggregator role changes per slot.
+ */
+export class SyncCommitteeDutiesService {
+  /** Maps a validator public key to their duties for each slot */
+  private readonly dutiesByIndexByPeriod = new Map<SyncPeriod, Map<ValidatorIndex, DutyAtPeriod>>();
+
+  constructor(
+    private readonly config: ChainForkConfig,
+    private readonly logger: LoggerVc,
+    private readonly api: ApiClient,
+    clock: IClock,
+    private readonly validatorStore: ValidatorStore,
+    syncingStatusTracker: SyncingStatusTracker,
+    metrics: Metrics | null,
+    private readonly opts?: SyncCommitteeDutiesServiceOpts
+  ) {
+    // Running this task every epoch is safe since a re-org of many epochs is very unlikely
+    // TODO: If the re-org event is reliable consider re-running then
+    clock.runEveryEpoch(this.runDutiesTasks);
+    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.syncCommitteeDutiesCount.addCollect(() => {
+        let duties = 0;
+        for (const dutiesByIndex of this.dutiesByIndexByPeriod.values()) {
+          duties += dutiesByIndex.size;
+        }
+        metrics.syncCommitteeDutiesCount.set(duties);
+        metrics.syncCommitteeDutiesEpochCount.set(this.dutiesByIndexByPeriod.size);
+      });
+    }
+  }
+
+  /**
+   * Returns all `ValidatorDuty` for the given `slot`
+   *
+   * Note: The range of slots a validator has to perform duties is off by one.
+   * The previous slot wording means that if your validator is in a sync committee for a period that runs from slot
+   * 100 to 200,then you would actually produce signatures in slot 99 - 199.
+   * https://github.com/ethereum/consensus-specs/pull/2400
+   */
+  async getDutiesAtSlot(slot: Slot): Promise<SyncDutyAndProofs[]> {
+    const period = computeSyncPeriodAtSlot(slot + 1); // See note above for the +1 offset
+    const duties: SyncDutyAndProofs[] = [];
+
+    const dutiesByIndex = this.dutiesByIndexByPeriod.get(period);
+    if (dutiesByIndex) {
+      for (const dutyAtPeriod of dutiesByIndex.values()) {
+        // Validator always has a duty during the entire period
+        duties.push({
+          duty: dutyAtPeriod.duty,
+          selectionProofs: await this.getSelectionProofs(slot, dutyAtPeriod.duty),
+        });
+      }
+    }
+
+    return duties;
+  }
+
+  removeDutiesForKey(pubkey: PubkeyHex): void {
+    for (const [syncPeriod, validatorDutyAtPeriodMap] of this.dutiesByIndexByPeriod) {
+      for (const [validatorIndex, dutyAtPeriod] of validatorDutyAtPeriodMap) {
+        if (dutyAtPeriod.duty.pubkey === pubkey) {
+          validatorDutyAtPeriodMap.delete(validatorIndex);
+          if (validatorDutyAtPeriodMap.size === 0) {
+            this.dutiesByIndexByPeriod.delete(syncPeriod);
+          }
+        }
+      }
+    }
+  }
+
+  private runDutiesTasks = async (currentEpoch: Epoch): Promise<void> => {
+    // Before altair fork (+ lookahead) no need to check duties
+    if (currentEpoch < this.config.ALTAIR_FORK_EPOCH - ALTAIR_FORK_LOOKAHEAD_EPOCHS) {
+      return;
+    }
+
+    await Promise.all([
+      // Run pollSyncCommittees immediately for all known local indices
+      this.pollSyncCommittees(currentEpoch, this.validatorStore.getAllLocalIndices()).catch((e: Error) => {
+        this.logger.error("Error on poll SyncDuties", {epoch: currentEpoch}, e);
+      }),
+
+      // At the same time fetch any remaining unknown validator indices, then poll duties for those newIndices only
+      this.validatorStore
+        .pollValidatorIndices()
+        .then((newIndices) => this.pollSyncCommittees(currentEpoch, newIndices))
+        .catch((e: Error) => {
+          this.logger.error("Error on poll indices and SyncDuties", {epoch: currentEpoch}, e);
+        }),
+    ]);
+
+    // After both, prune
+    this.pruneOldDuties(currentEpoch);
+  };
+
+  /**
+   * Query the beacon node for SyncDuties for any known validators.
+   *
+   * This function will perform (in the following order):
+   *
+   * 1. Poll for current-period duties and update the local duties map.
+   * 2. As above, but for the next-period.
+   * 3. Push out any Sync subnet subscriptions to the BN.
+   * 4. Prune old entries from duties.
+   */
+  private async pollSyncCommittees(currentEpoch: Epoch, indexArr: ValidatorIndex[]): Promise<void> {
+    // No need to bother the BN if we don't have any validators.
+    if (indexArr.length === 0) {
+      return;
+    }
+
+    const nextPeriodEpoch = currentEpoch + EPOCHS_PER_SYNC_COMMITTEE_PERIOD;
+    for (const epoch of [currentEpoch, nextPeriodEpoch]) {
+      // Download the duties and update the duties for the current and next period.
+      await this.pollSyncCommitteesForEpoch(epoch, indexArr).catch((e: Error) => {
+        this.logger.error("Failed to download SyncDuties", {epoch}, e);
+      });
+    }
+
+    const currentPeriod = computeSyncPeriodAtEpoch(currentEpoch);
+    const syncCommitteeSubscriptions: routes.validator.SyncCommitteeSubscription[] = [];
+
+    // For this and the next period, produce any beacon committee subscriptions.
+    //
+    // We are *always* pushing out subscriptions, even if we've subscribed before. This is
+    // potentially excessive on the BN in normal cases, but it will help with fast re-subscriptions
+    // if the BN goes offline or we swap to a different one.
+    const indexSet = new Set(indexArr);
+    for (const period of [currentPeriod, currentPeriod + 1]) {
+      const dutiesByIndex = this.dutiesByIndexByPeriod.get(period);
+      if (dutiesByIndex) {
+        for (const [validatorIndex, dutyAtEpoch] of dutiesByIndex.entries()) {
+          if (indexSet.has(validatorIndex)) {
+            const fromEpoch = period * EPOCHS_PER_SYNC_COMMITTEE_PERIOD;
+            const untilEpoch = (period + 1) * EPOCHS_PER_SYNC_COMMITTEE_PERIOD;
+            // Don't subscribe too early to save node's resources
+            if (currentEpoch >= fromEpoch - SUBSCRIPTIONS_LOOKAHEAD_EPOCHS) {
+              syncCommitteeSubscriptions.push({
+                validatorIndex,
+                // prepareSyncCommitteeSubnets does not care about which specific index in the sync committee the
+                // validator is, but at what subnets is it participating.
+                syncCommitteeIndices: dutyAtEpoch.duty.subnets.map((subnet) => subnet * SYNC_COMMITTEE_SUBNET_SIZE),
+                untilEpoch,
+                // No need to send isAggregator here since the beacon node will assume validator always aggregates
+              });
+            }
+          }
+        }
+      }
+    }
+
+    // If there are any subscriptions, push them out to the beacon node.
+    if (syncCommitteeSubscriptions.length > 0) {
+      // TODO: Should log or throw?
+      (await this.api.validator.prepareSyncCommitteeSubnets({subscriptions: syncCommitteeSubscriptions})).assertOk();
+    }
+  }
+
+  /**
+   * For the given `indexArr`, download the duties for the given `period` and store them in duties.
+   */
+  private async pollSyncCommitteesForEpoch(epoch: Epoch, indexArr: ValidatorIndex[]): Promise<void> {
+    // Don't fetch duties for periods before genesis. However, should fetch period 0 duties at period -1
+    if (epoch < 0) {
+      return;
+    }
+
+    const duties = (await this.api.validator.getSyncCommitteeDuties({epoch, indices: indexArr})).value();
+
+    const dutiesByIndex = new Map<ValidatorIndex, DutyAtPeriod>();
+    let count = 0;
+
+    for (const duty of duties) {
+      const {validatorIndex} = duty;
+      if (!this.validatorStore.hasValidatorIndex(validatorIndex)) {
+        continue;
+      }
+      count++;
+
+      // Note: For networks where `state.validators.length < SYNC_COMMITTEE_SIZE` the same validator can appear
+      // multiple times in the sync committee. So `routes.validator.SyncDuty` `.validatorSyncCommitteeIndices`
+      // is an array, with all of those appearances.
+      //
+      // Validator signs two messages:
+      // `SyncCommitteeMessage`:
+      //  - depends on slot, blockRoot, and validatorIndex.
+      //  - Validator signs and publishes only one message regardless of validatorSyncCommitteeIndices length
+      // `SyncCommitteeContribution`:
+      //  - depends on slot, blockRoot, validatorIndex, and subnet.
+      //  - Validator must sign and publish only one message per subnet MAX. Regardless of validatorSyncCommitteeIndices
+      const subnets = syncCommitteeIndicesToSubnets(duty.validatorSyncCommitteeIndices);
+
+      // TODO: Enable dependentRoot functionality
+      // Meanwhile just overwrite them, since the latest duty will be older and less likely to re-org
+      //
+      // Only update the duties if either is true:
+      //
+      // - There were no known duties for this period.
+      // - The dependent root has changed, signalling a re-org.
+      //
+      // if (reorg) this.metrics?.syncCommitteeDutiesReorg.inc()
+      //
+      // Using `alreadyWarnedReorg` avoids excessive logs.
+
+      // TODO: Use memory-efficient toHexString()
+      const pubkeyHex = toPubkeyHex(duty.pubkey);
+      dutiesByIndex.set(validatorIndex, {duty: {pubkey: pubkeyHex, validatorIndex, subnets}});
+    }
+
+    // these could be redundant duties due to the state of next period query reorged
+    // see https://github.com/ChainSafe/lodestar/issues/3572
+    // so we always overwrite duties
+    const period = computeSyncPeriodAtEpoch(epoch);
+    this.dutiesByIndexByPeriod.set(period, dutiesByIndex);
+
+    this.logger.debug("Downloaded SyncDuties", {epoch, count});
+  }
+
+  private async getSelectionProofs(slot: Slot, duty: SyncDutySubnet): Promise<SyncSelectionProof[]> {
+    const dutiesAndProofs: SyncSelectionProof[] = [];
+    for (const subnet of duty.subnets) {
+      const selectionProof = await this.validatorStore.signSyncCommitteeSelectionProof(duty.pubkey, slot, subnet);
+      if (this.opts?.distributedAggregationSelection) {
+        // Validator in distributed cluster only has a key share, not the full private key.
+        // Passing a partial selection proof to `is_sync_committee_aggregator` would produce incorrect result.
+        // SyncCommitteeService will exchange partial for combined selection proofs retrieved from
+        // distributed validator middleware client and determine aggregators at beginning of every slot.
+        dutiesAndProofs.push({
+          selectionProof: null,
+          partialSelectionProof: selectionProof,
+          subcommitteeIndex: subnet,
+        });
+      } else {
+        dutiesAndProofs.push({
+          // selectionProof === null is used to check if is aggregator
+          selectionProof: isSyncCommitteeAggregator(selectionProof) ? selectionProof : null,
+          subcommitteeIndex: subnet,
+        });
+      }
+    }
+    return dutiesAndProofs;
+  }
+
+  /** Run at least once per period to prune duties map */
+  private pruneOldDuties(currentEpoch: Epoch): void {
+    const currentPeriod = computeSyncPeriodAtEpoch(currentEpoch);
+    for (const period of this.dutiesByIndexByPeriod.keys()) {
+      if (period + HISTORICAL_DUTIES_PERIODS < currentPeriod) {
+        this.dutiesByIndexByPeriod.delete(period);
+      }
+    }
+  }
+}