@lodestar/config 1.35.0-dev.fcf8d024ea → 1.35.0-dev.feed916580

package/src/forkConfig/index.ts

@@ -1,236 +0,0 @@
-import {
-  BASIS_POINTS,
-  ForkAll,
-  ForkName,
-  ForkPostAltair,
-  ForkPostBellatrix,
-  ForkPostDeneb,
-  ForkSeq,
-  GENESIS_EPOCH,
-  SLOTS_PER_EPOCH,
-  isForkPostAltair,
-  isForkPostBellatrix,
-  isForkPostDeneb,
-  isForkPostGloas,
-} from "@lodestar/params";
-import {Epoch, SSZTypesFor, Slot, Version, sszTypesFor} from "@lodestar/types";
-import {ChainConfig} from "../chainConfig/index.js";
-import {BlobParameters, ForkBoundary, ForkConfig, ForkInfo} from "./types.js";
-
-export * from "./types.js";
-
-export function createForkConfig(config: ChainConfig): ForkConfig {
-  const phase0: ForkInfo = {
-    name: ForkName.phase0,
-    seq: ForkSeq.phase0,
-    epoch: GENESIS_EPOCH,
-    version: config.GENESIS_FORK_VERSION,
-    // Will never be used
-    prevVersion: config.GENESIS_FORK_VERSION,
-    prevForkName: ForkName.phase0,
-  };
-  const altair: ForkInfo = {
-    name: ForkName.altair,
-    seq: ForkSeq.altair,
-    epoch: config.ALTAIR_FORK_EPOCH,
-    version: config.ALTAIR_FORK_VERSION,
-    prevVersion: config.GENESIS_FORK_VERSION,
-    prevForkName: ForkName.phase0,
-  };
-  const bellatrix: ForkInfo = {
-    name: ForkName.bellatrix,
-    seq: ForkSeq.bellatrix,
-    epoch: config.BELLATRIX_FORK_EPOCH,
-    version: config.BELLATRIX_FORK_VERSION,
-    prevVersion: config.ALTAIR_FORK_VERSION,
-    prevForkName: ForkName.altair,
-  };
-  const capella: ForkInfo = {
-    name: ForkName.capella,
-    seq: ForkSeq.capella,
-    epoch: config.CAPELLA_FORK_EPOCH,
-    version: config.CAPELLA_FORK_VERSION,
-    prevVersion: config.BELLATRIX_FORK_VERSION,
-    prevForkName: ForkName.bellatrix,
-  };
-  const deneb: ForkInfo = {
-    name: ForkName.deneb,
-    seq: ForkSeq.deneb,
-    epoch: config.DENEB_FORK_EPOCH,
-    version: config.DENEB_FORK_VERSION,
-    prevVersion: config.CAPELLA_FORK_VERSION,
-    prevForkName: ForkName.capella,
-  };
-  const electra: ForkInfo = {
-    name: ForkName.electra,
-    seq: ForkSeq.electra,
-    epoch: config.ELECTRA_FORK_EPOCH,
-    version: config.ELECTRA_FORK_VERSION,
-    prevVersion: config.DENEB_FORK_VERSION,
-    prevForkName: ForkName.deneb,
-  };
-  const fulu: ForkInfo = {
-    name: ForkName.fulu,
-    seq: ForkSeq.fulu,
-    epoch: config.FULU_FORK_EPOCH,
-    version: config.FULU_FORK_VERSION,
-    prevVersion: config.ELECTRA_FORK_VERSION,
-    prevForkName: ForkName.electra,
-  };
-  const gloas: ForkInfo = {
-    name: ForkName.gloas,
-    seq: ForkSeq.gloas,
-    epoch: config.GLOAS_FORK_EPOCH,
-    version: config.GLOAS_FORK_VERSION,
-    prevVersion: config.FULU_FORK_VERSION,
-    prevForkName: ForkName.fulu,
-  };
-
-  /** Forks in order order of occurence, `phase0` first */
-  // Note: Downstream code relies on proper ordering.
-  const forks = {phase0, altair, bellatrix, capella, deneb, electra, fulu, gloas};
-
-  // Prevents allocating an array on every getForkInfo() call
-  const forksAscendingEpochOrder = Object.values(forks);
-  const forksDescendingEpochOrder = Object.values(forks).reverse();
-
-  const blobScheduleDescendingEpochOrder = [...config.BLOB_SCHEDULE].sort((a, b) => b.EPOCH - a.EPOCH);
-
-  const forkBoundariesAscendingEpochOrder: ForkBoundary[] = [
-    // Normal hard-forks (phase0, altair, etc.)
-    ...forksAscendingEpochOrder.map((fork) => ({
-      fork: fork.name,
-      epoch: fork.epoch,
-    })),
-    // Blob Parameter Only (BPO) forks
-    // Note: Must be appended after normal hard-forks to have precedence if scheduled at the same epoch
-    ...config.BLOB_SCHEDULE.map((entry) => ({
-      fork: forksDescendingEpochOrder.find((f) => entry.EPOCH >= f.epoch)?.name ?? phase0.name,
-      epoch: entry.EPOCH,
-    })),
-  ]
-    // Remove unscheduled fork boundaries
-    .filter(({epoch}) => epoch !== Infinity)
-    // Sort by epoch in ascending order
-    .sort((a, b) => a.epoch - b.epoch);
-
-  const forkBoundariesDescendingEpochOrder = [...forkBoundariesAscendingEpochOrder].reverse();
-
-  return {
-    forks,
-    forksAscendingEpochOrder,
-    forksDescendingEpochOrder,
-    forkBoundariesAscendingEpochOrder,
-    forkBoundariesDescendingEpochOrder,
-
-    // Fork convenience methods
-    getForkInfo(slot: Slot): ForkInfo {
-      const epoch = Math.floor(Math.max(slot, 0) / SLOTS_PER_EPOCH);
-      return this.getForkInfoAtEpoch(epoch);
-    },
-    getForkInfoAtEpoch(epoch: Epoch): ForkInfo {
-      return forks[this.getForkBoundaryAtEpoch(epoch).fork];
-    },
-    getForkBoundaryAtEpoch(epoch: Epoch): ForkBoundary {
-      if (epoch < 0) epoch = 0;
-      // NOTE: fork boundaries must be sorted by descending epoch, latest first
-      for (const boundary of forkBoundariesDescendingEpochOrder) {
-        if (epoch >= boundary.epoch) return boundary;
-      }
-      throw Error("Unreachable as phase0 is scheduled at epoch 0");
-    },
-    getForkName(slot: Slot): ForkName {
-      return this.getForkInfo(slot).name;
-    },
-    getForkSeq(slot: Slot): ForkSeq {
-      return this.getForkInfo(slot).seq;
-    },
-    getForkSeqAtEpoch(epoch: Epoch): ForkSeq {
-      return this.getForkInfoAtEpoch(epoch).seq;
-    },
-    getForkVersion(slot: Slot): Version {
-      return this.getForkInfo(slot).version;
-    },
-    getForkTypes<F extends ForkName = ForkAll>(slot: Slot): SSZTypesFor<F> {
-      return sszTypesFor(this.getForkName(slot)) as SSZTypesFor<F>;
-    },
-    getPostBellatrixForkTypes(slot: Slot): SSZTypesFor<ForkPostBellatrix> {
-      const forkName = this.getForkName(slot);
-      if (!isForkPostBellatrix(forkName)) {
-        throw Error(`Invalid slot=${slot} fork=${forkName} for post-bellatrix fork types`);
-      }
-      return sszTypesFor(forkName);
-    },
-    getPostAltairForkTypes(slot: Slot): SSZTypesFor<ForkPostAltair> {
-      const forkName = this.getForkName(slot);
-      if (!isForkPostAltair(forkName)) {
-        throw Error(`Invalid slot=${slot} fork=${forkName} for post-altair fork types`);
-      }
-      return sszTypesFor(forkName);
-    },
-    getPostDenebForkTypes(slot: Slot): SSZTypesFor<ForkPostDeneb> {
-      const forkName = this.getForkName(slot);
-      if (!isForkPostDeneb(forkName)) {
-        throw Error(`Invalid slot=${slot} fork=${forkName} for post-deneb fork types`);
-      }
-      return sszTypesFor(forkName);
-    },
-    getMaxBlobsPerBlock(epoch: Epoch): number {
-      const fork = this.getForkInfoAtEpoch(epoch).name;
-
-      switch (fork) {
-        case ForkName.electra:
-          return config.MAX_BLOBS_PER_BLOCK_ELECTRA;
-        case ForkName.deneb:
-          return config.MAX_BLOBS_PER_BLOCK;
-      }
-
-      return this.getBlobParameters(epoch).maxBlobsPerBlock;
-    },
-    getBlobParameters(epoch: Epoch): BlobParameters {
-      if (epoch < config.FULU_FORK_EPOCH) {
-        throw Error(`getBlobParameters is not available pre-fulu epoch=${epoch}`);
-      }
-
-      // Find the latest applicable value from blob schedule
-      for (const entry of blobScheduleDescendingEpochOrder) {
-        if (epoch >= entry.EPOCH) {
-          return {epoch: entry.EPOCH, maxBlobsPerBlock: entry.MAX_BLOBS_PER_BLOCK};
-        }
-      }
-
-      return {epoch: config.ELECTRA_FORK_EPOCH, maxBlobsPerBlock: config.MAX_BLOBS_PER_BLOCK_ELECTRA};
-    },
-    getAttestationDueMs(fork: ForkName): number {
-      if (isForkPostGloas(fork)) {
-        return this.getSlotComponentDurationMs(config.ATTESTATION_DUE_BPS_GLOAS);
-      }
-      return this.getSlotComponentDurationMs(config.ATTESTATION_DUE_BPS);
-    },
-    getAggregateDueMs(fork: ForkName): number {
-      if (isForkPostGloas(fork)) {
-        return this.getSlotComponentDurationMs(config.AGGREGATE_DUE_BPS_GLOAS);
-      }
-      return this.getSlotComponentDurationMs(config.AGGREGATE_DUE_BPS);
-    },
-    getSyncMessageDueMs(fork: ForkName): number {
-      if (isForkPostGloas(fork)) {
-        return this.getSlotComponentDurationMs(config.SYNC_MESSAGE_DUE_BPS_GLOAS);
-      }
-      return this.getSlotComponentDurationMs(config.SYNC_MESSAGE_DUE_BPS);
-    },
-    getSyncContributionDueMs(fork: ForkName): number {
-      if (isForkPostGloas(fork)) {
-        return this.getSlotComponentDurationMs(config.CONTRIBUTION_DUE_BPS_GLOAS);
-      }
-      return this.getSlotComponentDurationMs(config.CONTRIBUTION_DUE_BPS);
-    },
-    getProposerReorgCutoffMs(_fork: ForkName): number {
-      return this.getSlotComponentDurationMs(config.PROPOSER_REORG_CUTOFF_BPS);
-    },
-
-    getSlotComponentDurationMs(basisPoints: number): number {
-      return Math.round((basisPoints * config.SLOT_DURATION_MS) / BASIS_POINTS);
-    },
-  };
-}

