@1delta/margin-fetcher 0.0.286 → 0.0.300

package/dist/index.js

@@ -32926,18 +32926,22 @@ var upshiftFetcher = {
 // src/yields/intrinsic/fetchers/monadLst.ts
 var SMON_POOL_ID = "73c511a9-4dc0-4397-babe-e578fd75f0dd";
 var SHMON_POOL_ID = "ee40513c-9356-4c53-9f26-446b484a8ae2";
+var GMON_POOL_ID = "96f74061-dc9a-4ef7-8117-6cd3935230de";
 var SMON_KEY = "Kintsu Staked Monad::sMON";
 var SHMON_KEY = "ShMonad::shMON";
+var GMON_KEY = "gMON::gMON";
 var monadLstFetcher = {
   label: "MONAD_LST",
   fetch: async () => {
-    const [sMon, shMon] = await Promise.allSettled([
+    const [sMon, shMon, gMon] = await Promise.allSettled([
       fetchDefiLlamaApy(SMON_POOL_ID),
-      fetchDefiLlamaApy(SHMON_POOL_ID)
+      fetchDefiLlamaApy(SHMON_POOL_ID),
+      fetchDefiLlamaApy(GMON_POOL_ID)
     ]);
     const out = {};
     if (sMon.status === "fulfilled") out[SMON_KEY] = sMon.value;
     if (shMon.status === "fulfilled") out[SHMON_KEY] = shMon.value;
+    if (gMon.status === "fulfilled") out[GMON_KEY] = gMon.value;
     return out;
   }
 };
@@ -38028,6 +38032,38 @@ var fetchSiloVaults = async (chainId, prices = {}, tokenList = {}, options) => {
 };
 
 // src/vaults/euler-earn/fetchFromSubgraph.ts
+var DECIMALS_ABI = [
+  {
+    name: "decimals",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint8" }]
+  }
+];
+async function fetchShareDecimals(chainId, vaultAddrs, multicallRetry) {
+  const out = /* @__PURE__ */ new Map();
+  if (!multicallRetry || vaultAddrs.length === 0) return out;
+  try {
+    const res = await multicallRetry({
+      chain: chainId,
+      calls: vaultAddrs.map((address) => ({
+        address,
+        name: "decimals",
+        params: []
+      })),
+      abi: vaultAddrs.map(() => DECIMALS_ABI),
+      allowFailure: true,
+      maxRetries: 2
+    });
+    vaultAddrs.forEach((a, i) => {
+      const d = Number(res?.[i]);
+      if (Number.isFinite(d)) out.set(a.toLowerCase(), d);
+    });
+  } catch {
+  }
+  return out;
+}
 var EULER_EARN_PROJECT = "project_cm4iagnemt1wp01xn4gh1agft";
 var eulerSubgraphUrl = (slug) => `https://api.goldsky.com/api/public/${EULER_EARN_PROJECT}/subgraphs/${slug}/latest/gn`;
 var EULER_EARN_SUBGRAPH_URLS = {
@@ -38143,16 +38179,19 @@ function computeRealLiquidity(strategies, totalAssetsRaw, evkIndex) {
   const result = idle + withdrawable;
   return result > totalAssets ? totalAssets : result;
 }
-function parseVault6(v, chainId, prices, tokenList, evkIndex) {
+function parseVault6(v, chainId, prices, tokenList, evkIndex, shareDecimalsByVault) {
   const address = (v?.id ?? "").toLowerCase();
   const assetAddr = (v?.asset ?? "").toLowerCase();
   if (!address || !assetAddr) return null;
   const assetMeta = tokenList[assetAddr];
-  const decimals = Number(
+  const assetDecimals = Number(
     evkIndex.decimalsByAsset.get(assetAddr) ?? assetMeta?.decimals ?? 18
   );
+  const decimals = shareDecimalsByVault.get(address) ?? assetDecimals;
   const totalAssetsRaw = v.totalAssets?.toString() ?? "0";
-  const totalAssetsFormatted = Number(parseRawAmount(totalAssetsRaw, decimals));
+  const totalAssetsFormatted = Number(
+    parseRawAmount(totalAssetsRaw, assetDecimals)
+  );
   const oracleKey = toOracleKey(assetMeta?.assetGroup) ?? toGenericPriceKey(assetAddr, chainId);
   const priceUsd = prices[oracleKey] ?? prices[assetAddr] ?? 0;
   const fee = parseVaultFee(v);
@@ -38174,13 +38213,14 @@ function parseVault6(v, chainId, prices, tokenList, evkIndex) {
     evkIndex
   );
   const liquidityRaw = liquidityBig.toString();
-  const liquidityFormatted = Number(parseRawAmount(liquidityRaw, decimals));
+  const liquidityFormatted = Number(parseRawAmount(liquidityRaw, assetDecimals));
   return {
     address,
     underlying: assetAddr,
     symbol: v.symbol ?? "",
     name: v.name ?? "",
     decimals,
+    assetDecimals,
     totalAssets: totalAssetsRaw,
     totalSupply: totalSupplyRaw,
     convertToAssets,
@@ -38251,21 +38291,34 @@ async function fetchEvkIndex(url, assets) {
   }
   return empty;
 }
-async function fetchEulerEarnVaultsFromSubgraph(chainId, prices = {}, tokenList = {}) {
+async function fetchEulerEarnVaultsFromSubgraph(chainId, prices = {}, tokenList = {}, multicallRetry) {
   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();
+  const vaultAddrs = [];
   for (const v of items) {
     const a = v?.asset?.toLowerCase();
     if (a) assets.add(a);
+    const id = v?.id;
+    if (id) vaultAddrs.push(id);
   }
-  const evkIndex = await fetchEvkIndex(url, [...assets]);
+  const [evkIndex, shareDecimalsByVault] = await Promise.all([
+    fetchEvkIndex(url, [...assets]),
+    fetchShareDecimals(chainId, vaultAddrs, multicallRetry)
+  ]);
   const out = {};
   for (const v of items) {
-    const parsed = parseVault6(v, chainId, prices, tokenList, evkIndex);
+    const parsed = parseVault6(
+      v,
+      chainId,
+      prices,
+      tokenList,
+      evkIndex,
+      shareDecimalsByVault
+    );
     if (parsed) out[parsed.address] = parsed;
   }
   return out;
@@ -38293,6 +38346,12 @@ function safeBigInt2(v) {
     return 0n;
   }
 }
+function rescaleExchangeRate(exchangeRate, shareDecimals) {
+  const r = safeBigInt2(exchangeRate);
+  if (r === 0n) return "0";
+  const dec = Math.max(0, Math.round(Number(shareDecimals) || 0));
+  return (r * 10n ** BigInt(dec) / 10n ** 18n).toString();
+}
 async function getJson(url) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), API_TIMEOUT_MS);
@@ -38343,15 +38402,20 @@ function mapApiDetail(d, chainId, prices, tokenList) {
   if (!address || !underlying) return null;
   const assetMeta = tokenList[underlying];
   const decimals = Number(d.decimals ?? d.asset?.decimals ?? 18);
+  const assetDecimals = Number(
+    d.asset?.decimals ?? assetMeta?.decimals ?? decimals
+  );
   const totalAssetsRaw = String(d.totalAssets ?? "0");
   const totalSupplyRaw = String(d.totalShares ?? "0");
-  const convertToAssets = d.exchangeRate != null ? String(d.exchangeRate) : deriveConvertToAssets(totalAssetsRaw, totalSupplyRaw, decimals);
+  const convertToAssets = d.exchangeRate != null ? rescaleExchangeRate(d.exchangeRate, decimals) : deriveConvertToAssets(totalAssetsRaw, totalSupplyRaw, decimals);
   const supplyRate = Number(d.supplyApy ?? d.apyCurrent ?? 0) || 0;
   const availableRaw = safeBigInt2(d.availableAssets) || safeBigInt2(totalAssetsRaw);
   const totalAssetsBig = safeBigInt2(totalAssetsRaw);
   const liquidityRaw = (availableRaw > totalAssetsBig ? totalAssetsBig : availableRaw).toString();
-  const totalAssetsFormatted = Number(parseRawAmount(totalAssetsRaw, decimals));
-  const liquidityFormatted = Number(parseRawAmount(liquidityRaw, decimals));
+  const totalAssetsFormatted = Number(
+    parseRawAmount(totalAssetsRaw, assetDecimals)
+  );
+  const liquidityFormatted = Number(parseRawAmount(liquidityRaw, assetDecimals));
   const oracleKey = toOracleKey(assetMeta?.assetGroup) ?? toGenericPriceKey(underlying, chainId);
   const priceUsd = prices[oracleKey] ?? prices[underlying] ?? 0;
   const totalAssetsUsd = priceUsd ? totalAssetsFormatted * priceUsd : Number(d.totalSupplyUsd ?? 0);
@@ -38362,6 +38426,7 @@ function mapApiDetail(d, chainId, prices, tokenList) {
     symbol: d.symbol ?? "",
     name: d.name ?? "",
     decimals,
+    assetDecimals,
     totalAssets: totalAssetsRaw,
     totalSupply: totalSupplyRaw,
     convertToAssets,
@@ -38425,14 +38490,14 @@ async function fetchEulerEarnVaultsFromApi(chainId, prices = {}, tokenList = {})
 
 // src/vaults/euler-earn/fetchPublic.ts
 var isNonEmpty = (v) => !!v && Object.keys(v).length > 0;
-var fetchEulerEarnVaults = async (chainId, prices = {}, tokenList = {}) => {
+var fetchEulerEarnVaults = async (chainId, prices = {}, tokenList = {}, multicallRetry) => {
   const subgraphUrl = getEulerEarnSubgraphUrl(chainId);
   if (!subgraphUrl) {
     return await fetchEulerEarnVaultsFromApi(chainId, prices, tokenList) ?? {};
   }
   const [stale, subgraph] = await Promise.all([
     isEulerEarnSubgraphStale(chainId, subgraphUrl).catch(() => false),
-    fetchEulerEarnVaultsFromSubgraph(chainId, prices, tokenList).then((r) => ({ ok: true, data: r })).catch(() => ({ ok: false, data: void 0 }))
+    fetchEulerEarnVaultsFromSubgraph(chainId, prices, tokenList, multicallRetry).then((r) => ({ ok: true, data: r })).catch(() => ({ ok: false, data: void 0 }))
   ]);
   if (!stale && subgraph.ok && isNonEmpty(subgraph.data)) {
     return subgraph.data;
@@ -38651,6 +38716,91 @@ var solvBtcPlusFetcher = {
 
 // src/vaults/lst/registry.ts
 var LST_REGISTRY = {
+  // Monad (143) — native-MON LSTs. shMON / aprMON are ERC-4626 over native
+  // MON (asset() = the 0xEeee… native sentinel), with async redemptions
+  // (requestRedeem → claim). Priced via WMON. sMON (Kintsu) is a custom
+  // non-4626 contract and is added separately once its rate-getter ABI is
+  // available.
+  "143": [
+    {
+      address: "0x1b68626dca36c7fe922fd2d55e4f631d962de19c",
+      underlying: "0x0000000000000000000000000000000000000000",
+      priceUnderlying: "0x3bd359c1119da7da1d913d1c4d2b7c461115433a",
+      // WMON
+      symbol: "shMON",
+      brand: "ShMonad",
+      decimals: 18,
+      reader: "erc4626",
+      isErc4626: true,
+      isRebasing: false,
+      isMintable: true,
+      isNativeUnderlying: true,
+      mintContract: "0x1b68626dca36c7fe922fd2d55e4f631d962de19c",
+      mintInputAsset: "native",
+      withdrawalMode: "queued",
+      yieldFetcher: monadLstFetcher,
+      yieldKey: "ShMonad::shMON"
+    },
+    {
+      address: "0x0c65a0bc65a5d819235b71f554d210d3f80e0852",
+      underlying: "0x0000000000000000000000000000000000000000",
+      priceUnderlying: "0x3bd359c1119da7da1d913d1c4d2b7c461115433a",
+      // WMON
+      symbol: "aprMON",
+      brand: "aPriori",
+      decimals: 18,
+      reader: "erc4626",
+      isErc4626: true,
+      isRebasing: false,
+      isMintable: true,
+      isNativeUnderlying: true,
+      mintContract: "0x0c65a0bc65a5d819235b71f554d210d3f80e0852",
+      mintInputAsset: "native",
+      withdrawalMode: "queued"
+      // No DefiLlama pool for aPriori — `supplyRate` is left to the on-chain
+      // exchange-rate path; the ERC-4626 `convertToAssets` rate is surfaced.
+    },
+    {
+      // sMON (Kintsu) — custom (non-4626) native-MON LST. Rate derived from
+      // totalPooled()/totalShares(). Deposit/withdraw mechanics are custom
+      // and not yet wired on the action side (no verified source ABI).
+      address: "0xa3227c5969757783154c60bf0bc1944180ed81b9",
+      underlying: "0x0000000000000000000000000000000000000000",
+      priceUnderlying: "0x3bd359c1119da7da1d913d1c4d2b7c461115433a",
+      // WMON
+      symbol: "sMON",
+      brand: "Kintsu",
+      decimals: 18,
+      reader: "kintsuSMon",
+      isErc4626: false,
+      isRebasing: false,
+      isMintable: true,
+      isNativeUnderlying: true,
+      withdrawalMode: "queued",
+      yieldFetcher: monadLstFetcher,
+      yieldKey: "Kintsu Staked Monad::sMON"
+    },
+    {
+      // gMON (Magma) — ERC-4626 over WMON (ERC-20 underlying, priced
+      // directly). Deposit pulls WMON; redemption is sync/async on-chain.
+      // Action side not yet wired (deposit reverts opaquely without source).
+      address: "0x8498312a6b3cbd158bf0c93abdcf29e6e4f55081",
+      underlying: "0x3bd359c1119da7da1d913d1c4d2b7c461115433a",
+      // WMON
+      symbol: "gMON",
+      brand: "Magma",
+      decimals: 18,
+      reader: "erc4626",
+      isErc4626: true,
+      isRebasing: false,
+      isMintable: true,
+      isNativeUnderlying: false,
+      mintContract: "0x8498312a6b3cbd158bf0c93abdcf29e6e4f55081",
+      withdrawalMode: "queued",
+      yieldFetcher: monadLstFetcher,
+      yieldKey: "gMON::gMON"
+    }
+  ],
   "1": [
     {
       address: "0x7f39c581f595b53c5cb19bd0b3f8da6c935e2ca0",
@@ -41147,6 +41297,40 @@ var readerStellaStDot = (entry) => ({
   }
 });
 
+// src/vaults/lst/abis/kintsu.ts
+var KintsuSMonAbi = [
+  {
+    name: "totalPooled",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    name: "totalShares",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  }
+];
+
+// src/vaults/lst/readers/kintsu.ts
+var readerKintsuSMon = (entry) => ({
+  calls: [
+    { address: entry.address, name: "totalPooled", params: [] },
+    { address: entry.address, name: "totalShares", params: [] }
+  ],
+  abis: [KintsuSMonAbi, KintsuSMonAbi],
+  parse: ([pooled, shares]) => {
+    const totalAssets = toBigInt10(pooled);
+    const totalSupply = toBigInt10(shares);
+    if (totalAssets === void 0 || totalSupply === void 0) return void 0;
+    const exchangeRate = totalSupply > 0n ? totalAssets * ONE_E186 / totalSupply : ONE_E186;
+    return { totalAssets, totalSupply, exchangeRate };
+  }
+});
+
 // src/vaults/lst/readers/index.ts
 var buildReader = (entry) => {
   switch (entry.reader) {
@@ -41206,6 +41390,8 @@ var buildReader = (entry) => {
       return readerCoreStakedRatio(entry);
     case "stellaStDot":
       return readerStellaStDot(entry);
+    case "kintsuSMon":
+      return readerKintsuSMon(entry);
   }
 };
 
@@ -45465,8 +45651,8 @@ function parseVault8(v, chainId, prices, tokenList) {
   );
   const base = num2(v.apy?.apy) ?? 0;
   const campaign = num2(v.apy?.campaignApy);
-  const supplyRate = base;
-  const rewardsRate = campaign ?? 0;
+  const supplyRate = apyToAprPercent(base);
+  const rewardsRate = campaign != null ? apyToAprPercent(campaign) : 0;
   const oracleKey = toOracleKey(assetMeta?.assetGroup) ?? toGenericPriceKey(assetAddr, chainId);
   const apiTvlUsd = num2(v.latest_reported_tvl) ?? 0;
   const impliedPriceUsd = totalAssetsFormatted > 0 ? apiTvlUsd / totalAssetsFormatted : 0;
@@ -47418,7 +47604,7 @@ var getVaultPublicDataAll = async (chainId, providers, multicallRetry, prices =
   }
   if (requested.has("euler-earn")) {
     tasks.push(
-      fetchEulerEarnVaults(chainId, prices, tokenList).then((res) => {
+      fetchEulerEarnVaults(chainId, prices, tokenList, multicallRetry).then((res) => {
         out["euler-earn"] = res;
       }).catch((e) => {
         warn4(