@1delta/margin-fetcher 0.0.276 → 0.0.277

package/dist/index.js

@@ -5,7 +5,7 @@ import { Lender, isAaveType, isCompoundV3, isMultiMarket, isSiloV2Type, isSiloV3
 export { isAaveType, isAaveV2Type, isAaveV32Type, isAaveV3Type, isCompoundV3, isCompoundV3Type, isInit, isMorphoType, isMultiMarket, isYLDR } from '@1delta/lender-registry';
 import lodash from 'lodash';
 import { getEvmChain, getEvmClient, getEvmClientUniversal, multicallRetryUniversal, getEvmClientWithCustomRpcsUniversal } from '@1delta/providers';
-import { FluidLendingResolverAbi, FluidVaultResolverAbi, MetaMorphoAbi, MoolahVaultAbi, MorphoLensAbi, AaveV4SpokeAbi, AaveV4OracleAbi, AaveV4HubAbi, DolomiteMarginAbi, GearboxMarketCompressorV310Abi, MorphoBlueAbi, GearboxCreditAccountCompressorV310Abi } from '@1delta/abis';
+import { MetaMorphoAbi, FluidLendingResolverAbi, FluidVaultResolverAbi, MoolahVaultAbi, MorphoLensAbi, AaveV4SpokeAbi, AaveV4OracleAbi, AaveV4HubAbi, DolomiteMarginAbi, GearboxMarketCompressorV310Abi, MorphoBlueAbi, GearboxCreditAccountCompressorV310Abi } from '@1delta/abis';
 export { MorphoLensAbi } from '@1delta/abis';
 import { prepareDebitDataMulticall, prepareLenderDebitMulticall, parseDebitDataResult, parseLenderDebitResult, getPermit2ContractAddress, getCompoundV3CometAddress as getCompoundV3CometAddress$1, getMorphoAddress, getAaveCollateralTokenAddress, getSiloHalfForUnderlying, InitMarginAddresses, getLstAcceptedInputs } from '@1delta/calldata-sdk';
 import { proxyNativeFetch } from '@1delta/proxy-fetch';
@@ -36276,6 +36276,52 @@ function computeVaultAllocation(vaultAddress, decimals, totalAssetsFormatted, fe
     liquidityFormatted: Math.min(totalAssetsFormatted, idle + withdrawable)
   };
 }
+function computeV2Allocation(decimals, totalAssetsFormatted, feePercent, priceUsd, marketAssetsRaw, rateMap, tokenList, uidCtx) {
+  if (totalAssetsFormatted <= 0) {
+    return { depositRate: 0, exposures: [], liquidityFormatted: 0 };
+  }
+  if (marketAssetsRaw.size === 0) {
+    return {
+      depositRate: 0,
+      exposures: withIdleExposure([], totalAssetsFormatted, priceUsd),
+      liquidityFormatted: totalAssetsFormatted
+    };
+  }
+  let weighted = 0;
+  let allocated = 0;
+  let withdrawable = 0;
+  const exposures = [];
+  for (const [id, assetsRaw] of marketAssetsRaw) {
+    const allocAssets = Number(parseRawAmount(assetsRaw.toString(), decimals));
+    if (allocAssets <= 0) continue;
+    const rate = rateMap.get(id);
+    allocated += allocAssets;
+    const supplyApr = rate?.supplyApr ?? 0;
+    weighted += allocAssets * supplyApr;
+    const marketLiquidity = rate?.liquidity != null ? Number(parseRawAmount(rate.liquidity.toString(), decimals)) : allocAssets;
+    withdrawable += Math.min(allocAssets, Math.max(0, marketLiquidity));
+    const marketUid = marketUidFor(uidCtx, id);
+    const collateralAddress = rate?.collateralAddress ?? "";
+    exposures.push({
+      marketId: id,
+      ...marketUid ? { marketUid } : {},
+      collateralAddress,
+      collateral: collateralAddress ? tokenList[collateralAddress] : void 0,
+      assets: allocAssets,
+      assetsUsd: allocAssets * priceUsd,
+      weightPct: allocAssets / totalAssetsFormatted * 100,
+      supplyApr
+    });
+  }
+  exposures.sort((a, b) => b.weightPct - a.weightPct);
+  const grossApr = weighted / totalAssetsFormatted;
+  const idle = Math.max(0, totalAssetsFormatted - allocated);
+  return {
+    depositRate: grossApr * (1 - feePercent / 100),
+    exposures: withIdleExposure(exposures, totalAssetsFormatted, priceUsd),
+    liquidityFormatted: Math.min(totalAssetsFormatted, idle + withdrawable)
+  };
+}
 
 // src/vaults/morpho/fetchFromChain.ts
 var { chunk: chunk5 } = lodash;