package/src/forkConfig/types.ts

@@ -1,68 +0,0 @@
-import {ForkAll, ForkName, ForkPostAltair, ForkPostBellatrix, ForkPostDeneb, ForkSeq} from "@lodestar/params";
-import {Epoch, SSZTypesFor, Slot, UintNum64, Version} from "@lodestar/types";
-
-export type ForkInfo = {
-  name: ForkName;
-  seq: ForkSeq;
-  epoch: Epoch;
-  version: Version;
-  prevVersion: Version;
-  prevForkName: ForkName;
-};
-
-/**
- * Fork boundaries include both normal hard-forks (phase0, altair, etc.)
- * and Blob Parameter Only (BPO) forks and are used to un-/subscribe to gossip topics
- * and compute the fork digest primarily for domain separation on the p2p layer.
- */
-export type ForkBoundary = {fork: ForkName; epoch: Epoch};
-
-export type BlobParameters = {epoch: Epoch; maxBlobsPerBlock: UintNum64};
-
-/**
- * Fork schedule and helper methods
- */
-export type ForkConfig = {
-  /** Forks in order order of occurence, `phase0` first */
-  forks: {[K in ForkName]: ForkInfo};
-  forksAscendingEpochOrder: ForkInfo[];
-  forksDescendingEpochOrder: ForkInfo[];
-  forkBoundariesAscendingEpochOrder: ForkBoundary[];
-  forkBoundariesDescendingEpochOrder: ForkBoundary[];
-
-  /** Get the hard-fork info for the active fork at `slot` */
-  getForkInfo(slot: Slot): ForkInfo;
-  /** Get the hard-fork info for the active fork at `epoch` */
-  getForkInfoAtEpoch(epoch: Epoch): ForkInfo;
-  /** Get the active fork boundary at a given `epoch` */
-  getForkBoundaryAtEpoch(epoch: Epoch): ForkBoundary;
-  /** Get the hard-fork name at a given slot */
-  getForkName(slot: Slot): ForkName;
-  /** Get the hard-fork sequence number at a given slot */
-  getForkSeq(slot: Slot): ForkSeq;
-  /** Get the hard-fork sequence number at a given epoch */
-  getForkSeqAtEpoch(epoch: Epoch): ForkSeq;
-  /** Get the hard-fork version at a given slot */
-  getForkVersion(slot: Slot): Version;
-  /** Get SSZ types by hard-fork */
-  getForkTypes<F extends ForkName = ForkAll>(slot: Slot): SSZTypesFor<F>;
-  /** Get post-altair SSZ types by hard-fork*/
-  getPostAltairForkTypes(slot: Slot): SSZTypesFor<ForkPostAltair>;
-  /** Get post-bellatrix SSZ types by hard-fork*/
-  getPostBellatrixForkTypes(slot: Slot): SSZTypesFor<ForkPostBellatrix>;
-  /** Get post-deneb SSZ types by hard-fork*/
-  getPostDenebForkTypes(slot: Slot): SSZTypesFor<ForkPostDeneb>;
-  /** Get max blobs per block at a given epoch */
-  getMaxBlobsPerBlock(epoch: Epoch): number;
-  /** Get blob parameters at a given epoch */
-  getBlobParameters(epoch: Epoch): BlobParameters;
-
-  getAttestationDueMs(fork: ForkName): number;
-  getAggregateDueMs(fork: ForkName): number;
-  getSyncMessageDueMs(fork: ForkName): number;
-  getSyncContributionDueMs(fork: ForkName): number;
-  getProposerReorgCutoffMs(fork: ForkName): number;
-
-  /** Convert basis points to milliseconds into the slot */
-  getSlotComponentDurationMs(basisPoints: number): number;
-};

