@lodestar/state-transition 1.43.0 → 1.44.0-dev.055b83cb3d

package/src/lightClient/spec/processLightClientUpdate.ts

@@ -0,0 +1,119 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {SYNC_COMMITTEE_SIZE} from "@lodestar/params";
+import {LightClientUpdate, Slot, SyncPeriod} from "@lodestar/types";
+import {pruneSetToMax} from "@lodestar/utils";
+import {computeSyncPeriodAtSlot} from "../../util/epoch.js";
+import {LightClientUpdateSummary, isBetterUpdate, toLightClientUpdateSummary} from "./isBetterUpdate.js";
+import {type ILightClientStore, MAX_SYNC_PERIODS_CACHE, type SyncCommitteeFast} from "./store.js";
+import {deserializeSyncCommittee, getSafetyThreshold, isSyncCommitteeUpdate, sumBits} from "./utils.js";
+import {validateLightClientUpdate} from "./validateLightClientUpdate.js";
+
+export interface ProcessUpdateOpts {
+  allowForcedUpdates?: boolean;
+  updateHeadersOnForcedUpdate?: boolean;
+}
+
+export function processLightClientUpdate(
+  config: ChainForkConfig,
+  store: ILightClientStore,
+  currentSlot: Slot,
+  opts: ProcessUpdateOpts,
+  update: LightClientUpdate
+): void {
+  if (update.signatureSlot > currentSlot) {
+    throw Error(`update slot ${update.signatureSlot} must not be in the future, current slot ${currentSlot}`);
+  }
+
+  const updateSignaturePeriod = computeSyncPeriodAtSlot(update.signatureSlot);
+  // TODO: Consider attempting to retrieve LightClientUpdate from transport if missing
+  // Note: store.getSyncCommitteeAtPeriod() may advance store
+  const syncCommittee = getSyncCommitteeAtPeriod(store, updateSignaturePeriod, opts);
+
+  validateLightClientUpdate(config, store, update, syncCommittee);
+
+  // Track the maximum number of active participants in the committee signatures
+  const syncCommitteeTrueBits = sumBits(update.syncAggregate.syncCommitteeBits);
+  store.setActiveParticipants(updateSignaturePeriod, syncCommitteeTrueBits);
+
+  // Update the optimistic header
+  if (
+    syncCommitteeTrueBits > getSafetyThreshold(store.getMaxActiveParticipants(updateSignaturePeriod)) &&
+    update.attestedHeader.beacon.slot > store.optimisticHeader.beacon.slot
+  ) {
+    store.optimisticHeader = update.attestedHeader;
+  }
+
+  // Update finalized header
+  if (
+    syncCommitteeTrueBits * 3 >= SYNC_COMMITTEE_SIZE * 2 &&
+    update.finalizedHeader.beacon.slot > store.finalizedHeader.beacon.slot
+  ) {
+    store.finalizedHeader = update.finalizedHeader;
+    if (store.finalizedHeader.beacon.slot > store.optimisticHeader.beacon.slot) {
+      store.optimisticHeader = store.finalizedHeader;
+    }
+  }
+
+  if (isSyncCommitteeUpdate(update)) {
+    // Update the best update in case we have to force-update to it if the timeout elapses
+    const bestValidUpdate = store.bestValidUpdates.get(updateSignaturePeriod);
+    const updateSummary = toLightClientUpdateSummary(update);
+    if (!bestValidUpdate || isBetterUpdate(updateSummary, bestValidUpdate.summary)) {
+      store.bestValidUpdates.set(updateSignaturePeriod, {update, summary: updateSummary});
+      pruneSetToMax(store.bestValidUpdates, MAX_SYNC_PERIODS_CACHE);
+    }
+
+    // Note: defer update next sync committee to a future getSyncCommitteeAtPeriod() call
+  }
+}
+
+export function getSyncCommitteeAtPeriod(
+  store: ILightClientStore,
+  period: SyncPeriod,
+  opts: ProcessUpdateOpts
+): SyncCommitteeFast {
+  const syncCommittee = store.syncCommittees.get(period);
+  if (syncCommittee) {
+    return syncCommittee;
+  }
+
+  const bestValidUpdate = store.bestValidUpdates.get(period - 1);
+  if (bestValidUpdate && (isSafeLightClientUpdate(bestValidUpdate.summary) || opts.allowForcedUpdates)) {
+    const {update} = bestValidUpdate;
+    const syncCommittee = deserializeSyncCommittee(update.nextSyncCommittee);
+    store.syncCommittees.set(period, syncCommittee);
+    pruneSetToMax(store.syncCommittees, MAX_SYNC_PERIODS_CACHE);
+    store.bestValidUpdates.delete(period - 1);
+
+    if (opts.updateHeadersOnForcedUpdate) {
+      // From https://github.com/ethereum/consensus-specs/blob/a57e15636013eeba3610ff3ade41781dba1bb0cd/specs/altair/light-client/sync-protocol.md?plain=1#L403
+      if (update.finalizedHeader.beacon.slot <= store.finalizedHeader.beacon.slot) {
+        update.finalizedHeader = update.attestedHeader;
+      }
+
+      // From https://github.com/ethereum/consensus-specs/blob/a57e15636013eeba3610ff3ade41781dba1bb0cd/specs/altair/light-client/sync-protocol.md?plain=1#L374
+      if (update.finalizedHeader.beacon.slot > store.finalizedHeader.beacon.slot) {
+        store.finalizedHeader = update.finalizedHeader;
+      }
+      if (store.finalizedHeader.beacon.slot > store.optimisticHeader.beacon.slot) {
+        store.optimisticHeader = store.finalizedHeader;
+      }
+    }
+
+    return syncCommittee;
+  }
+
+  const availableSyncCommittees = Array.from(store.syncCommittees.keys());
+  const availableBestValidUpdates = Array.from(store.bestValidUpdates.keys());
+  throw Error(
+    `No SyncCommittee for period ${period}` +
+      ` available syncCommittees ${JSON.stringify(availableSyncCommittees)}` +
+      ` available bestValidUpdates ${JSON.stringify(availableBestValidUpdates)}`
+  );
+}
+
+export function isSafeLightClientUpdate(update: LightClientUpdateSummary): boolean {
+  return (
+    update.activeParticipants * 3 >= SYNC_COMMITTEE_SIZE * 2 && update.isFinalityUpdate && update.isSyncCommitteeUpdate
+  );
+}

