@t2000/sdk 0.7.2 → 0.8.0

package/dist/index.cjs

@@ -31,14 +31,35 @@ var SUPPORTED_ASSETS = {
   USDC: {
     type: "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
     decimals: 6,
-    symbol: "USDC"
+    symbol: "USDC",
+    displayName: "USDC"
+  },
+  USDT: {
+    type: "0x375f70cf2ae4c00bf37117d0c85a2c71545e6ee05c4a5c7d282cd66a4504b068::usdt::USDT",
+    decimals: 6,
+    symbol: "USDT",
+    displayName: "suiUSDT"
+  },
+  USDe: {
+    type: "0x41d587e5336f1c86cad50d38a7136db99333bb9bda91cea4ba69115defeb1402::sui_usde::SUI_USDE",
+    decimals: 6,
+    symbol: "USDe",
+    displayName: "suiUSDe"
+  },
+  USDsui: {
+    type: "0x44f838219cf67b058f3b37907b655f226153c18e33dfcd0da559a844fea9b1c1::usdsui::USDSUI",
+    decimals: 6,
+    symbol: "USDsui",
+    displayName: "USDsui"
   },
   SUI: {
     type: "0x2::sui::SUI",
     decimals: 9,
-    symbol: "SUI"
+    symbol: "SUI",
+    displayName: "SUI"
   }
 };
+var STABLE_ASSETS = ["USDC", "USDT", "USDe", "USDsui"];
 var T2000_PACKAGE_ID = process.env.T2000_PACKAGE_ID ?? "0xab92e9f1fe549ad3d6a52924a73181b45791e76120b975138fac9ec9b75db9f3";
 var T2000_CONFIG_ID = process.env.T2000_CONFIG_ID ?? "0x408add9aa9322f93cfd87523d8f603006eb8713894f4c460283c58a6888dae8a";
 var T2000_TREASURY_ID = process.env.T2000_TREASURY_ID ?? "0x3bb501b8300125dca59019247941a42af6b292a150ce3cfcce9449456be2ec91";
@@ -238,6 +259,15 @@ function usdcToRaw(amount) {
 function rawToUsdc(raw) {
   return Number(raw) / 10 ** USDC_DECIMALS;
 }
+function stableToRaw(amount, decimals) {
+  return BigInt(Math.round(amount * 10 ** decimals));
+}
+function rawToStable(raw, decimals) {
+  return Number(raw) / 10 ** decimals;
+}
+function getDecimals(asset) {
+  return SUPPORTED_ASSETS[asset].decimals;
+}
 function displayToRaw(amount, decimals) {
   return BigInt(Math.round(amount * 10 ** decimals));
 }
@@ -248,6 +278,12 @@ function formatSui(amount) {
   if (amount < 1e-3) return `${amount.toFixed(6)} SUI`;
   return `${amount.toFixed(3)} SUI`;
 }
+var ASSET_LOOKUP = new Map(
+  Object.keys(SUPPORTED_ASSETS).map((k) => [k.toUpperCase(), k])
+);
+function normalizeAsset(input) {
+  return ASSET_LOOKUP.get(input.toUpperCase()) ?? input;
+}
 
 // src/wallet/send.ts
 async function buildSendTx({
@@ -320,26 +356,35 @@ async function fetchSuiPrice(client) {
   return _cachedSuiPrice;
 }
 async function queryBalance(client, address) {
-  const [usdcBalance, suiBalance, suiPriceUsd] = await Promise.all([
-    client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.USDC.type }),
+  const stableBalancePromises = STABLE_ASSETS.map(
+    (asset) => client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS[asset].type }).then((b) => ({ asset, amount: Number(b.totalBalance) / 10 ** SUPPORTED_ASSETS[asset].decimals }))
+  );
+  const [suiBalance, suiPriceUsd, ...stableResults] = await Promise.all([
     client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.SUI.type }),
-    fetchSuiPrice(client)
+    fetchSuiPrice(client),
+    ...stableBalancePromises
   ]);
-  const usdcAmount = Number(usdcBalance.totalBalance) / 10 ** SUPPORTED_ASSETS.USDC.decimals;
+  const stables = {};
+  let totalStables = 0;
+  for (const { asset, amount } of stableResults) {
+    stables[asset] = amount;
+    totalStables += amount;
+  }
   const suiAmount = Number(suiBalance.totalBalance) / Number(MIST_PER_SUI);
   const savings = 0;
   const usdEquiv = suiAmount * suiPriceUsd;
-  const total = usdcAmount + savings + usdEquiv;
+  const total = totalStables + savings + usdEquiv;
   return {
-    available: usdcAmount,
+    available: totalStables,
     savings,
     gasReserve: {
       sui: suiAmount,
       usdEquiv
     },
     total,
+    stables,
     assets: {
-      USDC: usdcAmount,
+      USDC: stables.USDC ?? 0,
       SUI: suiAmount
     }
   };
@@ -427,7 +472,7 @@ async function reportFee(agentAddress, operation, feeAmount, feeRate, txDigest)
   } catch {
   }
 }
-var USDC_TYPE = SUPPORTED_ASSETS.USDC.type;
+SUPPORTED_ASSETS.USDC.type;
 var RATE_DECIMALS = 27;
 var LTV_DECIMALS = 27;
 var MIN_HEALTH_FACTOR = 1.5;
@@ -488,13 +533,24 @@ async function getPools(fresh = false) {
   poolsCache = { data, ts: Date.now() };
   return data;
 }
