@1delta/margin-fetcher 0.0.261 → 0.0.262

package/dist/index.js

@@ -35072,9 +35072,29 @@ var EULER_EARN_VAULTS_QUERY = `
     totalAssets
     totalShares
     totalSupply
+    strategies {
+      id
+      strategy
+      allocatedAssets
+    }
   }
 }
 `;
+var EVK_BY_ASSETS_QUERY = `
+query EvkByAssets($assets: [Bytes!]!) {
+  eulerVaults(first: 1000, where: { asset_in: $assets }) {
+    id
+    decimals
+    asset
+    state {
+      supplyApy
+      cash
+    }
+  }
+}
+`;
+var ZERO = 0n;
+var RAY_TO_PERCENT3 = 1e25;
 function readAddress2(field5) {
   if (!field5) return void 0;
   return field5.toLowerCase();
@@ -35087,19 +35107,84 @@ function parseVaultFee(v) {
   if (n > 100) return n / 1e16;
   return n;
 }
-function parseVault7(v, chainId, prices, tokenList) {
+function safeBigInt(v) {
+  if (v == null || v === "") return ZERO;
+  try {
+    return BigInt(v);
+  } catch {
+    return ZERO;
+  }
+}
+function computeWeightedSupplyApy(strategies, totalAssetsRaw, feePercent, evkIndex) {
+  if (!strategies?.length) return 0;
+  const totalAssets = safeBigInt(totalAssetsRaw);
+  if (totalAssets === ZERO) return 0;
+  let weightedRay = ZERO;
+  for (const s of strategies) {
+    const evk = s.strategy?.toLowerCase();
+    if (!evk) continue;
+    const apyRay = evkIndex.bySupplyApyRay.get(evk);
+    if (apyRay == null) continue;
+    const allocated = safeBigInt(s.allocatedAssets);
+    if (allocated === ZERO) continue;
+    weightedRay += allocated * apyRay;
+  }
+  if (weightedRay === ZERO) return 0;
+  const apyRayPerAsset = weightedRay / totalAssets;
+  const grossPercent = Number(apyRayPerAsset) / RAY_TO_PERCENT3;
+  const netPercent = grossPercent * (1 - feePercent / 100);
+  return Number.isFinite(netPercent) ? netPercent : 0;
+}
+function computeRealLiquidity(strategies, totalAssetsRaw, evkIndex) {
+  const totalAssets = safeBigInt(totalAssetsRaw);
+  if (totalAssets === ZERO) return ZERO;
+  if (evkIndex.byCash.size === 0 && evkIndex.bySupplyApyRay.size === 0) {
+    return totalAssets;
+  }
+  if (!strategies?.length) {
+    return totalAssets;
+  }
+  let allocSum = ZERO;
+  let withdrawable = ZERO;
+  for (const s of strategies) {
+    const alloc = safeBigInt(s.allocatedAssets);
+    if (alloc === ZERO) continue;
+    allocSum += alloc;
+    const evk = s.strategy?.toLowerCase();
+    const cash = evk ? evkIndex.byCash.get(evk) : void 0;
+    withdrawable += cash == null ? alloc : alloc < cash ? alloc : cash;
+  }
+  const idle = totalAssets > allocSum ? totalAssets - allocSum : ZERO;
+  const result = idle + withdrawable;
+  return result > totalAssets ? totalAssets : result;
+}
+function parseVault7(v, chainId, prices, tokenList, evkIndex) {
   const address = (v?.id ?? "").toLowerCase();
   const assetAddr = (v?.asset ?? "").toLowerCase();
   if (!address || !assetAddr) return null;
   const assetMeta = tokenList[assetAddr];
-  const decimals = Number(assetMeta?.decimals ?? 18);
+  const decimals = Number(
+    evkIndex.decimalsByAsset.get(assetAddr) ?? assetMeta?.decimals ?? 18
+  );
   const totalAssetsRaw = v.totalAssets?.toString() ?? "0";
   const totalAssetsFormatted = Number(parseRawAmount(totalAssetsRaw, decimals));
   const oracleKey = toOracleKey(assetMeta?.assetGroup) ?? toGenericPriceKey(assetAddr, chainId);
   const priceUsd = prices[oracleKey] ?? prices[assetAddr] ?? 0;
   const fee = parseVaultFee(v);
-  const supplyRate = 0;
+  const supplyRate = computeWeightedSupplyApy(
+    v.strategies,
+    totalAssetsRaw,
+    fee,
+    evkIndex
+  );
   const totalSupplyRaw = v.totalSupply?.toString() ?? v.totalShares?.toString() ?? "0";
+  const liquidityBig = computeRealLiquidity(
+    v.strategies,
+    totalAssetsRaw,
+    evkIndex
+  );
+  const liquidityRaw = liquidityBig.toString();
+  const liquidityFormatted = Number(parseRawAmount(liquidityRaw, decimals));
   return {
     address,
     underlying: assetAddr,
@@ -35120,31 +35205,75 @@ function parseVault7(v, chainId, prices, tokenList) {
     priceUsd: priceUsd || void 0,
     totalAssetsFormatted,
     totalAssetsUsd: totalAssetsFormatted * priceUsd,
-    // Subgraph doesn't expose immediate-withdraw — same optimistic
-    // ceiling as Morpho/Silo earn-vault fetchers.
-    liquidity: totalAssetsRaw,
-    liquidityFormatted: totalAssetsFormatted,
-    liquidityUsd: totalAssetsFormatted * priceUsd
+    liquidity: liquidityRaw,
+    liquidityFormatted,
+    liquidityUsd: liquidityFormatted * priceUsd
   };
 }
-async function fetchEulerEarnVaultsFromSubgraph(chainId, prices = {}, tokenList = {}) {
-  const url = EULER_EARN_SUBGRAPH_URLS[chainId];
-  if (!url) return {};
+async function postQuery(url, body) {
   const response = await fetch(url, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ query: EULER_EARN_VAULTS_QUERY })
+    body: JSON.stringify(body)
   });
   if (!response.ok) {
     throw new Error(
-      `Euler Earn vaults subgraph failed for chain ${chainId}: ${response.status} - ${response.statusText}`
+      `Euler Earn vaults subgraph failed: ${response.status} - ${response.statusText}`
     );
   }
-  const json = await response.json();
+  return response.json();
+}
+async function fetchEvkIndex(url, assets) {
+  const empty = {
+    bySupplyApyRay: /* @__PURE__ */ new Map(),
+    byCash: /* @__PURE__ */ new Map(),
+    decimalsByAsset: /* @__PURE__ */ new Map()
+  };
+  if (assets.length === 0) return empty;
+  let json;
+  try {
+    json = await postQuery(url, {
+      query: EVK_BY_ASSETS_QUERY,
+      variables: { assets }
+    });
+  } catch {
+    return empty;
+  }
+  const items = json?.data?.eulerVaults ?? [];
+  for (const e of items) {
+    const id = e?.id?.toLowerCase();
+    const asset = e?.asset?.toLowerCase();
+    if (!id || !asset) continue;
+    const decimals = Number(e.decimals ?? NaN);
+    if (Number.isFinite(decimals) && !empty.decimalsByAsset.has(asset)) {
+      empty.decimalsByAsset.set(asset, decimals);
+    }
+    const apyRaw = e.state?.supplyApy;
+    if (apyRaw != null) {
+      empty.bySupplyApyRay.set(id, safeBigInt(apyRaw));
+    }
+    const cashRaw = e.state?.cash;
+    if (cashRaw != null) {
+      empty.byCash.set(id, safeBigInt(cashRaw));
+    }
+  }
+  return empty;
+}
+async function fetchEulerEarnVaultsFromSubgraph(chainId, prices = {}, tokenList = {}) {
+  const url = EULER_EARN_SUBGRAPH_URLS[chainId];
+  if (!url) return {};
+  const json = await postQuery(url, { query: EULER_EARN_VAULTS_QUERY });
   const items = json?.data?.eulerEarnVaults ?? [];
+  if (items.length === 0) return {};
+  const assets = /* @__PURE__ */ new Set();
+  for (const v of items) {
+    const a = v?.asset?.toLowerCase();
+    if (a) assets.add(a);
+  }
+  const evkIndex = await fetchEvkIndex(url, [...assets]);
   const out = {};
   for (const v of items) {
-    const parsed = parseVault7(v, chainId, prices, tokenList);
+    const parsed = parseVault7(v, chainId, prices, tokenList, evkIndex);
     if (parsed) out[parsed.address] = parsed;
   }
   return out;