@@ -36292,13 +36338,36 @@ var VAULT_CALLS = [
   "guardian"
 ];
 var CALLS_PER_VAULT = VAULT_CALLS.length;
-var PHASE1_CALLS = [...VAULT_CALLS, "withdrawQueueLength"];
+var PHASE1_CALLS = [
+  ...VAULT_CALLS,
+  "withdrawQueueLength",
+  // V1 (MetaMorpho) — reverts on V2
+  "adaptersLength",
+  // V2 (Vaults V2) — reverts on V1
+  "performanceFee"
+  // V2 fee getter (V1 uses `fee()`)
+];
 var PHASE1_PER_VAULT = PHASE1_CALLS.length;
 var WITHDRAW_QUEUE_LENGTH_INDEX = CALLS_PER_VAULT;
+var ADAPTERS_LENGTH_INDEX = CALLS_PER_VAULT + 1;
+var PERFORMANCE_FEE_INDEX = CALLS_PER_VAULT + 2;
 var MORPHO_LENS_ABI = parseAbi([
   "function getMarketDataCompact(address morpho, bytes32[] calldata marketsIds) external view returns (bytes memory data)"
 ]);
 var MARKET_CHUNK = 100;
+var VAULT_V2_PHASE1_ABI = parseAbi([
+  "function adaptersLength() view returns (uint256)",
+  "function performanceFee() view returns (uint96)"
+]);
+var VAULT_V2_ABI = parseAbi([
+  "function adapters(uint256) view returns (address)"
+]);
+var VAULT_V2_ADAPTER_ABI = parseAbi([
+  "function marketIdsLength() view returns (uint256)",
+  "function marketIds(uint256) view returns (bytes32)",
+  "function expectedSupplyAssets(bytes32) view returns (uint256)"
+]);
+var PHASE1_ABI = [...MetaMorphoAbi, ...VAULT_V2_PHASE1_ABI];
 var FEE_SCALE = 1e18;
 var isHex40 = (addr) => typeof addr === "string" && /^0x[0-9a-f]{40}$/i.test(addr);
 var isHex64 = (v) => typeof v === "string" && /^0x[0-9a-f]{64}$/i.test(v);
@@ -36312,6 +36381,17 @@ var toStringSafe = (raw, fallback = "") => {
   if (raw === void 0 || raw === null) return fallback;
   return String(raw);
 };
