@lodestar/config 1.35.0-dev.8ea34e52ba → 1.35.0-dev.901d719660

package/src/genesisConfig/index.ts

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

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

@@ -0,0 +1,4 @@
+export * from "./beaconConfig.js";
+export * from "./chainConfig/index.js";
+export * from "./forkConfig/index.js";
+export * from "./genesisConfig/index.js";

package/src/networks.ts

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

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