@hinkal/common 0.0.104 → 0.0.107

package/data-structures/merkle-tree/MerkleTree.js

@@ -0,0 +1,177 @@
+import "ethers";
+import "axios";
+import "../../constants/chains.constants.js";
+import "../../types/circom-data.types.js";
+import "../../types/transactions.types.js";
+import "../../types/curve.types.js";
+import "circomlibjs";
+import "../crypto-keys/keys.js";
+import "../crypto-keys/encryptDecryptUtxo.js";
+import "../../functions/web3/events/getShieldedBalance.js";
+import "../../webworker/workerFactory.js";
+import "../../functions/utils/external-action.utils.js";
+import "../custom-token-registry/CustomTokenRegistry.js";
+import "../../functions/utils/convertIntegrationProviderToExternalActionId.js";
+import "../../constants/coingecko.constants.js";
+import { logError as l } from "../../error-handling/logError.js";
+import "../../functions/utils/userAgent.js";
+import { MerkleTreeIncompleteError as a } from "./MerkleTreeIncompleteError.js";
+import "../../constants/reorg-depths.constants.js";
+import "../../constants/kyc.constants.js";
+import "../volatile-helper/VolatileHelper.js";
+import "libsodium-wrappers";
+import "../../constants/vite.constants.js";
+import "../../constants/contracts.constants.js";
+import "../../constants/axelar.constants.js";
+import "../../constants/rewards.constants.js";
+class o {
+  constructor(e, t, i, r, n, s) {
+    this.hashFunction = e, this.levels = t, this.defaultNodeValue = i, this.tree = r ?? /* @__PURE__ */ new Map(), this.count = s ?? 0n, this.index = n ?? 2n ** (t - 1n);
+  }
+  /**
+   * the map where the items are stored
+   */
+  tree;
+  /**
+   * amount of elements inserted inside the bottom row of the tree
+   */
+  count;
+  /**
+   * the maximum index inserted into the tree
+   * used together with count to make sure that the merkle tree is complete.
+   * meaning that there aren't any missing elements between getStartIndex() and index
+   */
+  index;
+  static createWithData(e, t, i, r, n, s) {
+    return new o(r, n, s, e, t, i);
+  }
+  /**
+   * @param hashFunction the hashFunction used to fill the upper layers of the merkle tree
+   * @param levels the amount of layers in the merkle tree
+   * @param defaultNodeValue the default value of an empty node in the merkle tree
+   */
+  static create(e, t, i) {
+    return new o(e, t, i);
+  }
+  /**
+   * get starting nodeIndex from which inserts are allowed
+   */
+  getStartIndex() {
+    return 2n ** (this.levels - 1n);
+  }
+  /**
+   * implementation of logarithm2 function from merkle contract
+   */
+  logarithm2(e) {
+    let t = 0n;
+    for (; 2n ** t < e; )
+      t += 1n;
+    return t;
+  }
+  bigIntMax(e, t) {
+    return e > t ? e : t;
+  }
+  forceInsert(e, t) {
+    if (t < this.getStartIndex())
+      throw new RangeError();
+    this.tree.set(t, e);
+    const i = this.index - this.getStartIndex(), r = this.logarithm2(i);
+    let n = t;
+    for (let s = 1n; s <= r; s += 1n) {
+      n /= 2n;
+      const h = this.hashFunction(
+        this.tree.get(n * 2n) || this.defaultNodeValue,
+        this.tree.get(n * 2n + 1n) || this.defaultNodeValue
+      );
+      this.tree.set(n, h);
+    }
+  }
+  /**
+   * insert value into the merkle tree
+   * @param value the value to insert
+   * @param nodeIndex the index to insert the value, you can get starting index from getStartIndex()
+   * @return true - if added, false - if already exists
+   * @throws will throw RangeError if nodeIndex is less than getStartIndex()
+   */
+  insert(e, t) {
+    let i = !1;
+    return this.tree.has(t) && (i = !0, l(`Editing commitment index: ${t} `)), i || (this.count += 1n), this.index = this.bigIntMax(this.index, t + 1n), this.forceInsert(e, t), !0;
+  }
+  remove(e) {
+    this.forceInsert(this.defaultNodeValue, e);
+  }
+  completenessCheck() {
+    if (this.count !== this.index - this.getStartIndex())
+      throw new a();
+  }
+  /**
+   * get root hash of the merkle tree
+   * @returns the hash, if the merkle tree is empty, will return
+   * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+   */
+  getRootHash() {
+    this.completenessCheck();
+    for (let e = 1n; e < 2n ** this.levels; e *= 2n)
+      if (this.tree.get(e))
+        return this.tree.get(e);
+    return this.defaultNodeValue;
+  }
+  getMerkleData() {
+    return this.completenessCheck(), new Map(this.tree);
+  }
+  getSiblingIndex(e) {
+    return e === 1n ? 1n : e % 2n === 1n ? e - 1n : e + 1n;
+  }
+  /**
+   * get sibling hashes needed by main.circom
+   * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+   */
+  getSiblingHashesForVerification(e) {
+    this.completenessCheck();
+    let t;
+    for (let r = this.getStartIndex(); r < this.getStartIndex() + this.index; r += 1n)
+      if (this.tree.get(r) === e) {
+        t = r;
+        break;
+      }
+    if (t === void 0)
+      return new Array(Number(this.levels)).fill(0n);
+    const i = [];
+    for (; t !== 0n; )
+      i.push(this.tree.get(this.getSiblingIndex(t)) || this.defaultNodeValue), t /= 2n;
+    return i;
+  }
+  /**
+   * get item's sibling hashes side
+   * @returns sibling's indexes
+   * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+   */
+  getSiblingSides(e) {
+    this.completenessCheck();
+    let t;
+    for (let r = this.getStartIndex(); r < this.getStartIndex() + this.index; r += 1n)
+      if (this.tree.get(r) === e) {
+        t = r;
+        break;
+      }
+    if (t === void 0)
+      return new Array(Number(this.levels)).fill(0n);
+    const i = [];
+    for (; t !== 0n; ) {
+      const r = t % 2n === 0n ? 0n : 1n;
+      i.push(r), t /= 2n;
+    }
+    return i;
+  }
+  toJSON() {
+    const { tree: e, count: t, index: i } = this;
+    return {
+      tree: Object.fromEntries(e),
+      count: t.toString(),
+      index: i.toString()
+    };
+  }
+}
+export {
+  o as MerkleTree
+};

