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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lodestar/config",
-  "version": "1.35.0-dev.f80d2d52da",
+  "version": "1.35.0-dev.fcf8d024ea",
   "description": "Chain configuration required for lodestar",
   "author": "ChainSafe Systems",
   "license": "Apache-2.0",
@@ -11,15 +11,19 @@
   "type": "module",
   "exports": {
     ".": {
+      "bun": "./src/index.ts",
       "import": "./lib/index.js"
     },
     "./default": {
+      "bun": "./src/default.ts",
       "import": "./lib/default.js"
     },
     "./networks": {
+      "bun": "./src/networks.ts",
       "import": "./lib/networks.js"
     },
     "./configs": {
+      "bun": "./src/configs.ts",
       "import": "./lib/configs.js"
     }
   },
@@ -34,11 +38,9 @@
   },
   "types": "lib/index.d.ts",
   "files": [
-    "lib/**/*.js",
-    "lib/**/*.js.map",
-    "lib/**/*.d.ts",
-    "*.d.ts",
-    "*.js"
+    "src",
+    "lib",
+    "!**/*.tsbuildinfo"
   ],
   "scripts": {
     "clean": "rm -rf lib && rm -f *.tsbuildinfo",
@@ -65,9 +67,9 @@
   ],
   "dependencies": {
     "@chainsafe/ssz": "^1.2.2",
-    "@lodestar/params": "1.35.0-dev.f80d2d52da",
-    "@lodestar/types": "1.35.0-dev.f80d2d52da",
-    "@lodestar/utils": "1.35.0-dev.f80d2d52da"
+    "@lodestar/params": "1.35.0-dev.fcf8d024ea",
+    "@lodestar/types": "1.35.0-dev.fcf8d024ea",
+    "@lodestar/utils": "1.35.0-dev.fcf8d024ea"
   },
-  "gitHead": "16b0aa696115a011948479fd965d742e131dfc83"
+  "gitHead": "d72abda1a1607ce062febfcfc4528b9e9848c288"
 }

package/src/beaconConfig.ts

@@ -0,0 +1,31 @@
+import {Root} from "@lodestar/types";
+import {ChainConfig, createChainConfig} from "./chainConfig/index.js";
+import {ForkConfig, createForkConfig} from "./forkConfig/index.js";
+import {createCachedGenesis} from "./genesisConfig/index.js";
+import {CachedGenesis} from "./genesisConfig/types.js";
+
+/**
+ * Chain run-time configuration with additional fork schedule helpers
+ */
+export type ChainForkConfig = ChainConfig & ForkConfig;
+
+export type BeaconConfig = ChainForkConfig & CachedGenesis;
+
+/**
+ * Create an `BeaconConfig`, filling in missing values with preset defaults
+ */
+export function createChainForkConfig(chainConfig: Partial<ChainConfig>): ChainForkConfig {
+  const fullChainConfig = createChainConfig(chainConfig);
+  return {
+    ...fullChainConfig,
+    ...createForkConfig(fullChainConfig),
+  };
+}
+
+export function createBeaconConfig(chainConfig: Partial<ChainConfig>, genesisValidatorsRoot: Root): BeaconConfig {
+  const chainForkConfig = createChainForkConfig(chainConfig);
+  return {
+    ...chainForkConfig,
+    ...createCachedGenesis(chainForkConfig, genesisValidatorsRoot),
+  };
+}

package/src/chainConfig/configs/mainnet.ts

