@lodestar/config 1.35.0-dev.8689cc3545 → 1.35.0-dev.8b45b1e978

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;
-  }
-}