@lodestar/config 1.35.0-dev.47c570ab76 → 1.35.0-dev.549f58dd39

package/src/chainConfig/networks/hoodi.ts

@@ -0,0 +1,64 @@
+import {fromHex as b} from "@lodestar/utils";
+import {chainConfig as mainnet} from "../configs/mainnet.js";
+import {ChainConfig} from "../types.js";
+
+// Hoodi beacon chain config:
+// https://github.com/eth-clients/hoodi/blob/main/metadata/config.yaml
+
+export const hoodiChainConfig: ChainConfig = {
+  ...mainnet,
+
+  CONFIG_NAME: "hoodi",
+
+  // Genesis
+  // ---------------------------------------------------------------
+  // 2025-Mar-17 12:00:00 PM UTC
+  MIN_GENESIS_TIME: 1742212800,
+  GENESIS_DELAY: 600,
+  GENESIS_FORK_VERSION: b("0x10000910"),
+
+  // Forking
+  // ---------------------------------------------------------------
+  // # Altair
+  ALTAIR_FORK_VERSION: b("0x20000910"),
+  ALTAIR_FORK_EPOCH: 0,
+  // # Merge
+  BELLATRIX_FORK_VERSION: b("0x30000910"),
+  BELLATRIX_FORK_EPOCH: 0,
+  TERMINAL_TOTAL_DIFFICULTY: BigInt("0"),
+  // Capella
+  CAPELLA_FORK_VERSION: b("0x40000910"),
+  CAPELLA_FORK_EPOCH: 0,
+  // Deneb
+  DENEB_FORK_VERSION: b("0x50000910"),
+  DENEB_FORK_EPOCH: 0,
+  // Electra
+  ELECTRA_FORK_VERSION: b("0x60000910"),
+  ELECTRA_FORK_EPOCH: 2048,
+  // Fulu
+  FULU_FORK_VERSION: b("0x70000910"),
+  FULU_FORK_EPOCH: 50688,
+
+  // Time parameters
+  // ---------------------------------------------------------------
+  // 12 (update from older mainnet default of 14)
+  SECONDS_PER_ETH1_BLOCK: 12,
+
+  // Deposit contract
+  // ---------------------------------------------------------------
+  DEPOSIT_CHAIN_ID: 560048,
+  DEPOSIT_NETWORK_ID: 560048,
+
+  // Blob Scheduling
+  // ---------------------------------------------------------------
+  BLOB_SCHEDULE: [
+    {
+      EPOCH: 52480,
+      MAX_BLOBS_PER_BLOCK: 15,
+    },
+    {
+      EPOCH: 54016,
+      MAX_BLOBS_PER_BLOCK: 21,
+    },
+  ],
+};

package/src/chainConfig/networks/mainnet.ts

@@ -0,0 +1,19 @@
+import {fromHex as b} from "@lodestar/utils";
+import {chainConfig as mainnet} from "../configs/mainnet.js";
+import {ChainConfig} from "../types.js";
+
+export const mainnetChainConfig: ChainConfig = {
+  ...mainnet,
+
+  CONFIG_NAME: "mainnet",
+
+  DEPOSIT_CONTRACT_ADDRESS: b("0x00000000219ab540356cBB839Cbe05303d7705Fa"),
+
+  DEPOSIT_CHAIN_ID: 1,
+  DEPOSIT_NETWORK_ID: 1,
+
+  MIN_GENESIS_TIME: 1606824000, // Tuesday, December 1, 2020 12:00:00 PM UTC
+  GENESIS_DELAY: 604800,
+  // MUST NOT use `GENESIS_FORK_VERSION` here so for `minimal` networks the preset value of 0x00000001 take prevalence
+  // GENESIS_FORK_VERSION: "0x00000000",
+};

package/src/chainConfig/networks/sepolia.ts

@@ -0,0 +1,61 @@
+import {fromHex as b} from "@lodestar/utils";
+import {chainConfig as mainnet} from "../configs/mainnet.js";
+import {ChainConfig} from "../types.js";
+
+// Sepolia beacon chain config:
+// https://github.com/eth-clients/sepolia/blob/main/metadata/config.yaml
+
+export const sepoliaChainConfig: ChainConfig = {
+  ...mainnet,
+
+  CONFIG_NAME: "sepolia",
+
+  // Genesis
+  // ---------------------------------------------------------------
+  MIN_GENESIS_ACTIVE_VALIDATOR_COUNT: 1300,
+  // # Sunday, June 19, 2022 2:00:00 PM +UTC
+  MIN_GENESIS_TIME: 1655647200,
+  GENESIS_FORK_VERSION: b("0x90000069"),
+  GENESIS_DELAY: 86400,
+
+  // Forking
+  // ---------------------------------------------------------------
+  // # Altair
+  ALTAIR_FORK_VERSION: b("0x90000070"),
+  ALTAIR_FORK_EPOCH: 50,
+  // # Merge
+  BELLATRIX_FORK_VERSION: b("0x90000071"),
+  BELLATRIX_FORK_EPOCH: 100,
+  TERMINAL_TOTAL_DIFFICULTY: BigInt("17000000000000000"),
+  // Capella
+  CAPELLA_FORK_VERSION: b("0x90000072"),
+  CAPELLA_FORK_EPOCH: 56832,
+  // Deneb
+  DENEB_FORK_VERSION: b("0x90000073"),
+  DENEB_FORK_EPOCH: 132608,
+  // Electra
+  ELECTRA_FORK_VERSION: b("0x90000074"),
+  ELECTRA_FORK_EPOCH: 222464,
+  // Fulu
+  FULU_FORK_VERSION: b("0x90000075"),
+  FULU_FORK_EPOCH: 272640,
+
+  // Deposit contract
+  // ---------------------------------------------------------------
+  DEPOSIT_CHAIN_ID: 11155111,
+  DEPOSIT_NETWORK_ID: 11155111,
+  DEPOSIT_CONTRACT_ADDRESS: b("0x7f02C3E3c98b133055B8B348B2Ac625669Ed295D"),
+
+  // Blob Scheduling
+  // ---------------------------------------------------------------
+  BLOB_SCHEDULE: [
+    {
+      EPOCH: 274176,
+      MAX_BLOBS_PER_BLOCK: 15,
+    },
+    {
+      EPOCH: 275712,
+      MAX_BLOBS_PER_BLOCK: 21,
+    },
+  ],
+};

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 */
+  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,223 @@
+import {
+  BASIS_POINTS,
+  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};
+    },
+    getAttestationDueMs(_fork: ForkName): number {
+      return this.getSlotComponentDurationMs(config.ATTESTATION_DUE_BPS);
+    },
+    getAggregateDueMs(_fork: ForkName): number {
+      return this.getSlotComponentDurationMs(config.AGGREGATE_DUE_BPS);
+    },
+    getSyncMessageDueMs(_fork: ForkName): number {
+      return this.getSlotComponentDurationMs(config.SYNC_MESSAGE_DUE_BPS);
+    },
+    getSyncContributionDueMs(_fork: ForkName): number {
+      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);
+    },
+  };
+}