@@ -0,0 +1,172 @@
+import {PresetName} from "@lodestar/params";
+import {fromHex as b} from "@lodestar/utils";
+import {ChainConfig} from "../types.js";
+
+// Mainnet config
+// https://github.com/ethereum/consensus-specs/blob/dev/configs/mainnet.yaml
+
+export const chainConfig: ChainConfig = {
+  // Extends the mainnet preset
+  PRESET_BASE: PresetName.mainnet,
+  CONFIG_NAME: "mainnet",
+
+  // Transition
+  // Estimated: Sept 15, 2022
+  TERMINAL_TOTAL_DIFFICULTY: BigInt("58750000000000000000000"),
+  TERMINAL_BLOCK_HASH: b("0x0000000000000000000000000000000000000000000000000000000000000000"),
+  TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH: Infinity,
+
+  // Genesis
+  // ---------------------------------------------------------------
+  // `2**14` (= 16,384)
+  MIN_GENESIS_ACTIVE_VALIDATOR_COUNT: 16384,
+  // Dec 1, 2020, 12pm UTC
+  MIN_GENESIS_TIME: 1606824000,
+  // Mainnet initial fork version, recommend altering for testnets
+  GENESIS_FORK_VERSION: b("0x00000000"),
+  // 604800 seconds (7 days)
+  GENESIS_DELAY: 604800,
+
+  // Forking
+  // ---------------------------------------------------------------
+  // Some forks are disabled for now:
+  //  - These may be re-assigned to another fork-version later
+  //  - Temporarily set to max uint64 value: 2**64 - 1
+
+  // Altair
+  ALTAIR_FORK_VERSION: b("0x01000000"),
+  ALTAIR_FORK_EPOCH: 74240, // Oct 27, 2021, 10:56:23am UTC
+  // Bellatrix
+  BELLATRIX_FORK_VERSION: b("0x02000000"),
+  BELLATRIX_FORK_EPOCH: 144896, // Sept 6, 2022, 11:34:47am UTC
+
+  // Capella
+  CAPELLA_FORK_VERSION: b("0x03000000"),
+  CAPELLA_FORK_EPOCH: 194048, // April 12 (epoch: 194048    slot: 6209536    UTC: 4/12/2023, 10:27:35 PM)
+
+  // Deneb
+  DENEB_FORK_VERSION: b("0x04000000"),
+  DENEB_FORK_EPOCH: 269568, // March 13, 2024, 01:55:35pm UTC
+
+  // ELECTRA
+  ELECTRA_FORK_VERSION: b("0x05000000"),
+  ELECTRA_FORK_EPOCH: 364032, // May 7, 2025, 10:05:11am UTC
+
+  // FULU
+  FULU_FORK_VERSION: b("0x06000000"),
+  FULU_FORK_EPOCH: Infinity,
+
+  // GLOAS
+  GLOAS_FORK_VERSION: b("0x07000000"),
+  GLOAS_FORK_EPOCH: Infinity,
+
+  // Time parameters
+  // ---------------------------------------------------------------
+  // 12 seconds (DEPRECATED)
+  SECONDS_PER_SLOT: 12,
+  // 12000 milliseconds, 12 seconds
+  SLOT_DURATION_MS: 12000,
+  // 14 (estimate from Eth1 mainnet)
+  SECONDS_PER_ETH1_BLOCK: 14,
+  // 2**8 (= 256) epochs ~27 hours
+  MIN_VALIDATOR_WITHDRAWABILITY_DELAY: 256,
+  // 2**8 (= 256) epochs ~27 hours
+  SHARD_COMMITTEE_PERIOD: 256,
+  // 2**11 (= 2,048) Eth1 blocks ~8 hours
+  ETH1_FOLLOW_DISTANCE: 2048,
+  // 1667 basis points, ~17% of SLOT_DURATION_MS
+  PROPOSER_REORG_CUTOFF_BPS: 1667,
+  // 3333 basis points, ~33% of SLOT_DURATION_MS
+  ATTESTATION_DUE_BPS: 3333,
+  // 6667 basis points, ~67% of SLOT_DURATION_MS
+  AGGREGATE_DUE_BPS: 6667,
+
+  // Altair
+  // 3333 basis points, ~33% of SLOT_DURATION_MS
+  SYNC_MESSAGE_DUE_BPS: 3333,
+  // 6667 basis points, ~67% of SLOT_DURATION_MS
+  CONTRIBUTION_DUE_BPS: 6667,
+
+  // 25% of SLOT_DURATION_MS
+  ATTESTATION_DUE_BPS_GLOAS: 2500,
+  // 50% of SLOT_DURATION_MS
+  AGGREGATE_DUE_BPS_GLOAS: 5000,
+  // 25% of SLOT_DURATION_MS
+  SYNC_MESSAGE_DUE_BPS_GLOAS: 2500,
+  // 50% of SLOT_DURATION_MS
+  CONTRIBUTION_DUE_BPS_GLOAS: 5000,
+  // 75% of SLOT_DURATION_MS
+  PAYLOAD_ATTESTATION_DUE_BPS: 7500,
+
+  // Validator cycle
+  // ---------------------------------------------------------------
+  // 2**2 (= 4)
+  INACTIVITY_SCORE_BIAS: 4,
+  // 2**4 (= 16)
+  INACTIVITY_SCORE_RECOVERY_RATE: 16,
+  // 2**4 * 10**9 (= 16,000,000,000) Gwei
+  EJECTION_BALANCE: 16000000000,
+  // 2**2 (= 4)
+  MIN_PER_EPOCH_CHURN_LIMIT: 4,
+  // 2**3 (= 8)
+  MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT: 8,
+  // 2**16 (= 65,536)
+  CHURN_LIMIT_QUOTIENT: 65536,
+
+  // Fork choice
+  // ---------------------------------------------------------------
+  // 40%
+  PROPOSER_SCORE_BOOST: 40,
+  REORG_HEAD_WEIGHT_THRESHOLD: 20,
+  REORG_PARENT_WEIGHT_THRESHOLD: 160,
+  REORG_MAX_EPOCHS_SINCE_FINALIZATION: 2,
+
+  // Deposit contract
+  // ---------------------------------------------------------------
+  // Ethereum PoW Mainnet
+  DEPOSIT_CHAIN_ID: 1,
+  DEPOSIT_NETWORK_ID: 1,
+  DEPOSIT_CONTRACT_ADDRESS: b("0x00000000219ab540356cBB839Cbe05303d7705Fa"),
+
+  // Networking
+  // ---------------------------------------------------------------
+  // 2**10 (= 1024)
+  MAX_REQUEST_BLOCKS: 1024,
+  // `MIN_VALIDATOR_WITHDRAWABILITY_DELAY + CHURN_LIMIT_QUOTIENT // 2` (= 33024, ~5 months)
+  MIN_EPOCHS_FOR_BLOCK_REQUESTS: 33024,
+
+  // Deneb
+  // 2**7 (= 128)
+  MAX_REQUEST_BLOCKS_DENEB: 128,
+  // `2**12` (= 4096 epochs, ~18 days)
+  MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS: 4096,
+  BLOB_SIDECAR_SUBNET_COUNT: 6,
+  MAX_BLOBS_PER_BLOCK: 6,
+  // MAX_REQUEST_BLOCKS_DENEB * MAX_BLOBS_PER_BLOCK
+  MAX_REQUEST_BLOB_SIDECARS: 768,
+
+  // Electra
+  // 2**8 * 10**9 (= 256,000,000,000)
+  MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT: 256000000000,
+  // 2**7 * 10**9 (= 128,000,000,000)
+  MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA: 128000000000,
+  BLOB_SIDECAR_SUBNET_COUNT_ELECTRA: 9,
+  MAX_BLOBS_PER_BLOCK_ELECTRA: 9,
+  // MAX_REQUEST_BLOCKS_DENEB * MAX_BLOBS_PER_BLOCK_ELECTRA
+  MAX_REQUEST_BLOB_SIDECARS_ELECTRA: 1152,
+
+  // Fulu
+  NUMBER_OF_CUSTODY_GROUPS: 128,
+  DATA_COLUMN_SIDECAR_SUBNET_COUNT: 128,
+  MAX_REQUEST_DATA_COLUMN_SIDECARS: 16384,
+  SAMPLES_PER_SLOT: 8,
+  CUSTODY_REQUIREMENT: 4,
+  VALIDATOR_CUSTODY_REQUIREMENT: 8,
+  BALANCE_PER_ADDITIONAL_CUSTODY_GROUP: 32000000000,
+  // `2**12` (= 4096 epochs, ~18 days)
+  MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS: 4096,
+
+  // Blob Scheduling
+  // ---------------------------------------------------------------
+  BLOB_SCHEDULE: [],
+};

