@lodestar/light-client 1.35.0-dev.fcf8d024ea → 1.35.0-dev.feed916580

package/src/spec/isBetterUpdate.ts

@@ -1,94 +0,0 @@
-import {SYNC_COMMITTEE_SIZE} from "@lodestar/params";
-import {LightClientUpdate, Slot} from "@lodestar/types";
-import {computeSyncPeriodAtSlot} from "../utils/index.js";
-import {isFinalityUpdate, isSyncCommitteeUpdate, sumBits} from "./utils.js";
-
-/**
- * Wrapper type for `isBetterUpdate()` so we can apply its logic without requiring the full LightClientUpdate type.
- */
-export type LightClientUpdateSummary = {
-  activeParticipants: number;
-  attestedHeaderSlot: Slot;
-  signatureSlot: Slot;
-  finalizedHeaderSlot: Slot;
-  /** `if update.next_sync_committee_branch != [Bytes32() for _ in range(floorlog2(NEXT_SYNC_COMMITTEE_INDEX))]` */
-  isSyncCommitteeUpdate: boolean;
-  /** `if update.finality_branch != [Bytes32() for _ in range(floorlog2(FINALIZED_ROOT_INDEX))]` */
-  isFinalityUpdate: boolean;
-};
-
-/**
- * Returns the update with more bits. On ties, prevUpdate is the better
- *
- * https://github.com/ethereum/consensus-specs/blob/be3c774069e16e89145660be511c1b183056017e/specs/altair/light-client/sync-protocol.md#is_better_update
- */
-export function isBetterUpdate(newUpdate: LightClientUpdateSummary, oldUpdate: LightClientUpdateSummary): boolean {
-  // Compare supermajority (> 2/3) sync committee participation
-  const newNumActiveParticipants = newUpdate.activeParticipants;
-  const oldNumActiveParticipants = oldUpdate.activeParticipants;
-  const newHasSupermajority = newNumActiveParticipants * 3 >= SYNC_COMMITTEE_SIZE * 2;
-  const oldHasSupermajority = oldNumActiveParticipants * 3 >= SYNC_COMMITTEE_SIZE * 2;
-  if (newHasSupermajority !== oldHasSupermajority) {
-    return newHasSupermajority;
-  }
-  if (!newHasSupermajority && newNumActiveParticipants !== oldNumActiveParticipants) {
-    return newNumActiveParticipants > oldNumActiveParticipants;
-  }
-
-  // Compare presence of relevant sync committee
-  const newHasRelevantSyncCommittee =
-    newUpdate.isSyncCommitteeUpdate &&
-    computeSyncPeriodAtSlot(newUpdate.attestedHeaderSlot) === computeSyncPeriodAtSlot(newUpdate.signatureSlot);
-  const oldHasRelevantSyncCommittee =
-    oldUpdate.isSyncCommitteeUpdate &&
-    computeSyncPeriodAtSlot(oldUpdate.attestedHeaderSlot) === computeSyncPeriodAtSlot(oldUpdate.signatureSlot);
-  if (newHasRelevantSyncCommittee !== oldHasRelevantSyncCommittee) {
-    return newHasRelevantSyncCommittee;
-  }
-
-  // Compare indication of any finality
-  const newHasFinality = newUpdate.isFinalityUpdate;
-  const oldHasFinality = oldUpdate.isFinalityUpdate;
-  if (newHasFinality !== oldHasFinality) {
-    return newHasFinality;
-  }
-
-  // Compare sync committee finality
-  if (newHasFinality) {
-    const newHasSyncCommitteeFinality =
-      computeSyncPeriodAtSlot(newUpdate.finalizedHeaderSlot) === computeSyncPeriodAtSlot(newUpdate.attestedHeaderSlot);
-    const oldHasSyncCommitteeFinality =
-      computeSyncPeriodAtSlot(oldUpdate.finalizedHeaderSlot) === computeSyncPeriodAtSlot(oldUpdate.attestedHeaderSlot);
-    if (newHasSyncCommitteeFinality !== oldHasSyncCommitteeFinality) {
-      return newHasSyncCommitteeFinality;
-    }
-  }
-
-  // Tiebreaker 1: Sync committee participation beyond supermajority
-  if (newNumActiveParticipants !== oldNumActiveParticipants) {
-    return newNumActiveParticipants > oldNumActiveParticipants;
-  }
-
-  // Tiebreaker 2: Prefer older data (fewer changes to best)
-  if (newUpdate.attestedHeaderSlot !== oldUpdate.attestedHeaderSlot) {
-    return newUpdate.attestedHeaderSlot < oldUpdate.attestedHeaderSlot;
-  }
-  return newUpdate.signatureSlot < oldUpdate.signatureSlot;
-}
-
-export function isSafeLightClientUpdate(update: LightClientUpdateSummary): boolean {
-  return (
-    update.activeParticipants * 3 >= SYNC_COMMITTEE_SIZE * 2 && update.isFinalityUpdate && update.isSyncCommitteeUpdate
-  );
-}
-
-export function toLightClientUpdateSummary(update: LightClientUpdate): LightClientUpdateSummary {
-  return {
-    activeParticipants: sumBits(update.syncAggregate.syncCommitteeBits),
-    attestedHeaderSlot: update.attestedHeader.beacon.slot,
-    signatureSlot: update.signatureSlot,
-    finalizedHeaderSlot: update.finalizedHeader.beacon.slot,
-    isSyncCommitteeUpdate: isSyncCommitteeUpdate(update),
-    isFinalityUpdate: isFinalityUpdate(update),
-  };
-}