package/data-structures/merkle-tree/MerkleTreeIncompleteError.js

@@ -0,0 +1,8 @@
+class r extends Error {
+  constructor() {
+    super("Merkle tree is incomplete"), this.name = "MerkleTreeIncompleteError";
+  }
+}
+export {
+  r as MerkleTreeIncompleteError
+};

package/data-structures/snapshot/ClientAccessTokenSnapshotService.js

@@ -0,0 +1,48 @@
+import { AbstractAccessTokenSnapshotService as e } from "../event-service/AbstractAccessTokenSnapshotService.js";
+import "circomlibjs";
+import "ethers";
+import "axios";
+import "../../constants/chains.constants.js";
+import "../../types/circom-data.types.js";
+import "../../types/transactions.types.js";
+import "../../types/curve.types.js";
+import "../crypto-keys/keys.js";
+import "../crypto-keys/encryptDecryptUtxo.js";
+import "../../functions/web3/events/getShieldedBalance.js";
+import "../../webworker/workerFactory.js";
+import "../../functions/utils/external-action.utils.js";
+import "../custom-token-registry/CustomTokenRegistry.js";
+import "../../functions/utils/convertIntegrationProviderToExternalActionId.js";
+import "../../constants/coingecko.constants.js";
+import "../../constants/vite.constants.js";
+import "../../functions/utils/userAgent.js";
+import { fetchAccessTokenSnapshot as o } from "../../API/fetchCommitmentsCache.js";
+import "../../constants/kyc.constants.js";
+import "../volatile-helper/VolatileHelper.js";
+import "libsodium-wrappers";
+import "../../constants/contracts.constants.js";
+import "../../constants/axelar.constants.js";
+import "../../constants/rewards.constants.js";
+import "../../constants/reorg-depths.constants.js";
+class z extends e {
+  constructor(t, r) {
+    super(t, 0, !1, r);
+  }
+  async fetchSnapshot() {
+    const { chainId: t } = await this.contract.provider.getNetwork(), r = await o(t);
+    if (r.accessTokenContractAddress !== this.contract.address || r.chainId !== t)
+      throw Error("Commitment Snapshot: incorrect contract or chain id");
+    return {
+      latestBlockNumber: r.latestBlockNumber,
+      merkleTree: r.merkleTree,
+      senderAddresses: r.senderAddresses,
+      senderAddressIndexMap: r.senderAddressIndexMap
+    };
+  }
+  persistSnapshot(t) {
+    return Promise.resolve();
+  }
+}
+export {
+  z as ClientAccessTokenSnapshotService
+};