package/src/chainConfig/configs/minimal.ts

@@ -0,0 +1,167 @@
+import {PresetName} from "@lodestar/params";
+import {fromHex as b} from "@lodestar/utils";
+import {ChainConfig} from "../types.js";
+
+// Minimal config
+// https://github.com/ethereum/consensus-specs/blob/dev/configs/minimal.yaml
+
+export const chainConfig: ChainConfig = {
+  // Extends the minimal preset
+  PRESET_BASE: PresetName.minimal,
+  CONFIG_NAME: "minimal",
+
+  // Transition
+  // 2**256-2**10 for testing minimal network
+  TERMINAL_TOTAL_DIFFICULTY: BigInt("115792089237316195423570985008687907853269984665640564039457584007913129638912"),
+  TERMINAL_BLOCK_HASH: b("0x0000000000000000000000000000000000000000000000000000000000000000"),
+  TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH: Infinity,
+
+  // Genesis
+  // ---------------------------------------------------------------
+  // [customized]
+  MIN_GENESIS_ACTIVE_VALIDATOR_COUNT: 64,
+  // Jan 3, 2020
+  MIN_GENESIS_TIME: 1578009600,
+  // Highest byte set to 0x01 to avoid collisions with mainnet versioning
+  GENESIS_FORK_VERSION: b("0x00000001"),
+  // [customized] Faster to spin up testnets, but does not give validator reasonable warning time for genesis
+  GENESIS_DELAY: 300,
+
+  // Forking
+  // ---------------------------------------------------------------
+  // Values provided for illustrative purposes.
+  // Individual tests/testnets may set different values.
+
+  // Altair
+  ALTAIR_FORK_VERSION: b("0x01000001"),
+  ALTAIR_FORK_EPOCH: 74240, // Oct 27, 2021, 10:56:23am UTC
+  // Bellatrix
+  BELLATRIX_FORK_VERSION: b("0x02000001"),
+  BELLATRIX_FORK_EPOCH: Infinity,
+  // Capella
+  CAPELLA_FORK_VERSION: b("0x03000001"),
+  CAPELLA_FORK_EPOCH: Infinity,
+  // Deneb
+  DENEB_FORK_VERSION: b("0x04000001"),
+  DENEB_FORK_EPOCH: Infinity,
+  // ELECTRA
+  ELECTRA_FORK_VERSION: b("0x05000001"),
+  ELECTRA_FORK_EPOCH: Infinity,
+  // FULU
+  FULU_FORK_VERSION: b("0x06000001"),
+  FULU_FORK_EPOCH: Infinity,
+  // GLOAS
+  GLOAS_FORK_VERSION: b("0x07000001"),
+  GLOAS_FORK_EPOCH: Infinity,
+
+  // Time parameters
+  // ---------------------------------------------------------------
+  // [customized] Faster for testing purposes (DEPRECATED)
+  SECONDS_PER_SLOT: 6,
+  // [customized] 6000 milliseconds, 6 seconds
+  SLOT_DURATION_MS: 6000,
+  // 14 (estimate from Eth1 mainnet)
+  SECONDS_PER_ETH1_BLOCK: 14,
+  // 2**8 (= 256) epochs
+  MIN_VALIDATOR_WITHDRAWABILITY_DELAY: 256,
+  // [customized] higher frequency of committee turnover and faster time to acceptable voluntary exit
+  SHARD_COMMITTEE_PERIOD: 64,
+  // [customized] process deposits more quickly, but insecure
+  ETH1_FOLLOW_DISTANCE: 16,
+  // 1667 basis points, ~17% of SLOT_DURATION_MS
+  PROPOSER_REORG_CUTOFF_BPS: 1667,
+  // 3333 basis points, ~33% of SLOT_DURATION_MS
+  ATTESTATION_DUE_BPS: 3333,
+  // 6667 basis points, ~67% of SLOT_DURATION_MS
+  AGGREGATE_DUE_BPS: 6667,
+
+  // Altair
+  // 3333 basis points, ~33% of SLOT_DURATION_MS
+  SYNC_MESSAGE_DUE_BPS: 3333,
+  // 6667 basis points, ~67% of SLOT_DURATION_MS
+  CONTRIBUTION_DUE_BPS: 6667,
+
+  // 25% of SLOT_DURATION_MS
+  ATTESTATION_DUE_BPS_GLOAS: 2500,
+  // 50% of SLOT_DURATION_MS
+  AGGREGATE_DUE_BPS_GLOAS: 5000,
+  // 25% of SLOT_DURATION_MS
+  SYNC_MESSAGE_DUE_BPS_GLOAS: 2500,
+  // 50% of SLOT_DURATION_MS
+  CONTRIBUTION_DUE_BPS_GLOAS: 5000,
+  // 75% of SLOT_DURATION_MS
+  PAYLOAD_ATTESTATION_DUE_BPS: 7500,
+
+  // Validator cycle
+  // ---------------------------------------------------------------
+  // 2**2 (= 4)
+  INACTIVITY_SCORE_BIAS: 4,
+  // 2**4 (= 16)
+  INACTIVITY_SCORE_RECOVERY_RATE: 16,
+  // 2**4 * 10**9 (= 16,000,000,000) Gwei
+  EJECTION_BALANCE: 16000000000,
+  // 2**2 (= 4)
+  MIN_PER_EPOCH_CHURN_LIMIT: 2,
+  // [customized]
+  MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT: 4,
+  // [customized] scale queue churn at much lower validator counts for testing
+  CHURN_LIMIT_QUOTIENT: 32,
+
+  // Fork choice
+  // ---------------------------------------------------------------
+  // 40%
+  PROPOSER_SCORE_BOOST: 40,
+  REORG_HEAD_WEIGHT_THRESHOLD: 20,
+  REORG_PARENT_WEIGHT_THRESHOLD: 160,
+  REORG_MAX_EPOCHS_SINCE_FINALIZATION: 2,
+
+  // Deposit contract
+  // ---------------------------------------------------------------
+  // Ethereum Goerli testnet
+  DEPOSIT_CHAIN_ID: 5,
+  DEPOSIT_NETWORK_ID: 5,
+  // Configured on a per testnet basis
+  DEPOSIT_CONTRACT_ADDRESS: b("0x1234567890123456789012345678901234567890"),
+
+  // Networking
+  // ---------------------------------------------------------------
+  // 2**10 (= 1024)
+  MAX_REQUEST_BLOCKS: 1024,
+  // [customized] `MIN_VALIDATOR_WITHDRAWABILITY_DELAY + CHURN_LIMIT_QUOTIENT // 2` (= 272)
+  MIN_EPOCHS_FOR_BLOCK_REQUESTS: 272,
+
+  // Deneb
+  // 2**7 (= 128)
+  MAX_REQUEST_BLOCKS_DENEB: 128,
+  // `2**12` (= 4096 epochs, ~18 days)
+  MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS: 4096,
+  BLOB_SIDECAR_SUBNET_COUNT: 6,
+  MAX_BLOBS_PER_BLOCK: 6,
+  // MAX_REQUEST_BLOCKS_DENEB * MAX_BLOBS_PER_BLOCK
+  MAX_REQUEST_BLOB_SIDECARS: 768,
+
+  // Electra
+  // 2**7 * 10**9 (= 128,000,000,000)
+  MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT: 128000000000,
+  // 2**6 * 10**9 (= 64,000,000,000)
+  MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA: 64000000000,
+  BLOB_SIDECAR_SUBNET_COUNT_ELECTRA: 9,
+  MAX_BLOBS_PER_BLOCK_ELECTRA: 9,
+  // MAX_REQUEST_BLOCKS_DENEB * MAX_BLOBS_PER_BLOCK_ELECTRA
+  MAX_REQUEST_BLOB_SIDECARS_ELECTRA: 1152,
+
+  // Fulu
+  NUMBER_OF_CUSTODY_GROUPS: 128,
+  DATA_COLUMN_SIDECAR_SUBNET_COUNT: 128,
+  MAX_REQUEST_DATA_COLUMN_SIDECARS: 16384,
+  SAMPLES_PER_SLOT: 8,
+  CUSTODY_REQUIREMENT: 4,
+  VALIDATOR_CUSTODY_REQUIREMENT: 8,
+  BALANCE_PER_ADDITIONAL_CUSTODY_GROUP: 32000000000,
+  // `2**12` (= 4096 epochs, ~18 days)
+  MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS: 4096,
+
+  // Blob Scheduling
+  // ---------------------------------------------------------------
+  BLOB_SCHEDULE: [],
+};

