@lodestar/config 1.35.0-dev.e9dd48f165 → 1.35.0-dev.f45a2be721

package/src/chainConfig/types.ts

@@ -0,0 +1,267 @@
+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
+  /** @deprecated Use `SLOT_DURATION_MS` instead. */
+  SECONDS_PER_SLOT: number;
+  SLOT_DURATION_MS: number;
+  SECONDS_PER_ETH1_BLOCK: number;
+  MIN_VALIDATOR_WITHDRAWABILITY_DELAY: number;
+  SHARD_COMMITTEE_PERIOD: number;
+  ETH1_FOLLOW_DISTANCE: number;
+  PROPOSER_REORG_CUTOFF_BPS: number;
+  ATTESTATION_DUE_BPS: number;
+  AGGREGATE_DUE_BPS: number;
+  // Altair
+  SYNC_MESSAGE_DUE_BPS: number;
+  CONTRIBUTION_DUE_BPS: 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",
+  SLOT_DURATION_MS: "number",
+  SECONDS_PER_ETH1_BLOCK: "number",
+  MIN_VALIDATOR_WITHDRAWABILITY_DELAY: "number",
+  SHARD_COMMITTEE_PERIOD: "number",
+  ETH1_FOLLOW_DISTANCE: "number",
+  PROPOSER_REORG_CUTOFF_BPS: "number",
+  ATTESTATION_DUE_BPS: "number",
+  AGGREGATE_DUE_BPS: "number",
+  // Altair
+  SYNC_MESSAGE_DUE_BPS: "number",
+  CONTRIBUTION_DUE_BPS: "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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,236 @@
+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

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