@lodestar/config 1.35.0-dev.ba92bd8a88 → 1.35.0-dev.c0078a16b5

package/src/chainConfig/types.ts

@@ -1,252 +0,0 @@
-import {PresetName} from "@lodestar/params";
-
-/**
- * Run-time chain configuration
- */
-export type ChainConfig = {
-  PRESET_BASE: PresetName;
-  /**
-   * Free-form short name of the network that this configuration applies to - known
-   * canonical network names include:
-   * * 'mainnet' - there can be only one
-   * * 'holesky' - testnet
-   * Must match the regex: [a-z0-9\-]
-   */
-  CONFIG_NAME: string;
-
-  // Transition
-  TERMINAL_TOTAL_DIFFICULTY: bigint;
-  TERMINAL_BLOCK_HASH: Uint8Array;
-  TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH: number;
-
-  // Genesis
-  MIN_GENESIS_ACTIVE_VALIDATOR_COUNT: number;
-  MIN_GENESIS_TIME: number;
-  GENESIS_FORK_VERSION: Uint8Array;
-  GENESIS_DELAY: number;
-
-  // Forking
-  // Altair
-  ALTAIR_FORK_VERSION: Uint8Array;
-  ALTAIR_FORK_EPOCH: number;
-  // Bellatrix
-  BELLATRIX_FORK_VERSION: Uint8Array;
-  BELLATRIX_FORK_EPOCH: number;
-  // Capella
-  CAPELLA_FORK_VERSION: Uint8Array;
-  CAPELLA_FORK_EPOCH: number;
-  // DENEB
-  DENEB_FORK_VERSION: Uint8Array;
-  DENEB_FORK_EPOCH: number;
-  // ELECTRA
-  ELECTRA_FORK_VERSION: Uint8Array;
-  ELECTRA_FORK_EPOCH: number;
-  // FULU
-  FULU_FORK_VERSION: Uint8Array;
-  FULU_FORK_EPOCH: number;
-  // GLOAS
-  GLOAS_FORK_VERSION: Uint8Array;
-  GLOAS_FORK_EPOCH: number;
-
-  // Time parameters
-  SECONDS_PER_SLOT: number;
-  SECONDS_PER_ETH1_BLOCK: number;
-  MIN_VALIDATOR_WITHDRAWABILITY_DELAY: number;
-  SHARD_COMMITTEE_PERIOD: number;
-  ETH1_FOLLOW_DISTANCE: number;
-
-  ATTESTATION_DUE_BPS_GLOAS: number;
-  AGGREGATE_DUE_BPS_GLOAS: number;
-  SYNC_MESSAGE_DUE_BPS_GLOAS: number;
-  CONTRIBUTION_DUE_BPS_GLOAS: number;
-  PAYLOAD_ATTESTATION_DUE_BPS: number;
-
-  // Validator cycle
-  INACTIVITY_SCORE_BIAS: number;
-  INACTIVITY_SCORE_RECOVERY_RATE: number;
-  EJECTION_BALANCE: number;
-  MIN_PER_EPOCH_CHURN_LIMIT: number;
-  MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT: number;
-  CHURN_LIMIT_QUOTIENT: number;
-  MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT: number;
-  MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA: number;
-
-  // Fork choice
-  PROPOSER_SCORE_BOOST: number;
-  REORG_HEAD_WEIGHT_THRESHOLD: number;
-  REORG_PARENT_WEIGHT_THRESHOLD: number;
-  REORG_MAX_EPOCHS_SINCE_FINALIZATION: number;
-
-  // Deposit contract
-  DEPOSIT_CHAIN_ID: number;
-  DEPOSIT_NETWORK_ID: number;
-  DEPOSIT_CONTRACT_ADDRESS: Uint8Array;
-
-  // Networking
-  MAX_REQUEST_BLOCKS: number;
-  MAX_REQUEST_BLOCKS_DENEB: number;
-  MIN_EPOCHS_FOR_BLOCK_REQUESTS: number;
-  MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS: number;
-  MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS: number;
-  BLOB_SIDECAR_SUBNET_COUNT: number;
-  MAX_BLOBS_PER_BLOCK: number;
-  MAX_REQUEST_BLOB_SIDECARS: number;
-  BLOB_SIDECAR_SUBNET_COUNT_ELECTRA: number;
-  DATA_COLUMN_SIDECAR_SUBNET_COUNT: number;
-  MAX_BLOBS_PER_BLOCK_ELECTRA: number;
-  MAX_REQUEST_BLOB_SIDECARS_ELECTRA: number;
-  MAX_REQUEST_DATA_COLUMN_SIDECARS: number;
-
-  // Fulu
-  NUMBER_OF_CUSTODY_GROUPS: number;
-  SAMPLES_PER_SLOT: number;
-  CUSTODY_REQUIREMENT: number;
-  VALIDATOR_CUSTODY_REQUIREMENT: number;
-  BALANCE_PER_ADDITIONAL_CUSTODY_GROUP: number;
-
-  // Blob Scheduling
-  BLOB_SCHEDULE: BlobSchedule;
-};
-
-export const chainConfigTypes: SpecTypes<ChainConfig> = {
-  PRESET_BASE: "string",
-  CONFIG_NAME: "string",
-
-  // Transition
-  TERMINAL_TOTAL_DIFFICULTY: "bigint",
-  TERMINAL_BLOCK_HASH: "bytes",
-  TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH: "number",
-
-  // Genesis
-  MIN_GENESIS_ACTIVE_VALIDATOR_COUNT: "number",
-  MIN_GENESIS_TIME: "number",
-  GENESIS_FORK_VERSION: "bytes",
-  GENESIS_DELAY: "number",
-
-  // Forking
-  // Altair
-  ALTAIR_FORK_VERSION: "bytes",
-  ALTAIR_FORK_EPOCH: "number",
-  // Bellatrix
-  BELLATRIX_FORK_VERSION: "bytes",
-  BELLATRIX_FORK_EPOCH: "number",
-  // Capella
-  CAPELLA_FORK_VERSION: "bytes",
-  CAPELLA_FORK_EPOCH: "number",
-  // DENEB
-  DENEB_FORK_VERSION: "bytes",
-  DENEB_FORK_EPOCH: "number",
-  // ELECTRA
-  ELECTRA_FORK_VERSION: "bytes",
-  ELECTRA_FORK_EPOCH: "number",
-  // FULU
-  FULU_FORK_VERSION: "bytes",
-  FULU_FORK_EPOCH: "number",
-  // GLOAS
-  GLOAS_FORK_VERSION: "bytes",
-  GLOAS_FORK_EPOCH: "number",
-
-  // Time parameters
-  SECONDS_PER_SLOT: "number",
-  SECONDS_PER_ETH1_BLOCK: "number",
-  MIN_VALIDATOR_WITHDRAWABILITY_DELAY: "number",
-  SHARD_COMMITTEE_PERIOD: "number",
-  ETH1_FOLLOW_DISTANCE: "number",
-
-  ATTESTATION_DUE_BPS_GLOAS: "number",
-  AGGREGATE_DUE_BPS_GLOAS: "number",
-  SYNC_MESSAGE_DUE_BPS_GLOAS: "number",
-  CONTRIBUTION_DUE_BPS_GLOAS: "number",
-  PAYLOAD_ATTESTATION_DUE_BPS: "number",
-
-  // Validator cycle
-  INACTIVITY_SCORE_BIAS: "number",
-  INACTIVITY_SCORE_RECOVERY_RATE: "number",
-  EJECTION_BALANCE: "number",
-  MIN_PER_EPOCH_CHURN_LIMIT: "number",
-  MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT: "number",
-  CHURN_LIMIT_QUOTIENT: "number",
-  MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT: "number",
-  MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA: "number",
-
-  // Fork choice
-  PROPOSER_SCORE_BOOST: "number",
-  REORG_HEAD_WEIGHT_THRESHOLD: "number",
-  REORG_PARENT_WEIGHT_THRESHOLD: "number",
-  REORG_MAX_EPOCHS_SINCE_FINALIZATION: "number",
-
-  // Deposit contract
-  DEPOSIT_CHAIN_ID: "number",
-  DEPOSIT_NETWORK_ID: "number",
-  DEPOSIT_CONTRACT_ADDRESS: "bytes",
-
-  // Networking
-  MAX_REQUEST_BLOCKS: "number",
-  MAX_REQUEST_BLOCKS_DENEB: "number",
-  MIN_EPOCHS_FOR_BLOCK_REQUESTS: "number",
-  MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS: "number",
-  MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS: "number",
-  BLOB_SIDECAR_SUBNET_COUNT: "number",
-  DATA_COLUMN_SIDECAR_SUBNET_COUNT: "number",
-  MAX_BLOBS_PER_BLOCK: "number",
-  MAX_REQUEST_BLOB_SIDECARS: "number",
-  BLOB_SIDECAR_SUBNET_COUNT_ELECTRA: "number",
-  MAX_BLOBS_PER_BLOCK_ELECTRA: "number",
-  MAX_REQUEST_BLOB_SIDECARS_ELECTRA: "number",
-  MAX_REQUEST_DATA_COLUMN_SIDECARS: "number",
-
-  // Fulu
-  NUMBER_OF_CUSTODY_GROUPS: "number",
-  SAMPLES_PER_SLOT: "number",
-  CUSTODY_REQUIREMENT: "number",
-  VALIDATOR_CUSTODY_REQUIREMENT: "number",
-  BALANCE_PER_ADDITIONAL_CUSTODY_GROUP: "number",
-
-  // Blob Scheduling
-  BLOB_SCHEDULE: "blob_schedule",
-};
-
-export type BlobScheduleEntry = {
-  EPOCH: number;
-  MAX_BLOBS_PER_BLOCK: number;
-};
-
-export type BlobSchedule = BlobScheduleEntry[];
-
-export function isBlobSchedule(value: unknown): value is BlobSchedule {
-  return (
-    Array.isArray(value) &&
-    value.every(
-      (entry) =>
-        typeof entry === "object" &&
-        entry !== null &&
-        typeof entry.EPOCH === "number" &&
-        typeof entry.MAX_BLOBS_PER_BLOCK === "number"
-    )
-  );
-}
-
-/** Allows values in a Spec file */
-export type SpecValue = number | bigint | Uint8Array | string | BlobSchedule;
-
-/** Type value name of each spec field. Numbers are ignored since they are the most common */
-export type SpecValueType<V extends SpecValue> = V extends number
-  ? "number"
-  : V extends bigint
-    ? "bigint"
-    : V extends Uint8Array
-      ? "bytes"
-      : V extends string
-        ? "string"
-        : V extends BlobSchedule
-          ? "blob_schedule"
-          : never;
-
-/** All possible type names for a SpecValue */
-export type SpecValueTypeName = SpecValueType<SpecValue>;
-
-export type SpecTypes<Spec extends Record<string, SpecValue>> = {
-  [K in keyof Spec]: SpecValueType<Spec[K]>;
-};
-
-export type SpecJson = Record<string, string | Record<string, string>[]>;

package/src/configs.ts

@@ -1,4 +0,0 @@
-import {chainConfig as mainnetChainConfig} from "./chainConfig/configs/mainnet.js";
-import {chainConfig as minimalChainConfig} from "./chainConfig/configs/minimal.js";
-
-export {mainnetChainConfig, minimalChainConfig};

package/src/default.ts

@@ -1,6 +0,0 @@
-import {createChainForkConfig} from "./beaconConfig.js";
-import {defaultChainConfig} from "./chainConfig/index.js";
-
-export const chainConfig = defaultChainConfig;
-// for testing purpose only
-export const config = createChainForkConfig(defaultChainConfig);

package/src/forkConfig/index.ts

@@ -1,203 +0,0 @@
-import {
-  ForkAll,
-  ForkName,
-  ForkPostAltair,
-  ForkPostBellatrix,
-  ForkPostDeneb,
-  ForkSeq,
-  GENESIS_EPOCH,
-  SLOTS_PER_EPOCH,
-  isForkPostAltair,
-  isForkPostBellatrix,
-  isForkPostDeneb,
-} 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};
-    },
-  };
-}

package/src/forkConfig/types.ts

@@ -1,59 +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;
-};