package/src/genesisConfig/index.ts

@@ -1,180 +0,0 @@
-import {digest} from "@chainsafe/as-sha256";
-import {DOMAIN_VOLUNTARY_EXIT, ForkName, ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
-import {DomainType, Epoch, ForkDigest, Root, Slot, Version, phase0, ssz} from "@lodestar/types";
-import {intToBytes, strip0xPrefix, toHex, xor} from "@lodestar/utils";
-import {ChainForkConfig} from "../beaconConfig.js";
-import {ForkBoundary} from "../forkConfig/types.js";
-import {CachedGenesis, ForkDigestHex} from "./types.js";
-
-export type {ForkDigestContext} from "./types.js";
-
-export function createCachedGenesis(chainForkConfig: ChainForkConfig, genesisValidatorsRoot: Root): CachedGenesis {
-  const domainCache = new Map<ForkName, Map<DomainType, Uint8Array>>();
-
-  const forkDigestByEpoch = new Map<Epoch, ForkDigest>();
-  const forkDigestHexByEpoch = new Map<Epoch, ForkDigestHex>();
-  /** Map of ForkDigest in hex format without prefix: `0011aabb` */
-  const epochByForkDigest = new Map<ForkDigestHex, Epoch>();
-
-  const {forkBoundariesAscendingEpochOrder} = chainForkConfig;
-
-  for (let i = 0; i < forkBoundariesAscendingEpochOrder.length; i++) {
-    const currentForkBoundary = forkBoundariesAscendingEpochOrder[i];
-    const nextForkBoundary = forkBoundariesAscendingEpochOrder[i + 1];
-
-    const currentEpoch = currentForkBoundary.epoch;
-    const nextEpoch = nextForkBoundary !== undefined ? nextForkBoundary.epoch : Infinity;
-
-    // Edge case: If multiple fork boundaries start at the same epoch, only consider the latest one
-    if (currentEpoch === nextEpoch) {
-      continue;
-    }
-
-    const forkDigest = computeForkDigest(chainForkConfig, genesisValidatorsRoot, currentEpoch);
-    const forkDigestHex = toHexStringNoPrefix(forkDigest);
-
-    epochByForkDigest.set(forkDigestHex, currentEpoch);
-    forkDigestByEpoch.set(currentEpoch, forkDigest);
-    forkDigestHexByEpoch.set(currentEpoch, forkDigestHex);
-  }
-
-  return {
-    genesisValidatorsRoot,
-
-    getDomain(stateSlot: Slot, domainType: DomainType, messageSlot?: Slot): Uint8Array {
-      // ```py
-      // def get_domain(state: BeaconState, domain_type: DomainType, epoch: Epoch=None) -> Domain:
-      //   """
-      //   Return the signature domain (fork version concatenated with domain type) of a message.
-      //   """
-      //   epoch = get_current_epoch(state) if epoch is None else epoch
-      //   fork_version = state.fork.previous_version if epoch < state.fork.epoch else state.fork.current_version
-      //   return compute_domain(domain_type, fork_version, state.genesis_validators_root)
-      // ```
-
-      const epoch = Math.floor((messageSlot ?? stateSlot) / SLOTS_PER_EPOCH);
-      // Get pre-computed fork schedule, which _should_ match the one in the state
-      const stateForkInfo = chainForkConfig.getForkInfo(stateSlot);
-      // Only allow to select either current or previous fork respective of the fork schedule at stateSlot
-      const forkName = epoch < stateForkInfo.epoch ? stateForkInfo.prevForkName : stateForkInfo.name;
-      const forkInfo = chainForkConfig.forks[forkName];
-
-      let domainByType = domainCache.get(forkInfo.name);
-      if (!domainByType) {
-        domainByType = new Map<DomainType, Uint8Array>();
-        domainCache.set(forkInfo.name, domainByType);
-      }
-      let domain = domainByType.get(domainType);
-      if (!domain) {
-        domain = computeDomain(domainType, forkInfo.version, genesisValidatorsRoot);
-        domainByType.set(domainType, domain);
-      }
-      return domain;
-    },
-
-    getDomainAtFork(forkName: ForkName, domainType: DomainType): Uint8Array {
-      // For some of the messages, irrespective of which slot they are signed
-      // they need to use a fixed fork version even if other forks are scheduled
-      // at the same fork.
-      //
-      // For e.g. BLSToExecutionChange has to be signed using GENESIS_FORK_VERSION
-      // corresponding to phase0
-      const forkInfo = chainForkConfig.forks[forkName];
-      let domainByType = domainCache.get(forkInfo.name);
-      if (!domainByType) {
-        domainByType = new Map<DomainType, Uint8Array>();
-        domainCache.set(forkInfo.name, domainByType);
-      }
-      let domain = domainByType.get(domainType);
-      if (!domain) {
-        domain = computeDomain(domainType, forkInfo.version, genesisValidatorsRoot);
-        domainByType.set(domainType, domain);
-      }
-      return domain;
-    },
-
-    getDomainForVoluntaryExit(stateSlot: Slot, messageSlot?: Slot) {
-      // Deneb onwards the signature domain fork is fixed to capella
-      const domain =
-        stateSlot < chainForkConfig.DENEB_FORK_EPOCH * SLOTS_PER_EPOCH
-          ? this.getDomain(stateSlot, DOMAIN_VOLUNTARY_EXIT, messageSlot)
-          : this.getDomainAtFork(ForkName.capella, DOMAIN_VOLUNTARY_EXIT);
-
-      return domain;
-    },
-
-    forkDigest2ForkBoundary(forkDigest: ForkDigest | ForkDigestHex): ForkBoundary {
-      const forkDigestHex = toHexStringNoPrefix(forkDigest);
-      const epoch = epochByForkDigest.get(forkDigestHex);
-      if (epoch == null) {
-        throw Error(`Unknown forkDigest ${forkDigestHex}`);
-      }
-
-      return chainForkConfig.getForkBoundaryAtEpoch(epoch);
-    },
-
-    forkDigest2ForkBoundaryOption(forkDigest: ForkDigest | ForkDigestHex): ForkBoundary | null {
-      const forkDigestHex = toHexStringNoPrefix(forkDigest);
-      const epoch = epochByForkDigest.get(forkDigestHex);
-      if (epoch == null) {
-        return null;
-      }
-
-      return chainForkConfig.getForkBoundaryAtEpoch(epoch);
-    },
-
-    forkBoundary2ForkDigest(boundary: ForkBoundary): ForkDigest {
-      const forkDigest = forkDigestByEpoch.get(boundary.epoch);
-      if (!forkDigest) {
-        throw Error(`No precomputed forkDigest for ${boundary.epoch}`);
-      }
-      return forkDigest;
-    },
-
-    forkBoundary2ForkDigestHex(boundary: ForkBoundary): ForkDigestHex {
-      const forkDigestHex = forkDigestHexByEpoch.get(boundary.epoch);
-      if (!forkDigestHex) {
-        throw Error(`No precomputed forkDigest for ${boundary.epoch}`);
-      }
-      return toHexStringNoPrefix(forkDigestHex);
-    },
-  };
-}
-
-function computeDomain(domainType: DomainType, forkVersion: Version, genesisValidatorRoot: Root): Uint8Array {
-  const forkDataRoot = computeForkDataRoot(forkVersion, genesisValidatorRoot);
-  const domain = new Uint8Array(32);
-  domain.set(domainType, 0);
-  domain.set(forkDataRoot.slice(0, 28), 4);
-  return domain;
-}
-
-function computeForkDataRoot(currentVersion: Version, genesisValidatorsRoot: Root): Uint8Array {
-  const forkData: phase0.ForkData = {
-    currentVersion,
-    genesisValidatorsRoot,
-  };
-  return ssz.phase0.ForkData.hashTreeRoot(forkData);
-}
-
-function toHexStringNoPrefix(hex: string | Uint8Array): string {
-  return strip0xPrefix(typeof hex === "string" ? hex : toHex(hex));
-}
-
-export function computeForkDigest(config: ChainForkConfig, genesisValidatorsRoot: Root, epoch: Epoch): ForkDigest {
-  const currentFork = config.getForkInfoAtEpoch(epoch);
-  const baseDigest = computeForkDataRoot(currentFork.version, genesisValidatorsRoot);
-
-  if (currentFork.seq < ForkSeq.fulu) {
-    return baseDigest.slice(0, 4);
-  }
-
-  const blobParameters = config.getBlobParameters(epoch);
-
-  return xor(
-    baseDigest,
-    digest(
-      Buffer.concat([intToBytes(blobParameters.epoch, 8, "le"), intToBytes(blobParameters.maxBlobsPerBlock, 8, "le")])
-    )
-  ).slice(0, 4);
-}

package/src/genesisConfig/types.ts

@@ -1,29 +0,0 @@
-import {ForkName} from "@lodestar/params";
-import {DomainType, ForkDigest, Root, Slot} from "@lodestar/types";
-import {ForkBoundary} from "../forkConfig/types.js";
-
-export type ForkDigestHex = string;
-
-export type ForkDigestContext = {
-  forkDigest2ForkBoundary(forkDigest: ForkDigest | ForkDigestHex): ForkBoundary;
-  forkDigest2ForkBoundaryOption(forkDigest: ForkDigest | ForkDigestHex): ForkBoundary | null;
-  forkBoundary2ForkDigest(boundary: ForkBoundary): ForkDigest;
-  forkBoundary2ForkDigestHex(boundary: ForkBoundary): ForkDigestHex;
-};
-
-export interface CachedGenesis extends ForkDigestContext {
-  /**
-   * Return the signature domain (fork version concatenated with domain type) of a message.
-   *
-   * Note: The configured fork schedule is always used rather than on-chain fork schedule.
-   */
-  getDomain(stateSlot: Slot, domainType: DomainType, messageSlot?: Slot): Uint8Array;
-  /**
-   * Return the signature domain corresponding to a particular fork version
-   */
-  getDomainAtFork(forkName: ForkName, domainType: DomainType): Uint8Array;
-
-  getDomainForVoluntaryExit(stateSlot: Slot, messageSlot?: Slot): Uint8Array;
-
-  readonly genesisValidatorsRoot: Root;
-}

package/src/index.ts

@@ -1,4 +0,0 @@
-export * from "./beaconConfig.js";
-export * from "./chainConfig/index.js";
-export * from "./forkConfig/index.js";
-export * from "./genesisConfig/index.js";

package/src/networks.ts

@@ -1,65 +0,0 @@
-import {ChainConfig} from "./chainConfig/index.js";
-import {chiadoChainConfig} from "./chainConfig/networks/chiado.js";
-import {ephemeryChainConfig} from "./chainConfig/networks/ephemery.js";
-import {gnosisChainConfig} from "./chainConfig/networks/gnosis.js";
-import {holeskyChainConfig} from "./chainConfig/networks/holesky.js";
-import {hoodiChainConfig} from "./chainConfig/networks/hoodi.js";
-import {mainnetChainConfig} from "./chainConfig/networks/mainnet.js";
-import {sepoliaChainConfig} from "./chainConfig/networks/sepolia.js";
-
-export {
-  mainnetChainConfig,
-  gnosisChainConfig,
-  sepoliaChainConfig,
-  holeskyChainConfig,
-  hoodiChainConfig,
-  chiadoChainConfig,
-  ephemeryChainConfig,
-};
-
-export type NetworkName = "mainnet" | "gnosis" | "sepolia" | "holesky" | "hoodi" | "chiado" | "ephemery";
-export const networksChainConfig: Record<NetworkName, ChainConfig> = {
-  mainnet: mainnetChainConfig,
-  gnosis: gnosisChainConfig,
-  sepolia: sepoliaChainConfig,
-  holesky: holeskyChainConfig,
-  hoodi: hoodiChainConfig,
-  chiado: chiadoChainConfig,
-  ephemery: ephemeryChainConfig,
-};
-
-export type GenesisData = {
-  genesisTime: number;
-  genesisValidatorsRoot: string;
-};
-
-export const genesisData: Record<NetworkName, GenesisData> = {
-  mainnet: {
-    genesisTime: 1606824023,
-    genesisValidatorsRoot: "0x4b363db94e286120d76eb905340fdd4e54bfe9f06bf33ff6cf5ad27f511bfe95",
-  },
-  gnosis: {
-    genesisTime: 1638993340,
-    genesisValidatorsRoot: "0xf5dcb5564e829aab27264b9becd5dfaa017085611224cb3036f573368dbb9d47",
-  },
-  sepolia: {
-    genesisTime: 1655733600,
-    genesisValidatorsRoot: "0xd8ea171f3c94aea21ebc42a1ed61052acf3f9209c00e4efbaaddac09ed9b8078",
-  },
-  holesky: {
-    genesisTime: 1695902400,
-    genesisValidatorsRoot: "0x9143aa7c615a7f7115e2b6aac319c03529df8242ae705fba9df39b79c59fa8b1",
-  },
-  hoodi: {
-    genesisTime: 1742213400,
-    genesisValidatorsRoot: "0x212f13fc4df078b6cb7db228f1c8307566dcecf900867401a92023d7ba99cb5f",
-  },
-  chiado: {
-    genesisTime: 1665396300,
-    genesisValidatorsRoot: "0x9d642dac73058fbf39c0ae41ab1e34e4d889043cb199851ded7095bc99eb4c1e",
-  },
-  ephemery: {
-    genesisTime: ephemeryChainConfig.MIN_GENESIS_TIME + ephemeryChainConfig.GENESIS_DELAY,
-    genesisValidatorsRoot: "0x0000000000000000000000000000000000000000000000000000000000000000",
-  },
-};

package/src/utils/validateBlobSchedule.ts

@@ -1,32 +0,0 @@
-import {MAX_BLOB_COMMITMENTS_PER_BLOCK} from "@lodestar/params";
-import {BlobSchedule} from "../chainConfig/types.js";
-
-export function validateBlobSchedule(blobSchedule: BlobSchedule): void {
-  if (blobSchedule.length === 0) {
-    return;
-  }
-
-  let previousEpoch: number | undefined;
-
-  for (const [i, entry] of blobSchedule.entries()) {
-    if (previousEpoch !== undefined) {
-      if (entry.EPOCH < previousEpoch) {
-        throw Error(
-          `Invalid BLOB_SCHEDULE expected entries to be sorted by EPOCH in ascending order, ${entry.EPOCH} < ${previousEpoch} at index ${i}`
-        );
-      }
-      if (entry.EPOCH === previousEpoch) {
-        throw Error(
-          `Invalid BLOB_SCHEDULE[${i}] entry with the same epoch value ${entry.EPOCH} as previous BLOB_SCHEDULE[${i - 1}] entry`
-        );
-      }
-    }
-    if (entry.MAX_BLOBS_PER_BLOCK > MAX_BLOB_COMMITMENTS_PER_BLOCK) {
-      throw Error(
-        `Invalid BLOB_SCHEDULE[${i}].MAX_BLOBS_PER_BLOCK value ${entry.MAX_BLOBS_PER_BLOCK} exceeds limit ${MAX_BLOB_COMMITMENTS_PER_BLOCK}`
-      );
-    }
-
-    previousEpoch = entry.EPOCH;
-  }
-}