package/data-structures/snapshot/ClientCommitmentsSnapshotService.js

@@ -0,0 +1,47 @@
+import "../../constants/chains.constants.js";
+import "../../types/circom-data.types.js";
+import "../../types/transactions.types.js";
+import "../../types/curve.types.js";
+import "ethers";
+import "circomlibjs";
+import "../crypto-keys/keys.js";
+import "axios";
+import "../crypto-keys/encryptDecryptUtxo.js";
+import "../../functions/web3/events/getShieldedBalance.js";
+import "../../webworker/workerFactory.js";
+import "../../functions/utils/external-action.utils.js";
+import "../custom-token-registry/CustomTokenRegistry.js";
+import "../../functions/utils/convertIntegrationProviderToExternalActionId.js";
+import "../../constants/coingecko.constants.js";
+import "../../constants/vite.constants.js";
+import "../../functions/utils/userAgent.js";
+import { fetchCommitmentsSnapshot as o } from "../../API/fetchCommitmentsCache.js";
+import "../../constants/kyc.constants.js";
+import "../volatile-helper/VolatileHelper.js";
+import "libsodium-wrappers";
+import "../../constants/contracts.constants.js";
+import "../../constants/axelar.constants.js";
+import "../../constants/rewards.constants.js";
+import "../../constants/reorg-depths.constants.js";
+import { AbstractCommitmentsSnapshotService as i } from "../event-service/AbstractCommitmentsSnapshotService.js";
+class z extends i {
+  constructor(r, t) {
+    super(r, 0, !1, t);
+  }
+  async fetchSnapshot() {
+    const { chainId: r } = await this.contract.provider.getNetwork(), t = await o(r);
+    if (t.hinkalAddress !== this.contract.address || t.chainId !== r)
+      throw Error("Commitment Snapshot: incorrect contract or chain id");
+    return {
+      latestBlockNumber: t.latestBlockNumber,
+      merkleTree: t.merkleTree,
+      encryptedOutputs: t.encryptedOutputs
+    };
+  }
+  persistSnapshot(r) {
+    return Promise.resolve();
+  }
+}
+export {
+  z as ClientCommitmentsSnapshotService
+};

package/data-structures/snapshot/ClientNullifierSnapshotService.js

@@ -0,0 +1,44 @@
+import "../../constants/chains.constants.js";
+import "../../types/circom-data.types.js";
+import "../../types/transactions.types.js";
+import "../../types/curve.types.js";
+import "ethers";
+import "circomlibjs";
+import "../crypto-keys/keys.js";
+import "axios";
+import "../crypto-keys/encryptDecryptUtxo.js";
+import "../../functions/web3/events/getShieldedBalance.js";
+import "../../webworker/workerFactory.js";
+import "../../functions/utils/external-action.utils.js";
+import "../custom-token-registry/CustomTokenRegistry.js";
+import "../../functions/utils/convertIntegrationProviderToExternalActionId.js";
+import "../../constants/coingecko.constants.js";
+import "../../constants/vite.constants.js";
+import "../../functions/utils/userAgent.js";
+import { fetchNullifiers as i } from "../../API/fetchNullifiers.js";
+import "../../constants/kyc.constants.js";
+import "../volatile-helper/VolatileHelper.js";
+import "libsodium-wrappers";
+import "../../constants/contracts.constants.js";
+import "../../constants/axelar.constants.js";
+import "../../constants/rewards.constants.js";
+import "../../constants/reorg-depths.constants.js";
+import { AbstractNullifierSnapshotService as o } from "../event-service/AbstractNullifierSnapshotService.js";
+class P extends o {
+  constructor(t, r) {
+    super(t, 0, !1, r);
+  }
+  async fetchSnapshot() {
+    const { chainId: t } = await this.contract.provider.getNetwork(), r = await i(t);
+    return {
+      latestBlockNumber: r.latestBlockNumber,
+      nullifiers: r.nullifiers
+    };
+  }
+  persistSnapshot(t) {
+    return Promise.resolve();
+  }
+}
+export {
+  P as ClientNullifierSnapshotService
+};

package/data-structures/token-price-fetcher/TokenChecker.js

