@t2000/sdk 0.7.1 → 0.8.0

package/dist/index.js

@@ -29,14 +29,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";
@@ -236,6 +257,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));
 }
@@ -246,6 +276,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({
@@ -318,26 +354,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
     }
   };
@@ -425,7 +470,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;
@@ -486,13 +531,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);
@@ -580,10 +636,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 Transaction();
   tx.setSender(address);
   const coinObj = mergeCoins(tx, coins);
@@ -606,18 +664,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 Transaction();
   tx.setSender(address);
   addOracleUpdate(tx, config, pool);
@@ -648,8 +708,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 Transaction();
   tx.setSender(address);
   addOracleUpdate(tx, config, pool);
@@ -679,14 +741,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 Transaction();
   tx.setSender(address);
   addOracleUpdate(tx, config, pool);
@@ -710,21 +774,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 Transaction();
       tx.moveCall({
@@ -733,14 +812,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,
@@ -750,11 +829,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,
@@ -766,12 +847,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 } };
   }
@@ -1109,6 +1198,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()) {
@@ -1146,6 +1270,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
@@ -1170,7 +1312,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) {
@@ -1196,20 +1338,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) {
@@ -1357,16 +1503,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";
@@ -1473,8 +1625,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;
@@ -1518,12 +1670,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 = normalizeStructTag(coinType);
       return reserves.find((r) => {
@@ -1572,8 +1726,12 @@ var SuilendAdapter = class {
   resolveSymbol(coinType) {
     try {
       const normalized = normalizeStructTag(coinType);
-      if (normalized === normalizeStructTag(USDC_TYPE2)) return "USDC";
-      if (normalized === normalizeStructTag("0x2::sui::SUI")) return "SUI";
+      for (const [key, info] of Object.entries(SUPPORTED_ASSETS)) {
+        try {
+          if (normalizeStructTag(info.type) === normalized) return key;
+        } catch {
+        }
+      }
     } catch {
     }
     const parts = coinType.split("::");
@@ -1621,22 +1779,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 Transaction();
     tx.setSender(address);
@@ -1651,33 +1830,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
@@ -1688,42 +1867,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 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
@@ -1732,11 +1913,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 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 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);
@@ -1750,8 +1984,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 = [];
@@ -2145,48 +2381,55 @@ var T2000 = class _T2000 extends 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,
@@ -2195,10 +2438,7 @@ var T2000 = class _T2000 extends 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);
     }
@@ -2235,7 +2475,7 @@ var T2000 = class _T2000 extends 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,
@@ -2244,26 +2484,31 @@ var T2000 = class _T2000 extends 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;
       });
@@ -2271,7 +2516,7 @@ var T2000 = class _T2000 extends 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");
@@ -2290,27 +2535,30 @@ var T2000 = class _T2000 extends 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,
@@ -2322,10 +2570,7 @@ var T2000 = class _T2000 extends 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") {
@@ -2343,7 +2588,7 @@ var T2000 = class _T2000 extends 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,
@@ -2369,8 +2614,8 @@ var T2000 = class _T2000 extends 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`);
     }
@@ -2429,8 +2674,8 @@ var T2000 = class _T2000 extends 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 } };
@@ -2459,14 +2704,225 @@ var T2000 = class _T2000 extends 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) {
@@ -2507,13 +2963,32 @@ var T2000 = class _T2000 extends 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) {
@@ -2622,6 +3097,6 @@ var allDescriptors = [
   descriptor
 ];
 
-export { BPS_DENOMINATOR, CLOCK_ID, CetusAdapter, DEFAULT_NETWORK, MIST_PER_SUI, NaviAdapter, ProtocolRegistry, SENTINEL, SUI_DECIMALS, SUPPORTED_ASSETS, SuilendAdapter, T2000, T2000Error, USDC_DECIMALS, addCollectFeeToTx, allDescriptors, calculateFee, descriptor3 as cetusDescriptor, executeAutoTopUp, executeWithGas, exportPrivateKey, formatSui, formatUsd, generateKeypair, getAddress, getGasStatus, getPoolPrice, getRates, getSentinelInfo, getSwapQuote, keypairFromPrivateKey, listSentinels, loadKey, mapMoveAbortCode, mapWalletError, mistToSui, descriptor2 as naviDescriptor, rawToUsdc, requestAttack, saveKey, attack as sentinelAttack, descriptor as sentinelDescriptor, settleAttack, shouldAutoTopUp, simulateTransaction, solveHashcash, submitPrompt, suiToMist, descriptor4 as suilendDescriptor, throwIfSimulationFailed, truncateAddress, usdcToRaw, validateAddress, walletExists };
+export { BPS_DENOMINATOR, CLOCK_ID, CetusAdapter, DEFAULT_NETWORK, MIST_PER_SUI, NaviAdapter, ProtocolRegistry, SENTINEL, STABLE_ASSETS, SUI_DECIMALS, SUPPORTED_ASSETS, SuilendAdapter, T2000, T2000Error, USDC_DECIMALS, addCollectFeeToTx, allDescriptors, calculateFee, descriptor3 as cetusDescriptor, executeAutoTopUp, executeWithGas, exportPrivateKey, formatSui, formatUsd, generateKeypair, getAddress, getDecimals, getGasStatus, getPoolPrice, getRates, getSentinelInfo, getSwapQuote, keypairFromPrivateKey, listSentinels, loadKey, mapMoveAbortCode, mapWalletError, mistToSui, descriptor2 as naviDescriptor, normalizeAsset, rawToStable, rawToUsdc, requestAttack, saveKey, attack as sentinelAttack, descriptor as sentinelDescriptor, settleAttack, shouldAutoTopUp, simulateTransaction, solveHashcash, stableToRaw, submitPrompt, suiToMist, descriptor4 as suilendDescriptor, throwIfSimulationFailed, truncateAddress, usdcToRaw, validateAddress, walletExists };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map