package/src/chainConfig/default.ts

@@ -0,0 +1,19 @@
+import {ACTIVE_PRESET, PresetName} from "@lodestar/params";
+import {chainConfig as mainnet} from "./configs/mainnet.js";
+import {chainConfig as minimal} from "./configs/minimal.js";
+import {ChainConfig} from "./types.js";
+
+let defaultChainConfig: ChainConfig;
+
+switch (ACTIVE_PRESET) {
+  case PresetName.minimal:
+    defaultChainConfig = minimal;
+    break;
+  case PresetName.mainnet:
+    defaultChainConfig = mainnet;
+    break;
+  default:
+    defaultChainConfig = mainnet;
+}
+
+export {defaultChainConfig};

package/src/chainConfig/index.ts

@@ -0,0 +1,33 @@
+import {ACTIVE_PRESET} from "@lodestar/params";
+import {defaultChainConfig} from "./default.js";
+import {ChainConfig} from "./types.js";
+
+export * from "./default.js";
+export {chainConfigFromJson, chainConfigToJson, deserializeBlobSchedule, specValuesToJson} from "./json.js";
+export * from "./types.js";
+
+/**
+ * Create an `ChainConfig`, filling in missing values with preset defaults
+ */
+export function createChainConfig(input: Partial<ChainConfig>): ChainConfig {
+  const config = {
+    // Set the config first with default preset values
+    ...defaultChainConfig,
+    // Override with input
+    ...input,
+  };
+
+  // Set SLOT_DURATION_MS if SECONDS_PER_SLOT is provided but SLOT_DURATION_MS is not.
+  // This is to provide backward compatibility until Gloas is live
+  if (input.SLOT_DURATION_MS === undefined) {
+    config.SLOT_DURATION_MS = config.SECONDS_PER_SLOT * 1000;
+  }
+
+  // Assert that the preset matches the active preset
+  if (config.PRESET_BASE !== ACTIVE_PRESET) {
+    throw new Error(
+      `Can only create a config for the active preset: ACTIVE_PRESET=${ACTIVE_PRESET} PRESET_BASE=${config.PRESET_BASE}`
+    );
+  }
+  return config;
+}