package/src/lightClient/spec/store.ts

@@ -0,0 +1,106 @@
+import type {PublicKey} from "@chainsafe/blst";
+import {BeaconConfig} from "@lodestar/config";
+import {LightClientBootstrap, LightClientHeader, LightClientUpdate, SyncPeriod} from "@lodestar/types";
+import {computeSyncPeriodAtSlot} from "../../util/epoch.js";
+import type {LightClientUpdateSummary} from "./isBetterUpdate.js";
+import {deserializeSyncCommittee} from "./utils.js";
+
+export const MAX_SYNC_PERIODS_CACHE = 2;
+
+export interface ILightClientStore {
+  readonly config: BeaconConfig;
+
+  /** Map of trusted SyncCommittee to be used for sig validation */
+  readonly syncCommittees: Map<SyncPeriod, SyncCommitteeFast>;
+  /** Map of best valid updates */
+  readonly bestValidUpdates: Map<SyncPeriod, LightClientUpdateWithSummary>;
+
+  getMaxActiveParticipants(period: SyncPeriod): number;
+  setActiveParticipants(period: SyncPeriod, activeParticipants: number): void;
+
+  // Header that is finalized
+  finalizedHeader: LightClientHeader;
+
+  // Most recent available reasonably-safe header
+  optimisticHeader: LightClientHeader;
+}
+
+export interface LightClientStoreEvents {
+  onSetFinalizedHeader?: (header: LightClientHeader) => void;
+  onSetOptimisticHeader?: (header: LightClientHeader) => void;
+}
+
+export class LightClientStore implements ILightClientStore {
+  readonly syncCommittees = new Map<SyncPeriod, SyncCommitteeFast>();
+  readonly bestValidUpdates = new Map<SyncPeriod, LightClientUpdateWithSummary>();
+
+  private finalizedHeaderValue: LightClientHeader;
+  private optimisticHeaderValue: LightClientHeader;
+
+  private readonly maxActiveParticipants = new Map<SyncPeriod, number>();
+
+  constructor(
+    readonly config: BeaconConfig,
+    bootstrap: LightClientBootstrap,
+    private readonly events: LightClientStoreEvents
+  ) {
+    const bootstrapPeriod = computeSyncPeriodAtSlot(bootstrap.header.beacon.slot);
+    this.syncCommittees.set(bootstrapPeriod, deserializeSyncCommittee(bootstrap.currentSyncCommittee));
+    this.finalizedHeaderValue = bootstrap.header;
+    this.optimisticHeaderValue = bootstrap.header;
+  }
+
+  get finalizedHeader(): LightClientHeader {
+    return this.finalizedHeaderValue;
+  }
+
+  set finalizedHeader(value: LightClientHeader) {
+    this.finalizedHeaderValue = value;
+    this.events.onSetFinalizedHeader?.(value);
+  }
+
+  get optimisticHeader(): LightClientHeader {
+    return this.optimisticHeaderValue;
+  }
+
+  set optimisticHeader(value: LightClientHeader) {
+    this.optimisticHeaderValue = value;
+    this.events.onSetOptimisticHeader?.(value);
+  }
+
+  getMaxActiveParticipants(period: SyncPeriod): number {
+    const currMaxParticipants = this.maxActiveParticipants.get(period) ?? 0;
+    const prevMaxParticipants = this.maxActiveParticipants.get(period - 1) ?? 0;
+
+    return Math.max(currMaxParticipants, prevMaxParticipants);
+  }
+
+  setActiveParticipants(period: SyncPeriod, activeParticipants: number): void {
+    const maxActiveParticipants = this.maxActiveParticipants.get(period) ?? 0;
+    if (activeParticipants > maxActiveParticipants) {
+      this.maxActiveParticipants.set(period, activeParticipants);
+    }
+
+    // Prune old entries
+    for (const key of this.maxActiveParticipants.keys()) {
+      if (key < period - MAX_SYNC_PERIODS_CACHE) {
+        this.maxActiveParticipants.delete(key);
+      }
+    }
+  }
+}
+
+export type SyncCommitteeFast = {
+  pubkeys: PublicKey[];
+  aggregatePubkey: PublicKey;
+};
+
+export type LightClientUpdateWithSummary = {
+  update: LightClientUpdate;
+  summary: LightClientUpdateSummary;
+};
+
+// === storePeriod ? store.currentSyncCommittee : store.nextSyncCommittee;
+// if (!syncCommittee) {
+//   throw Error(`syncCommittee not available for signature period ${updateSignaturePeriod}`);
+// }