-async function getUsdcPool() {
+function matchesCoinType(poolType, targetType) {
+  const poolSuffix = poolType.split("::").slice(1).join("::").toLowerCase();
+  const targetSuffix = targetType.split("::").slice(1).join("::").toLowerCase();
+  return poolSuffix === targetSuffix;
+}
+async function getPool(asset = "USDC") {
   const pools = await getPools();
-  const usdc = pools.find(
-    (p) => p.token?.symbol === "USDC" || p.coinType?.toLowerCase().includes("usdc")
+  const targetType = SUPPORTED_ASSETS[asset].type;
+  const pool = pools.find(
+    (p) => matchesCoinType(p.suiCoinType || p.coinType || "", targetType)
   );
-  if (!usdc) throw new T2000Error("PROTOCOL_UNAVAILABLE", "USDC pool not found on NAVI");
-  return usdc;
+  if (!pool) {
+    throw new T2000Error(
+      "ASSET_NOT_SUPPORTED",
+      `${SUPPORTED_ASSETS[asset].displayName} pool not found on NAVI. Try: ${STABLE_ASSETS.filter((a) => a !== asset).join(", ")}`
+    );
+  }
+  return pool;
 }
 function addOracleUpdate(tx, config, pool) {
   const feed = config.oracle.feeds?.find((f2) => f2.assetId === pool.id);
@@ -582,10 +638,12 @@ async function buildSaveTx(client, address, amount, options = {}) {
   if (!amount || amount <= 0 || !Number.isFinite(amount)) {
     throw new T2000Error("INVALID_AMOUNT", "Save amount must be a positive number");
   }
-  const rawAmount = Number(usdcToRaw(amount));
-  const [config, pool] = await Promise.all([getConfig(), getUsdcPool()]);
-  const coins = await fetchCoins(client, address, USDC_TYPE);
-  if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins found");
+  const asset = options.asset ?? "USDC";
+  const assetInfo = SUPPORTED_ASSETS[asset];
+  const rawAmount = Number(stableToRaw(amount, assetInfo.decimals));
+  const [config, pool] = await Promise.all([getConfig(), getPool(asset)]);
+  const coins = await fetchCoins(client, address, assetInfo.type);
+  if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} coins found`);
   const tx = new transactions.Transaction();
   tx.setSender(address);
   const coinObj = mergeCoins(tx, coins);
@@ -608,18 +666,20 @@ async function buildSaveTx(client, address, amount, options = {}) {
   });
   return tx;
 }
-async function buildWithdrawTx(client, address, amount) {
+async function buildWithdrawTx(client, address, amount, options = {}) {
+  const asset = options.asset ?? "USDC";
+  const assetInfo = SUPPORTED_ASSETS[asset];
   const [config, pool, pools, states] = await Promise.all([
     getConfig(),
-    getUsdcPool(),
+    getPool(asset),
     getPools(),
     getUserState(client, address)
   ]);
-  const usdcState = states.find((s) => s.assetId === pool.id);
-  const deposited = usdcState ? compoundBalance(usdcState.supplyBalance, pool.currentSupplyIndex) : 0;
+  const assetState = states.find((s) => s.assetId === pool.id);
+  const deposited = assetState ? compoundBalance(assetState.supplyBalance, pool.currentSupplyIndex) : 0;
   const effectiveAmount = Math.min(amount, Math.max(0, deposited - WITHDRAW_DUST_BUFFER));
-  if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", "Nothing to withdraw");
-  const rawAmount = Number(usdcToRaw(effectiveAmount));
+  if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", `Nothing to withdraw for ${assetInfo.displayName} on NAVI`);
+  const rawAmount = Number(stableToRaw(effectiveAmount, assetInfo.decimals));
   const tx = new transactions.Transaction();
   tx.setSender(address);
   addOracleUpdate(tx, config, pool);
@@ -650,8 +710,10 @@ async function buildBorrowTx(client, address, amount, options = {}) {
   if (!amount || amount <= 0 || !Number.isFinite(amount)) {
     throw new T2000Error("INVALID_AMOUNT", "Borrow amount must be a positive number");
   }
-  const rawAmount = Number(usdcToRaw(amount));
-  const [config, pool] = await Promise.all([getConfig(), getUsdcPool()]);
+  const asset = options.asset ?? "USDC";
+  const assetInfo = SUPPORTED_ASSETS[asset];
+  const rawAmount = Number(stableToRaw(amount, assetInfo.decimals));
+  const [config, pool] = await Promise.all([getConfig(), getPool(asset)]);
   const tx = new transactions.Transaction();
   tx.setSender(address);
   addOracleUpdate(tx, config, pool);
@@ -681,14 +743,16 @@ async function buildBorrowTx(client, address, amount, options = {}) {
   tx.transferObjects([borrowedCoin], address);
   return tx;
 }
-async function buildRepayTx(client, address, amount) {
+async function buildRepayTx(client, address, amount, options = {}) {
   if (!amount || amount <= 0 || !Number.isFinite(amount)) {
     throw new T2000Error("INVALID_AMOUNT", "Repay amount must be a positive number");
   }
-  const rawAmount = Number(usdcToRaw(amount));
-  const [config, pool] = await Promise.all([getConfig(), getUsdcPool()]);
-  const coins = await fetchCoins(client, address, USDC_TYPE);
-  if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins to repay with");
+  const asset = options.asset ?? "USDC";
+  const assetInfo = SUPPORTED_ASSETS[asset];
+  const rawAmount = Number(stableToRaw(amount, assetInfo.decimals));
+  const [config, pool] = await Promise.all([getConfig(), getPool(asset)]);
+  const coins = await fetchCoins(client, address, assetInfo.type);
+  if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} coins to repay with`);
   const tx = new transactions.Transaction();
   tx.setSender(address);
   addOracleUpdate(tx, config, pool);
@@ -712,21 +776,36 @@ async function buildRepayTx(client, address, amount) {
 }
 async function getHealthFactor(client, addressOrKeypair) {
   const address = typeof addressOrKeypair === "string" ? addressOrKeypair : addressOrKeypair.getPublicKey().toSuiAddress();
-  const [config, pool, states] = await Promise.all([
+  const [config, pools, states] = await Promise.all([
     getConfig(),
-    getUsdcPool(),
+    getPools(),
     getUserState(client, address)
   ]);
-  const usdcState = states.find((s) => s.assetId === pool.id);
-  const supplied = usdcState ? compoundBalance(usdcState.supplyBalance, pool.currentSupplyIndex) : 0;
-  const borrowed = usdcState ? compoundBalance(usdcState.borrowBalance, pool.currentBorrowIndex) : 0;
-  const ltv = parseLtv(pool.ltv);
-  const liqThreshold = parseLiqThreshold(pool.liquidationFactor.threshold);
+  let supplied = 0;
+  let borrowed = 0;
+  let weightedLtv = 0;
+  let weightedLiqThreshold = 0;
+  for (const state of states) {
+    const pool = pools.find((p) => p.id === state.assetId);
+    if (!pool) continue;
+    const supplyBal = compoundBalance(state.supplyBalance, pool.currentSupplyIndex);
+    const borrowBal = compoundBalance(state.borrowBalance, pool.currentBorrowIndex);
+    const price = pool.token?.price ?? 1;
+    supplied += supplyBal * price;
+    borrowed += borrowBal * price;
+    if (supplyBal > 0) {
+      weightedLtv += supplyBal * price * parseLtv(pool.ltv);
+      weightedLiqThreshold += supplyBal * price * parseLiqThreshold(pool.liquidationFactor.threshold);
+    }
+  }
+  const ltv = supplied > 0 ? weightedLtv / supplied : 0.75;
+  const liqThreshold = supplied > 0 ? weightedLiqThreshold / supplied : 0.75;
   const maxBorrowVal = Math.max(0, supplied * ltv - borrowed);
+  const usdcPool = pools.find((p) => matchesCoinType(p.suiCoinType || p.coinType || "", SUPPORTED_ASSETS.USDC.type));
   let healthFactor;
   if (borrowed <= 0) {
     healthFactor = Infinity;
-  } else {
+  } else if (usdcPool) {
     try {
       const tx = new transactions.Transaction();
       tx.moveCall({
@@ -735,14 +814,14 @@ async function getHealthFactor(client, addressOrKeypair) {
           tx.object(CLOCK),
           tx.object(config.storage),
           tx.object(config.oracle.priceOracle),
-          tx.pure.u8(pool.id),
+          tx.pure.u8(usdcPool.id),
           tx.pure.address(address),
-          tx.pure.u8(pool.id),
+          tx.pure.u8(usdcPool.id),
           tx.pure.u64(0),
           tx.pure.u64(0),
           tx.pure.bool(false)
         ],
-        typeArguments: [pool.suiCoinType]
+        typeArguments: [usdcPool.suiCoinType]
       });
       const result = await client.devInspectTransactionBlock({
         transactionBlock: tx,
@@ -752,11 +831,13 @@ async function getHealthFactor(client, addressOrKeypair) {
       if (decoded !== void 0) {
         healthFactor = normalizeHealthFactor(Number(decoded));
       } else {
-        healthFactor = borrowed > 0 ? supplied * liqThreshold / borrowed : Infinity;
+        healthFactor = supplied * liqThreshold / borrowed;
       }
     } catch {
-      healthFactor = borrowed > 0 ? supplied * liqThreshold / borrowed : Infinity;
+      healthFactor = supplied * liqThreshold / borrowed;
     }
+  } else {
+    healthFactor = supplied * liqThreshold / borrowed;
   }
   return {
     healthFactor,
@@ -768,12 +849,20 @@ async function getHealthFactor(client, addressOrKeypair) {
 }
 async function getRates(client) {
   try {
-    const pool = await getUsdcPool();
-    let saveApy = rateToApy(pool.currentSupplyRate);
-    let borrowApy = rateToApy(pool.currentBorrowRate);
-    if (saveApy <= 0 || saveApy > 100) saveApy = 4;
-    if (borrowApy <= 0 || borrowApy > 100) borrowApy = 6;
-    return { USDC: { saveApy, borrowApy } };
+    const pools = await getPools();
+    const result = {};
+    for (const asset of STABLE_ASSETS) {
+      const targetType = SUPPORTED_ASSETS[asset].type;
+      const pool = pools.find((p) => matchesCoinType(p.suiCoinType || p.coinType || "", targetType));
+      if (!pool) continue;
+      let saveApy = rateToApy(pool.currentSupplyRate);
+      let borrowApy = rateToApy(pool.currentBorrowRate);
+      if (saveApy <= 0 || saveApy > 100) saveApy = 0;
+      if (borrowApy <= 0 || borrowApy > 100) borrowApy = 0;
+      result[asset] = { saveApy, borrowApy };
+    }
+    if (!result.USDC) result.USDC = { saveApy: 4, borrowApy: 6 };
+    return result;
   } catch {
     return { USDC: { saveApy: 4, borrowApy: 6 } };
   }
@@ -1111,6 +1200,41 @@ var ProtocolRegistry = class {
     candidates.sort((a, b) => b.quote.expectedOutput - a.quote.expectedOutput);
     return candidates[0];
   }
+  async bestSaveRateAcrossAssets() {
+    const candidates = [];
+    for (const asset of STABLE_ASSETS) {
+      for (const adapter of this.lending.values()) {
+        if (!adapter.supportedAssets.includes(asset)) continue;
+        if (!adapter.capabilities.includes("save")) continue;
+        try {
+          const rate = await adapter.getRates(asset);
+          candidates.push({ adapter, rate, asset });
+        } catch {
+        }
+      }
+    }
+    if (candidates.length === 0) {
+      throw new T2000Error("ASSET_NOT_SUPPORTED", "No lending adapter found for any stablecoin");
+    }
+    candidates.sort((a, b) => b.rate.saveApy - a.rate.saveApy);
+    return candidates[0];
+  }
+  async allRatesAcrossAssets() {
+    const results = [];
+    for (const asset of STABLE_ASSETS) {
+      for (const adapter of this.lending.values()) {
+        if (!adapter.supportedAssets.includes(asset)) continue;
+        try {
+          const rates = await adapter.getRates(asset);
+          if (rates.saveApy > 0 || rates.borrowApy > 0) {
+            results.push({ protocol: adapter.name, protocolId: adapter.id, asset, rates });
+          }
+        } catch {
+        }
+      }
+    }
+    return results;
+  }
   async allRates(asset) {
     const results = [];
     for (const adapter of this.lending.values()) {
@@ -1148,6 +1272,24 @@ var ProtocolRegistry = class {
   listSwap() {
     return [...this.swap.values()];
   }
+  isSupportedAsset(asset, capability) {
+    for (const adapter of this.lending.values()) {
+      if (!adapter.supportedAssets.includes(asset)) continue;
+      if (capability && !adapter.capabilities.includes(capability)) continue;
+      return true;
+    }
+    return false;
+  }
+  getSupportedAssets(capability) {
+    const assets = /* @__PURE__ */ new Set();
+    for (const adapter of this.lending.values()) {
+      if (capability && !adapter.capabilities.includes(capability)) continue;
+      for (const a of adapter.supportedAssets) {
+        assets.add(a);
+      }
+    }
+    return [...assets];
+  }
 };
 
 // src/adapters/navi.ts
@@ -1172,7 +1314,7 @@ var NaviAdapter = class {
   name = "NAVI Protocol";
   version = "1.0.0";
   capabilities = ["save", "withdraw", "borrow", "repay"];
-  supportedAssets = ["USDC"];
+  supportedAssets = [...STABLE_ASSETS];
   supportsSameAssetBorrow = true;
   client;
   async init(client) {
@@ -1198,20 +1340,24 @@ var NaviAdapter = class {
   async getHealth(address) {
     return getHealthFactor(this.client, address);
   }
-  async buildSaveTx(address, amount, _asset, options) {
-    const tx = await buildSaveTx(this.client, address, amount, options);
+  async buildSaveTx(address, amount, asset, options) {
+    const stableAsset = asset?.toUpperCase() === "USDC" ? "USDC" : asset;
+    const tx = await buildSaveTx(this.client, address, amount, { ...options, asset: stableAsset });
     return { tx };
   }
-  async buildWithdrawTx(address, amount, _asset) {
-    const result = await buildWithdrawTx(this.client, address, amount);
+  async buildWithdrawTx(address, amount, asset) {
+    const stableAsset = asset?.toUpperCase() === "USDC" ? "USDC" : asset;
+    const result = await buildWithdrawTx(this.client, address, amount, { asset: stableAsset });
     return { tx: result.tx, effectiveAmount: result.effectiveAmount };
   }
-  async buildBorrowTx(address, amount, _asset, options) {
-    const tx = await buildBorrowTx(this.client, address, amount, options);
+  async buildBorrowTx(address, amount, asset, options) {
+    const stableAsset = asset?.toUpperCase() === "USDC" ? "USDC" : asset;
+    const tx = await buildBorrowTx(this.client, address, amount, { ...options, asset: stableAsset });
     return { tx };
   }
-  async buildRepayTx(address, amount, _asset) {
-    const tx = await buildRepayTx(this.client, address, amount);
+  async buildRepayTx(address, amount, asset) {
+    const stableAsset = asset?.toUpperCase() === "USDC" ? "USDC" : asset;
+    const tx = await buildRepayTx(this.client, address, amount, { asset: stableAsset });
     return { tx };
   }
   async maxWithdraw(address, _asset) {
@@ -1359,16 +1505,22 @@ var CetusAdapter = class {
     };
   }
   getSupportedPairs() {
-    return [
+    const pairs = [
       { from: "USDC", to: "SUI" },
       { from: "SUI", to: "USDC" }
     ];
+    for (const a of STABLE_ASSETS) {
+      for (const b of STABLE_ASSETS) {
+        if (a !== b) pairs.push({ from: a, to: b });
+      }
+    }
+    return pairs;
   }
   async getPoolPrice() {
     return getPoolPrice(this.client);
   }
 };
-var USDC_TYPE2 = SUPPORTED_ASSETS.USDC.type;
+SUPPORTED_ASSETS.USDC.type;
 var WAD = 1e18;
 var MIN_HEALTH_FACTOR2 = 1.5;
 var CLOCK2 = "0x6";
@@ -1475,8 +1627,8 @@ var SuilendAdapter = class {
   id = "suilend";
   name = "Suilend";
   version = "2.0.0";
-  capabilities = ["save", "withdraw"];
-  supportedAssets = ["USDC"];
+  capabilities = ["save", "withdraw", "borrow", "repay"];
+  supportedAssets = [...STABLE_ASSETS];
   supportsSameAssetBorrow = false;
   client;
   publishedAt = null;
@@ -1520,12 +1672,14 @@ var SuilendAdapter = class {
     return this.reserveCache;
   }
   findReserve(reserves, asset) {
-    const upper = asset.toUpperCase();
     let coinType;
-    if (upper === "USDC") coinType = USDC_TYPE2;
-    else if (upper === "SUI") coinType = "0x2::sui::SUI";
-    else if (asset.includes("::")) coinType = asset;
-    else return void 0;
+    if (asset in SUPPORTED_ASSETS) {
+      coinType = SUPPORTED_ASSETS[asset].type;
+    } else if (asset.includes("::")) {
+      coinType = asset;
+    } else {
+      return void 0;
+    }
     try {
       const normalized = utils.normalizeStructTag(coinType);
       return reserves.find((r) => {
@@ -1574,8 +1728,12 @@ var SuilendAdapter = class {
   resolveSymbol(coinType) {
     try {
       const normalized = utils.normalizeStructTag(coinType);
-      if (normalized === utils.normalizeStructTag(USDC_TYPE2)) return "USDC";
-      if (normalized === utils.normalizeStructTag("0x2::sui::SUI")) return "SUI";
+      for (const [key, info] of Object.entries(SUPPORTED_ASSETS)) {
+        try {
+          if (utils.normalizeStructTag(info.type) === normalized) return key;
+        } catch {
+        }
+      }
     } catch {
     }
     const parts = coinType.split("::");
@@ -1623,22 +1781,43 @@ var SuilendAdapter = class {
     if (caps.length === 0) {
       return { healthFactor: Infinity, supplied: 0, borrowed: 0, maxBorrow: 0, liquidationThreshold: 0 };
     }
-    const positions = await this.getPositions(address);
-    const supplied = positions.supplies.reduce((s, p) => s + p.amount, 0);
-    const borrowed = positions.borrows.reduce((s, p) => s + p.amount, 0);
-    const reserves = await this.loadReserves();
-    const reserve = this.findReserve(reserves, "USDC");
-    const closeLtv = reserve?.closeLtvPct ?? 75;
-    const openLtv = reserve?.openLtvPct ?? 70;
-    const liqThreshold = closeLtv / 100;
+    const [reserves, obligation] = await Promise.all([
+      this.loadReserves(),
+      this.fetchObligation(caps[0].obligationId)
+    ]);
+    let supplied = 0;
+    let borrowed = 0;
+    let weightedCloseLtv = 0;
+    let weightedOpenLtv = 0;
+    for (const dep of obligation.deposits) {
+      const reserve = reserves[dep.reserveIdx];
+      if (!reserve) continue;
+      const ratio = cTokenRatio(reserve);
+      const amount = dep.ctokenAmount * ratio / 10 ** reserve.mintDecimals;
+      supplied += amount;
+      weightedCloseLtv += amount * (reserve.closeLtvPct / 100);
+      weightedOpenLtv += amount * (reserve.openLtvPct / 100);
+    }
+    for (const bor of obligation.borrows) {
+      const reserve = reserves[bor.reserveIdx];
+      if (!reserve) continue;
+      const rawAmount = bor.borrowedWad / WAD / 10 ** reserve.mintDecimals;
+      const reserveRate = reserve.cumulativeBorrowRateWad / WAD;
+      const posRate = bor.cumBorrowRateWad / WAD;
+      borrowed += posRate > 0 ? rawAmount * (reserveRate / posRate) : rawAmount;
+    }
+    const liqThreshold = supplied > 0 ? weightedCloseLtv / supplied : 0.75;
+    const openLtv = supplied > 0 ? weightedOpenLtv / supplied : 0.7;
     const healthFactor = borrowed > 0 ? supplied * liqThreshold / borrowed : Infinity;
-    const maxBorrow = Math.max(0, supplied * (openLtv / 100) - borrowed);
+    const maxBorrow = Math.max(0, supplied * openLtv - borrowed);
     return { healthFactor, supplied, borrowed, maxBorrow, liquidationThreshold: liqThreshold };
   }
-  async buildSaveTx(address, amount, _asset, options) {
+  async buildSaveTx(address, amount, asset, options) {
+    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
+    const assetInfo = SUPPORTED_ASSETS[assetKey];
     const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves()]);
-    const usdcReserve = this.findReserve(reserves, "USDC");
-    if (!usdcReserve) throw new T2000Error("ASSET_NOT_SUPPORTED", "USDC reserve not found on Suilend");
+    const reserve = this.findReserve(reserves, assetKey);
+    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend. Try: NAVI or a different asset.`);
     const caps = await this.fetchObligationCaps(address);
     const tx = new transactions.Transaction();
     tx.setSender(address);
@@ -1653,33 +1832,33 @@ var SuilendAdapter = class {
     } else {
       capRef = caps[0].id;
     }
-    const allCoins = await this.fetchAllCoins(address, USDC_TYPE2);
-    if (allCoins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins found");
+    const allCoins = await this.fetchAllCoins(address, assetInfo.type);
+    if (allCoins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} coins found`);
     const primaryCoinId = allCoins[0].coinObjectId;
     if (allCoins.length > 1) {
       tx.mergeCoins(tx.object(primaryCoinId), allCoins.slice(1).map((c) => tx.object(c.coinObjectId)));
     }
-    const rawAmount = usdcToRaw(amount).toString();
+    const rawAmount = stableToRaw(amount, assetInfo.decimals).toString();
     const [depositCoin] = tx.splitCoins(tx.object(primaryCoinId), [rawAmount]);
     if (options?.collectFee) {
       addCollectFeeToTx(tx, depositCoin, "save");
     }
     const [ctokens] = tx.moveCall({
       target: `${pkg}::lending_market::deposit_liquidity_and_mint_ctokens`,
-      typeArguments: [LENDING_MARKET_TYPE, USDC_TYPE2],
+      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
       arguments: [
         tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(usdcReserve.arrayIndex),
+        tx.pure.u64(reserve.arrayIndex),
         tx.object(CLOCK2),
         depositCoin
       ]
     });
     tx.moveCall({
       target: `${pkg}::lending_market::deposit_ctokens_into_obligation`,
-      typeArguments: [LENDING_MARKET_TYPE, USDC_TYPE2],
+      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
       arguments: [
         tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(usdcReserve.arrayIndex),
+        tx.pure.u64(reserve.arrayIndex),
         typeof capRef === "string" ? tx.object(capRef) : capRef,
         tx.object(CLOCK2),
         ctokens
@@ -1690,42 +1869,44 @@ var SuilendAdapter = class {
     }
     return { tx };
   }
-  async buildWithdrawTx(address, amount, _asset) {
+  async buildWithdrawTx(address, amount, asset) {
+    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
+    const assetInfo = SUPPORTED_ASSETS[assetKey];
     const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves(true)]);
-    const usdcReserve = this.findReserve(reserves, "USDC");
-    if (!usdcReserve) throw new T2000Error("ASSET_NOT_SUPPORTED", "USDC reserve not found on Suilend");
+    const reserve = this.findReserve(reserves, assetKey);
+    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend`);
     const caps = await this.fetchObligationCaps(address);
     if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend position found");
     const positions = await this.getPositions(address);
-    const deposited = positions.supplies.find((s) => s.asset === "USDC")?.amount ?? 0;
+    const deposited = positions.supplies.find((s) => s.asset === assetKey)?.amount ?? 0;
     const effectiveAmount = Math.min(amount, deposited);
-    if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", "Nothing to withdraw from Suilend");
-    const ratio = cTokenRatio(usdcReserve);
-    const ctokenAmount = Math.ceil(effectiveAmount * 10 ** usdcReserve.mintDecimals / ratio);
+    if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", `Nothing to withdraw for ${assetInfo.displayName} on Suilend`);
+    const ratio = cTokenRatio(reserve);
+    const ctokenAmount = Math.ceil(effectiveAmount * 10 ** reserve.mintDecimals / ratio);
     const tx = new transactions.Transaction();
     tx.setSender(address);
     const [ctokens] = tx.moveCall({
       target: `${pkg}::lending_market::withdraw_ctokens`,
-      typeArguments: [LENDING_MARKET_TYPE, USDC_TYPE2],
+      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
       arguments: [
         tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(usdcReserve.arrayIndex),
+        tx.pure.u64(reserve.arrayIndex),
         tx.object(caps[0].id),
         tx.object(CLOCK2),
         tx.pure.u64(ctokenAmount)
       ]
     });
-    const exemptionType = `${SUILEND_PACKAGE}::lending_market::RateLimiterExemption<${LENDING_MARKET_TYPE}, ${USDC_TYPE2}>`;
+    const exemptionType = `${SUILEND_PACKAGE}::lending_market::RateLimiterExemption<${LENDING_MARKET_TYPE}, ${assetInfo.type}>`;
     const [none] = tx.moveCall({
       target: "0x1::option::none",
       typeArguments: [exemptionType]
     });
     const [coin] = tx.moveCall({
       target: `${pkg}::lending_market::redeem_ctokens_and_withdraw_liquidity`,
-      typeArguments: [LENDING_MARKET_TYPE, USDC_TYPE2],
+      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
       arguments: [
         tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(usdcReserve.arrayIndex),
+        tx.pure.u64(reserve.arrayIndex),
         tx.object(CLOCK2),
         ctokens,
         none
@@ -1734,11 +1915,64 @@ var SuilendAdapter = class {
     tx.transferObjects([coin], address);
     return { tx, effectiveAmount };
   }
-  async buildBorrowTx(_address, _amount, _asset, _options) {
-    throw new T2000Error("ASSET_NOT_SUPPORTED", "Suilend borrow requires different collateral/borrow assets. Deferred to Phase 10.");
+  async buildBorrowTx(address, amount, asset, options) {
+    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
+    const assetInfo = SUPPORTED_ASSETS[assetKey];
+    const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves()]);
+    const reserve = this.findReserve(reserves, assetKey);
+    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend. Try: NAVI or a different asset.`);
+    const caps = await this.fetchObligationCaps(address);
+    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend position found. Deposit collateral first with: t2000 save <amount>");
+    const rawAmount = stableToRaw(amount, assetInfo.decimals);
+    const tx = new transactions.Transaction();
+    tx.setSender(address);
+    const [coin] = tx.moveCall({
+      target: `${pkg}::lending_market::borrow`,
+      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
+      arguments: [
+        tx.object(LENDING_MARKET_ID),
+        tx.pure.u64(reserve.arrayIndex),
+        tx.object(caps[0].id),
+        tx.object(CLOCK2),
+        tx.pure.u64(rawAmount)
+      ]
+    });
+    if (options?.collectFee) {
+      addCollectFeeToTx(tx, coin, "borrow");
+    }
+    tx.transferObjects([coin], address);
+    return { tx };
   }
-  async buildRepayTx(_address, _amount, _asset) {
-    throw new T2000Error("ASSET_NOT_SUPPORTED", "Suilend repay deferred to Phase 10.");
+  async buildRepayTx(address, amount, asset) {
+    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
+    const assetInfo = SUPPORTED_ASSETS[assetKey];
+    const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves()]);
+    const reserve = this.findReserve(reserves, assetKey);
+    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend`);
+    const caps = await this.fetchObligationCaps(address);
+    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend obligation found");
+    const allCoins = await this.fetchAllCoins(address, assetInfo.type);
+    if (allCoins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} coins to repay with`);
+    const rawAmount = stableToRaw(amount, assetInfo.decimals);
+    const tx = new transactions.Transaction();
+    tx.setSender(address);
+    const primaryCoinId = allCoins[0].coinObjectId;
+    if (allCoins.length > 1) {
+      tx.mergeCoins(tx.object(primaryCoinId), allCoins.slice(1).map((c) => tx.object(c.coinObjectId)));
+    }
+    const [repayCoin] = tx.splitCoins(tx.object(primaryCoinId), [rawAmount.toString()]);
+    tx.moveCall({
+      target: `${pkg}::lending_market::repay`,
+      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
+      arguments: [
+        tx.object(LENDING_MARKET_ID),
+        tx.pure.u64(reserve.arrayIndex),
+        tx.object(caps[0].id),
+        tx.object(CLOCK2),
+        repayCoin
+      ]
+    });
+    return { tx };
   }
   async maxWithdraw(address, _asset) {
     const health = await this.getHealth(address);
@@ -1752,8 +1986,10 @@ var SuilendAdapter = class {
     const hfAfter = health.borrowed > 0 ? remainingSupply * health.liquidationThreshold / health.borrowed : Infinity;
     return { maxAmount, healthFactorAfter: hfAfter, currentHF: health.healthFactor };
   }
-  async maxBorrow(_address, _asset) {
-    throw new T2000Error("ASSET_NOT_SUPPORTED", "Suilend maxBorrow deferred to Phase 10.");
+  async maxBorrow(address, _asset) {
+    const health = await this.getHealth(address);
+    const maxAmount = health.maxBorrow;
+    return { maxAmount, healthFactorAfter: MIN_HEALTH_FACTOR2, currentHF: health.healthFactor };
   }
   async fetchAllCoins(owner, coinType) {
     const all = [];
@@ -2147,48 +2383,55 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
   }
   // -- Savings --
   async save(params) {
-    const asset = (params.asset ?? "USDC").toUpperCase();
-    if (asset !== "USDC") {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `Only USDC is supported for save. Got: ${asset}`);
+    const asset = normalizeAsset(params.asset ?? "USDC");
+    if (!this.registry.isSupportedAsset(asset, "save")) {
+      const supported = this.registry.getSupportedAssets("save").join(", ");
+      throw new T2000Error("ASSET_NOT_SUPPORTED", `${asset} is not supported for save. Supported: ${supported}`);
     }
     let amount;
     if (params.amount === "all") {
       const bal = await queryBalance(this.client, this._address);
-      const GAS_RESERVE_USDC = 1;
-      amount = bal.available - GAS_RESERVE_USDC;
+      const assetBalance = bal.stables[asset] ?? 0;
+      const reserve = asset === "USDC" ? 1 : 0;
+      amount = assetBalance - reserve;
       if (amount <= 0) {
-        throw new T2000Error("INSUFFICIENT_BALANCE", "Balance too low to save after $1 gas reserve", {
-          reason: "gas_reserve_required",
-          available: bal.available
+        throw new T2000Error("INSUFFICIENT_BALANCE", `Balance too low to save${asset === "USDC" ? " after $1 gas reserve" : ""}`, {
+          reason: asset === "USDC" ? "gas_reserve_required" : "zero_balance",
+          available: assetBalance
         });
       }
     } else {
       amount = params.amount;
       const bal = await queryBalance(this.client, this._address);
-      if (amount > bal.available) {
-        throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient USDC. Available: $${bal.available.toFixed(2)}, requested: $${amount.toFixed(2)}`);
+      const assetBalance = bal.stables[asset] ?? 0;
+      if (amount > assetBalance) {
+        throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient ${asset}. Available: $${assetBalance.toFixed(2)}, requested: $${amount.toFixed(2)}`);
       }
     }
-    const fee = calculateFee("save", amount);
+    const shouldCollectFee = asset === "USDC";
+    const fee = shouldCollectFee ? calculateFee("save", amount) : { amount: 0, rate: 0};
     const saveAmount = amount;
     const adapter = await this.resolveLending(params.protocol, asset, "save");
     const gasResult = await executeWithGas(this.client, this.keypair, async () => {
-      const { tx } = await adapter.buildSaveTx(this._address, saveAmount, asset, { collectFee: true });
+      const { tx } = await adapter.buildSaveTx(this._address, saveAmount, asset, { collectFee: shouldCollectFee });
       return tx;
     });
     const rates = await adapter.getRates(asset);
-    reportFee(this._address, "save", fee.amount, fee.rate, gasResult.digest);
-    this.emitBalanceChange("USDC", saveAmount, "save", gasResult.digest);
+    if (shouldCollectFee) {
+      reportFee(this._address, "save", fee.amount, fee.rate, gasResult.digest);
+    }
+    this.emitBalanceChange(asset, saveAmount, "save", gasResult.digest);
     let savingsBalance = saveAmount;
     try {
       const positions = await this.positions();
-      savingsBalance = positions.positions.filter((p) => p.type === "save").reduce((sum, p) => sum + p.amount, 0);
+      savingsBalance = positions.positions.filter((p) => p.type === "save" && p.asset === asset).reduce((sum, p) => sum + p.amount, 0);
     } catch {
     }
     return {
       success: true,
       tx: gasResult.digest,
       amount: saveAmount,
+      asset,
       apy: rates.saveApy,
       fee: fee.amount,
       gasCost: gasResult.gasCostSui,
@@ -2197,10 +2440,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     };
   }
   async withdraw(params) {
-    const asset = (params.asset ?? "USDC").toUpperCase();
-    if (asset !== "USDC") {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `Only USDC is supported for withdraw. Got: ${asset}`);
-    }
+    const asset = normalizeAsset(params.asset ?? "USDC");
     if (params.amount === "all" && !params.protocol) {
       return this.withdrawAllProtocols(asset);
     }
@@ -2237,7 +2477,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
       effectiveAmount = built.effectiveAmount;
       return built.tx;
     });
-    this.emitBalanceChange("USDC", effectiveAmount, "withdraw", gasResult.digest);
+    this.emitBalanceChange(asset, effectiveAmount, "withdraw", gasResult.digest);
     return {
       success: true,
       tx: gasResult.digest,
@@ -2246,26 +2486,31 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
       gasMethod: gasResult.gasMethod
     };
   }
-  async withdrawAllProtocols(asset) {
+  async withdrawAllProtocols(_asset) {
     const allPositions = await this.registry.allPositions(this._address);
-    const withSupply = allPositions.filter(
-      (p) => p.positions.supplies.some((s) => s.asset === asset && s.amount > 1e-3)
-    );
-    if (withSupply.length === 0) {
+    const withdrawable = [];
+    for (const pos of allPositions) {
+      for (const supply of pos.positions.supplies) {
+        if (supply.amount > 1e-3) {
+          withdrawable.push({ protocolId: pos.protocolId, asset: supply.asset, amount: supply.amount });
+        }
+      }
+    }
+    if (withdrawable.length === 0) {
       throw new T2000Error("NO_COLLATERAL", "No savings to withdraw across any protocol");
     }
     let totalWithdrawn = 0;
     let lastDigest = "";
     let totalGasCost = 0;
     let lastGasMethod = "self-funded";
-    for (const pos of withSupply) {
-      const adapter = this.registry.getLending(pos.protocolId);
+    for (const entry of withdrawable) {
+      const adapter = this.registry.getLending(entry.protocolId);
       if (!adapter) continue;
-      const maxResult = await adapter.maxWithdraw(this._address, asset);
+      const maxResult = await adapter.maxWithdraw(this._address, entry.asset);
       if (maxResult.maxAmount <= 1e-3) continue;
       let effectiveAmount = maxResult.maxAmount;
       const gasResult = await executeWithGas(this.client, this.keypair, async () => {
-        const built = await adapter.buildWithdrawTx(this._address, maxResult.maxAmount, asset);
+        const built = await adapter.buildWithdrawTx(this._address, maxResult.maxAmount, entry.asset);
         effectiveAmount = built.effectiveAmount;
         return built.tx;
       });
@@ -2273,7 +2518,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
       lastDigest = gasResult.digest;
       totalGasCost += gasResult.gasCostSui;
       lastGasMethod = gasResult.gasMethod;
-      this.emitBalanceChange("USDC", effectiveAmount, "withdraw", gasResult.digest);
+      this.emitBalanceChange(entry.asset, effectiveAmount, "withdraw", gasResult.digest);
     }
     if (totalWithdrawn <= 0) {
       throw new T2000Error("NO_COLLATERAL", "No savings to withdraw across any protocol");
@@ -2292,27 +2537,30 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
   }
   // -- Borrowing --
   async borrow(params) {
-    const asset = (params.asset ?? "USDC").toUpperCase();
-    if (asset !== "USDC") {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `Only USDC is supported for borrow. Got: ${asset}`);
-    }
+    const asset = normalizeAsset(params.asset ?? "USDC");
     const adapter = await this.resolveLending(params.protocol, asset, "borrow");
     const maxResult = await adapter.maxBorrow(this._address, asset);
+    if (maxResult.maxAmount <= 0) {
+      throw new T2000Error("NO_COLLATERAL", "No collateral deposited. Save first with `t2000 save <amount>`.");
+    }
     if (params.amount > maxResult.maxAmount) {
       throw new T2000Error("HEALTH_FACTOR_TOO_LOW", `Max safe borrow: $${maxResult.maxAmount.toFixed(2)}`, {
         maxBorrow: maxResult.maxAmount,
         currentHF: maxResult.currentHF
       });
     }
-    const fee = calculateFee("borrow", params.amount);
+    const shouldCollectFee = asset === "USDC";
+    const fee = shouldCollectFee ? calculateFee("borrow", params.amount) : { amount: 0, rate: 0};
     const borrowAmount = params.amount;
     const gasResult = await executeWithGas(this.client, this.keypair, async () => {
-      const { tx } = await adapter.buildBorrowTx(this._address, borrowAmount, asset, { collectFee: true });
+      const { tx } = await adapter.buildBorrowTx(this._address, borrowAmount, asset, { collectFee: shouldCollectFee });
       return tx;
     });
     const hf = await adapter.getHealth(this._address);
-    reportFee(this._address, "borrow", fee.amount, fee.rate, gasResult.digest);
-    this.emitBalanceChange("USDC", borrowAmount, "borrow", gasResult.digest);
+    if (shouldCollectFee) {
+      reportFee(this._address, "borrow", fee.amount, fee.rate, gasResult.digest);
+    }
+    this.emitBalanceChange(asset, borrowAmount, "borrow", gasResult.digest);
     return {
       success: true,
       tx: gasResult.digest,
@@ -2324,10 +2572,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     };
   }
   async repay(params) {
-    const asset = (params.asset ?? "USDC").toUpperCase();
-    if (asset !== "USDC") {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `Only USDC is supported for repay. Got: ${asset}`);
-    }
+    const asset = normalizeAsset(params.asset ?? "USDC");
     const adapter = await this.resolveLending(params.protocol, asset, "repay");
     let amount;
     if (params.amount === "all") {
@@ -2345,7 +2590,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
       return tx;
     });
     const hf = await adapter.getHealth(this._address);
-    this.emitBalanceChange("USDC", repayAmount, "repay", gasResult.digest);
+    this.emitBalanceChange(asset, repayAmount, "repay", gasResult.digest);
     return {
       success: true,
       tx: gasResult.digest,
@@ -2371,8 +2616,8 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
   }
   // -- Swap --
   async swap(params) {
-    const fromAsset = params.from.toUpperCase();
-    const toAsset = params.to.toUpperCase();
+    const fromAsset = normalizeAsset(params.from);
+    const toAsset = normalizeAsset(params.to);
     if (!(fromAsset in SUPPORTED_ASSETS) || !(toAsset in SUPPORTED_ASSETS)) {
       throw new T2000Error("ASSET_NOT_SUPPORTED", `Swap pair ${fromAsset}/${toAsset} is not supported`);
     }
@@ -2431,8 +2676,8 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     };
   }
   async swapQuote(params) {
-    const fromAsset = params.from.toUpperCase();
-    const toAsset = params.to.toUpperCase();
+    const fromAsset = normalizeAsset(params.from);
+    const toAsset = normalizeAsset(params.to);
     const best = await this.registry.bestSwapQuote(fromAsset, toAsset, params.amount);
     const fee = calculateFee("swap", params.amount);
     return { ...best.quote, fee: { amount: fee.amount, rate: fee.rate } };
@@ -2461,14 +2706,225 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     return { positions };
   }
   async rates() {
-    const allRatesResult = await this.registry.allRates("USDC");
-    if (allRatesResult.length === 0) return { USDC: { saveApy: 0, borrowApy: 0 } };
-    const best = allRatesResult.reduce((a, b) => b.rates.saveApy > a.rates.saveApy ? b : a);
-    return { USDC: { saveApy: best.rates.saveApy, borrowApy: best.rates.borrowApy } };
+    const allRatesResult = await this.registry.allRatesAcrossAssets();
+    const result = {};
+    for (const entry of allRatesResult) {
+      if (!result[entry.asset] || entry.rates.saveApy > result[entry.asset].saveApy) {
+        result[entry.asset] = { saveApy: entry.rates.saveApy, borrowApy: entry.rates.borrowApy };
+      }
+    }
+    if (!result.USDC) result.USDC = { saveApy: 0, borrowApy: 0 };
+    return result;
   }
   async allRates(asset = "USDC") {
     return this.registry.allRates(asset);
   }
+  async allRatesAcrossAssets() {
+    return this.registry.allRatesAcrossAssets();
+  }
+  async rebalance(opts = {}) {
+    const dryRun = opts.dryRun ?? false;
+    const minYieldDiff = opts.minYieldDiff ?? 0.5;
+    const maxBreakEven = opts.maxBreakEven ?? 30;
+    const [allPositions, allRates] = await Promise.all([
+      this.registry.allPositions(this._address),
+      this.registry.allRatesAcrossAssets()
+    ]);
+    const savePositions = allPositions.flatMap(
+      (p) => p.positions.supplies.filter((s) => s.amount > 0.01).map((s) => ({
+        protocolId: p.protocolId,
+        protocol: p.protocol,
+        asset: s.asset,
+        amount: s.amount,
+        apy: s.apy
+      }))
+    );
+    if (savePositions.length === 0) {
+      throw new T2000Error("NO_COLLATERAL", "No savings positions to rebalance. Use `t2000 save <amount>` first.");
+    }
+    const borrowPositions = allPositions.flatMap(
+      (p) => p.positions.borrows.filter((b) => b.amount > 0.01)
+    );
+    if (borrowPositions.length > 0) {
+      const healthResults = await Promise.all(
+        allPositions.filter((p) => p.positions.borrows.some((b) => b.amount > 0.01)).map(async (p) => {
+          const adapter = this.registry.getLending(p.protocolId);
+          if (!adapter) return null;
+          return adapter.getHealth(this._address);
+        })
+      );
+      for (const hf of healthResults) {
+        if (hf && hf.healthFactor < 1.5) {
+          throw new T2000Error(
+            "HEALTH_FACTOR_TOO_LOW",
+            `Cannot rebalance \u2014 health factor is ${hf.healthFactor.toFixed(2)} (minimum 1.5). Repay some debt first.`,
+            { healthFactor: hf.healthFactor }
+          );
+        }
+      }
+    }
+    const bestRate = allRates.reduce(
+      (best, r) => r.rates.saveApy > best.rates.saveApy ? r : best
+    );
+    const current = savePositions.reduce(
+      (worst, p) => p.apy < worst.apy ? p : worst
+    );
+    const apyDiff = bestRate.rates.saveApy - current.apy;
+    const isSameProtocol = current.protocolId === bestRate.protocolId;
+    const isSameAsset = current.asset === bestRate.asset;
+    if (apyDiff < minYieldDiff) {
+      return {
+        executed: false,
+        steps: [],
+        fromProtocol: current.protocol,
+        fromAsset: current.asset,
+        toProtocol: bestRate.protocol,
+        toAsset: bestRate.asset,
+        amount: current.amount,
+        currentApy: current.apy,
+        newApy: bestRate.rates.saveApy,
+        annualGain: current.amount * apyDiff / 100,
+        estimatedSwapCost: 0,
+        breakEvenDays: Infinity,
+        txDigests: [],
+        totalGasCost: 0
+      };
+    }
+    if (isSameProtocol && isSameAsset) {
+      return {
+        executed: false,
+        steps: [],
+        fromProtocol: current.protocol,
+        fromAsset: current.asset,
+        toProtocol: bestRate.protocol,
+        toAsset: bestRate.asset,
+        amount: current.amount,
+        currentApy: current.apy,
+        newApy: bestRate.rates.saveApy,
+        annualGain: 0,
+        estimatedSwapCost: 0,
+        breakEvenDays: Infinity,
+        txDigests: [],
+        totalGasCost: 0
+      };
+    }
+    const steps = [];
+    let estimatedSwapCost = 0;
+    steps.push({
+      action: "withdraw",
+      protocol: current.protocolId,
+      fromAsset: current.asset,
+      amount: current.amount
+    });
+    let amountToDeposit = current.amount;
+    if (!isSameAsset) {
+      try {
+        const quote = await this.registry.bestSwapQuote(current.asset, bestRate.asset, current.amount);
+        amountToDeposit = quote.quote.expectedOutput;
+        estimatedSwapCost = Math.abs(current.amount - amountToDeposit);
+      } catch {
+        estimatedSwapCost = current.amount * 3e-3;
+        amountToDeposit = current.amount - estimatedSwapCost;
+      }
+      steps.push({
+        action: "swap",
+        fromAsset: current.asset,
+        toAsset: bestRate.asset,
+        amount: current.amount,
+        estimatedOutput: amountToDeposit
+      });
+    }
+    steps.push({
+      action: "deposit",
+      protocol: bestRate.protocolId,
+      toAsset: bestRate.asset,
+      amount: amountToDeposit
+    });
+    const annualGain = amountToDeposit * apyDiff / 100;
+    const breakEvenDays = estimatedSwapCost > 0 ? Math.ceil(estimatedSwapCost / annualGain * 365) : 0;
+    if (breakEvenDays > maxBreakEven && estimatedSwapCost > 0) {
+      return {
+        executed: false,
+        steps,
+        fromProtocol: current.protocol,
+        fromAsset: current.asset,
+        toProtocol: bestRate.protocol,
+        toAsset: bestRate.asset,
+        amount: current.amount,
+        currentApy: current.apy,
+        newApy: bestRate.rates.saveApy,
+        annualGain,
+        estimatedSwapCost,
+        breakEvenDays,
+        txDigests: [],
+        totalGasCost: 0
+      };
+    }
+    if (dryRun) {
+      return {
+        executed: false,
+        steps,
+        fromProtocol: current.protocol,
+        fromAsset: current.asset,
+        toProtocol: bestRate.protocol,
+        toAsset: bestRate.asset,
+        amount: current.amount,
+        currentApy: current.apy,
+        newApy: bestRate.rates.saveApy,
+        annualGain,
+        estimatedSwapCost,
+        breakEvenDays,
+        txDigests: [],
+        totalGasCost: 0
+      };
+    }
+    const txDigests = [];
+    let totalGasCost = 0;
+    const withdrawAdapter = this.registry.getLending(current.protocolId);
+    if (!withdrawAdapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", `Protocol ${current.protocolId} not found`);
+    const withdrawResult = await executeWithGas(this.client, this.keypair, async () => {
+      const built = await withdrawAdapter.buildWithdrawTx(this._address, current.amount, current.asset);
+      amountToDeposit = isSameAsset ? built.effectiveAmount : built.effectiveAmount;
+      return built.tx;
+    });
+    txDigests.push(withdrawResult.digest);
+    totalGasCost += withdrawResult.gasCostSui;
+    if (!isSameAsset) {
+      const swapAdapter = this.registry.listSwap()[0];
+      if (!swapAdapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", "No swap adapter available");
+      const swapResult = await executeWithGas(this.client, this.keypair, async () => {
+        const built = await swapAdapter.buildSwapTx(this._address, current.asset, bestRate.asset, amountToDeposit);
+        amountToDeposit = built.estimatedOut / 10 ** built.toDecimals;
+        return built.tx;
+      });
+      txDigests.push(swapResult.digest);
+      totalGasCost += swapResult.gasCostSui;
+    }
+    const depositAdapter = this.registry.getLending(bestRate.protocolId);
+    if (!depositAdapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", `Protocol ${bestRate.protocolId} not found`);
+    const depositResult = await executeWithGas(this.client, this.keypair, async () => {
+      const { tx } = await depositAdapter.buildSaveTx(this._address, amountToDeposit, bestRate.asset, { collectFee: bestRate.asset === "USDC" });
+      return tx;
+    });
+    txDigests.push(depositResult.digest);
+    totalGasCost += depositResult.gasCostSui;
+    return {
+      executed: true,
+      steps,
+      fromProtocol: current.protocol,
+      fromAsset: current.asset,
+      toProtocol: bestRate.protocol,
+      toAsset: bestRate.asset,
+      amount: current.amount,
+      currentApy: current.apy,
+      newApy: bestRate.rates.saveApy,
+      annualGain,
+      estimatedSwapCost,
+      breakEvenDays,
+      txDigests,
+      totalGasCost
+    };
+  }
   async earnings() {
     const result = await getEarnings(this.client, this.keypair);
     if (result.totalYieldEarned > 0) {
@@ -2509,13 +2965,32 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
       const adapters2 = this.registry.listLending().filter(
         (a) => a.supportedAssets.includes(asset) && a.capabilities.includes(capability) && (capability !== "borrow" || a.supportsSameAssetBorrow)
       );
-      if (adapters2.length === 0) throw new T2000Error("ASSET_NOT_SUPPORTED", `No adapter supports ${capability} ${asset}`);
+      if (adapters2.length === 0) {
+        const alternatives = this.registry.listLending().filter(
+          (a) => a.capabilities.includes(capability) && (capability !== "borrow" || a.supportsSameAssetBorrow)
+        );
+        if (alternatives.length > 0) {
+          const altList = alternatives.map((a) => a.name).join(", ");
+          const altAssets = [...new Set(alternatives.flatMap((a) => [...a.supportedAssets]))].join(", ");
+          throw new T2000Error("ASSET_NOT_SUPPORTED", `No protocol supports ${capability} for ${asset}. Available for ${capability}: ${altList} (assets: ${altAssets})`);
+        }
+        throw new T2000Error("ASSET_NOT_SUPPORTED", `No adapter supports ${capability} ${asset}`);
+      }
       return adapters2[0];
     }
     const adapters = this.registry.listLending().filter(
       (a) => a.supportedAssets.includes(asset) && a.capabilities.includes(capability)
     );
-    if (adapters.length === 0) throw new T2000Error("ASSET_NOT_SUPPORTED", `No adapter supports ${capability} ${asset}`);
+    if (adapters.length === 0) {
+      const alternatives = this.registry.listLending().filter(
+        (a) => a.capabilities.includes(capability)
+      );
+      if (alternatives.length > 0) {
+        const altList = alternatives.map((a) => `${a.name} (${[...a.supportedAssets].join(", ")})`).join("; ");
+        throw new T2000Error("ASSET_NOT_SUPPORTED", `No protocol supports ${capability} for ${asset}. Try: ${altList}`);
+      }
+      throw new T2000Error("ASSET_NOT_SUPPORTED", `No adapter supports ${capability} ${asset}`);
+    }
     return adapters[0];
   }
   emitBalanceChange(asset, amount, cause, tx) {
@@ -2632,6 +3107,7 @@ exports.MIST_PER_SUI = MIST_PER_SUI;
 exports.NaviAdapter = NaviAdapter;
 exports.ProtocolRegistry = ProtocolRegistry;
 exports.SENTINEL = SENTINEL;
+exports.STABLE_ASSETS = STABLE_ASSETS;
 exports.SUI_DECIMALS = SUI_DECIMALS;
 exports.SUPPORTED_ASSETS = SUPPORTED_ASSETS;
 exports.SuilendAdapter = SuilendAdapter;
@@ -2649,6 +3125,7 @@ exports.formatSui = formatSui;
 exports.formatUsd = formatUsd;
 exports.generateKeypair = generateKeypair;
 exports.getAddress = getAddress;
+exports.getDecimals = getDecimals;
 exports.getGasStatus = getGasStatus;
 exports.getPoolPrice = getPoolPrice;
 exports.getRates = getRates;
@@ -2661,6 +3138,8 @@ exports.mapMoveAbortCode = mapMoveAbortCode;
 exports.mapWalletError = mapWalletError;
 exports.mistToSui = mistToSui;
 exports.naviDescriptor = descriptor2;
+exports.normalizeAsset = normalizeAsset;
+exports.rawToStable = rawToStable;
 exports.rawToUsdc = rawToUsdc;
 exports.requestAttack = requestAttack;
 exports.saveKey = saveKey;
@@ -2670,6 +3149,7 @@ exports.settleAttack = settleAttack;
 exports.shouldAutoTopUp = shouldAutoTopUp;
 exports.simulateTransaction = simulateTransaction;
 exports.solveHashcash = solveHashcash;
+exports.stableToRaw = stableToRaw;
 exports.submitPrompt = submitPrompt;
 exports.suiToMist = suiToMist;
 exports.suilendDescriptor = descriptor4;