@t2000/engine 0.49.0 → 0.50.0

package/dist/index.d.ts

@@ -1962,6 +1962,9 @@ declare const balanceCheckTool: Tool<{
     debt: number;
     pendingRewards: number;
     gasReserve: number;
+    defi: number;
+    defiByProtocol: Partial<Record<"cetus" | "suilend" | "scallop" | "bluefin" | "aftermath" | "haedal", number>>;
+    defiSource: "blockvision" | "partial" | "degraded";
     total: number;
     stables: number;
     holdings: any[];

package/dist/index.js

@@ -711,6 +711,262 @@ function parseNumberOrNull(input) {
   const n = Number(input);
   return Number.isFinite(n) ? n : null;
 }
+var DEFI_PORTFOLIO_TIMEOUT_MS = 4e3;
+var DEFI_CACHE_TTL_MS = 6e4;
+var DEFI_PROTOCOLS = [
+  "cetus",
+  "suilend",
+  "scallop",
+  "bluefin",
+  "aftermath",
+  "haedal"
+];
+var defiCache = /* @__PURE__ */ new Map();
+var defiInflight = /* @__PURE__ */ new Map();
+async function fetchAddressDefiPortfolio(address, apiKey, priceHints = {}) {
+  if (!apiKey || apiKey.trim().length === 0) {
+    return { totalUsd: 0, perProtocol: {}, pricedAt: Date.now(), source: "degraded" };
+  }
+  const now = Date.now();
+  const cached = defiCache.get(address);
+  if (cached && now - cached.ts < DEFI_CACHE_TTL_MS) return cached.data;
+  let inflight = defiInflight.get(address);
+  if (inflight) return inflight;
+  inflight = (async () => {
+    try {
+      const settled = await Promise.allSettled(
+        DEFI_PROTOCOLS.map((p) => fetchOneDefiProtocol(address, p, apiKey))
+      );
+      const seen = /* @__PURE__ */ new Set();
+      for (const s of settled) {
+        if (s.status === "fulfilled" && s.value) collectCoinTypes(s.value, seen);
+      }
+      const normalizedHints = {};
+      for (const [k, v] of Object.entries(priceHints)) {
+        normalizedHints[normalizeCoinType(k)] = v;
+      }
+      const missing = Array.from(seen).filter((ct) => {
+        const norm = normalizeCoinType(ct);
+        return !normalizedHints[norm] && !STABLE_USD_PRICES[norm];
+      });
+      let fetchedPrices = {};
+      if (missing.length > 0) {
+        try {
+          fetchedPrices = await fetchTokenPrices(missing, apiKey);
+        } catch (err) {
+          console.warn("[defi] fill-missing-prices failed:", err);
+        }
+      }
+      const prices = { ...normalizedHints };
+      for (const [ct, v] of Object.entries(fetchedPrices)) {
+        prices[normalizeCoinType(ct)] ??= v.price;
+      }
+      for (const [ct, p] of Object.entries(STABLE_USD_PRICES)) {
+        prices[normalizeCoinType(ct)] ??= p;
+      }
+      let totalUsd = 0;
+      let failures = 0;
+      const perProtocol = {};
+      for (let i = 0; i < DEFI_PROTOCOLS.length; i++) {
+        const proto = DEFI_PROTOCOLS[i];
+        const s = settled[i];
+        if (s.status !== "fulfilled" || !s.value) {
+          failures++;
+          continue;
+        }
+        try {
+          const usd = NORMALIZERS[proto](s.value, prices);
+          if (Number.isFinite(usd) && usd !== 0) {
+            perProtocol[proto] = usd;
+            totalUsd += usd;
+          }
+        } catch (err) {
+          console.warn(`[defi] ${proto} normaliser threw:`, err);
+          failures++;
+        }
+      }
+      if (totalUsd < 0) totalUsd = 0;
+      const summary = {
+        totalUsd,
+        perProtocol,
+        pricedAt: Date.now(),
+        source: failures === DEFI_PROTOCOLS.length ? "degraded" : failures > 0 ? "partial" : "blockvision"
+      };
+      defiCache.set(address, { data: summary, ts: Date.now() });
+      return summary;
+    } finally {
+      defiInflight.delete(address);
+    }
+  })();
+  defiInflight.set(address, inflight);
+  return inflight;
+}
+async function fetchOneDefiProtocol(address, protocol, apiKey) {
+  const url = `${BLOCKVISION_BASE}/account/defiPortfolio?address=${encodeURIComponent(address)}&protocol=${protocol}`;
+  let res;
+  try {
+    res = await fetch(url, {
+      headers: { "x-api-key": apiKey, accept: "application/json" },
+      signal: AbortSignal.timeout(DEFI_PORTFOLIO_TIMEOUT_MS)
+    });
+  } catch (err) {
+    console.warn(`[defi] ${protocol} fetch threw:`, err);
+    return null;
+  }
+  if (!res.ok) {
+    console.warn(`[defi] ${protocol} HTTP ${res.status}`);
+    return null;
+  }
+  let json;
+  try {
+    json = await res.json();
+  } catch (err) {
+    console.warn(`[defi] ${protocol} JSON parse failed:`, err);
+    return null;
+  }
+  if (json.code !== 200 || !json.result) return null;
+  return json.result;
+}
+function collectCoinTypes(obj, out) {
+  if (!obj || typeof obj !== "object") return;
+  if (Array.isArray(obj)) {
+    for (const x of obj) collectCoinTypes(x, out);
+    return;
+  }
+  for (const [k, v] of Object.entries(obj)) {
+    if (typeof v === "string" && v.startsWith("0x") && v.includes("::")) {
+      const lk = k.toLowerCase();
+      if (lk.includes("cointype") || lk === "cointypea" || lk === "cointypeb" || lk === "tokenxtype" || lk === "tokenytype" || lk === "coinaddress" || lk === "phantomtype" || lk === "typename") {
+        out.add(v);
+      }
+    } else if (typeof v === "object" && v !== null) {
+      collectCoinTypes(v, out);
+    }
+  }
+}
+function priceFor(coinType, prices) {
+  const norm = normalizeCoinType(coinType);
+  return prices[norm] ?? prices[coinType] ?? STABLE_USD_PRICES[norm] ?? 0;
+}
+function rawToUsd(coinType, raw, decimalsHint, prices) {
+  if (raw == null) return 0;
+  const decimals = typeof decimalsHint === "number" ? decimalsHint : getDecimalsForCoinType(coinType);
+  const amount = Number(raw) / 10 ** decimals;
+  if (!Number.isFinite(amount)) return 0;
+  return amount * priceFor(coinType, prices);
+}
+var NORMALIZERS = {
+  cetus: normalizeCetus,
+  suilend: normalizeSuilend,
+  scallop: normalizeScallop,
+  bluefin: normalizeBluefin,
+  aftermath: normalizeAftermath,
+  haedal: normalizeHaedal
+};
+function normalizeCetus(result, prices) {
+  const data = result.cetus ?? {};
+  let total = 0;
+  const sumPair = (item, aField, bField) => {
+    if (item.coinTypeA && item[aField] != null) {
+      const dec = item.coinTypeADecimals ?? item.coinA?.decimals;
+      total += rawToUsd(item.coinTypeA, item[aField], dec, prices);
+    }
+    if (item.coinTypeB && item[bField] != null) {
+      const dec = item.coinTypeBDecimals ?? item.coinB?.decimals;
+      total += rawToUsd(item.coinTypeB, item[bField], dec, prices);
+    }
+  };
+  for (const lp of data.lps ?? []) sumPair(lp, "balanceA", "balanceB");
+  for (const farm of data.farms ?? []) sumPair(farm, "balanceA", "balanceB");
+  for (const vault of data.vaults ?? []) sumPair(vault, "coinAAmount", "coinBAmount");
+  return total;
+}
+function normalizeSuilend(result, prices) {
+  const data = result.suilend ?? {};
+  let total = 0;
+  for (const d of data.deposits ?? []) {
+    if (d.coinType && d.amount != null) total += rawToUsd(d.coinType, d.amount, d.decimals, prices);
+  }
+  for (const b of data.borrows ?? []) {
+    if (b.coinType && b.amount != null) total -= rawToUsd(b.coinType, b.amount, b.decimals, prices);
+  }
+  for (const s of data.strategies ?? []) {
+    if (s.coinType && s.amount != null) total += rawToUsd(s.coinType, s.amount, s.decimals, prices);
+  }
+  return total;
+}
+function normalizeScallop(result, _prices) {
+  const s = result.scallop;
+  if (!s) return 0;
+  const supply = Number(s.totalSupplyValue ?? 0);
+  const collateral = Number(s.totalCollateralValue ?? 0);
+  const locked = Number(s.totalLockedScaValue ?? 0);
+  const debt = Number(s.totalDebtValue ?? 0);
+  const net = (Number.isFinite(supply) ? supply : 0) + (Number.isFinite(collateral) ? collateral : 0) + (Number.isFinite(locked) ? locked : 0) - (Number.isFinite(debt) ? debt : 0);
+  return net;
+}
+function normalizeBluefin(result, prices) {
+  const data = result.bluefin ?? {};
+  let total = 0;
+  for (const lp of data.lps ?? []) {
+    if (lp.coinTypeA && lp.coinAmountA != null) {
+      total += rawToUsd(lp.coinTypeA, lp.coinAmountA, void 0, prices);
+    }
+    if (lp.coinTypeB && lp.coinAmountB != null) {
+      total += rawToUsd(lp.coinTypeB, lp.coinAmountB, void 0, prices);
+    }
+  }
+  if (data.usdcVault?.amount != null) {
+    total += rawToUsd(
+      "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
+      data.usdcVault.amount,
+      6,
+      prices
+    );
+  }
+  if (data.blueVault?.amount != null) {
+    total += rawToUsd(
+      "0xe1b45a0e641b9955a20aa0ad1c1f4ad86aad8afb07296d4085e349a50e90bdca::blue::BLUE",
+      data.blueVault.amount,
+      9,
+      prices
+    );
+  }
+  return total;
+}
+function normalizeAftermath(result, prices) {
+  const data = result.aftermath ?? {};
+  let total = 0;
+  const positions = [...data.lpPositions ?? [], ...data.farmPositions ?? []];
+  for (const pos of positions) {
+    for (const c of pos.coins ?? []) {
+      if (c.coinType && c.amount != null) {
+        total += rawToUsd(c.coinType, c.amount, void 0, prices);
+      }
+    }
+  }
+  return total;
+}
+function normalizeHaedal(result, prices) {
+  const SUI_TYPE_FULL = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
+  const data = result.haedal ?? {};
+  let total = 0;
+  for (const lp of data.lps ?? []) {
+    const item = lp;
+    if (item.coinTypeA && item.balanceA != null) {
+      total += rawToUsd(item.coinTypeA, item.balanceA, void 0, prices);
+    }
+    if (item.coinTypeB && item.balanceB != null) {
+      total += rawToUsd(item.coinTypeB, item.balanceB, void 0, prices);
+    }
+  }
+  for (const stake of data.stakings ?? []) {
+    if (stake.sui_amount != null) {
+      total += rawToUsd(SUI_TYPE_FULL, stake.sui_amount, 9, prices);
+    }
+  }
+  return total;
+}
 function clearPortfolioCache() {
   portfolioCache.clear();
   portfolioInflight.clear();
@@ -808,7 +1064,7 @@ var balanceCheckTool = buildTool({
       const address = targetAddress;
       const mgr = getMcpManager(context);
       const hasPositionFetcher = !!context.positionFetcher;
-      const [portfolio, positions, rewards, serverPositions] = await Promise.all([
+      const [portfolio, positions, rewards, serverPositions, defiPortfolio] = await Promise.all([
         loadPortfolio(
           address,
           context.blockvisionApiKey,
@@ -839,7 +1095,22 @@ var balanceCheckTool = buildTool({
         hasPositionFetcher ? context.positionFetcher(address).catch((err) => {
           console.warn("[balance_check] positionFetcher failed:", err);
           return null;
-        }) : Promise.resolve(null)
+        }) : Promise.resolve(null),
+        // [v0.50] DeFi leg — independent of NAVI (excluded) and the wallet
+        // portfolio (which only has coin holdings). Failure here surfaces
+        // as defi.totalUsd === 0 and `source: 'degraded'`, leaving the
+        // rest of balance_check unaffected. The fetcher fills its own
+        // prices via fetchTokenPrices for any coin types it discovers.
+        fetchAddressDefiPortfolio(address, context.blockvisionApiKey).catch((err) => {
+          console.warn("[balance_check] defi fetch failed:", err);
+          const fallback = {
+            totalUsd: 0,
+            perProtocol: {},
+            pricedAt: Date.now(),
+            source: "degraded"
+          };
+          return fallback;
+        })
       ]);
       await applyVsuiPriceFallback(portfolio);
       let availableUsd = 0;
@@ -886,13 +1157,17 @@ var balanceCheckTool = buildTool({
       const visibleHoldings = holdings.filter((h) => h.usdValue >= 0.01).sort((a, b) => b.usdValue - a.usdValue);
       const usdcHolding2 = holdings.find((h) => h.symbol === "USDC");
       const saveableUsdc = usdcHolding2 ? usdcHolding2.balance : 0;
+      const defi2 = defiPortfolio;
       const bal = {
         available: availableUsd,
         savings,
         debt,
         pendingRewards: pendingRewardsUsd,
         gasReserve: gasReserveUsd2,
-        total: availableUsd + savings + gasReserveUsd2 + pendingRewardsUsd - debt,
+        defi: defi2.totalUsd,
+        defiByProtocol: defi2.perProtocol,
+        defiSource: defi2.source,
+        total: availableUsd + savings + gasReserveUsd2 + pendingRewardsUsd + defi2.totalUsd - debt,
         stables: stablesUsd,
         holdings: visibleHoldings,
         saveableUsdc,
@@ -902,9 +1177,10 @@ var balanceCheckTool = buildTool({
       };
       const holdingsList = visibleHoldings.map((h) => `${h.symbol}: ${h.balance < 1 ? h.balance.toFixed(6) : h.balance.toFixed(2)} ($${h.usdValue.toFixed(2)})`).join(", ");
       const subjectPrefix = isSelfQuery ? "Balance" : `Balance for ${address.slice(0, 6)}\u2026${address.slice(-4)}`;
+      const defiSummaryText = defi2.totalUsd > 0 ? ` Other DeFi positions (LPs/staking/lending across ${Object.keys(defi2.perProtocol).join("/")}): $${defi2.totalUsd.toFixed(2)}.` : "";
       return {
         data: bal,
-        displayText: `${subjectPrefix}: $${bal.total.toFixed(2)} total. Wallet holdings (NOT savings): ${holdingsList || "none"}. NAVI savings deposits: $${bal.savings.toFixed(2)}. Saveable USDC (only USDC can be saved): ${saveableUsdc.toFixed(2)} USDC.`
+        displayText: `${subjectPrefix}: $${bal.total.toFixed(2)} total. Wallet holdings (NOT savings): ${holdingsList || "none"}. NAVI savings deposits: $${bal.savings.toFixed(2)}.${defiSummaryText} Saveable USDC (only USDC can be saved): ${saveableUsdc.toFixed(2)} USDC.`
       };
     }
     if (input.address && context.walletAddress && input.address.toLowerCase() !== context.walletAddress.toLowerCase()) {
@@ -913,13 +1189,28 @@ var balanceCheckTool = buildTool({
       );
     }
     const agent = requireAgent(context);
-    const balance = await agent.balance();
+    const fetchAddress = targetAddress ?? context.walletAddress;
+    const [balance, defi] = await Promise.all([
+      agent.balance(),
+      fetchAddressDefiPortfolio(fetchAddress, context.blockvisionApiKey).catch((err) => {
+        console.warn("[balance_check] sdk-path defi fetch failed:", err);
+        const fallback = {
+          totalUsd: 0,
+          perProtocol: {},
+          pricedAt: Date.now(),
+          source: "degraded"
+        };
+        return fallback;
+      })
+    ]);
     const gasReserveUsd = typeof balance.gasReserve === "number" ? balance.gasReserve : balance.gasReserve.usdEquiv ?? 0;
     const stablesTotal = typeof balance.stables === "number" ? balance.stables : Object.values(balance.stables).reduce((a, b) => a + b, 0);
     const sdkHoldings = balance.holdings;
     const holdingsArr = Array.isArray(sdkHoldings) ? sdkHoldings : [];
     const usdcHolding = holdingsArr.find((h) => h.symbol === "USDC");
     const sdkSaveableUsdc = usdcHolding ? usdcHolding.balance ?? 0 : 0;
+    const sdkDefiSummaryText = defi.totalUsd > 0 ? ` Other DeFi positions (LPs/staking/lending across ${Object.keys(defi.perProtocol).join("/")}): $${defi.totalUsd.toFixed(2)}.` : "";
+    const sdkTotal = balance.total + defi.totalUsd;
     return {
       data: {
         available: balance.available,
@@ -927,14 +1218,17 @@ var balanceCheckTool = buildTool({
         debt: balance.debt,
         pendingRewards: balance.pendingRewards,
         gasReserve: gasReserveUsd,
-        total: balance.total,
+        defi: defi.totalUsd,
+        defiByProtocol: defi.perProtocol,
+        defiSource: defi.source,
+        total: sdkTotal,
         stables: stablesTotal,
         holdings: holdingsArr,
         saveableUsdc: sdkSaveableUsdc,
         address: targetAddress ?? "",
         isSelfQuery: true
       },
-      displayText: `Balance: $${balance.total.toFixed(2)} total. Wallet: $${balance.available.toFixed(2)} available. NAVI savings deposits: $${balance.savings.toFixed(2)}. Saveable USDC (only USDC can be saved): ${sdkSaveableUsdc.toFixed(2)} USDC.`
+      displayText: `Balance: $${sdkTotal.toFixed(2)} total. Wallet: $${balance.available.toFixed(2)} available. NAVI savings deposits: $${balance.savings.toFixed(2)}.${sdkDefiSummaryText} Saveable USDC (only USDC can be saved): ${sdkSaveableUsdc.toFixed(2)} USDC.`
     };
   }
 });
@@ -1576,7 +1870,7 @@ var transactionHistoryTool = buildTool({
     const targetAddress = input.address ?? context.walletAddress;
     const isSelfQuery = !!targetAddress && !!context.walletAddress && targetAddress.toLowerCase() === context.walletAddress.toLowerCase();
     const prices = context.tokenPrices;
-    const priceFor = (sym) => {
+    const priceFor2 = (sym) => {
       if (!sym || !prices) return void 0;
       return prices[sym.toUpperCase()] ?? prices[sym.toLowerCase()] ?? prices[sym];
     };
@@ -1597,8 +1891,8 @@ var transactionHistoryTool = buildTool({
           if (r.amount == null) return false;
           const sym = r.asset?.toUpperCase() ?? "";
           const isStableLike = sym === "USDC" || sym === "USDT" || sym === "WUSDC" || sym === "WUSDT" || sym === "SUIUSDT" || sym === "USDY" || sym === "USDSUI" || sym === "USDE" || sym === "AUSD" || sym === "FDUSD" || sym === "BUCK";
-          const usd = isStableLike ? r.amount : (priceFor(sym) ?? 0) * r.amount;
-          if (!isStableLike && priceFor(sym) == null) return true;
+          const usd = isStableLike ? r.amount : (priceFor2(sym) ?? 0) * r.amount;
+          if (!isStableLike && priceFor2(sym) == null) return true;
           return usd >= minUsd;
         });
       }