@@ -0,0 +1,29 @@
+import { lowerCaseIncludes as a } from "../../functions/utils/caseInsensitive.utils.js";
+import { wstEthSymbol as r, stMaticSymbol as o } from "../../constants/lido.constants.js";
+import { chainIds as T } from "../../constants/chains.constants.js";
+class m {
+  static isCurveLPToken = (s, e) => a(e, s.erc20TokenAddress);
+  static isCurveStakeToken = (s) => s.name.includes("Gauge") && s.symbol.includes("-gauge");
+  static isConvexToken = (s) => s.name.includes("Convex") && s.symbol.includes("cvx");
+  static isBeefyLpToken = (s) => s.name.startsWith("moo") && s.symbol.startsWith("moo");
+  static isBeefyStakeToken = (s) => s.name.includes("-Boost") && s.symbol.includes("-Boost");
+  static isLidoToken = (s) => s.symbol === r || s.symbol === o;
+  static isCurveOrConvex = (s, e) => this.isCurveLPToken(s, e) || this.isCurveStakeToken(s) || this.isConvexToken(s);
+  static isBeefyToken = (s) => this.isBeefyLpToken(s) || this.isBeefyStakeToken(s);
+  static isStakeToken = (s) => this.isCurveStakeToken(s) || this.isConvexToken(s) || this.isBeefyStakeToken(s);
+  static isPendleYtToken = (s) => s.name.startsWith("Pendle-YT-") && s.symbol.startsWith("Pendle-YT-");
+  static isPendleLPToken = (s) => s.name.startsWith("Pendle-LP-") && s.symbol.startsWith("Pendle-LP-");
+  static isPendleSyToken = (s) => s.name.startsWith("SY ") && s.symbol.includes("SY-");
+  static isPendleNativeToken = (s) => {
+    const e = s.name.startsWith("YT ") && s.symbol.includes("YT-"), i = this.isPendleSyToken(s), t = s.name.startsWith("PT ") && s.symbol.includes("PT-"), n = s.name.startsWith("LP ") && s.symbol.includes("LP-");
+    return e || i || t || n;
+  };
+  static isPendleToken = (s) => this.isPendleYtToken(s) || this.isPendleLPToken(s) || this.isPendleNativeToken(s);
+  static isAaveToken = (s) => s.aaveToken;
+  static isNonRebasingBlastToken = (s) => s.chainId === T.blast && s.symbol.startsWith("nr");
+  static isKinzaToken = (s) => s.name.startsWith("Kinza");
+  static isProtocolToken = (s, e) => this.isCurveLPToken(s, e) || this.isCurveStakeToken(s) || this.isConvexToken(s) || this.isBeefyLpToken(s) || this.isBeefyStakeToken(s) || this.isLidoToken(s) || this.isPendleToken(s) || this.isAaveToken(s) || this.isNonRebasingBlastToken(s);
+}
+export {
+  m as TokenChecker
+};

package/data-structures/token-price-fetcher/TokenPriceFetcher.js

