@ozdao/prometheus-framework 0.1.66 → 0.1.68

package/dist/node_modules/web3-eth-accounts/lib/esm/common/common.js

@@ -0,0 +1,741 @@
+import y from "../../../../crc-32/crc32.js";
+import { TypeOutput as p } from "./types.js";
+import { parseGethGenesis as E, toType as g, intToUint8Array as _ } from "./utils.js";
+import A from "./chains/goerli.js";
+import C from "./chains/mainnet.js";
+import x from "./chains/sepolia.js";
+import { EIPs as H } from "./eips/index.js";
+import { Hardfork as b, CustomChain as u, Chain as P } from "./enums.js";
+import { hardforks as F } from "./hardforks/index.js";
+import { uint8ArrayConcat as B } from "../../../../web3-utils/lib/esm/uint8array.js";
+import { EventEmitter as T } from "../../../../web3-utils/lib/esm/event_emitter.js";
+import { hexToBytes as O, bytesToHex as N } from "../../../../web3-utils/lib/esm/converters.js";
+const { buf: R } = y;
+class h extends T {
+  constructor(t) {
+    var r, n;
+    super(), this._eips = [], this._customChains = (r = t.customChains) !== null && r !== void 0 ? r : [], this._chainParams = this.setChain(t.chain), this.DEFAULT_HARDFORK = (n = this._chainParams.defaultHardfork) !== null && n !== void 0 ? n : b.Merge, this.HARDFORK_CHANGES = this.hardforks().map((e) => [
+      e.name,
+      F[e.name]
+    ]), this._hardfork = this.DEFAULT_HARDFORK, t.hardfork !== void 0 && this.setHardfork(t.hardfork), t.eips && this.setEIPs(t.eips);
+  }
+  /**
+   * Creates a {@link Common} object for a custom chain, based on a standard one.
+   *
+   * It uses all the {@link Chain} parameters from the {@link baseChain} option except the ones overridden
+   * in a provided {@link chainParamsOrName} dictionary. Some usage example:
+   *
+   * ```javascript
+   * Common.custom({chainId: 123})
+   * ```
+   *
+   * There are also selected supported custom chains which can be initialized by using one of the
+   * {@link CustomChains} for {@link chainParamsOrName}, e.g.:
+   *
+   * ```javascript
+   * Common.custom(CustomChains.MaticMumbai)
+   * ```
+   *
+   * Note that these supported custom chains only provide some base parameters (usually the chain and
+   * network ID and a name) and can only be used for selected use cases (e.g. sending a tx with
+   * the `web3-utils/tx` library to a Layer-2 chain).
+   *
+   * @param chainParamsOrName Custom parameter dict (`name` will default to `custom-chain`) or string with name of a supported custom chain
+   * @param opts Custom chain options to set the {@link CustomCommonOpts.baseChain}, selected {@link CustomCommonOpts.hardfork} and others
+   */
+  static custom(t, r = {}) {
+    var n;
+    const e = (n = r.baseChain) !== null && n !== void 0 ? n : "mainnet", i = Object.assign({}, h._getChainParams(e));
+    if (i.name = "custom-chain", typeof t != "string")
+      return new h(Object.assign({ chain: Object.assign(Object.assign({}, i), t) }, r));
+    if (t === u.PolygonMainnet)
+      return h.custom({
+        name: u.PolygonMainnet,
+        chainId: 137,
+        networkId: 137
+      }, r);
+    if (t === u.PolygonMumbai)
+      return h.custom({
+        name: u.PolygonMumbai,
+        chainId: 80001,
+        networkId: 80001
+      }, r);
+    if (t === u.ArbitrumRinkebyTestnet)
+      return h.custom({
+        name: u.ArbitrumRinkebyTestnet,
+        chainId: 421611,
+        networkId: 421611
+      }, r);
+    if (t === u.ArbitrumOne)
+      return h.custom({
+        name: u.ArbitrumOne,
+        chainId: 42161,
+        networkId: 42161
+      }, r);
+    if (t === u.xDaiChain)
+      return h.custom({
+        name: u.xDaiChain,
+        chainId: 100,
+        networkId: 100
+      }, r);
+    if (t === u.OptimisticKovan)
+      return h.custom({
+        name: u.OptimisticKovan,
+        chainId: 69,
+        networkId: 69
+      }, Object.assign({ hardfork: b.Berlin }, r));
+    if (t === u.OptimisticEthereum)
+      return h.custom({
+        name: u.OptimisticEthereum,
+        chainId: 10,
+        networkId: 10
+      }, Object.assign({ hardfork: b.Berlin }, r));
+    throw new Error(`Custom chain ${t} not supported`);
+  }
+  /**
+   * Static method to load and set common from a geth genesis json
+   * @param genesisJson json of geth configuration
+   * @param { chain, eips, genesisHash, hardfork, mergeForkIdPostMerge } to further configure the common instance
+   * @returns Common
+   */
+  static fromGethGenesis(t, { chain: r, eips: n, genesisHash: e, hardfork: i, mergeForkIdPostMerge: s }) {
+    var o;
+    const d = E(t, r, s), c = new h({
+      chain: (o = d.name) !== null && o !== void 0 ? o : "custom",
+      customChains: [d],
+      eips: n,
+      hardfork: i ?? d.hardfork
+    });
+    return e !== void 0 && c.setForkHashes(e), c;
+  }
+  /**
+   * Static method to determine if a {@link chainId} is supported as a standard chain
+   * @param chainId bigint id (`1`) of a standard chain
+   * @returns boolean
+   */
+  static isSupportedChainId(t) {
+    return !!this._getInitializedChains().names[t.toString()];
+  }
+  static _getChainParams(t, r) {
+    let n = t;
+    const e = this._getInitializedChains(r);
+    if (typeof n == "number" || typeof n == "bigint") {
+      if (n = n.toString(), e.names[n]) {
+        const i = e.names[n];
+        return e[i];
+      }
+      throw new Error(`Chain with ID ${n} not supported`);
+    }
+    if (e[n] !== void 0)
+      return e[n];
+    throw new Error(`Chain with name ${n} not supported`);
+  }
+  /**
+   * Sets the chain
+   * @param chain String ('mainnet') or Number (1) chain representation.
+   *              Or, a Dictionary of chain parameters for a private network.
+   * @returns The dictionary with parameters set as chain
+   */
+  setChain(t) {
+    if (typeof t == "number" || typeof t == "bigint" || typeof t == "string")
+      this._chainParams = h._getChainParams(t, this._customChains);
+    else if (typeof t == "object") {
+      if (this._customChains.length > 0)
+        throw new Error("Chain must be a string, number, or bigint when initialized with customChains passed in");
+      const r = ["networkId", "genesis", "hardforks", "bootstrapNodes"];
+      for (const n of r)
+        if (!(n in t))
+          throw new Error(`Missing required chain parameter: ${n}`);
+      this._chainParams = t;
+    } else
+      throw new Error("Wrong input format");
+    for (const r of this.hardforks())
+      if (r.block === void 0)
+        throw new Error("Hardfork cannot have undefined block number");
+    return this._chainParams;
+  }
+  /**
+   * Sets the hardfork to get params for
+   * @param hardfork String identifier (e.g. 'byzantium') or {@link Hardfork} enum
+   */
+  setHardfork(t) {
+    let r = !1;
+    for (const n of this.HARDFORK_CHANGES)
+      n[0] === t && (this._hardfork !== t && (this._hardfork = t, this.emit("hardforkChanged", t)), r = !0);
+    if (!r)
+      throw new Error(`Hardfork with name ${t} not supported`);
+  }
+  /**
+   * Returns the hardfork based on the block number or an optional
+   * total difficulty (Merge HF) provided.
+   *
+   * An optional TD takes precedence in case the corresponding HF block
+   * is set to `null` or otherwise needs to match (if not an error
+   * will be thrown).
+   *
+   * @param blockNumber
+   * @param td : total difficulty of the parent block (for block hf) OR of the chain latest (for chain hf)
+   * @param timestamp: timestamp in seconds at which block was/is to be minted
+   * @returns The name of the HF
+   */
+  getHardforkByBlockNumber(t, r, n) {
+    const e = g(t, p.BigInt), i = g(r, p.BigInt), s = g(n, p.Number), o = this.hardforks().filter((f) => (
+      // eslint-disable-next-line no-null/no-null
+      f.block !== null || // eslint-disable-next-line no-null/no-null
+      f.ttd !== null && f.ttd !== void 0 || f.timestamp !== void 0
+    )), d = o.findIndex((f) => f.ttd !== null && f.ttd !== void 0);
+    if (o.slice(d + 1).findIndex((f) => f.ttd !== null && f.ttd !== void 0) >= 0)
+      throw Error("More than one merge hardforks found with ttd specified");
+    let a = o.findIndex((f) => (
+      // eslint-disable-next-line no-null/no-null
+      f.block !== null && f.block > e || s !== void 0 && Number(f.timestamp) > s
+    ));
+    if (a === -1)
+      a = o.length;
+    else if (a === 0)
+      throw Error("Must have at least one hardfork at block 0");
+    if (s === void 0) {
+      const f = o.slice(0, a).reverse().findIndex((v) => v.block !== null || v.ttd !== void 0);
+      a -= f;
+    }
+    if (a -= 1, o[a].block === null && o[a].timestamp === void 0)
+      (i == null || BigInt(o[a].ttd) > i) && (a -= 1);
+    else if (d >= 0 && i !== void 0 && i !== null) {
+      if (a >= d && BigInt(o[d].ttd) > i)
+        throw Error("Maximum HF determined by total difficulty is lower than the block number HF");
+      if (a < d && BigInt(o[d].ttd) <= i)
+        throw Error("HF determined by block number is lower than the minimum total difficulty HF");
+    }
+    const l = a;
+    for (; a < o.length - 1 && !(o[a].block !== o[a + 1].block || o[a].timestamp !== o[a + 1].timestamp); a += 1)
+      ;
+    if (s) {
+      if (o.slice(0, l).reduce((I, w) => {
+        var k;
+        return Math.max(Number((k = w.timestamp) !== null && k !== void 0 ? k : "0"), I);
+      }, 0) > s)
+        throw Error("Maximum HF determined by timestamp is lower than the block number/ttd HF");
+      if (o.slice(a + 1).reduce((I, w) => {
+        var k;
+        return Math.min(Number((k = w.timestamp) !== null && k !== void 0 ? k : s), I);
+      }, s) < s)
+        throw Error("Maximum HF determined by block number/ttd is lower than timestamp HF");
+    }
+    return o[a].name;
+  }
+  /**
+   * Sets a new hardfork based on the block number or an optional
+   * total difficulty (Merge HF) provided.
+   *
+   * An optional TD takes precedence in case the corresponding HF block
+   * is set to `null` or otherwise needs to match (if not an error
+   * will be thrown).
+   *
+   * @param blockNumber
+   * @param td
+   * @param timestamp
+   * @returns The name of the HF set
+   */
+  setHardforkByBlockNumber(t, r, n) {
+    const e = this.getHardforkByBlockNumber(t, r, n);
+    return this.setHardfork(e), e;
+  }
+  /**
+   * Internal helper function, returns the params for the given hardfork for the chain set
+   * @param hardfork Hardfork name
+   * @returns Dictionary with hardfork params or null if hardfork not on chain
+   */
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  _getHardfork(t) {
+    const r = this.hardforks();
+    for (const n of r)
+      if (n.name === t)
+        return n;
+    return null;
+  }
+  /**
+   * Sets the active EIPs
+   * @param eips
+   */
+  setEIPs(t = []) {
+    for (const r of t) {
+      if (!(r in H))
+        throw new Error(`${r} not supported`);
+      const n = this.gteHardfork(H[r].minimumHardfork);
+      if (!n)
+        throw new Error(
+          // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+          `${r} cannot be activated on hardfork ${this.hardfork()}, minimumHardfork: ${n}`
+        );
+      if (H[r].requiredEIPs !== void 0) {
+        for (const e of H[r].requiredEIPs)
+          if (!(t.includes(e) || this.isActivatedEIP(e)))
+            throw new Error(
+              // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+              `${r} requires EIP ${e}, but is not included in the EIP list`
+            );
+      }
+    }
+    this._eips = t;
+  }
+  /**
+   * Returns a parameter for the current chain setup
+   *
+   * If the parameter is present in an EIP, the EIP always takes precedence.
+   * Otherwise the parameter if taken from the latest applied HF with
+   * a change on the respective parameter.
+   *
+   * @param topic Parameter topic ('gasConfig', 'gasPrices', 'vm', 'pow')
+   * @param name Parameter name (e.g. 'minGasLimit' for 'gasConfig' topic)
+   * @returns The value requested or `BigInt(0)` if not found
+   */
+  param(t, r) {
+    let n;
+    for (const e of this._eips)
+      if (n = this.paramByEIP(t, r, e), n !== void 0)
+        return n;
+    return this.paramByHardfork(t, r, this._hardfork);
+  }
+  /**
+   * Returns the parameter corresponding to a hardfork
+   * @param topic Parameter topic ('gasConfig', 'gasPrices', 'vm', 'pow')
+   * @param name Parameter name (e.g. 'minGasLimit' for 'gasConfig' topic)
+   * @param hardfork Hardfork name
+   * @returns The value requested or `BigInt(0)` if not found
+   */
+  paramByHardfork(t, r, n) {
+    let e = null;
+    for (const i of this.HARDFORK_CHANGES) {
+      if ("eips" in i[1]) {
+        const s = i[1].eips;
+        for (const o of s) {
+          const d = this.paramByEIP(t, r, o);
+          e = typeof d == "bigint" ? d : e;
+        }
+      } else {
+        if (i[1][t] === void 0)
+          throw new Error(`Topic ${t} not defined`);
+        i[1][t][r] !== void 0 && (e = i[1][t][r].v);
+      }
+      if (i[0] === n)
+        break;
+    }
+    return BigInt(e ?? 0);
+  }
+  /**
+   * Returns a parameter corresponding to an EIP
+   * @param topic Parameter topic ('gasConfig', 'gasPrices', 'vm', 'pow')
+   * @param name Parameter name (e.g. 'minGasLimit' for 'gasConfig' topic)
+   * @param eip Number of the EIP
+   * @returns The value requested or `undefined` if not found
+   */
+  // eslint-disable-next-line class-methods-use-this
+  paramByEIP(t, r, n) {
+    if (!(n in H))
+      throw new Error(`${n} not supported`);
+    const e = H[n];
+    if (!(t in e))
+      throw new Error(`Topic ${t} not defined`);
+    if (e[t][r] === void 0)
+      return;
+    const i = e[t][r].v;
+    return BigInt(i);
+  }
+  /**
+   * Returns a parameter for the hardfork active on block number or
+   * optional provided total difficulty (Merge HF)
+   * @param topic Parameter topic
+   * @param name Parameter name
+   * @param blockNumber Block number
+   * @param td Total difficulty
+   *    * @returns The value requested or `BigInt(0)` if not found
+   */
+  paramByBlock(t, r, n, e, i) {
+    const s = this.getHardforkByBlockNumber(n, e, i);
+    return this.paramByHardfork(t, r, s);
+  }
+  /**
+   * Checks if an EIP is activated by either being included in the EIPs
+   * manually passed in with the {@link CommonOpts.eips} or in a
+   * hardfork currently being active
+   *
+   * Note: this method only works for EIPs being supported
+   * by the {@link CommonOpts.eips} constructor option
+   * @param eip
+   */
+  isActivatedEIP(t) {
+    if (this.eips().includes(t))
+      return !0;
+    for (const r of this.HARDFORK_CHANGES) {
+      const n = r[1];
+      if (this.gteHardfork(n.name) && "eips" in n && n.eips.includes(t))
+        return !0;
+    }
+    return !1;
+  }
+  /**
+   * Checks if set or provided hardfork is active on block number
+   * @param hardfork Hardfork name or null (for HF set)
+   * @param blockNumber
+   * @returns True if HF is active on block number
+   */
+  hardforkIsActiveOnBlock(t, r) {
+    const n = g(r, p.BigInt), e = t ?? this._hardfork, i = this.hardforkBlock(e);
+    return typeof i == "bigint" && i !== BigInt(0) && n >= i;
+  }
+  /**
+   * Alias to hardforkIsActiveOnBlock when hardfork is set
+   * @param blockNumber
+   * @returns True if HF is active on block number
+   */
+  activeOnBlock(t) {
+    return this.hardforkIsActiveOnBlock(null, t);
+  }
+  /**
+   * Sequence based check if given or set HF1 is greater than or equal HF2
+   * @param hardfork1 Hardfork name or null (if set)
+   * @param hardfork2 Hardfork name
+   * @param opts Hardfork options
+   * @returns True if HF1 gte HF2
+   */
+  hardforkGteHardfork(t, r) {
+    const n = t ?? this._hardfork, e = this.hardforks();
+    let i = -1, s = -1, o = 0;
+    for (const d of e)
+      d.name === n && (i = o), d.name === r && (s = o), o += 1;
+    return i >= s && s !== -1;
+  }
+  /**
+   * Alias to hardforkGteHardfork when hardfork is set
+   * @param hardfork Hardfork name
+   * @returns True if hardfork set is greater than hardfork provided
+   */
+  gteHardfork(t) {
+    return this.hardforkGteHardfork(null, t);
+  }
+  /**
+   * Returns the hardfork change block for hardfork provided or set
+   * @param hardfork Hardfork name, optional if HF set
+   * @returns Block number or null if unscheduled
+   */
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  hardforkBlock(t) {
+    var r;
+    const n = t ?? this._hardfork, e = (r = this._getHardfork(n)) === null || r === void 0 ? void 0 : r.block;
+    return e == null ? null : BigInt(e);
+  }
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  hardforkTimestamp(t) {
+    var r;
+    const n = t ?? this._hardfork, e = (r = this._getHardfork(n)) === null || r === void 0 ? void 0 : r.timestamp;
+    return e == null ? null : BigInt(e);
+  }
+  /**
+   * Returns the hardfork change block for eip
+   * @param eip EIP number
+   * @returns Block number or null if unscheduled
+   */
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  eipBlock(t) {
+    for (const r of this.HARDFORK_CHANGES) {
+      const n = r[1];
+      if ("eips" in n && n.eips.includes(t))
+        return this.hardforkBlock(typeof r[0] == "number" ? String(r[0]) : r[0]);
+    }
+    return null;
+  }
+  /**
+   * Returns the hardfork change total difficulty (Merge HF) for hardfork provided or set
+   * @param hardfork Hardfork name, optional if HF set
+   * @returns Total difficulty or null if no set
+   */
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  hardforkTTD(t) {
+    var r;
+    const n = t ?? this._hardfork, e = (r = this._getHardfork(n)) === null || r === void 0 ? void 0 : r.ttd;
+    return e == null ? null : BigInt(e);
+  }
+  /**
+   * True if block number provided is the hardfork (given or set) change block
+   * @param blockNumber Number of the block to check
+   * @param hardfork Hardfork name, optional if HF set
+   * @returns True if blockNumber is HF block
+   * @deprecated
+   */
+  isHardforkBlock(t, r) {
+    const n = g(t, p.BigInt), e = r ?? this._hardfork, i = this.hardforkBlock(e);
+    return typeof i == "bigint" && i !== BigInt(0) ? i === n : !1;
+  }
+  /**
+   * Returns the change block for the next hardfork after the hardfork provided or set
+   * @param hardfork Hardfork name, optional if HF set
+   * @returns Block timestamp, number or null if not available
+   */
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  nextHardforkBlockOrTimestamp(t) {
+    var r, n;
+    const e = t ?? this._hardfork, i = this.hardforks();
+    let s = i.findIndex((a) => a.name === e);
+    if (e === b.Merge && (s -= 1), s < 0)
+      return null;
+    let o = (r = i[s].timestamp) !== null && r !== void 0 ? r : i[s].block;
+    o = // eslint-disable-next-line no-null/no-null
+    o != null ? Number(o) : (
+      // eslint-disable-next-line no-null/no-null
+      null
+    );
+    const d = i.slice(s + 1).find((a) => {
+      var l;
+      let m = (l = a.timestamp) !== null && l !== void 0 ? l : a.block;
+      return m = // eslint-disable-next-line no-null/no-null
+      m != null ? Number(m) : (
+        // eslint-disable-next-line no-null/no-null
+        null
+      ), a.name !== b.Merge && // eslint-disable-next-line no-null/no-null
+      m !== null && m !== void 0 && m !== o;
+    });
+    if (d === void 0)
+      return null;
+    const c = (n = d.timestamp) !== null && n !== void 0 ? n : d.block;
+    return c == null ? null : BigInt(c);
+  }
+  /**
+   * Returns the change block for the next hardfork after the hardfork provided or set
+   * @param hardfork Hardfork name, optional if HF set
+   * @returns Block number or null if not available
+   * @deprecated
+   */
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  nextHardforkBlock(t) {
+    const r = t ?? this._hardfork;
+    let n = this.hardforkBlock(r);
+    if (n === null && r === b.Merge) {
+      const i = this.hardforks(), s = i.findIndex((o) => o.ttd !== null && o.ttd !== void 0);
+      if (s < 0)
+        throw Error("Merge hardfork should have been found");
+      n = this.hardforkBlock(i[s - 1].name);
+    }
+    return n === null ? null : this.hardforks().reduce((i, s) => {
+      const o = BigInt(
+        // eslint-disable-next-line no-null/no-null
+        s.block === null || s.ttd !== void 0 && s.ttd !== null ? 0 : s.block
+      );
+      return o > n && i === null ? o : i;
+    }, null);
+  }
+  /**
+   * True if block number provided is the hardfork change block following the hardfork given or set
+   * @param blockNumber Number of the block to check
+   * @param hardfork Hardfork name, optional if HF set
+   * @returns True if blockNumber is HF block
+   * @deprecated
+   */
+  isNextHardforkBlock(t, r) {
+    const n = g(t, p.BigInt), e = r ?? this._hardfork, i = this.nextHardforkBlock(e);
+    return i === null ? !1 : i === n;
+  }
+  /**
+   * Internal helper function to calculate a fork hash
+   * @param hardfork Hardfork name
+   * @param genesisHash Genesis block hash of the chain
+   * @returns Fork hash as hex string
+   */
+  _calcForkHash(t, r) {
+    let n = new Uint8Array(), e = 0;
+    for (const o of this.hardforks()) {
+      const { block: d, timestamp: c, name: a } = o;
+      let l = c ?? d;
+      if (l = l !== null ? Number(l) : null, typeof l == "number" && l !== 0 && l !== e && a !== b.Merge) {
+        const m = O(l.toString(16).padStart(16, "0"));
+        n = B(n, m), e = l;
+      }
+      if (o.name === t)
+        break;
+    }
+    const i = B(r, n);
+    return N(_(R(i) >>> 0));
+  }
+  /**
+   * Returns an eth/64 compliant fork hash (EIP-2124)
+   * @param hardfork Hardfork name, optional if HF set
+   * @param genesisHash Genesis block hash of the chain, optional if already defined and not needed to be calculated
+   */
+  forkHash(t, r) {
+    const n = t ?? this._hardfork, e = this._getHardfork(n);
+    if (
+      // eslint-disable-next-line no-null/no-null
+      e === null || // eslint-disable-next-line no-null/no-null
+      (e == null ? void 0 : e.block) === null && (e == null ? void 0 : e.timestamp) === void 0 && (e == null ? void 0 : e.ttd) === void 0
+    ) {
+      const i = "No fork hash calculation possible for future hardfork";
+      throw new Error(i);
+    }
+    if ((e == null ? void 0 : e.forkHash) !== null && (e == null ? void 0 : e.forkHash) !== void 0)
+      return e.forkHash;
+    if (!r)
+      throw new Error("genesisHash required for forkHash calculation");
+    return this._calcForkHash(n, r);
+  }
+  /**
+   *
+   * @param forkHash Fork hash as a hex string
+   * @returns Array with hardfork data (name, block, forkHash)
+   */
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  hardforkForForkHash(t) {
+    const r = this.hardforks().filter((n) => n.forkHash === t);
+    return r.length >= 1 ? r[r.length - 1] : null;
+  }
+  /**
+   * Sets any missing forkHashes on the passed-in {@link Common} instance
+   * @param common The {@link Common} to set the forkHashes for
+   * @param genesisHash The genesis block hash
+   */
+  setForkHashes(t) {
+    var r;
+    for (const n of this.hardforks()) {
+      const e = (r = n.timestamp) !== null && r !== void 0 ? r : n.block;
+      // eslint-disable-next-line no-null/no-null
+      (n.forkHash === null || n.forkHash === void 0) && // eslint-disable-next-line no-null/no-null
+      (e != null || typeof n.ttd < "u") && (n.forkHash = this.forkHash(n.name, t));
+    }
+  }
+  /**
+   * Returns the Genesis parameters of the current chain
+   * @returns Genesis dictionary
+   */
+  genesis() {
+    return this._chainParams.genesis;
+  }
+  /**
+   * Returns the hardforks for current chain
+   * @returns {Array} Array with arrays of hardforks
+   */
+  hardforks() {
+    return this._chainParams.hardforks;
+  }
+  /**
+   * Returns bootstrap nodes for the current chain
+   * @returns {Dictionary} Dict with bootstrap nodes
+   */
+  bootstrapNodes() {
+    return this._chainParams.bootstrapNodes;
+  }
+  /**
+   * Returns DNS networks for the current chain
+   * @returns {String[]} Array of DNS ENR urls
+   */
+  dnsNetworks() {
+    return this._chainParams.dnsNetworks;
+  }
+  /**
+   * Returns the hardfork set
+   * @returns Hardfork name
+   */
+  hardfork() {
+    return this._hardfork;
+  }
+  /**
+   * Returns the Id of current chain
+   * @returns chain Id
+   */
+  chainId() {
+    return BigInt(this._chainParams.chainId);
+  }
+  /**
+   * Returns the name of current chain
+   * @returns chain name (lower case)
+   */
+  chainName() {
+    return this._chainParams.name;
+  }
+  /**
+   * Returns the Id of current network
+   * @returns network Id
+   */
+  networkId() {
+    return BigInt(this._chainParams.networkId);
+  }
+  /**
+   * Returns the active EIPs
+   * @returns List of EIPs
+   */
+  eips() {
+    return this._eips;
+  }
+  /**
+   * Returns the consensus type of the network
+   * Possible values: "pow"|"poa"|"pos"
+   *
+   * Note: This value can update along a Hardfork.
+   */
+  consensusType() {
+    const t = this.hardfork();
+    let r;
+    for (const n of this.HARDFORK_CHANGES)
+      if ("consensus" in n[1] && (r = n[1].consensus.type), n[0] === t)
+        break;
+    return r ?? this._chainParams.consensus.type;
+  }
+  /**
+   * Returns the concrete consensus implementation
+   * algorithm or protocol for the network
+   * e.g. "ethash" for "pow" consensus type,
+   * "clique" for "poa" consensus type or
+   * "casper" for "pos" consensus type.
+   *
+   * Note: This value can update along a Hardfork.
+   */
+  consensusAlgorithm() {
+    const t = this.hardfork();
+    let r;
+    for (const n of this.HARDFORK_CHANGES)
+      if ("consensus" in n[1] && (r = n[1].consensus.algorithm), n[0] === t)
+        break;
+    return r ?? this._chainParams.consensus.algorithm;
+  }
+  /**
+   * Returns a dictionary with consensus configuration
+   * parameters based on the consensus algorithm
+   *
+   * Expected returns (parameters must be present in
+   * the respective chain json files):
+   *
+   * ethash: empty object
+   * clique: period, epoch
+   * casper: empty object
+   *
+   * Note: This value can update along a Hardfork.
+   */
+  consensusConfig() {
+    var t;
+    const r = this.hardfork();
+    let n;
+    for (const e of this.HARDFORK_CHANGES)
+      if ("consensus" in e[1] && (n = e[1].consensus[e[1].consensus.algorithm]), e[0] === r)
+        break;
+    return (t = n ?? this._chainParams.consensus[this.consensusAlgorithm()]) !== null && t !== void 0 ? t : {};
+  }
+  /**
+   * Returns a deep copy of this {@link Common} instance.
+   */
+  copy() {
+    const t = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+    return t.removeAllListeners(), t;
+  }
+  static _getInitializedChains(t) {
+    const r = {};
+    for (const [e, i] of Object.entries(P))
+      r[i] = e.toLowerCase();
+    const n = { mainnet: C, goerli: A, sepolia: x };
+    if (t)
+      for (const e of t) {
+        const { name: i } = e;
+        r[e.chainId.toString()] = i, n[i] = e;
+      }
+    return n.names = r, n;
+  }
+}
+export {
+  h as Common
+};