package/src/lightClient/spec/utils.ts

@@ -0,0 +1,317 @@
+import {PublicKey} from "@chainsafe/blst";
+import {BitArray} from "@chainsafe/ssz";
+import {ChainForkConfig} from "@lodestar/config";
+import {
+  BLOCK_BODY_EXECUTION_PAYLOAD_DEPTH as EXECUTION_PAYLOAD_DEPTH,
+  BLOCK_BODY_EXECUTION_PAYLOAD_INDEX as EXECUTION_PAYLOAD_INDEX,
+  FINALIZED_ROOT_DEPTH,
+  FINALIZED_ROOT_DEPTH_ELECTRA,
+  ForkName,
+  ForkSeq,
+  NEXT_SYNC_COMMITTEE_DEPTH,
+  NEXT_SYNC_COMMITTEE_DEPTH_ELECTRA,
+  isForkPostElectra,
+} from "@lodestar/params";
+import {
+  BeaconBlockHeader,
+  LightClientFinalityUpdate,
+  LightClientHeader,
+  LightClientOptimisticUpdate,
+  LightClientUpdate,
+  Slot,
+  SyncCommittee,
+  isElectraLightClientUpdate,
+  ssz,
+} from "@lodestar/types";
+import {byteArrayEquals, verifyMerkleBranch} from "@lodestar/utils";
+import {computeEpochAtSlot, computeSyncPeriodAtSlot} from "../../util/epoch.js";
+import type {LightClientStore, SyncCommitteeFast} from "./store.js";
+
+export const GENESIS_SLOT = 0;
+export const ZERO_HASH = new Uint8Array(32);
+export const ZERO_PUBKEY = new Uint8Array(48);
+export const ZERO_SYNC_COMMITTEE = ssz.altair.SyncCommittee.defaultValue();
+export const ZERO_HEADER = ssz.phase0.BeaconBlockHeader.defaultValue();
+/** From https://notes.ethereum.org/@vbuterin/extended_light_client_protocol#Optimistic-head-determining-function */
+const SAFETY_THRESHOLD_FACTOR = 2;
+
+export function sumBits(bits: BitArray): number {
+  return bits.getTrueBitIndexes().length;
+}
+
+/**
+ * Util to guarantee that all bits have a corresponding pubkey.
+ */
+export function getParticipantPubkeys<T>(pubkeys: T[], bits: BitArray): T[] {
+  // BitArray.intersectValues() checks the length is correct.
+  return bits.intersectValues(pubkeys);
+}
+
+function deserializePubkeys(pubkeys: SyncCommittee["pubkeys"]): PublicKey[] {
+  return pubkeys.map((pk) => PublicKey.fromBytes(pk, true));
+}
+
+function serializePubkeys(pubkeys: PublicKey[]): SyncCommittee["pubkeys"] {
+  return pubkeys.map((pk) => pk.toBytes());
+}
+
+export function deserializeSyncCommittee(syncCommittee: SyncCommittee): SyncCommitteeFast {
+  return {
+    pubkeys: deserializePubkeys(syncCommittee.pubkeys),
+    aggregatePubkey: PublicKey.fromBytes(syncCommittee.aggregatePubkey, true),
+  };
+}
+
+export function serializeSyncCommittee(syncCommittee: SyncCommitteeFast): SyncCommittee {
+  return {
+    pubkeys: serializePubkeys(syncCommittee.pubkeys),
+    aggregatePubkey: syncCommittee.aggregatePubkey.toBytes(),
+  };
+}
+
+export function getSafetyThreshold(maxActiveParticipants: number): number {
+  return Math.floor(maxActiveParticipants / SAFETY_THRESHOLD_FACTOR);
+}
+
+export function getZeroSyncCommitteeBranch(fork: ForkName): Uint8Array[] {
+  const nextSyncCommitteeDepth = isForkPostElectra(fork)
+    ? NEXT_SYNC_COMMITTEE_DEPTH_ELECTRA
+    : NEXT_SYNC_COMMITTEE_DEPTH;
+
+  return Array.from({length: nextSyncCommitteeDepth}, () => ZERO_HASH);
+}
+
+export function getZeroFinalityBranch(fork: ForkName): Uint8Array[] {
+  const finalizedRootDepth = isForkPostElectra(fork) ? FINALIZED_ROOT_DEPTH_ELECTRA : FINALIZED_ROOT_DEPTH;
+
+  return Array.from({length: finalizedRootDepth}, () => ZERO_HASH);
+}
+
+export function isSyncCommitteeUpdate(update: LightClientUpdate): boolean {
+  return (
+    // Fast return for when constructing full LightClientUpdate from partial updates
+    update.nextSyncCommitteeBranch !==
+      getZeroSyncCommitteeBranch(isElectraLightClientUpdate(update) ? ForkName.electra : ForkName.altair) &&
+    update.nextSyncCommitteeBranch.some((branch) => !byteArrayEquals(branch, ZERO_HASH))
+  );
+}
+
+export function isFinalityUpdate(update: LightClientUpdate): boolean {
+  return (
+    // Fast return for when constructing full LightClientUpdate from partial updates
+    update.finalityBranch !==
+      getZeroFinalityBranch(isElectraLightClientUpdate(update) ? ForkName.electra : ForkName.altair) &&
+    update.finalityBranch.some((branch) => !byteArrayEquals(branch, ZERO_HASH))
+  );
+}
+
+export function isZeroedHeader(header: BeaconBlockHeader): boolean {
+  // Fast return for when constructing full LightClientUpdate from partial updates
+  return header === ZERO_HEADER || byteArrayEquals(header.bodyRoot, ZERO_HASH);
+}
+
+export function isZeroedSyncCommittee(syncCommittee: SyncCommittee): boolean {
+  // Fast return for when constructing full LightClientUpdate from partial updates
+  return syncCommittee === ZERO_SYNC_COMMITTEE || byteArrayEquals(syncCommittee.pubkeys[0], ZERO_PUBKEY);
+}
+
+export function isValidMerkleBranch(
+  leaf: Uint8Array,
+  branch: Uint8Array[],
+  depth: number,
+  index: number,
+  root: Uint8Array
+): boolean {
+  if (branch.length !== depth) {
+    return false;
+  }
+
+  return verifyMerkleBranch(leaf, branch, depth, index, root);
+}
+
+export function normalizeMerkleBranch(branch: Uint8Array[], depth: number): Uint8Array[] {
+  const numExtraDepth = depth - branch.length;
+
+  return [...Array.from({length: numExtraDepth}, () => ZERO_HASH), ...branch];
+}
+
+export function upgradeLightClientHeader(
+  config: ChainForkConfig,
+  targetFork: ForkName,
+  header: LightClientHeader
+): LightClientHeader {
+  const headerFork = config.getForkName(header.beacon.slot);
+  if (ForkSeq[headerFork] >= ForkSeq[targetFork]) {
+    throw Error(`Invalid upgrade request from headerFork=${headerFork} to targetFork=${targetFork}`);
+  }
+
+  // We are modifying the same header object, may be we could create a copy, but its
+  // not required as of now
+  const upgradedHeader = header;
+  const startUpgradeFromFork = Object.values(ForkName)[ForkSeq[headerFork] + 1];
+
+  switch (startUpgradeFromFork) {
+    // biome-ignore lint/suspicious/useDefaultSwitchClauseLast: We want default to evaluate at first to throw error early
+    default:
+      throw Error(
+        `Invalid startUpgradeFromFork=${startUpgradeFromFork} for headerFork=${headerFork} in upgradeLightClientHeader to targetFork=${targetFork}`
+      );
+
+    case ForkName.altair:
+    // biome-ignore lint/suspicious/noFallthroughSwitchClause: We need fall-through behavior here
+    case ForkName.bellatrix:
+      // Break if no further upgradation is required else fall through
+      if (ForkSeq[targetFork] <= ForkSeq.bellatrix) break;
+
+    // biome-ignore lint/suspicious/noFallthroughSwitchClause: We need fall-through behavior here
+    case ForkName.capella:
+      (upgradedHeader as LightClientHeader<ForkName.capella>).execution =
+        ssz.capella.LightClientHeader.fields.execution.defaultValue();
+      (upgradedHeader as LightClientHeader<ForkName.capella>).executionBranch =
+        ssz.capella.LightClientHeader.fields.executionBranch.defaultValue();
+
+      // Break if no further upgradation is required else fall through
+      if (ForkSeq[targetFork] <= ForkSeq.capella) break;
+
+    // biome-ignore lint/suspicious/noFallthroughSwitchClause: We need fall-through behavior here
+    case ForkName.deneb:
+      (upgradedHeader as LightClientHeader<ForkName.deneb>).execution.blobGasUsed =
+        ssz.deneb.LightClientHeader.fields.execution.fields.blobGasUsed.defaultValue();
+      (upgradedHeader as LightClientHeader<ForkName.deneb>).execution.excessBlobGas =
+        ssz.deneb.LightClientHeader.fields.execution.fields.excessBlobGas.defaultValue();
+
+      // Break if no further upgradation is required else fall through
+      if (ForkSeq[targetFork] <= ForkSeq.deneb) break;
+
+    // biome-ignore lint/suspicious/noFallthroughSwitchClause: We need fall-through behavior here
+    case ForkName.electra:
+      // No changes to LightClientHeader in Electra
+
+      // Break if no further upgrades is required else fall through
+      if (ForkSeq[targetFork] <= ForkSeq.electra) break;
+
+    // biome-ignore lint/suspicious/noFallthroughSwitchClause: We need fall-through behavior here
+    case ForkName.fulu:
+      // No changes to LightClientHeader in Fulu
+
+      // Break if no further upgrades is required else fall through
+      if (ForkSeq[targetFork] <= ForkSeq.fulu) break;
+
+    case ForkName.gloas:
+      // No changes to LightClientHeader in Gloas
+
+      // Break if no further upgrades is required else fall through
+      if (ForkSeq[targetFork] <= ForkSeq.gloas) break;
+  }
+  return upgradedHeader;
+}
+
+export function isValidLightClientHeader(config: ChainForkConfig, header: LightClientHeader): boolean {
+  const epoch = computeEpochAtSlot(header.beacon.slot);
+
+  if (epoch < config.CAPELLA_FORK_EPOCH) {
+    return (
+      ((header as LightClientHeader<ForkName.capella>).execution === undefined ||
+        ssz.capella.ExecutionPayloadHeader.equals(
+          (header as LightClientHeader<ForkName.capella>).execution,
+          ssz.capella.LightClientHeader.fields.execution.defaultValue()
+        )) &&
+      ((header as LightClientHeader<ForkName.capella>).executionBranch === undefined ||
+        ssz.capella.LightClientHeader.fields.executionBranch.equals(
+          ssz.capella.LightClientHeader.fields.executionBranch.defaultValue(),
+          (header as LightClientHeader<ForkName.capella>).executionBranch
+        ))
+    );
+  }
+
+  if (
+    epoch < config.DENEB_FORK_EPOCH &&
+    (((header as LightClientHeader<ForkName.deneb>).execution.blobGasUsed &&
+      (header as LightClientHeader<ForkName.deneb>).execution.blobGasUsed !== BigInt(0)) ||
+      ((header as LightClientHeader<ForkName.deneb>).execution.excessBlobGas &&
+        (header as LightClientHeader<ForkName.deneb>).execution.excessBlobGas !== BigInt(0)))
+  ) {
+    return false;
+  }
+
+  return isValidMerkleBranch(
+    config
+      .getPostBellatrixForkTypes(header.beacon.slot)
+      .ExecutionPayloadHeader.hashTreeRoot((header as LightClientHeader<ForkName.capella>).execution),
+    (header as LightClientHeader<ForkName.capella>).executionBranch,
+    EXECUTION_PAYLOAD_DEPTH,
+    EXECUTION_PAYLOAD_INDEX,
+    header.beacon.bodyRoot
+  );
+}
+
+export function upgradeLightClientUpdate(
+  config: ChainForkConfig,
+  targetFork: ForkName,
+  update: LightClientUpdate
+): LightClientUpdate {
+  update.attestedHeader = upgradeLightClientHeader(config, targetFork, update.attestedHeader);
+  update.finalizedHeader = upgradeLightClientHeader(config, targetFork, update.finalizedHeader);
+  update.nextSyncCommitteeBranch = normalizeMerkleBranch(
+    update.nextSyncCommitteeBranch,
+    isForkPostElectra(targetFork) ? NEXT_SYNC_COMMITTEE_DEPTH_ELECTRA : NEXT_SYNC_COMMITTEE_DEPTH
+  );
+  update.finalityBranch = normalizeMerkleBranch(
+    update.finalityBranch,
+    isForkPostElectra(targetFork) ? FINALIZED_ROOT_DEPTH_ELECTRA : FINALIZED_ROOT_DEPTH
+  );
+
+  return update;
+}
+
+export function upgradeLightClientFinalityUpdate(
+  config: ChainForkConfig,
+  targetFork: ForkName,
+  finalityUpdate: LightClientFinalityUpdate
+): LightClientFinalityUpdate {
+  finalityUpdate.attestedHeader = upgradeLightClientHeader(config, targetFork, finalityUpdate.attestedHeader);
+  finalityUpdate.finalizedHeader = upgradeLightClientHeader(config, targetFork, finalityUpdate.finalizedHeader);
+  finalityUpdate.finalityBranch = normalizeMerkleBranch(
+    finalityUpdate.finalityBranch,
+    isForkPostElectra(targetFork) ? FINALIZED_ROOT_DEPTH_ELECTRA : FINALIZED_ROOT_DEPTH
+  );
+
+  return finalityUpdate;
+}
+
+export function upgradeLightClientOptimisticUpdate(
+  config: ChainForkConfig,
+  targetFork: ForkName,
+  optimisticUpdate: LightClientOptimisticUpdate
+): LightClientOptimisticUpdate {
+  optimisticUpdate.attestedHeader = upgradeLightClientHeader(config, targetFork, optimisticUpdate.attestedHeader);
+
+  return optimisticUpdate;
+}
+
+/**
+ * Currently this upgradation is not required because all processing is done based on the
+ * summary that the store generates and maintains. In case store needs to be saved to disk,
+ * this could be required depending on the format the store is saved to the disk
+ */
+export function upgradeLightClientStore(
+  config: ChainForkConfig,
+  targetFork: ForkName,
+  store: LightClientStore,
+  signatureSlot: Slot
+): LightClientStore {
+  const updateSignaturePeriod = computeSyncPeriodAtSlot(signatureSlot);
+  const bestValidUpdate = store.bestValidUpdates.get(updateSignaturePeriod);
+
+  if (bestValidUpdate) {
+    store.bestValidUpdates.set(updateSignaturePeriod, {
+      update: upgradeLightClientUpdate(config, targetFork, bestValidUpdate.update),
+      summary: bestValidUpdate.summary,
+    });
+  }
+
+  store.finalizedHeader = upgradeLightClientHeader(config, targetFork, store.finalizedHeader);
+  store.optimisticHeader = upgradeLightClientHeader(config, targetFork, store.optimisticHeader);
+
+  return store;
+}