@@ -0,0 +1,218 @@
+import l from "axios";
+import { ethers as u } from "ethers";
+import { getCoingeckoPrice as g, getCoingeckoPrice2 as m } from "../../API/getCoingeckoPrice.js";
+import { getCurvePoolsforPriceFetching as y } from "../../API/callCurveAPI.js";
+import { coingeckoRegistry as P } from "../../constants/token-data/index.js";
+import { getNonLocalhostChainId as h, chainIds as k, networkRegistry as T } from "../../constants/chains.constants.js";
+import "../../types/circom-data.types.js";
+import "../../types/transactions.types.js";
+import "../../types/curve.types.js";
+import { zeroAddress as p, beefyChainIds as v } from "../../constants/protocol.constants.js";
+import "circomlibjs";
+import "../crypto-keys/keys.js";
+import "../crypto-keys/encryptDecryptUtxo.js";
+import "../../functions/web3/events/getShieldedBalance.js";
+import "../../webworker/workerFactory.js";
+import "../../functions/utils/external-action.utils.js";
+import { getERC20Token as I } from "../../functions/utils/erc20tokenFunctions.js";
+import "../../functions/utils/convertIntegrationProviderToExternalActionId.js";
+import { getOdosPriceForToken as b } from "../../API/callOdosAPI.js";
+import "../../functions/utils/userAgent.js";
+import { caseInsensitiveEqual as c } from "../../functions/utils/caseInsensitive.utils.js";
+import "../../constants/reorg-depths.constants.js";
+import "../../constants/kyc.constants.js";
+import { TokenChecker as a } from "./TokenChecker.js";
+import { abi as C } from "../../externalABIs/BeefyVaultAbi.json.js";
+import { urlForBeefyVaultTokens as A, urlForBeefyVaultTotalInUSD as w, urlForPendleAPI as B, urlForBeefyVaultLpTokens as D } from "../../constants/token-data/tokenPricing.consts.js";
+import "../volatile-helper/VolatileHelper.js";
+import "../custom-token-registry/CustomTokenRegistry.js";
+import "../../constants/vite.constants.js";
+import "libsodium-wrappers";
+import "../../constants/contracts.constants.js";
+import { CoinGeckoChainLabels as R, getCoingeckoIdForNativeTokens as E, getCoingeckoPlatform as S } from "../../constants/coingecko.constants.js";
+import "../../constants/axelar.constants.js";
+import { getCrvCvxWithChainId as L } from "../../constants/crvCvx.registry.js";
+import "../../constants/rewards.constants.js";
+import { getERC20Registry as x } from "../../constants/token-data/ERC20Registry.js";
+class Pe extends a {
+  chainId;
+  provider;
+  erc20Registry = [];
+  // Curve state variables
+  crvCvxRegistry = [];
+  curvePools = [];
+  // Beefy state variables:
+  beefyVaults = [];
+  beefyTvlData = {};
+  usdcSymbol = "USDC";
+  supportsCurve = () => h(this.chainId) !== k.bnbMainnet;
+  constructor(r, t) {
+    super(), this.chainId = r, this.provider = t;
+    const e = h(this.chainId);
+    this.erc20Registry = x(this.chainId), this.crvCvxRegistry = L(e), this.supportsCurve() && y(this.chainId).then((i) => {
+      this.curvePools = i;
+    });
+  }
+  async updateBeefyVault() {
+    this.beefyVaults.length === 0 && (this.beefyVaults = (await l.get(A)).data);
+  }
+  findTokenId(r) {
+    let t;
+    const e = R[this.chainId];
+    return r === p ? E[this.chainId] : (P.find((i) => Object.entries(i.platforms).find(
+      ([s, n]) => s === e && (r ? c(r, n) : !1)
+    ) ? (t = i.id, !0) : !1), t);
+  }
+  async fetchPriceById(r) {
+    const t = await g(r);
+    return { usd: t?.usd, eth: t.eth };
+  }
+  async fetchPriceByAddress(r) {
+    const t = S(this.chainId);
+    return (await m(r, t))?.usd;
+  }
+  async fetchHETHPrice(r) {
+    const t = I(r, this.chainId);
+    if (!t || t.underlyingErc20TokenAddress !== p || !t.isHToken || !this.provider)
+      return;
+    const { contractData: e } = T[this.chainId];
+    if (!e.hETHOracleAddress || !e.HTokenOracleABI)
+      return;
+    const o = await new u.Contract(
+      e.hETHOracleAddress,
+      e.HTokenOracleABI,
+      this.provider
+    ).callStatic.exchangeRate(), s = Number(u.utils.formatEther(o)), n = await this.fetchPriceByTokenAddress(t.underlyingErc20TokenAddress);
+    if (n)
+      return s * n;
+  }
+  // This is general fetch price function: it has flexibility to fetch only with coingecko or also to try to find protocol specific price (use onlyMainRegistry parameter)
+  async fetchPriceByTokenAddress(r, t = !1) {
+    try {
+      console.log("fetchPriceByTokenAddress", { address: r });
+      const e = await this.fetchHETHPrice(r);
+      if (e)
+        return e;
+      const i = this.findTokenId(r);
+      if (i) {
+        const f = (await this.fetchPriceById(i)).usd;
+        if (f)
+          return f;
+      }
+      const o = await this.fetchPriceByAddress(r);
+      if (console.log({ coingecko: o }), o || t)
+        return o;
+      const s = await this.fetchProtocolPriceinUSD(r);
+      if (console.log({ protocolPrice: s }), s)
+        return s;
+      const n = await this.fetchOdosPriceinUSD(r);
+      if (console.log({ odosPrice: n }), n)
+        return n;
+      const d = await this.findBeefyLpPrice(r);
+      return console.log({ beefyLpPrice: d }), d || void 0;
+    } catch (e) {
+      console.log("fetchPriceByTokenAddress error ", e);
+      return;
+    }
+  }
+  async fetchOdosPriceinUSD(r) {
+    const t = h(this.chainId), e = await b(t, r);
+    if (e)
+      return e;
+  }
+  async fetchProtocolPriceinUSD(r) {
+    const t = this.erc20Registry.find(
+      (e) => c(e.erc20TokenAddress, r)
+    );
+    if (t) {
+      if (this.supportsCurve() && this.curvePools.length === 0 && (this.curvePools = await y(this.chainId)), a.isCurveOrConvex(
+        t,
+        this.curvePools.map((e) => e.lpTokenAddress)
+      )) {
+        const e = await this.fetchCurvePriceinUSD(t.underlyingErc20TokenAddress ?? r);
+        if (e)
+          return e;
+      }
+      if (a.isBeefyToken(t)) {
+        const e = await this.findBeefyPriceInUSD(t.underlyingErc20TokenAddress ?? r);
+        if (e)
+          return e;
+      }
+      if (a.isPendleToken(t)) {
+        const e = await this.fetchPendleTokenPriceInUSD(r);
+        if (e)
+          return e;
+      }
+      if (a.isAaveToken(t)) {
+        const { underlyingErc20TokenAddress: e } = t;
+        if (!e)
+          return console.log("missing underlying token for aave"), 0;
+        const i = await this.fetchPriceByTokenAddress(e);
+        if (i)
+          return i;
+      }
+      if (a.isNonRebasingBlastToken(t)) {
+        const e = this.erc20Registry.find((o) => o.symbol === t.symbol.slice(2));
+        if (!e)
+          return console.log("missing rebasing variant for non-rebasing token"), 0;
+        const i = await this.fetchPriceByTokenAddress(e.erc20TokenAddress);
+        if (i)
+          return i;
+      }
+      if (a.isKinzaToken(t)) {
+        const { underlyingErc20TokenAddress: e } = t;
+        if (!e)
+          return console.log("underlying token does not exists for Kinza token"), 0;
+        const i = await this.fetchPriceByTokenAddress(e);
+        if (i)
+          return i;
+      }
+    }
+  }
+  // this should work for Curve Pools, Curve Staking and Convex
+  async fetchCurvePriceinUSD(r) {
+    const t = this.crvCvxRegistry.find(
+      (i) => c(i.lpToken, r) || c(i.gauge, r) || c(i.cvxRewards, r)
+    ), e = this.curvePools.find(
+      (i) => c(i.address, t?.pool) || c(i.lpTokenAddress, r) || c(i.gaugeAddress, r)
+    );
+    if (e?.lpPrice)
+      return e.lpPrice;
+  }
+  // this should work for Beefy Lp Provision and Beefy Staking
+  async findBeefyPriceInUSD(r) {
+    await this.updateBeefyVault();
+    const t = h(this.chainId), e = this.beefyVaults.find(
+      (i) => c(r, i.earnedTokenAddress) && v[t] === i.chain
+    );
+    if (e && this.provider) {
+      const { earnedTokenAddress: i, id: o } = e, n = (await new u.Contract(i, C, this.provider).totalSupply()).toBigInt(), d = Number(u.utils.formatUnits(n, 18));
+      Object.keys(this.beefyTvlData).length === 0 && (this.beefyTvlData = (await l.get(w)).data);
+      const f = this.beefyTvlData[t][o];
+      return !f || !d ? void 0 : f / d;
+    }
+  }
+  async fetchPendleTokenPriceInUSD(r) {
+    const t = h(this.chainId), i = this.erc20Registry.find(
+      (n) => c(n.erc20TokenAddress, r)
+    )?.underlyingErc20TokenAddress ?? r;
+    console.log({ searchToken: i });
+    const o = `${t}/assets/${i}`, s = (await l.get(`${B}${o}`)).data;
+    return s ? s?.price.usd : 0;
+  }
+  async findBeefyLpPrice(r) {
+    await this.updateBeefyVault();
+    const t = this.beefyVaults.find((e) => c(r, e.tokenAddress));
+    if (t)
+      try {
+        const { oracleId: e } = t;
+        return (await l.get(D)).data?.[e];
+      } catch (e) {
+        console.log("findBeefyLpPrice error:", e);
+        return;
+      }
+  }
+}
+export {
+  Pe as TokenPriceFetcher
+};