+var toBigIntSafe2 = (raw) => {
+  if (raw === void 0 || raw === null) return void 0;
+  try {
+    if (typeof raw === "bigint") return raw;
+    if (typeof raw === "number") return BigInt(Math.trunc(raw));
+    if (typeof raw === "string" && /^\d+$/.test(raw)) return BigInt(raw);
+    return void 0;
+  } catch {
+    return void 0;
+  }
+};
 var toRawAmount = (formatted, decimals) => {
   try {
     return parseUnits(formatted.toFixed(decimals), decimals).toString();
@@ -36350,10 +36430,19 @@ var fetchMorphoVaultsFromChain = async (chainId, multicallRetry, prices = {}, to
   const phase1 = await multicallRetry({
     chain: chainId,
     calls: phase1Calls,
-    abi: phase1Calls.map(() => MetaMorphoAbi),
+    abi: phase1Calls.map(() => PHASE1_ABI),
     allowFailure: true
   });
+  const adapterLens = entries.map(
+    (_3, i) => Number(phase1[i * PHASE1_PER_VAULT + ADAPTERS_LENGTH_INDEX])
+  );
+  const isV2 = entries.map(({ entry }, i) => {
+    if (entry.version === "v2") return true;
+    if (entry.version === "v1") return false;
+    return Number.isFinite(adapterLens[i]);
+  });
   const queueLens = entries.map((_3, i) => {
+    if (isV2[i]) return 0;
     const n = Number(phase1[i * PHASE1_PER_VAULT + WITHDRAW_QUEUE_LENGTH_INDEX]);
     return Number.isFinite(n) && n > 0 ? n : 0;
   });
@@ -36397,11 +36486,41 @@ var fetchMorphoVaultsFromChain = async (chainId, multicallRetry, prices = {}, to
     ),
     fetchAssetDecimals(chainId, underlyings, multicallRetry)
   ]);
+  const resolveDecimals = (i) => {
+    const { entry } = entries[i];
+    const underlying = entry.underlying?.toLowerCase() ?? "";
+    const decimalsRaw = phase1[i * PHASE1_PER_VAULT + 2];
+    return assetDecimals.get(underlying) ?? tokenList[underlying]?.decimals ?? Number(decimalsRaw ?? 18);
+  };
+  const v2Inputs = entries.map(({ entry }, i) => ({ entry, i })).filter(({ i }) => isV2[i]).map(({ entry, i }) => {
+    const decimals = resolveDecimals(i);
+    const underlying = entry.underlying?.toLowerCase() ?? "";
+    const totalAssets = toStringSafe(phase1[i * PHASE1_PER_VAULT + 3], "0");
+    const oracleKey = toOracleKey(tokenList[underlying]?.assetGroup) ?? toGenericPriceKey(underlying, chainId);
+    return {
+      vault: entry.vault.toLowerCase(),
+      underlying,
+      decimals,
+      totalAssetsFormatted: Number(parseRawAmount(totalAssets, decimals)),
+      feePercent: toNumberSafe(phase1[i * PHASE1_PER_VAULT + PERFORMANCE_FEE_INDEX]) / FEE_SCALE * 100,
+      priceUsd: prices[oracleKey] ?? prices[underlying] ?? 0,
+      adaptersLength: Math.max(0, Math.trunc(adapterLens[i]) || 0)
+    };
+  });
+  const v2ByVault = await fetchV2Allocations(
+    chainId,
+    multicallRetry,
+    v2Inputs,
+    core,
+    tokenList
+  );
   const out = {};
   for (let i = 0; i < entries.length; i++) {
     const { entry } = entries[i];
     const base = i * PHASE1_PER_VAULT;
     const slice = phase1.slice(base, base + CALLS_PER_VAULT);
+    const v2 = isV2[i] ? v2ByVault.get(entry.vault.toLowerCase()) ?? null : null;
+    const v2FeePercent = isV2[i] ? toNumberSafe(phase1[base + PERFORMANCE_FEE_INDEX]) / FEE_SCALE * 100 : void 0;
     const parsed = parseVault3(
       entry,
       slice,
@@ -36411,12 +36530,132 @@ var fetchMorphoVaultsFromChain = async (chainId, multicallRetry, prices = {}, to
       marketIdsByVault[i],
       rateMap,
       positionMap,
-      assetDecimals
+      assetDecimals,
+      v2,
+      v2FeePercent
     );
     if (parsed) out[parsed.address] = parsed;
   }
   return out;
 };
+async function fetchV2Allocations(chainId, multicallRetry, v2, core, tokenList) {
+  const out = /* @__PURE__ */ new Map();
+  if (v2.length === 0) return out;
+  const aCalls = [];
+  const aVaultIdx = [];
+  v2.forEach((v, vi) => {
+    for (let a = 0; a < v.adaptersLength; a++) {
+      aCalls.push({ address: v.vault, name: "adapters", params: [BigInt(a)] });
+      aVaultIdx.push(vi);
+    }
+  });
+  const adaptersByVault = v2.map(() => []);
+  if (aCalls.length > 0) {
+    const aRes = await multicallRetry({
+      chain: chainId,
+      calls: aCalls,
+      abi: aCalls.map(() => VAULT_V2_ABI),
+      allowFailure: true
+    });
+    aRes.forEach((r, k) => {
+      if (isHex40(r)) adaptersByVault[aVaultIdx[k]].push(r.toLowerCase());
+    });
+  }
+  const allAdapters = [...new Set(adaptersByVault.flat())];
+  if (allAdapters.length === 0) return out;
+  const bRes = await multicallRetry({
+    chain: chainId,
+    calls: allAdapters.map((a) => ({
+      address: a,
+      name: "marketIdsLength",
+      params: []
+    })),
+    abi: allAdapters.map(() => VAULT_V2_ADAPTER_ABI),
+    allowFailure: true
+  });
+  const mkLen = /* @__PURE__ */ new Map();
+  allAdapters.forEach((a, i) => {
+    const n = Number(bRes[i]);
+    mkLen.set(a, Number.isFinite(n) && n > 0 ? n : 0);
+  });
+  const cCalls = [];
+  const cAdapter = [];
+  for (const a of allAdapters) {
+    for (let j = 0; j < (mkLen.get(a) ?? 0); j++) {
+      cCalls.push({ address: a, name: "marketIds", params: [BigInt(j)] });
+      cAdapter.push(a);
+    }
+  }
+  const marketIdsByAdapter = new Map(
+    allAdapters.map((a) => [a, []])
+  );
+  if (cCalls.length > 0) {
+    const cRes = await multicallRetry({
+      chain: chainId,
+      calls: cCalls,
+      abi: cCalls.map(() => VAULT_V2_ADAPTER_ABI),
+      allowFailure: true
+    });
+    cRes.forEach((r, k) => {
+      if (isHex64(r)) marketIdsByAdapter.get(cAdapter[k]).push(r.toLowerCase());
+    });
+  }
+  const dCalls = [];
+  const dMeta = [];
+  for (const a of allAdapters) {
+    for (const mid of marketIdsByAdapter.get(a) ?? []) {
+      dCalls.push({ address: a, name: "expectedSupplyAssets", params: [mid] });
+      dMeta.push({ adapter: a, mid });
+    }
+  }
+  const assetsByAdapter = /* @__PURE__ */ new Map();
+  if (dCalls.length > 0) {
+    const dRes = await multicallRetry({
+      chain: chainId,
+      calls: dCalls,
+      abi: dCalls.map(() => VAULT_V2_ADAPTER_ABI),
+      allowFailure: true
+    });
+    dRes.forEach((r, k) => {
+      const v = toBigIntSafe2(r);
+      if (v === void 0) return;
+      const { adapter, mid } = dMeta[k];
+      if (!assetsByAdapter.has(adapter)) assetsByAdapter.set(adapter, /* @__PURE__ */ new Map());
+      assetsByAdapter.get(adapter).set(mid, v);
+    });
+  }
+  const allMids = [...new Set([...marketIdsByAdapter.values()].flat())];
+  const rateMap = await fetchMorphoMarketRates(
+    chainId,
+    core,
+    allMids,
+    multicallRetry
+  );
+  v2.forEach((v, vi) => {
+    const marketAssetsRaw = /* @__PURE__ */ new Map();
+    for (const a of adaptersByVault[vi]) {
+      const m = assetsByAdapter.get(a);
+      if (!m) continue;
+      for (const [mid, amt] of m) {
+        marketAssetsRaw.set(mid, (marketAssetsRaw.get(mid) ?? 0n) + amt);
+      }
+    }
+    out.set(
+      v.vault,
+      computeV2Allocation(
+        v.decimals,
+        v.totalAssetsFormatted,
+        v.feePercent,
+        v.priceUsd,
+        marketAssetsRaw,
+        rateMap,
+        tokenList,
+        { chainId, underlying: v.underlying, protocol: "MORPHO_BLUE" }
+      )
+    );
+  });
+  return out;
+}
 async function fetchMorphoMarketRates(chainId, core, marketIds, multicallRetry) {
   const map = /* @__PURE__ */ new Map();
   const lens = MORPHO_LENS[chainId];
@@ -36472,7 +36711,7 @@ async function fetchMorphoMarketRates(chainId, core, marketIds, multicallRetry)
   });
   return map;
 }