package/src/lightClient/spec/validateLightClientBootstrap.ts

@@ -0,0 +1,39 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {isForkPostElectra} from "@lodestar/params";
+import {LightClientBootstrap, Root, ssz} from "@lodestar/types";
+import {byteArrayEquals, toHex} from "@lodestar/utils";
+import {isValidLightClientHeader, isValidMerkleBranch} from "./utils.js";
+
+const CURRENT_SYNC_COMMITTEE_INDEX = 22;
+const CURRENT_SYNC_COMMITTEE_DEPTH = 5;
+const CURRENT_SYNC_COMMITTEE_INDEX_ELECTRA = 22;
+const CURRENT_SYNC_COMMITTEE_DEPTH_ELECTRA = 6;
+
+export function validateLightClientBootstrap(
+  config: ChainForkConfig,
+  trustedBlockRoot: Root,
+  bootstrap: LightClientBootstrap
+): void {
+  const headerRoot = ssz.phase0.BeaconBlockHeader.hashTreeRoot(bootstrap.header.beacon);
+  const fork = config.getForkName(bootstrap.header.beacon.slot);
+
+  if (!isValidLightClientHeader(config, bootstrap.header)) {
+    throw Error("Bootstrap Header is not Valid Light Client Header");
+  }
+
+  if (!byteArrayEquals(headerRoot, trustedBlockRoot)) {
+    throw Error(`bootstrap header root ${toHex(headerRoot)} != trusted root ${toHex(trustedBlockRoot)}`);
+  }
+
+  if (
+    !isValidMerkleBranch(
+      ssz.altair.SyncCommittee.hashTreeRoot(bootstrap.currentSyncCommittee),
+      bootstrap.currentSyncCommitteeBranch,
+      isForkPostElectra(fork) ? CURRENT_SYNC_COMMITTEE_DEPTH_ELECTRA : CURRENT_SYNC_COMMITTEE_DEPTH,
+      isForkPostElectra(fork) ? CURRENT_SYNC_COMMITTEE_INDEX_ELECTRA : CURRENT_SYNC_COMMITTEE_INDEX,
+      bootstrap.header.beacon.stateRoot
+    )
+  ) {
+    throw Error("Invalid currentSyncCommittee merkle branch");
+  }
+}