@t2000/engine 0.50.0 → 0.50.1

package/dist/index.d.ts

@@ -1963,7 +1963,7 @@ declare const balanceCheckTool: Tool<{
     pendingRewards: number;
     gasReserve: number;
     defi: number;
-    defiByProtocol: Partial<Record<"cetus" | "suilend" | "scallop" | "bluefin" | "aftermath" | "haedal", 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;

package/dist/index.js

@@ -714,13 +714,39 @@ function parseNumberOrNull(input) {
 var DEFI_PORTFOLIO_TIMEOUT_MS = 4e3;
 var DEFI_CACHE_TTL_MS = 6e4;
 var DEFI_PROTOCOLS = [
+  "aftermath",
+  "alphafi",
+  "alphalend",
+  "bluefin",
+  "bluemove",
+  "bucket",
+  "bucket2",
   "cetus",
-  "suilend",
+  "deepbook",
+  "ember",
+  "ferra",
+  "flowx",
+  "haedal",
+  "kai",
+  "kriya",
+  "magma",
+  "momentum",
+  "r25",
   "scallop",
-  "bluefin",
-  "aftermath",
-  "haedal"
+  "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 = {}) {
@@ -775,7 +801,7 @@ async function fetchAddressDefiPortfolio(address, apiKey, priceHints = {}) {
           continue;
         }
         try {
-          const usd = NORMALIZERS[proto](s.value, prices);
+          const usd = normalizeProtocol(proto, s.value, prices);
           if (Number.isFinite(usd) && usd !== 0) {
             perProtocol[proto] = usd;
             totalUsd += usd;
@@ -827,6 +853,166 @@ async function fetchOneDefiProtocol(address, protocol, apiKey) {
   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)) {
@@ -834,139 +1020,108 @@ function collectCoinTypes(obj, out) {
     return;
   }
   for (const [k, v] of Object.entries(obj)) {
-    if (typeof v === "string" && v.startsWith("0x") && v.includes("::")) {
+    if (typeof v === "string" && isCoinTypeString(v)) {
       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);
+      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 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);
+      total += toUsd(lp.coinTypeA, lp.coinAmountA, void 0, prices);
     }
     if (lp.coinTypeB && lp.coinAmountB != null) {
-      total += rawToUsd(lp.coinTypeB, lp.coinAmountB, void 0, prices);
+      total += toUsd(lp.coinTypeB, lp.coinAmountB, void 0, prices);
     }
   }
   if (data.usdcVault?.amount != null) {
-    total += rawToUsd(
-      "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
-      data.usdcVault.amount,
-      6,
-      prices
-    );
+    total += toUsd(USDC_TYPE_FULL, 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);
-      }
-    }
+    total += toUsd(BLUE_TYPE_FULL, data.blueVault.amount, 9, 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 (lp.coinTypeA && lp.balanceA != null) {
+      total += toUsd(lp.coinTypeA, lp.balanceA, void 0, prices);
     }
-    if (item.coinTypeB && item.balanceB != null) {
-      total += rawToUsd(item.coinTypeB, item.balanceB, 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 += rawToUsd(SUI_TYPE_FULL, stake.sui_amount, 9, prices);
+      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();