package/src/chainConfig/json.ts

@@ -0,0 +1,175 @@
+import {fromHex, toHex} from "@lodestar/utils";
+import {validateBlobSchedule} from "../utils/validateBlobSchedule.js";
+import {
+  BlobSchedule,
+  BlobScheduleEntry,
+  ChainConfig,
+  SpecJson,
+  SpecValue,
+  SpecValueTypeName,
+  chainConfigTypes,
+  isBlobSchedule,
+} from "./types.js";
+
+const MAX_UINT64_JSON = "18446744073709551615";
+
+export function chainConfigToJson(config: ChainConfig): SpecJson {
+  const json: SpecJson = {};
+
+  for (const key of Object.keys(chainConfigTypes) as (keyof ChainConfig)[]) {
+    const value = config[key];
+    if (value !== undefined) {
+      json[key] = serializeSpecValue(value, chainConfigTypes[key]);
+    }
+  }
+
+  return json;
+}
+
+export function chainConfigFromJson(json: Record<string, unknown>): ChainConfig {
+  const config = {} as ChainConfig;
+
+  for (const key of Object.keys(chainConfigTypes) as (keyof ChainConfig)[]) {
+    const value = json[key];
+    if (value !== undefined) {
+      config[key] = deserializeSpecValue(json[key], chainConfigTypes[key], key) as never;
+    }
+  }
+
+  return config;
+}
+
+export function specValuesToJson(spec: Record<string, SpecValue>): SpecJson {
+  const json: SpecJson = {};
+
+  for (const key of Object.keys(spec)) {
+    json[key] = serializeSpecValue(spec[key], toSpecValueTypeName(spec[key]));
+  }
+
+  return json;
+}
+
+/** Automatic inference of typeName. For critical variables define type names, else infer */
+export function toSpecValueTypeName(value: SpecValue): SpecValueTypeName {
+  if (value instanceof Uint8Array) return "bytes";
+  if (typeof value === "number") return "number";
+  if (typeof value === "bigint") return "bigint";
+  if (typeof value === "string") return "string";
+  if (isBlobSchedule(value)) return "blob_schedule";
+  throw Error(`Unknown value type ${value}`);
+}
+
+export function serializeSpecValue(
+  value: SpecValue,
+  typeName: SpecValueTypeName
+): string | Record<keyof BlobScheduleEntry, string>[] {
+  switch (typeName) {
+    case "number":
+      if (typeof value !== "number") {
+        throw Error(`Invalid value ${value.toString()} expected number`);
+      }
+      if (value === Infinity) {
+        return MAX_UINT64_JSON;
+      }
+      return value.toString(10);
+
+    case "bigint":
+      if (typeof value !== "bigint") {
+        throw Error(`Invalid value ${value.toString()} expected bigint`);
+      }
+      return value.toString(10);
+
+    case "bytes":
+      if (!(value instanceof Uint8Array)) {
+        throw Error(`Invalid value ${value.toString()} expected Uint8Array`);
+      }
+      return toHex(value);
+
+    case "string":
+      if (typeof value !== "string") {
+        throw Error(`Invalid value ${value.toString()} expected string`);
+      }
+      return value;
+
+    case "blob_schedule":
+      if (!isBlobSchedule(value)) {
+        throw Error(`Invalid value ${value.toString()} expected BlobSchedule`);
+      }
+
+      return value.map(({EPOCH, MAX_BLOBS_PER_BLOCK}) => ({
+        EPOCH: EPOCH === Infinity ? MAX_UINT64_JSON : EPOCH.toString(10),
+        MAX_BLOBS_PER_BLOCK: MAX_BLOBS_PER_BLOCK === Infinity ? MAX_UINT64_JSON : MAX_BLOBS_PER_BLOCK.toString(10),
+      }));
+  }
+}
+
+export function deserializeSpecValue(valueStr: unknown, typeName: SpecValueTypeName, keyName: string): SpecValue {
+  if (typeName === "blob_schedule") {
+    return deserializeBlobSchedule(valueStr);
+  }
+
+  if (typeof valueStr !== "string") {
+    throw Error(`Invalid ${keyName} value ${valueStr} expected string`);
+  }
+
+  switch (typeName) {
+    case "number":
+      if (valueStr === MAX_UINT64_JSON) {
+        return Infinity;
+      }
+      return parseInt(valueStr, 10);
+
+    case "bigint":
+      return BigInt(valueStr);
+
+    case "bytes":
+      return fromHex(valueStr);
+
+    case "string":
+      return valueStr;
+  }
+}
+
+export function deserializeBlobSchedule(input: unknown): BlobSchedule {
+  if (!Array.isArray(input)) {
+    throw Error(`Invalid BLOB_SCHEDULE value ${input} expected array`);
+  }
+
+  const blobSchedule = input.map((entry, i) => {
+    if (typeof entry !== "object" || entry === null) {
+      throw Error(`Invalid BLOB_SCHEDULE[${i}] entry ${entry} expected object`);
+    }
+
+    const out = {} as BlobScheduleEntry;
+
+    for (const key of ["EPOCH", "MAX_BLOBS_PER_BLOCK"] as Array<keyof BlobScheduleEntry>) {
+      const value = entry[key];
+
+      if (value === undefined) {
+        throw Error(`Invalid BLOB_SCHEDULE[${i}] entry ${JSON.stringify(entry)} missing ${key}`);
+      }
+
+      if (typeof value !== "string") {
+        throw Error(`Invalid BLOB_SCHEDULE[${i}].${key} value ${value} expected string`);
+      }
+
+      if (value === MAX_UINT64_JSON) {
+        out[key] = Infinity;
+      } else {
+        const parsed = parseInt(value, 10);
+
+        if (Number.isNaN(parsed)) {
+          throw Error(`Invalid BLOB_SCHEDULE[${i}].${key} value ${value} expected number`);
+        }
+
+        out[key] = parsed;
+      }
+    }
+
+    return out;
+  });
+
+  validateBlobSchedule(blobSchedule);
+
+  return blobSchedule;
+}