-function parseVault3(entry, results, chainId, prices, tokenList, marketIds, rateMap, positionMap, assetDecimals) {
+function parseVault3(entry, results, chainId, prices, tokenList, marketIds, rateMap, positionMap, assetDecimals, v2Allocation, v2FeePercent) {
   const address = entry?.vault?.toLowerCase();
   const underlying = entry?.underlying?.toLowerCase();
   if (!address || !underlying) return null;
@@ -36503,9 +36742,9 @@ function parseVault3(entry, results, chainId, prices, tokenList, marketIds, rate
   const onchainName = toStringSafe(nameRaw).trim();
   const fallbackName = onchainName || (entry.name ?? "").trim();
   const symbol = toStringSafe(symbolRaw);
-  const fee = toNumberSafe(feeRaw) / FEE_SCALE * 100;
+  const fee = v2FeePercent !== void 0 ? v2FeePercent : toNumberSafe(feeRaw) / FEE_SCALE * 100;
   const timelock = toNumberSafe(timelockRaw);
-  const { depositRate, exposures, liquidityFormatted } = computeVaultAllocation(
+  const { depositRate, exposures, liquidityFormatted } = v2Allocation ?? computeVaultAllocation(
     address,
     decimals,
     totalAssetsFormatted,
@@ -38630,6 +38869,8 @@ var LST_REGISTRY = {
       // stake PoL assets in an Infrared vault). Exit is DEX-only.
       address: "0xac03caba51e17c86c921e1f6cbfbdc91f8bb2e6b",
       underlying: "0x656b95e550c07a9ffe548bd4085c72418ceb1dba",
+      // BGT is unpriced; the wrapper is 1:1 redeemable to BERA → price via WBERA.
+      priceUnderlying: "0x6969696969696969696969696969696969696969",
       symbol: "iBGT",
       brand: "Infrared",
       decimals: 18,
@@ -38650,6 +38891,8 @@ var LST_REGISTRY = {
       // queue that pays out native BERA (via BGT.redeem).
       address: "0xbaadcc2962417c01af99fb2b7c75706b9bd6babe",
       underlying: "0x656b95e550c07a9ffe548bd4085c72418ceb1dba",
+      // BGT is unpriced; the wrapper is 1:1 redeemable to BERA → price via WBERA.
+      priceUnderlying: "0x6969696969696969696969696969696969696969",
       symbol: "LBGT",
       brand: "BeraPaw",
       decimals: 18,
@@ -38671,6 +38914,8 @@ var LST_REGISTRY = {
       // native BERA (minus fee).
       address: "0x7e768f47dfdd5dae874aac233f1bc5817137e453",
       underlying: "0x656b95e550c07a9ffe548bd4085c72418ceb1dba",
+      // BGT is unpriced; the wrapper is 1:1 redeemable to BERA → price via WBERA.
+      priceUnderlying: "0x6969696969696969696969696969696969696969",
       symbol: "yBGT",
       brand: "Bearn",
       decimals: 18,
@@ -38689,6 +38934,8 @@ var LST_REGISTRY = {
       // redeem path is unverified, so treated as DEX-only exit.
       address: "0x2cec7f1ac87f5345ced3d6c74bbb61bfae231ffb",
       underlying: "0x656b95e550c07a9ffe548bd4085c72418ceb1dba",
+      // BGT is unpriced; the wrapper is 1:1 redeemable to BERA → price via WBERA.
+      priceUnderlying: "0x6969696969696969696969696969696969696969",
       symbol: "stBGT",
       brand: "Stride",
       decimals: 18,
@@ -40295,7 +40542,7 @@ var fetchLstShareTokens = async (chainId, multicallRetry, prices = {}, tokenList
     const addressLc = entry.address.toLowerCase();
     const underlyingLc = entry.underlying.toLowerCase();
     const asset = tokenList[underlyingLc];
-    const priceUsd = prices[underlyingLc];
+    const priceUsd = prices[entry.priceUnderlying?.toLowerCase() ?? underlyingLc];
     const supplyRate = aprByAddress[addressLc] ?? 0;
     const rewardsRate = 0;
     const depositRate = supplyRate + rewardsRate;
@@ -44501,7 +44748,18 @@ var stampVaultClassification = (data, chainId, tokenList = {}) => {
       });
       v.yieldProfile = c.yieldProfile;
       v.denomination = c.denomination;
-      v.sharePrice = v.convertToAssets ?? v.pricePerShare;
+      const raw = v.convertToAssets ?? v.pricePerShare;
+      if (raw != null) {
+        v.sharePriceRaw = raw;
+        const assetDec = v.assetDecimals ?? v.decimals;
+        if (assetDec != null) {
+          const formatted = Number(raw) / 10 ** assetDec;
+          if (Number.isFinite(formatted)) {
+            v.sharePrice = formatted;
+            if (v.priceUsd != null) v.sharePriceUSD = formatted * v.priceUsd;
+          }
+        }
+      }
     }
   };
   stampBag(data.fluid, "fluid");
@@ -45775,7 +46033,9 @@ function buildVaultLookup(data) {
         // provider objects before the lookup is built).
         yieldProfile: v.yieldProfile,
         denomination: v.denomination,
-        sharePrice: v.sharePrice
+        sharePriceRaw: v.sharePriceRaw,
+        sharePrice: v.sharePrice,
+        sharePriceUSD: v.sharePriceUSD
       });
     }
   };