package/src/spec/processLightClientUpdate.ts

@@ -1,119 +0,0 @@
-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, deserializeSyncCommittee, sumBits} from "../utils/index.js";
-import {LightClientUpdateSummary, isBetterUpdate, toLightClientUpdateSummary} from "./isBetterUpdate.js";
-import {ILightClientStore, MAX_SYNC_PERIODS_CACHE, SyncCommitteeFast} from "./store.js";
-import {getSafetyThreshold, isSyncCommitteeUpdate} 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/spec/store.ts

@@ -1,105 +0,0 @@
-import type {PublicKey} from "@chainsafe/bls/types";
-import {BeaconConfig} from "@lodestar/config";
-import {LightClientBootstrap, LightClientHeader, LightClientUpdate, SyncPeriod} from "@lodestar/types";
-import {computeSyncPeriodAtSlot, deserializeSyncCommittee} from "../utils/index.js";
-import {LightClientUpdateSummary} from "./isBetterUpdate.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 _finalizedHeader: LightClientHeader;
-  private _optimisticHeader: 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._finalizedHeader = bootstrap.header;
-    this._optimisticHeader = bootstrap.header;
-  }
-
-  get finalizedHeader(): LightClientHeader {
-    return this._finalizedHeader;
-  }
-
-  set finalizedHeader(value: LightClientHeader) {
-    this._finalizedHeader = value;
-    this.events.onSetFinalizedHeader?.(value);
-  }
-
-  get optimisticHeader(): LightClientHeader {
-    return this._optimisticHeader;
-  }
-
-  set optimisticHeader(value: LightClientHeader) {
-    this._optimisticHeader = 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/spec/utils.ts

@@ -1,266 +0,0 @@
-import {BitArray, byteArrayEquals} 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 {computeEpochAtSlot, computeSyncPeriodAtSlot, isValidMerkleBranch} from "../utils/index.js";
-import {normalizeMerkleBranch} from "../utils/normalizeMerkleBranch.js";
-import {LightClientStore} 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;
-}
-
-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 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/spec/validateLightClientBootstrap.ts

@@ -1,41 +0,0 @@
-import {byteArrayEquals} from "@chainsafe/ssz";
-import {ChainForkConfig} from "@lodestar/config";
-import {isForkPostElectra} from "@lodestar/params";
-import {LightClientBootstrap, Root, ssz} from "@lodestar/types";
-import {toHex} from "@lodestar/utils";
-import {isValidMerkleBranch} from "../utils/verifyMerkleBranch.js";
-import {isValidLightClientHeader} 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");
-  }
-}