@t2000/engine 0.49.0 → 0.50.1

package/dist/index.d.ts

@@ -1962,6 +1962,9 @@ declare const balanceCheckTool: Tool<{
     debt: number;
     pendingRewards: number;
     gasReserve: number;
+    defi: number;
+    defiByProtocol: Partial<Record<"aftermath" | "alphafi" | "alphalend" | "bluefin" | "bluemove" | "bucket" | "bucket2" | "cetus" | "deepbook" | "ember" | "ferra" | "flowx" | "haedal" | "kai" | "kriya" | "magma" | "momentum" | "r25" | "scallop" | "steamm" | "suilend" | "suins-staking" | "suistake" | "turbos" | "typus" | "unihouse" | "walrus", number>>;
+    defiSource: "blockvision" | "partial" | "degraded";
     total: number;
     stables: number;
     holdings: any[];

package/dist/index.js

@@ -711,6 +711,417 @@ 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 = [
+  "aftermath",
+  "alphafi",
+  "alphalend",
+  "bluefin",
+  "bluemove",
+  "bucket",
+  "bucket2",
+  "cetus",
+  "deepbook",
+  "ember",
+  "ferra",
+  "flowx",
+  "haedal",
+  "kai",
+  "kriya",
+  "magma",
+  "momentum",
+  "r25",
+  "scallop",
+  "steamm",
+  "suilend",
+  "suins-staking",
+  "suistake",
+  "turbos",
+  "typus",
+  "unihouse",
+  "walrus"
+];
+var SUI_TYPE_FULL = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
+var USDC_TYPE_FULL = "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC";
+var BLUE_TYPE_FULL = "0xe1b45a0e641b9955a20aa0ad1c1f4ad86aad8afb07296d4085e349a50e90bdca::blue::BLUE";
+var WAL_TYPE_FULL = "0x356a26eb9e012a68958082340d4c4116e7f55615cf27affcff209cf0ae544f59::wal::WAL";
+var NS_TYPE_FULL = "0x5145494a5f5100e645e4b0aa950fa6b68f614e8c59e17bc5ded3495123a79178::ns::NS";
+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 = normalizeProtocol(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;
+}
+var PAIR_A_COIN_KEYS = ["coinTypeA", "coinTypeX", "tokenXType"];
+var PAIR_B_COIN_KEYS = ["coinTypeB", "coinTypeY", "tokenYType"];
+var PAIR_A_AMOUNT_KEYS = [
+  "balanceA",
+  "amountA",
+  "coinAmountA",
+  "coinAAmount",
+  "coinTypeAAmount",
+  "tokenXBalance",
+  "tokenXAmount",
+  "amountX",
+  "valueA"
+];
+var PAIR_B_AMOUNT_KEYS = [
+  "balanceB",
+  "amountB",
+  "coinAmountB",
+  "coinBAmount",
+  "coinTypeBAmount",
+  "tokenYBalance",
+  "tokenYAmount",
+  "amountY",
+  "valueB"
+];
+var PAIR_A_DECIMALS_KEYS = ["coinTypeADecimals", "tokenXDecimals", "decimalsA"];
+var PAIR_B_DECIMALS_KEYS = ["coinTypeBDecimals", "tokenYDecimals", "decimalsB"];
+var SINGLE_COIN_KEYS = ["coinType", "depositToken", "token"];
+var SINGLE_AMOUNT_KEYS = ["amount", "balance", "value", "equity"];
+var SINGLE_DECIMALS_KEYS = ["decimals", "decimal", "coinDecimals"];
+var DEBT_KEYS = /* @__PURE__ */ new Set([
+  "borrow",
+  "borrows",
+  "debt",
+  "debts",
+  "borrowings",
+  "borrowedpools"
+]);
+var SKIP_KEYS = /* @__PURE__ */ new Set([
+  "rewards",
+  "reward",
+  "fees",
+  "fee",
+  "pendingrewards",
+  "incentiveinfos",
+  "feereward",
+  "incentivereward"
+]);
+function isCoinTypeString(v) {
+  if (typeof v !== "string" || !v.includes("::")) return false;
+  return v.startsWith("0x") || /^[0-9a-fA-F]/.test(v);
+}
+function ensure0xPrefix(coinType) {
+  return coinType.startsWith("0x") ? coinType : "0x" + coinType;
+}
+function isAmountValue(v) {
+  return typeof v === "string" && v.trim().length > 0 || typeof v === "number" && Number.isFinite(v);
+}
+function isFiniteNumber(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+function pickField(obj, keys, predicate) {
+  for (const k of keys) {
+    const v = obj[k];
+    if (predicate(v)) return v;
+  }
+  return void 0;
+}
+function nestedDecimals(node) {
+  if (!node || typeof node !== "object") return void 0;
+  const obj = node;
+  if (typeof obj.decimals === "number") return obj.decimals;
+  return void 0;
+}
+function toHumanQuantity(raw, decimalsHint) {
+  if (typeof raw === "number") {
+    if (!Number.isFinite(raw)) return 0;
+    if (!Number.isInteger(raw)) return raw;
+    if (decimalsHint != null) return raw / 10 ** decimalsHint;
+    return raw;
+  }
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return 0;
+  if (trimmed.includes(".") || trimmed.includes("e") || trimmed.includes("E")) {
+    const n2 = Number(trimmed);
+    return Number.isFinite(n2) ? n2 : 0;
+  }
+  const n = Number(trimmed);
+  if (!Number.isFinite(n)) return 0;
+  const dec = decimalsHint ?? 9;
+  return n / 10 ** dec;
+}
+function priceFor(coinType, prices) {
+  const prefixed = ensure0xPrefix(coinType);
+  const norm = normalizeCoinType(prefixed);
+  return prices[norm] ?? prices[prefixed] ?? prices[coinType] ?? STABLE_USD_PRICES[norm] ?? 0;
+}
+function toUsd(coinType, raw, decimalsHint, prices) {
+  if (raw == null || typeof raw !== "string" && typeof raw !== "number") return 0;
+  if (typeof raw === "string" && raw.trim().length === 0) return 0;
+  const prefixed = ensure0xPrefix(coinType);
+  const decimals = typeof decimalsHint === "number" ? decimalsHint : getDecimalsForCoinType(prefixed);
+  const human = toHumanQuantity(raw, decimals);
+  if (!Number.isFinite(human)) return 0;
+  return human * priceFor(prefixed, prices);
+}
+function extractPair(obj) {
+  const coinTypeA = pickField(obj, PAIR_A_COIN_KEYS, isCoinTypeString);
+  const coinTypeB = pickField(obj, PAIR_B_COIN_KEYS, isCoinTypeString);
+  if (!coinTypeA || !coinTypeB) return null;
+  const amountA = pickField(obj, PAIR_A_AMOUNT_KEYS, isAmountValue);
+  const amountB = pickField(obj, PAIR_B_AMOUNT_KEYS, isAmountValue);
+  if (amountA == null || amountB == null) return null;
+  const decimalsA = pickField(obj, PAIR_A_DECIMALS_KEYS, isFiniteNumber) ?? nestedDecimals(obj.coinA);
+  const decimalsB = pickField(obj, PAIR_B_DECIMALS_KEYS, isFiniteNumber) ?? nestedDecimals(obj.coinB);
+  return { coinTypeA, amountA, decimalsA, coinTypeB, amountB, decimalsB };
+}
+function extractSingle(obj) {
+  const coinType = pickField(obj, SINGLE_COIN_KEYS, isCoinTypeString);
+  if (!coinType) return null;
+  const amount = pickField(obj, SINGLE_AMOUNT_KEYS, isAmountValue);
+  if (amount == null) return null;
+  const decimals = pickField(obj, SINGLE_DECIMALS_KEYS, isFiniteNumber);
+  const isBorrow = obj.type === "Borrow";
+  return { coinType, amount, decimals, isBorrow };
+}
+function walkProtocolResponse(result, prices) {
+  let total = 0;
+  walk(result, false);
+  return total;
+  function walk(node, debtSide) {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      for (const item of node) walk(item, debtSide);
+      return;
+    }
+    const obj = node;
+    if (typeof obj.totalSupplyValue === "number") total += obj.totalSupplyValue;
+    if (typeof obj.totalCollateralValue === "number") total += obj.totalCollateralValue;
+    if (typeof obj.totalLockedScaValue === "number") total += obj.totalLockedScaValue;
+    if (typeof obj.totalDebtValue === "number") total -= obj.totalDebtValue;
+    const pair = extractPair(obj);
+    if (pair) {
+      const a = toUsd(pair.coinTypeA, pair.amountA, pair.decimalsA, prices);
+      const b = toUsd(pair.coinTypeB, pair.amountB, pair.decimalsB, prices);
+      total += debtSide ? -(a + b) : a + b;
+    } else {
+      const single = extractSingle(obj);
+      if (single) {
+        const usd = toUsd(single.coinType, single.amount, single.decimals, prices);
+        total += debtSide || single.isBorrow ? -usd : usd;
+      }
+    }
+    for (const [k, v] of Object.entries(obj)) {
+      const lk = k.toLowerCase();
+      if (SKIP_KEYS.has(lk)) continue;
+      const childDebt = debtSide || DEBT_KEYS.has(lk);
+      walk(v, childDebt);
+    }
+  }
+}
+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" && isCoinTypeString(v)) {
+      const lk = k.toLowerCase();
+      if (lk.includes("cointype") || lk === "tokenxtype" || lk === "tokenytype" || lk === "deposittoken" || lk === "rewardstoken" || lk === "token" || lk === "coinaddress" || lk === "phantomtype" || lk === "typename") {
+        out.add(ensure0xPrefix(v));
+      }
+    } else if (typeof v === "object" && v !== null) {
+      collectCoinTypes(v, out);
+    }
+  }
+}
+function normalizeBluefin(result, prices) {
+  const data = result.bluefin ?? {};
+  let total = 0;
+  for (const lp of data.lps ?? []) {
+    if (lp.coinTypeA && lp.coinAmountA != null) {
+      total += toUsd(lp.coinTypeA, lp.coinAmountA, void 0, prices);
+    }
+    if (lp.coinTypeB && lp.coinAmountB != null) {
+      total += toUsd(lp.coinTypeB, lp.coinAmountB, void 0, prices);
+    }
+  }
+  if (data.usdcVault?.amount != null) {
+    total += toUsd(USDC_TYPE_FULL, data.usdcVault.amount, 6, prices);
+  }
+  if (data.blueVault?.amount != null) {
+    total += toUsd(BLUE_TYPE_FULL, data.blueVault.amount, 9, prices);
+  }
+  return total;
+}
+function normalizeHaedal(result, prices) {
+  const data = result.haedal ?? {};
+  let total = 0;
+  for (const lp of data.lps ?? []) {
+    if (lp.coinTypeA && lp.balanceA != null) {
+      total += toUsd(lp.coinTypeA, lp.balanceA, void 0, prices);
+    }
+    if (lp.coinTypeB && lp.balanceB != null) {
+      total += toUsd(lp.coinTypeB, lp.balanceB, void 0, prices);
+    }
+  }
+  for (const stake of data.stakings ?? []) {
+    if (stake.sui_amount != null) {
+      total += toUsd(SUI_TYPE_FULL, stake.sui_amount, 9, prices);
+    }
+  }
+  return total;
+}
+function normalizeKai(result, prices) {
+  const data = result.kai ?? {};
+  let total = 0;
+  for (const v of data.vaults ?? []) {
+    const coinType = v.coin?.p?.phantomType ?? v.coin?.p?.typeName;
+    if (coinType && v.equity != null) {
+      total += toUsd(coinType, v.equity, v.coin?.decimals, prices);
+    }
+  }
+  for (const lp of data.lpVaults ?? []) {
+    const coinTypeA = lp.coinA?.p?.phantomType ?? lp.coinA?.p?.typeName;
+    const coinTypeB = lp.coinB?.p?.phantomType ?? lp.coinB?.p?.typeName;
+    if (coinTypeA && lp.balanceA != null) {
+      total += toUsd(coinTypeA, lp.balanceA, lp.coinA?.decimals, prices);
+    }
+    if (coinTypeB && lp.balanceB != null) {
+      total += toUsd(coinTypeB, lp.balanceB, lp.coinB?.decimals, prices);
+    }
+  }
+  return total;
+}
+function sumBareStakings(data, impliedCoinType, decimals, prices) {
+  if (!data) return 0;
+  let total = 0;
+  for (const s of data.stakings ?? []) {
+    const amt = s.sui_amount ?? s.amount;
+    if (amt != null) total += toUsd(impliedCoinType, amt, decimals, prices);
+  }
+  return total;
+}
+function normalizeSuistake(result, prices) {
+  const data = result.suistake;
+  return sumBareStakings(data, SUI_TYPE_FULL, 9, prices);
+}
+function normalizeWalrus(result, prices) {
+  const data = result.walrus;
+  return sumBareStakings(data, WAL_TYPE_FULL, 9, prices);
+}
+function normalizeSuinsStaking(result, prices) {
+  const data = result["suins-staking"] ?? result.suinsStaking ?? result.suins_staking;
+  return sumBareStakings(data, NS_TYPE_FULL, 6, prices);
+}
+var BESPOKE_NORMALIZERS = {
+  bluefin: normalizeBluefin,
+  haedal: normalizeHaedal,
+  kai: normalizeKai,
+  suistake: normalizeSuistake,
+  walrus: normalizeWalrus,
+  "suins-staking": normalizeSuinsStaking
+};
+function normalizeProtocol(protocol, result, prices) {
+  const bespoke = BESPOKE_NORMALIZERS[protocol];
+  if (bespoke) return bespoke(result, prices);
+  return walkProtocolResponse(result, prices);
+}
 function clearPortfolioCache() {
   portfolioCache.clear();
   portfolioInflight.clear();
@@ -808,7 +1219,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 +1250,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 +1312,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 +1332,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 +1344,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 +1373,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 +2025,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 +2046,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;
         });
       }