@t2000/sdk 0.18.10 → 0.18.11

package/dist/adapters/index.cjs

@@ -1,9 +1,13 @@
 'use strict';
 
 var transactions = require('@mysten/sui/transactions');
-var bcs = require('@mysten/sui/bcs');
+var lending = require('@naviprotocol/lending');
 var aggregatorSdk = require('@cetusprotocol/aggregator-sdk');
 var utils = require('@mysten/sui/utils');
+var client = require('@suilend/sdk/client');
+var initialize = require('@suilend/sdk/lib/initialize');
+var types = require('@suilend/sdk/lib/types');
+require('@mysten/sui/bcs');
 
 // src/constants.ts
 var SAVE_FEE_BPS = 10n;
@@ -282,79 +286,34 @@ function addCollectFeeToTx(tx, paymentCoin, operation) {
     ]
   });
 }
-var RATE_DECIMALS = 27;
-var LTV_DECIMALS = 27;
+
+// src/protocols/navi.ts
 var MIN_HEALTH_FACTOR = 1.5;
-function withdrawDustBuffer(decimals) {
-  return 1e3 / 10 ** decimals;
-}
-var CLOCK = "0x06";
-var SUI_SYSTEM_STATE = "0x05";
-var NAVI_BALANCE_DECIMALS = 9;
-var CONFIG_API = "https://open-api.naviprotocol.io/api/navi/config?env=prod";
-var POOLS_API = "https://open-api.naviprotocol.io/api/navi/pools?env=prod";
-var PACKAGE_API = "https://open-api.naviprotocol.io/api/package";
-var packageCache = null;
-function toBigInt(v) {
-  if (typeof v === "bigint") return v;
-  return BigInt(String(v));
-}
-var UserStateInfo = bcs.bcs.struct("UserStateInfo", {
-  asset_id: bcs.bcs.u8(),
-  borrow_balance: bcs.bcs.u256(),
-  supply_balance: bcs.bcs.u256()
-});
-function decodeDevInspect(result, schema) {
-  const rv = result.results?.[0]?.returnValues?.[0];
-  if (result.error || !rv) return void 0;
-  const bytes = Uint8Array.from(rv[0]);
-  return schema.parse(bytes);
-}
-var configCache = null;
-var poolsCache = null;
-var CACHE_TTL = 5 * 6e4;
-async function fetchJson(url) {
-  const res = await fetch(url);
-  if (!res.ok) throw new T2000Error("PROTOCOL_UNAVAILABLE", `NAVI API error: ${res.status}`);
-  const json = await res.json();
-  return json.data ?? json;
-}
-async function getLatestPackageId() {
-  if (packageCache && Date.now() - packageCache.ts < CACHE_TTL) return packageCache.id;
-  const res = await fetch(PACKAGE_API);
-  if (!res.ok) throw new T2000Error("PROTOCOL_UNAVAILABLE", `NAVI package API error: ${res.status}`);
-  const json = await res.json();
-  if (!json.packageId) throw new T2000Error("PROTOCOL_UNAVAILABLE", "NAVI package API returned no packageId");
-  packageCache = { id: json.packageId, ts: Date.now() };
-  return json.packageId;
-}
-async function getConfig(fresh = false) {
-  if (configCache && !fresh && Date.now() - configCache.ts < CACHE_TTL) return configCache.data;
-  const [data, latestPkg] = await Promise.all([
-    fetchJson(CONFIG_API),
-    getLatestPackageId()
-  ]);
-  data.package = latestPkg;
-  configCache = { data, ts: Date.now() };
-  return data;
-}
-async function getPools(fresh = false) {
-  if (poolsCache && !fresh && Date.now() - poolsCache.ts < CACHE_TTL) return poolsCache.data;
-  const data = await fetchJson(POOLS_API);
-  poolsCache = { data, ts: Date.now() };
-  return data;
-}
-function matchesCoinType(poolType, targetType) {
-  const poolSuffix = poolType.split("::").slice(1).join("::").toLowerCase();
-  const targetSuffix = targetType.split("::").slice(1).join("::").toLowerCase();
-  return poolSuffix === targetSuffix;
+var NAVI_SUPPORTED_ASSETS = [...STABLE_ASSETS, "SUI", "ETH", "GOLD"];
+function sdkOptions(client) {
+  return { env: "prod", client };
 }
-function resolvePoolSymbol(pool) {
-  const coinType = pool.suiCoinType || pool.coinType || "";
+var NAVI_SYMBOL_MAP = {
+  nUSDC: "USDC",
+  suiUSDT: "USDT",
+  suiUSDe: "USDe",
+  XAUM: "GOLD",
+  WBTC: "BTC",
+  suiETH: "ETH",
+  WETH: "ETH",
+  SUI: "SUI",
+  USDC: "USDC",
+  USDT: "USDT",
+  USDe: "USDe",
+  USDsui: "USDsui"
+};
+function resolveNaviSymbol(sdkSymbol, coinType) {
   for (const [key, info] of Object.entries(SUPPORTED_ASSETS)) {
-    if (matchesCoinType(coinType, info.type)) return key;
+    const poolSuffix = coinType.split("::").slice(1).join("::").toLowerCase();
+    const targetSuffix = info.type.split("::").slice(1).join("::").toLowerCase();
+    if (poolSuffix === targetSuffix) return key;
   }
-  return pool.token?.symbol ?? "UNKNOWN";
+  return NAVI_SYMBOL_MAP[sdkSymbol] ?? sdkSymbol;
 }
 function resolveAssetInfo(asset) {
   if (asset in SUPPORTED_ASSETS) {
@@ -363,109 +322,6 @@ function resolveAssetInfo(asset) {
   }
   throw new T2000Error("ASSET_NOT_SUPPORTED", `Unknown asset: ${asset}`);
 }
-async function getPool(asset = "USDC") {
-  const pools = await getPools();
-  const { type: targetType, displayName } = resolveAssetInfo(asset);
-  const pool = pools.find(
-    (p) => matchesCoinType(p.suiCoinType || p.coinType || "", targetType)
-  );
-  if (!pool) {
-    throw new T2000Error(
-      "ASSET_NOT_SUPPORTED",
-      `${displayName} pool not found on NAVI`
-    );
-  }
-  return pool;
-}
-function addOracleUpdate(tx, config, pool) {
-  const feed = config.oracle.feeds?.find((f2) => f2.assetId === pool.id);
-  if (!feed) {
-    throw new T2000Error("PROTOCOL_UNAVAILABLE", `Oracle feed not found for asset ${pool.token?.symbol ?? pool.id}`);
-  }
-  tx.moveCall({
-    target: `${config.oracle.packageId}::oracle_pro::update_single_price_v2`,
-    arguments: [
-      tx.object(CLOCK),
-      tx.object(config.oracle.oracleConfig),
-      tx.object(config.oracle.priceOracle),
-      tx.object(config.oracle.supraOracleHolder),
-      tx.object(feed.pythPriceInfoObject),
-      tx.object(config.oracle.switchboardAggregator),
-      tx.pure.address(feed.feedId)
-    ]
-  });
-}
-function refreshOracles(tx, config, pools, opts) {
-  const assetsToRefresh = NAVI_SUPPORTED_ASSETS;
-  const targetTypes = assetsToRefresh.map((a) => SUPPORTED_ASSETS[a].type);
-  const matchedPools = pools.filter((p) => {
-    const ct = p.suiCoinType || p.coinType || "";
-    return targetTypes.some((t) => matchesCoinType(ct, t));
-  });
-  for (const pool of matchedPools) {
-    addOracleUpdate(tx, config, pool);
-  }
-}
-function rateToApy(rawRate) {
-  if (!rawRate || rawRate === "0") return 0;
-  return Number(BigInt(rawRate)) / 10 ** RATE_DECIMALS * 100;
-}
-function poolSaveApy(pool) {
-  const incentive = parseFloat(pool.supplyIncentiveApyInfo?.apy ?? "0");
-  if (incentive > 0) return incentive;
-  return rateToApy(pool.currentSupplyRate);
-}
-function poolBorrowApy(pool) {
-  const incentive = parseFloat(pool.borrowIncentiveApyInfo?.apy ?? "0");
-  if (incentive > 0) return incentive;
-  return rateToApy(pool.currentBorrowRate);
-}
-function parseLtv(rawLtv) {
-  if (!rawLtv || rawLtv === "0") return 0.75;
-  return Number(BigInt(rawLtv)) / 10 ** LTV_DECIMALS;
-}
-function parseLiqThreshold(val) {
-  if (typeof val === "number") return val;
-  const n = Number(val);
-  if (n > 1) return Number(BigInt(val)) / 10 ** LTV_DECIMALS;
-  return n;
-}
-function normalizeHealthFactor(raw) {
-  const v = raw / 10 ** RATE_DECIMALS;
-  return v > 1e5 ? Infinity : v;
-}
-function naviStorageDecimals(poolId, tokenDecimals) {
-  if (poolId <= 10) return NAVI_BALANCE_DECIMALS;
-  return tokenDecimals;
-}
-function compoundBalance(rawBalance, currentIndex, pool) {
-  if (!rawBalance || !currentIndex || currentIndex === "0") return 0;
-  const scale = BigInt("1" + "0".repeat(RATE_DECIMALS));
-  const half = scale / 2n;
-  const result = (rawBalance * BigInt(currentIndex) + half) / scale;
-  const decimals = pool ? naviStorageDecimals(pool.id, pool.token.decimals) : NAVI_BALANCE_DECIMALS;
-  return Number(result) / 10 ** decimals;
-}
-async function getUserState(client, address) {
-  const config = await getConfig();
-  const tx = new transactions.Transaction();
-  tx.moveCall({
-    target: `${config.uiGetter}::getter_unchecked::get_user_state`,
-    arguments: [tx.object(config.storage), tx.pure.address(address)]
-  });
-  const result = await client.devInspectTransactionBlock({
-    transactionBlock: tx,
-    sender: address
-  });
-  const decoded = decodeDevInspect(result, bcs.bcs.vector(UserStateInfo));
-  if (!decoded) return [];
-  const mapped = decoded.map((s) => ({
-    assetId: s.asset_id,
-    supplyBalance: toBigInt(s.supply_balance),
-    borrowBalance: toBigInt(s.borrow_balance)
-  }));
-  return mapped.filter((s) => s.supplyBalance !== 0n || s.borrowBalance !== 0n);
-}
 async function fetchCoins(client, owner, coinType) {
   const all = [];
   let cursor;
@@ -486,14 +342,98 @@ function mergeCoins(tx, coins) {
   }
   return primary;
 }
+async function getPositions(client, addressOrKeypair) {
+  const address = typeof addressOrKeypair === "string" ? addressOrKeypair : addressOrKeypair.getPublicKey().toSuiAddress();
+  try {
+    const naviPositions = await lending.getLendingPositions(address, {
+      ...sdkOptions(client),
+      markets: ["main"]
+    });
+    const positions = [];
+    for (const pos of naviPositions) {
+      const data = pos["navi-lending-supply"] ?? pos["navi-lending-emode-supply"] ?? pos["navi-lending-borrow"] ?? pos["navi-lending-emode-borrow"];
+      if (!data) continue;
+      const isBorrow = pos.type.includes("borrow");
+      const symbol = resolveNaviSymbol(data.token.symbol, data.token.coinType);
+      const amount = parseFloat(data.amount);
+      const amountUsd = parseFloat(data.valueUSD);
+      const pool = data.pool;
+      const apy = isBorrow ? parseFloat(pool.borrowIncentiveApyInfo?.apy ?? "0") : parseFloat(pool.supplyIncentiveApyInfo?.apy ?? "0");
+      if (amount > 1e-4 || amountUsd > 1e-3) {
+        positions.push({
+          protocol: "navi",
+          asset: symbol,
+          type: isBorrow ? "borrow" : "save",
+          amount,
+          amountUsd,
+          apy
+        });
+      }
+    }
+    return { positions };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("not found") || msg.includes("404")) return { positions: [] };
+    throw new T2000Error("PROTOCOL_UNAVAILABLE", `NAVI getPositions failed: ${msg}`);
+  }
+}
+async function getRates(client) {
+  try {
+    const pools = await lending.getPools(sdkOptions(client));
+    const result = {};
+    for (const asset of NAVI_SUPPORTED_ASSETS) {
+      const targetType = SUPPORTED_ASSETS[asset].type;
+      const pool = pools.find((p) => {
+        const poolSuffix = (p.suiCoinType || p.coinType || "").split("::").slice(1).join("::").toLowerCase();
+        const targetSuffix = targetType.split("::").slice(1).join("::").toLowerCase();
+        return poolSuffix === targetSuffix;
+      });
+      if (!pool) continue;
+      const saveApy = parseFloat(pool.supplyIncentiveApyInfo?.apy ?? "0");
+      const borrowApy = parseFloat(pool.borrowIncentiveApyInfo?.apy ?? "0");
+      if (saveApy >= 0 && saveApy < 200) {
+        result[asset] = { saveApy, borrowApy: borrowApy >= 0 && borrowApy < 200 ? borrowApy : 0 };
+      }
+    }
+    if (!result.USDC) result.USDC = { saveApy: 4, borrowApy: 6 };
+    return result;
+  } catch {
+    return { USDC: { saveApy: 4, borrowApy: 6 } };
+  }
+}
+async function getHealthFactor(client, addressOrKeypair) {
+  const address = typeof addressOrKeypair === "string" ? addressOrKeypair : addressOrKeypair.getPublicKey().toSuiAddress();
+  const posResult = await getPositions(client, address);
+  let supplied = 0;
+  let borrowed = 0;
+  for (const pos of posResult.positions) {
+    const usd = pos.amountUsd ?? pos.amount;
+    if (pos.type === "save") supplied += usd;
+    else if (pos.type === "borrow") borrowed += usd;
+  }
+  let healthFactor;
+  try {
+    const hf = await lending.getHealthFactor(address, sdkOptions(client));
+    healthFactor = hf > 1e5 ? Infinity : hf;
+  } catch {
+    healthFactor = borrowed > 0 ? supplied * 0.75 / borrowed : Infinity;
+  }
+  const ltv = 0.75;
+  const maxBorrow = Math.max(0, supplied * ltv - borrowed);
+  return {
+    healthFactor,
+    supplied,
+    borrowed,
+    maxBorrow,
+    liquidationThreshold: ltv
+  };
+}
 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 asset = options.asset ?? "USDC";
   const assetInfo = resolveAssetInfo(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();
@@ -502,159 +442,103 @@ async function buildSaveTx(client, address, amount, options = {}) {
   if (options.collectFee) {
     addCollectFeeToTx(tx, coinObj, "save");
   }
-  tx.moveCall({
-    target: `${config.package}::incentive_v3::entry_deposit`,
-    arguments: [
-      tx.object(CLOCK),
-      tx.object(config.storage),
-      tx.object(pool.contract.pool),
-      tx.pure.u8(pool.id),
-      coinObj,
-      tx.pure.u64(rawAmount),
-      tx.object(config.incentiveV2),
-      tx.object(config.incentiveV3)
-    ],
-    typeArguments: [pool.suiCoinType]
-  });
+  const rawAmount = Number(stableToRaw(amount, assetInfo.decimals));
+  try {
+    await lending.depositCoinPTB(tx, assetInfo.type, coinObj, {
+      ...sdkOptions(client),
+      amount: rawAmount
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new T2000Error("PROTOCOL_UNAVAILABLE", `NAVI deposit failed: ${msg}`);
+  }
   return tx;
 }
 async function buildWithdrawTx(client, address, amount, options = {}) {
   const asset = options.asset ?? "USDC";
   const assetInfo = resolveAssetInfo(asset);
-  const [config, pool, pools, states] = await Promise.all([
-    getConfig(),
-    getPool(asset),
-    getPools(),
-    getUserState(client, address)
-  ]);
-  const assetState = states.find((s) => s.assetId === pool.id);
-  const deposited = assetState ? compoundBalance(assetState.supplyBalance, pool.currentSupplyIndex, pool) : 0;
-  const effectiveAmount = Math.min(amount, Math.max(0, deposited - withdrawDustBuffer(assetInfo.decimals)));
+  const posResult = await getPositions(client, address);
+  const supply = posResult.positions.find(
+    (p) => p.type === "save" && p.asset === asset
+  );
+  const deposited = supply?.amount ?? 0;
+  const dustBuffer = 1e3 / 10 ** assetInfo.decimals;
+  const effectiveAmount = Math.min(amount, Math.max(0, deposited - dustBuffer));
   if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", `Nothing to withdraw for ${assetInfo.displayName} on NAVI`);
   const rawAmount = Number(stableToRaw(effectiveAmount, assetInfo.decimals));
   if (rawAmount <= 0) {
-    throw new T2000Error("INVALID_AMOUNT", `Withdrawal amount rounds to zero \u2014 balance is dust`);
+    throw new T2000Error("INVALID_AMOUNT", "Withdrawal amount rounds to zero \u2014 balance is dust");
   }
   const tx = new transactions.Transaction();
   tx.setSender(address);
-  refreshOracles(tx, config, pools);
-  const [balance] = tx.moveCall({
-    target: `${config.package}::incentive_v3::withdraw_v2`,
-    arguments: [
-      tx.object(CLOCK),
-      tx.object(config.oracle.priceOracle),
-      tx.object(config.storage),
-      tx.object(pool.contract.pool),
-      tx.pure.u8(pool.id),
-      tx.pure.u64(rawAmount),
-      tx.object(config.incentiveV2),
-      tx.object(config.incentiveV3),
-      tx.object(SUI_SYSTEM_STATE)
-    ],
-    typeArguments: [pool.suiCoinType]
-  });
-  const [coin] = tx.moveCall({
-    target: "0x2::coin::from_balance",
-    arguments: [balance],
-    typeArguments: [pool.suiCoinType]
-  });
-  tx.transferObjects([coin], address);
+  try {
+    const coinResult = await lending.withdrawCoinPTB(tx, assetInfo.type, rawAmount, sdkOptions(client));
+    const [coin] = tx.moveCall({
+      target: "0x2::coin::from_balance",
+      arguments: [coinResult],
+      typeArguments: [assetInfo.type]
+    });
+    tx.transferObjects([coin], address);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new T2000Error("PROTOCOL_UNAVAILABLE", `NAVI withdraw failed: ${msg}`);
+  }
   return { tx, effectiveAmount };
 }
 async function addWithdrawToTx(tx, client, address, amount, options = {}) {
   const asset = options.asset ?? "USDC";
   const assetInfo = resolveAssetInfo(asset);
-  const [config, pool, pools, states] = await Promise.all([
-    getConfig(),
-    getPool(asset),
-    getPools(),
-    getUserState(client, address)
-  ]);
-  const assetState = states.find((s) => s.assetId === pool.id);
-  const deposited = assetState ? compoundBalance(assetState.supplyBalance, pool.currentSupplyIndex, pool) : 0;
-  const effectiveAmount = Math.min(amount, Math.max(0, deposited - withdrawDustBuffer(assetInfo.decimals)));
+  const posResult = await getPositions(client, address);
+  const supply = posResult.positions.find(
+    (p) => p.type === "save" && p.asset === asset
+  );
+  const deposited = supply?.amount ?? 0;
+  const dustBuffer = 1e3 / 10 ** assetInfo.decimals;
+  const effectiveAmount = Math.min(amount, Math.max(0, deposited - dustBuffer));
   if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", `Nothing to withdraw for ${assetInfo.displayName} on NAVI`);
   const rawAmount = Number(stableToRaw(effectiveAmount, assetInfo.decimals));
   if (rawAmount <= 0) {
-    const [coin2] = tx.moveCall({
+    const [coin] = tx.moveCall({
       target: "0x2::coin::zero",
-      typeArguments: [pool.suiCoinType]
+      typeArguments: [assetInfo.type]
     });
-    return { coin: coin2, effectiveAmount: 0 };
+    return { coin, effectiveAmount: 0 };
+  }
+  try {
+    const coinResult = await lending.withdrawCoinPTB(tx, assetInfo.type, rawAmount, sdkOptions(client));
+    const [coin] = tx.moveCall({
+      target: "0x2::coin::from_balance",
+      arguments: [coinResult],
+      typeArguments: [assetInfo.type]
+    });
+    return { coin, effectiveAmount };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new T2000Error("PROTOCOL_UNAVAILABLE", `NAVI withdraw failed: ${msg}`);
   }
-  refreshOracles(tx, config, pools);
-  const [balance] = tx.moveCall({
-    target: `${config.package}::incentive_v3::withdraw_v2`,
-    arguments: [
-      tx.object(CLOCK),
-      tx.object(config.oracle.priceOracle),
-      tx.object(config.storage),
-      tx.object(pool.contract.pool),
-      tx.pure.u8(pool.id),
-      tx.pure.u64(rawAmount),
-      tx.object(config.incentiveV2),
-      tx.object(config.incentiveV3),
-      tx.object(SUI_SYSTEM_STATE)
-    ],
-    typeArguments: [pool.suiCoinType]
-  });
-  const [coin] = tx.moveCall({
-    target: "0x2::coin::from_balance",
-    arguments: [balance],
-    typeArguments: [pool.suiCoinType]
-  });
-  return { coin, effectiveAmount };
 }
 async function addSaveToTx(tx, _client, _address, coin, options = {}) {
   const asset = options.asset ?? "USDC";
-  const [config, pool] = await Promise.all([getConfig(), getPool(asset)]);
+  const assetInfo = resolveAssetInfo(asset);
   if (options.collectFee) {
     addCollectFeeToTx(tx, coin, "save");
   }
-  const [coinValue] = tx.moveCall({
-    target: "0x2::coin::value",
-    typeArguments: [pool.suiCoinType],
-    arguments: [coin]
-  });
-  tx.moveCall({
-    target: `${config.package}::incentive_v3::entry_deposit`,
-    arguments: [
-      tx.object(CLOCK),
-      tx.object(config.storage),
-      tx.object(pool.contract.pool),
-      tx.pure.u8(pool.id),
-      coin,
-      coinValue,
-      tx.object(config.incentiveV2),
-      tx.object(config.incentiveV3)
-    ],
-    typeArguments: [pool.suiCoinType]
-  });
+  try {
+    await lending.depositCoinPTB(tx, assetInfo.type, coin, { env: "prod" });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new T2000Error("PROTOCOL_UNAVAILABLE", `NAVI deposit failed: ${msg}`);
+  }
 }
 async function addRepayToTx(tx, _client, _address, coin, options = {}) {
   const asset = options.asset ?? "USDC";
-  const [config, pool] = await Promise.all([getConfig(), getPool(asset)]);
-  addOracleUpdate(tx, config, pool);
-  const [coinValue] = tx.moveCall({
-    target: "0x2::coin::value",
-    typeArguments: [pool.suiCoinType],
-    arguments: [coin]
-  });
-  tx.moveCall({
-    target: `${config.package}::incentive_v3::entry_repay`,
-    arguments: [
-      tx.object(CLOCK),
-      tx.object(config.oracle.priceOracle),
-      tx.object(config.storage),
-      tx.object(pool.contract.pool),
-      tx.pure.u8(pool.id),
-      coin,
-      coinValue,
-      tx.object(config.incentiveV2),
-      tx.object(config.incentiveV3)
-    ],
-    typeArguments: [pool.suiCoinType]
-  });
+  const assetInfo = resolveAssetInfo(asset);
+  try {
+    await lending.repayCoinPTB(tx, assetInfo.type, coin, { env: "prod" });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new T2000Error("PROTOCOL_UNAVAILABLE", `NAVI repay failed: ${msg}`);
+  }
 }
 async function buildBorrowTx(client, address, amount, options = {}) {
   if (!amount || amount <= 0 || !Number.isFinite(amount)) {
@@ -663,38 +547,23 @@ async function buildBorrowTx(client, address, amount, options = {}) {
   const asset = options.asset ?? "USDC";
   const assetInfo = resolveAssetInfo(asset);
   const rawAmount = Number(stableToRaw(amount, assetInfo.decimals));
-  const [config, pool, pools] = await Promise.all([
-    getConfig(),
-    getPool(asset),
-    getPools()
-  ]);
   const tx = new transactions.Transaction();
   tx.setSender(address);
-  refreshOracles(tx, config, pools);
-  const [balance] = tx.moveCall({
-    target: `${config.package}::incentive_v3::borrow_v2`,
-    arguments: [
-      tx.object(CLOCK),
-      tx.object(config.oracle.priceOracle),
-      tx.object(config.storage),
-      tx.object(pool.contract.pool),
-      tx.pure.u8(pool.id),
-      tx.pure.u64(rawAmount),
-      tx.object(config.incentiveV2),
-      tx.object(config.incentiveV3),
-      tx.object(SUI_SYSTEM_STATE)
-    ],
-    typeArguments: [pool.suiCoinType]
-  });
-  const [borrowedCoin] = tx.moveCall({
-    target: "0x2::coin::from_balance",
-    arguments: [balance],
-    typeArguments: [pool.suiCoinType]
-  });
-  if (options.collectFee) {
-    addCollectFeeToTx(tx, borrowedCoin, "borrow");
+  try {
+    const coinResult = await lending.borrowCoinPTB(tx, assetInfo.type, rawAmount, sdkOptions(client));
+    const [borrowedCoin] = tx.moveCall({
+      target: "0x2::coin::from_balance",
+      arguments: [coinResult],
+      typeArguments: [assetInfo.type]
+    });
+    if (options.collectFee) {
+      addCollectFeeToTx(tx, borrowedCoin, "borrow");
+    }
+    tx.transferObjects([borrowedCoin], address);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new T2000Error("PROTOCOL_UNAVAILABLE", `NAVI borrow failed: ${msg}`);
   }
-  tx.transferObjects([borrowedCoin], address);
   return tx;
 }
 async function buildRepayTx(client, address, amount, options = {}) {
@@ -703,163 +572,23 @@ async function buildRepayTx(client, address, amount, options = {}) {
   }
   const asset = options.asset ?? "USDC";
   const assetInfo = resolveAssetInfo(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);
   const coinObj = mergeCoins(tx, coins);
-  tx.moveCall({
-    target: `${config.package}::incentive_v3::entry_repay`,
-    arguments: [
-      tx.object(CLOCK),
-      tx.object(config.oracle.priceOracle),
-      tx.object(config.storage),
-      tx.object(pool.contract.pool),
-      tx.pure.u8(pool.id),
-      coinObj,
-      tx.pure.u64(rawAmount),
-      tx.object(config.incentiveV2),
-      tx.object(config.incentiveV3)
-    ],
-    typeArguments: [pool.suiCoinType]
-  });
-  return tx;
-}
-async function getHealthFactor(client, addressOrKeypair) {
-  const address = typeof addressOrKeypair === "string" ? addressOrKeypair : addressOrKeypair.getPublicKey().toSuiAddress();
-  const [config, pools, states] = await Promise.all([
-    getConfig(),
-    getPools(),
-    getUserState(client, address)
-  ]);
-  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, pool);
-    const borrowBal = compoundBalance(state.borrowBalance, pool.currentBorrowIndex, pool);
-    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 if (usdcPool) {
-    try {
-      const tx = new transactions.Transaction();
-      tx.moveCall({
-        target: `${config.uiGetter}::calculator_unchecked::dynamic_health_factor`,
-        arguments: [
-          tx.object(CLOCK),
-          tx.object(config.storage),
-          tx.object(config.oracle.priceOracle),
-          tx.pure.u8(usdcPool.id),
-          tx.pure.address(address),
-          tx.pure.u8(usdcPool.id),
-          tx.pure.u64(0),
-          tx.pure.u64(0),
-          tx.pure.bool(false)
-        ],
-        typeArguments: [usdcPool.suiCoinType]
-      });
-      const result = await client.devInspectTransactionBlock({
-        transactionBlock: tx,
-        sender: address
-      });
-      const decoded = decodeDevInspect(result, bcs.bcs.u256());
-      if (decoded !== void 0) {
-        healthFactor = normalizeHealthFactor(Number(decoded));
-      } else {
-        healthFactor = supplied * liqThreshold / borrowed;
-      }
-    } catch {
-      healthFactor = supplied * liqThreshold / borrowed;
-    }
-  } else {
-    healthFactor = supplied * liqThreshold / borrowed;
-  }
-  return {
-    healthFactor,
-    supplied,
-    borrowed,
-    maxBorrow: maxBorrowVal,
-    liquidationThreshold: liqThreshold
-  };
-}
-var NAVI_SUPPORTED_ASSETS = [...STABLE_ASSETS, "SUI", "ETH", "GOLD"];
-async function getRates(client) {
+  const rawAmount = Number(stableToRaw(amount, assetInfo.decimals));
+  const [repayCoin] = tx.splitCoins(coinObj, [rawAmount]);
   try {
-    const pools = await getPools();
-    const result = {};
-    for (const asset of NAVI_SUPPORTED_ASSETS) {
-      const targetType = SUPPORTED_ASSETS[asset].type;
-      const pool = pools.find((p) => matchesCoinType(p.suiCoinType || p.coinType || "", targetType));
-      if (!pool) continue;
-      let saveApy = poolSaveApy(pool);
-      let borrowApy = poolBorrowApy(pool);
-      if (saveApy <= 0 || saveApy > 200) saveApy = 0;
-      if (borrowApy <= 0 || borrowApy > 200) borrowApy = 0;
-      result[asset] = { saveApy, borrowApy };
-    }
-    if (!result.USDC) result.USDC = { saveApy: 4, borrowApy: 6 };
-    return result;
-  } catch {
-    return { USDC: { saveApy: 4, borrowApy: 6 } };
-  }
-}
-async function getPositions(client, addressOrKeypair) {
-  const address = typeof addressOrKeypair === "string" ? addressOrKeypair : addressOrKeypair.getPublicKey().toSuiAddress();
-  const [states, cachedPools] = await Promise.all([getUserState(client, address), getPools()]);
-  let pools = cachedPools;
-  const unmatchedIds = states.filter((s) => !pools.find((p) => p.id === s.assetId)).map((s) => s.assetId);
-  if (unmatchedIds.length > 0) {
-    pools = await getPools(true);
-  }
-  const positions = [];
-  for (const state of states) {
-    const pool = pools.find((p) => p.id === state.assetId);
-    if (!pool) {
-      console.warn(`[NAVI] No pool found for assetId=${state.assetId} (supply=${state.supplyBalance}, borrow=${state.borrowBalance}) \u2014 funds may be invisible`);
-      continue;
-    }
-    const symbol = resolvePoolSymbol(pool);
-    const supplyBal = compoundBalance(state.supplyBalance, pool.currentSupplyIndex, pool);
-    const borrowBal = compoundBalance(state.borrowBalance, pool.currentBorrowIndex, pool);
-    if (supplyBal > 1e-4) {
-      positions.push({
-        protocol: "navi",
-        asset: symbol,
-        type: "save",
-        amount: supplyBal,
-        apy: poolSaveApy(pool)
-      });
-    }
-    if (borrowBal > 1e-4) {
-      positions.push({
-        protocol: "navi",
-        asset: symbol,
-        type: "borrow",
-        amount: borrowBal,
-        apy: poolBorrowApy(pool)
-      });
-    }
+    await lending.repayCoinPTB(tx, assetInfo.type, repayCoin, {
+      ...sdkOptions(client),
+      amount: rawAmount
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new T2000Error("PROTOCOL_UNAVAILABLE", `NAVI repay failed: ${msg}`);
   }
-  return { positions };
+  return tx;
 }
 async function maxWithdrawAmount(client, addressOrKeypair) {
   const hf = await getHealthFactor(client, addressOrKeypair);
@@ -880,164 +609,61 @@ async function maxBorrowAmount(client, addressOrKeypair) {
   const maxAmount = Math.max(0, hf.supplied * ltv / MIN_HEALTH_FACTOR - hf.borrowed);
   return { maxAmount, healthFactorAfter: MIN_HEALTH_FACTOR, currentHF: hf.healthFactor };
 }
-var CERT_TYPE = "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55::cert::CERT";
-var DEEP_TYPE = "0xdeeb7a4662eec9f2f3def03fb937a663dddaa2e215b8078a284d026b7946c270::deep::DEEP";
-var REWARD_FUNDS = {
-  [CERT_TYPE]: "0x7093cf7549d5e5b35bfde2177223d1050f71655c7f676a5e610ee70eb4d93b5c",
-  [DEEP_TYPE]: "0xc889d78b634f954979e80e622a2ae0fece824c0f6d9590044378a2563035f32f"
-};
-var REWARD_SYMBOLS = {
-  [CERT_TYPE]: "vSUI",
-  [DEEP_TYPE]: "DEEP"
-};
-var incentiveRulesCache = null;
-async function getIncentiveRules(client) {
-  if (incentiveRulesCache && Date.now() - incentiveRulesCache.ts < CACHE_TTL) {
-    return incentiveRulesCache.data;
-  }
-  const [pools, obj] = await Promise.all([
-    getPools(),
-    client.getObject({
-      id: "0x62982dad27fb10bb314b3384d5de8d2ac2d72ab2dbeae5d801dbdb9efa816c80",
-      options: { showContent: true }
-    })
-  ]);
-  const rewardCoinMap = /* @__PURE__ */ new Map();
-  for (const pool of pools) {
-    const ct = (pool.suiCoinType || pool.coinType || "").toLowerCase();
-    const suffix = ct.split("::").slice(1).join("::");
-    const coins = pool.supplyIncentiveApyInfo?.rewardCoin;
-    if (Array.isArray(coins) && coins.length > 0) {
-      rewardCoinMap.set(suffix, coins[0]);
-    }
-  }
-  const result = /* @__PURE__ */ new Map();
-  if (obj.data?.content?.dataType !== "moveObject") {
-    incentiveRulesCache = { data: result, ts: Date.now() };
-    return result;
-  }
-  const fields = obj.data.content.fields;
-  const poolsObj = fields.pools;
-  const entries = poolsObj?.fields?.contents;
-  if (!Array.isArray(entries)) {
-    incentiveRulesCache = { data: result, ts: Date.now() };
-    return result;
-  }
-  for (const entry of entries) {
-    const ef = entry?.fields;
-    if (!ef) continue;
-    const key = String(ef.key ?? "");
-    const value = ef.value;
-    const rules = value?.fields?.rules;
-    const ruleEntries = rules?.fields?.contents;
-    if (!Array.isArray(ruleEntries)) continue;
-    const ruleIds = ruleEntries.map((re) => {
-      const rf = re?.fields;
-      return String(rf?.key ?? "");
-    }).filter(Boolean);
-    const suffix = key.split("::").slice(1).join("::").toLowerCase();
-    const full = key.toLowerCase();
-    const rewardCoin = rewardCoinMap.get(suffix) ?? rewardCoinMap.get(full) ?? null;
-    result.set(key, { ruleIds, rewardCoinType: rewardCoin });
-  }
-  incentiveRulesCache = { data: result, ts: Date.now() };
-  return result;
-}
-function stripPrefix(coinType) {
-  return coinType.replace(/^0x0*/, "");
-}
 async function getPendingRewards(client, address) {
-  const [pools, states] = await Promise.all([
-    getPools(),
-    getUserState(client, address)
-  ]);
-  const rewards = [];
-  const deposited = states.filter((s) => s.supplyBalance > 0n);
-  if (deposited.length === 0) return rewards;
-  for (const state of deposited) {
-    const pool = pools.find((p) => p.id === state.assetId);
-    if (!pool) continue;
-    const boostedApr = parseFloat(pool.supplyIncentiveApyInfo?.boostedApr ?? "0");
-    if (boostedApr <= 0) continue;
-    const rewardCoins = pool.supplyIncentiveApyInfo?.rewardCoin;
-    if (!Array.isArray(rewardCoins) || rewardCoins.length === 0) continue;
-    const rewardType = rewardCoins[0];
-    const assetSymbol = resolvePoolSymbol(pool);
-    rewards.push({
-      protocol: "navi",
-      asset: assetSymbol,
-      coinType: rewardType,
-      symbol: REWARD_SYMBOLS[rewardType] ?? rewardType.split("::").pop() ?? "UNKNOWN",
-      amount: 0,
-      estimatedValueUsd: 0
+  try {
+    const rewards = await lending.getUserAvailableLendingRewards(address, {
+      ...sdkOptions(client),
+      markets: ["main"]
     });
+    if (!rewards || rewards.length === 0) return [];
+    const summary = lending.summaryLendingRewards(rewards);
+    const result = [];
+    for (const s of summary) {
+      for (const rw of s.rewards) {
+        const available = Number(rw.available);
+        if (available <= 0) continue;
+        const symbol = rw.coinType.split("::").pop() ?? "UNKNOWN";
+        result.push({
+          protocol: "navi",
+          asset: String(s.assetId),
+          coinType: rw.coinType,
+          symbol,
+          amount: available,
+          estimatedValueUsd: 0
+        });
+      }
+    }
+    return result;
+  } catch {
+    return [];
   }
-  return rewards;
 }
 async function addClaimRewardsToTx(tx, client, address) {
-  const [config, pools, states, rules] = await Promise.all([
-    getConfig(),
-    getPools(),
-    getUserState(client, address),
-    getIncentiveRules(client)
-  ]);
-  const deposited = states.filter((s) => s.supplyBalance > 0n);
-  if (deposited.length === 0) return [];
-  const claimGroups = /* @__PURE__ */ new Map();
-  for (const state of deposited) {
-    const pool = pools.find((p) => p.id === state.assetId);
-    if (!pool) continue;
-    const boostedApr = parseFloat(pool.supplyIncentiveApyInfo?.boostedApr ?? "0");
-    if (boostedApr <= 0) continue;
-    const rewardCoins = pool.supplyIncentiveApyInfo?.rewardCoin;
-    if (!Array.isArray(rewardCoins) || rewardCoins.length === 0) continue;
-    const rewardType = rewardCoins[0];
-    const fundId = REWARD_FUNDS[rewardType];
-    if (!fundId) continue;
-    const coinType = pool.suiCoinType || pool.coinType || "";
-    const strippedType = stripPrefix(coinType);
-    const ruleData = Array.from(rules.entries()).find(
-      ([key]) => stripPrefix(key) === strippedType || key.split("::").slice(1).join("::").toLowerCase() === coinType.split("::").slice(1).join("::").toLowerCase()
-    );
-    if (!ruleData || ruleData[1].ruleIds.length === 0) continue;
-    const group = claimGroups.get(rewardType) ?? { assets: [], ruleIds: [] };
-    for (const ruleId of ruleData[1].ruleIds) {
-      group.assets.push(strippedType);
-      group.ruleIds.push(ruleId);
-    }
-    claimGroups.set(rewardType, group);
-  }
-  const claimed = [];
-  for (const [rewardType, { assets, ruleIds }] of claimGroups) {
-    const fundId = REWARD_FUNDS[rewardType];
-    const [balance] = tx.moveCall({
-      target: `${config.package}::incentive_v3::claim_reward`,
-      typeArguments: [rewardType],
-      arguments: [
-        tx.object(CLOCK),
-        tx.object(config.incentiveV3),
-        tx.object(config.storage),
-        tx.object(fundId),
-        tx.pure(bcs.bcs.vector(bcs.bcs.string()).serialize(assets)),
-        tx.pure(bcs.bcs.vector(bcs.bcs.Address).serialize(ruleIds))
-      ]
+  try {
+    const rewards = await lending.getUserAvailableLendingRewards(address, {
+      ...sdkOptions(client),
+      markets: ["main"]
     });
-    const [coin] = tx.moveCall({
-      target: "0x2::coin::from_balance",
-      typeArguments: [rewardType],
-      arguments: [balance]
+    if (!rewards || rewards.length === 0) return [];
+    const claimable = rewards.filter(
+      (r) => Number(r.userClaimableReward) > 0
+    );
+    if (claimable.length === 0) return [];
+    const claimed = await lending.claimLendingRewardsPTB(tx, claimable, {
+      env: "prod",
+      customCoinReceive: { type: "transfer", transfer: address }
     });
-    tx.transferObjects([coin], address);
-    claimed.push({
+    return claimed.map((c) => ({
       protocol: "navi",
-      asset: assets.join(", "),
-      coinType: rewardType,
-      symbol: REWARD_SYMBOLS[rewardType] ?? "UNKNOWN",
+      asset: "",
+      coinType: "",
+      symbol: "REWARD",
       amount: 0,
       estimatedValueUsd: 0
-    });
+    }));
+  } catch {
+    return [];
   }
-  return claimed;
 }
 
 // src/adapters/navi.ts
@@ -1081,8 +707,8 @@ var NaviAdapter = class {
   async getPositions(address) {
     const result = await getPositions(this.client, address);
     return {
-      supplies: result.positions.filter((p) => p.type === "save").map((p) => ({ asset: p.asset, amount: p.amount, apy: p.apy })),
-      borrows: result.positions.filter((p) => p.type === "borrow").map((p) => ({ asset: p.asset, amount: p.amount, apy: p.apy }))
+      supplies: result.positions.filter((p) => p.type === "save").map((p) => ({ asset: p.asset, amount: p.amount, amountUsd: p.amountUsd, apy: p.apy })),
+      borrows: result.positions.filter((p) => p.type === "borrow").map((p) => ({ asset: p.asset, amount: p.amount, amountUsd: p.amountUsd, apy: p.apy }))
     };
   }
   async getHealth(address) {
@@ -1363,15 +989,8 @@ var CetusAdapter = class {
     });
   }
 };
-var WAD = 1e18;
-var MIN_HEALTH_FACTOR2 = 1.5;
-var CLOCK2 = "0x6";
-var SUI_SYSTEM_STATE2 = "0x5";
-var LENDING_MARKET_ID = "0x84030d26d85eaa7035084a057f2f11f701b7e2e4eda87551becbc7c97505ece1";
-var LENDING_MARKET_TYPE = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::suilend::MAIN_POOL";
 var SUILEND_PACKAGE = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf";
-var UPGRADE_CAP_ID = "0x3d4ef1859c3ee9fc72858f588b56a09da5466e64f8cc4e90a7b3b909fba8a7ae";
-var FALLBACK_PUBLISHED_AT = "0x3d4353f3bd3565329655e6b77bc2abfd31e558b86662ebd078ae453d416bc10f";
+var MIN_HEALTH_FACTOR2 = 1.5;
 var descriptor3 = {
   id: "suilend",
   name: "Suilend",
@@ -1389,224 +1008,31 @@ var descriptor3 = {
     "lending_market::repay": "repay"
   }
 };
-function interpolateRate(utilBreakpoints, aprBreakpoints, utilizationPct) {
-  if (utilBreakpoints.length === 0) return 0;
-  if (utilizationPct <= utilBreakpoints[0]) return aprBreakpoints[0];
-  if (utilizationPct >= utilBreakpoints[utilBreakpoints.length - 1]) {
-    return aprBreakpoints[aprBreakpoints.length - 1];
-  }
-  for (let i = 1; i < utilBreakpoints.length; i++) {
-    if (utilizationPct <= utilBreakpoints[i]) {
-      const t = (utilizationPct - utilBreakpoints[i - 1]) / (utilBreakpoints[i] - utilBreakpoints[i - 1]);
-      return aprBreakpoints[i - 1] + t * (aprBreakpoints[i] - aprBreakpoints[i - 1]);
-    }
-  }
-  return aprBreakpoints[aprBreakpoints.length - 1];
-}
-function computeRates(reserve) {
-  const available = reserve.availableAmount / 10 ** reserve.mintDecimals;
-  const borrowed = reserve.borrowedAmountWad / WAD / 10 ** reserve.mintDecimals;
-  const totalDeposited = available + borrowed;
-  const utilizationPct = totalDeposited > 0 ? borrowed / totalDeposited * 100 : 0;
-  if (reserve.interestRateUtils.length === 0) return { borrowAprPct: 0, depositAprPct: 0 };
-  const aprs = reserve.interestRateAprs.map((a) => a / 100);
-  const borrowAprPct = interpolateRate(reserve.interestRateUtils, aprs, utilizationPct);
-  const depositAprPct = utilizationPct / 100 * (borrowAprPct / 100) * (1 - reserve.spreadFeeBps / 1e4) * 100;
-  return { borrowAprPct, depositAprPct };
-}
-var MS_PER_YEAR = 365.25 * 24 * 3600 * 1e3;
-function computeDepositRewardApr(reserve, allReserves) {
-  if (reserve.depositTotalShares <= 0 || reserve.price <= 0) return 0;
-  const totalDepositValue = reserve.depositTotalShares / 10 ** reserve.mintDecimals * reserve.price;
-  if (totalDepositValue <= 0) return 0;
-  const priceMap = /* @__PURE__ */ new Map();
-  for (const r of allReserves) {
-    if (r.price > 0) priceMap.set(r.coinType, { price: r.price, decimals: r.mintDecimals });
-  }
-  let rewardApr = 0;
-  for (const rw of reserve.depositPoolRewards) {
-    const info = priceMap.get(rw.coinType);
-    if (!info || info.price <= 0) continue;
-    const durationMs = rw.endTimeMs - rw.startTimeMs;
-    if (durationMs <= 0) continue;
-    const annualTokens = rw.totalRewards / 10 ** info.decimals * (MS_PER_YEAR / durationMs);
-    rewardApr += annualTokens * info.price / totalDepositValue * 100;
-  }
-  return rewardApr;
-}
-function cTokenRatio(reserve) {
-  if (reserve.ctokenSupply === 0) return 1;
-  const totalSupply = reserve.availableAmount + reserve.borrowedAmountWad / WAD - reserve.unclaimedSpreadFeesWad / WAD;
-  return totalSupply / reserve.ctokenSupply;
-}
-function f(obj) {
-  if (obj && typeof obj === "object" && "fields" in obj) return obj.fields;
-  return obj;
-}
-function str(v) {
-  return String(v ?? "0");
-}
-function num(v) {
-  return Number(str(v));
-}
-function parseReserve(raw, index) {
-  const r = f(raw);
-  const coinTypeField = f(r.coin_type);
-  const config = f(f(r.config)?.element);
-  const dMgr = f(r.deposits_pool_reward_manager);
-  const rawRewards = Array.isArray(dMgr?.pool_rewards) ? dMgr.pool_rewards : [];
-  const now = Date.now();
-  const depositPoolRewards = rawRewards.map((rw, idx) => {
-    if (rw === null) return null;
-    const rwf = f(rw);
-    return {
-      coinType: str(f(rwf.coin_type)?.name),
-      totalRewards: num(rwf.total_rewards),
-      startTimeMs: num(rwf.start_time_ms),
-      endTimeMs: num(rwf.end_time_ms),
-      rewardIndex: idx
-    };
-  }).filter((rw) => rw !== null && rw.endTimeMs > now && rw.totalRewards > 0);
-  return {
-    coinType: str(coinTypeField?.name),
-    mintDecimals: num(r.mint_decimals),
-    availableAmount: num(r.available_amount),
-    borrowedAmountWad: num(f(r.borrowed_amount)?.value),
-    ctokenSupply: num(r.ctoken_supply),
-    unclaimedSpreadFeesWad: num(f(r.unclaimed_spread_fees)?.value),
-    cumulativeBorrowRateWad: num(f(r.cumulative_borrow_rate)?.value),
-    openLtvPct: num(config?.open_ltv_pct),
-    closeLtvPct: num(config?.close_ltv_pct),
-    spreadFeeBps: num(config?.spread_fee_bps),
-    interestRateUtils: Array.isArray(config?.interest_rate_utils) ? config.interest_rate_utils.map(num) : [],
-    interestRateAprs: Array.isArray(config?.interest_rate_aprs) ? config.interest_rate_aprs.map(num) : [],
-    arrayIndex: index,
-    price: num(f(r.price)?.value) / WAD,
-    depositTotalShares: num(dMgr?.total_shares),
-    depositPoolRewards
-  };
-}
-function parseObligation(raw) {
-  const deposits = Array.isArray(raw.deposits) ? raw.deposits.map((d) => {
-    const df = f(d);
-    return {
-      coinType: str(f(df.coin_type)?.name),
-      ctokenAmount: num(df.deposited_ctoken_amount),
-      reserveIdx: num(df.reserve_array_index)
-    };
-  }) : [];
-  const borrows = Array.isArray(raw.borrows) ? raw.borrows.map((b) => {
-    const bf = f(b);
-    return {
-      coinType: str(f(bf.coin_type)?.name),
-      borrowedWad: num(f(bf.borrowed_amount)?.value),
-      cumBorrowRateWad: num(f(bf.cumulative_borrow_rate)?.value),
-      reserveIdx: num(bf.reserve_array_index)
-    };
-  }) : [];
-  return { deposits, borrows };
-}
 var SuilendAdapter = class {
   id = "suilend";
   name = "Suilend";
-  version = "2.0.0";
+  version = "3.0.0";
   capabilities = ["save", "withdraw", "borrow", "repay"];
   supportedAssets = [...STABLE_ASSETS, "SUI", "ETH", "BTC", "GOLD"];
   supportsSameAssetBorrow = false;
   client;
-  publishedAt = null;
-  reserveCache = null;
+  sdkClient = null;
   async init(client) {
     this.client = client;
   }
   initSync(client) {
     this.client = client;
   }
-  // -- On-chain reads -------------------------------------------------------
-  async resolvePackage() {
-    if (this.publishedAt) return this.publishedAt;
-    try {
-      const cap = await this.client.getObject({ id: UPGRADE_CAP_ID, options: { showContent: true } });
-      if (cap.data?.content?.dataType === "moveObject") {
-        const fields = cap.data.content.fields;
-        this.publishedAt = str(fields.package);
-        return this.publishedAt;
-      }
-    } catch {
+  async getSdkClient() {
+    if (!this.sdkClient) {
+      this.sdkClient = await client.SuilendClient.initialize(
+        client.LENDING_MARKET_ID,
+        client.LENDING_MARKET_TYPE,
+        this.client,
+        false
+      );
     }
-    this.publishedAt = FALLBACK_PUBLISHED_AT;
-    return this.publishedAt;
-  }
-  async loadReserves(fresh = false) {
-    if (this.reserveCache && !fresh) return this.reserveCache;
-    const market = await this.client.getObject({
-      id: LENDING_MARKET_ID,
-      options: { showContent: true }
-    });
-    if (market.data?.content?.dataType !== "moveObject") {
-      throw new T2000Error("PROTOCOL_UNAVAILABLE", "Failed to read Suilend lending market");
-    }
-    const fields = market.data.content.fields;
-    const reservesRaw = fields.reserves;
-    if (!Array.isArray(reservesRaw)) {
-      throw new T2000Error("PROTOCOL_UNAVAILABLE", "Failed to parse Suilend reserves");
-    }
-    this.reserveCache = reservesRaw.map((r, i) => parseReserve(r, i));
-    return this.reserveCache;
-  }
-  findReserve(reserves, asset) {
-    let coinType;
-    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) => {
-        try {
-          return utils.normalizeStructTag(r.coinType) === normalized;
-        } catch {
-          return false;
-        }
-      });
-    } catch {
-      return void 0;
-    }
-  }
-  async fetchObligationCaps(address) {
-    const capType = `${SUILEND_PACKAGE}::lending_market::ObligationOwnerCap<${LENDING_MARKET_TYPE}>`;
-    const caps = [];
-    let cursor;
-    let hasNext = true;
-    while (hasNext) {
-      const page = await this.client.getOwnedObjects({
-        owner: address,
-        filter: { StructType: capType },
-        options: { showContent: true },
-        cursor: cursor ?? void 0
-      });
-      for (const item of page.data) {
-        if (item.data?.content?.dataType !== "moveObject") continue;
-        const fields = item.data.content.fields;
-        caps.push({
-          id: item.data.objectId,
-          obligationId: str(fields.obligation_id)
-        });
-      }
-      cursor = page.nextCursor;
-      hasNext = page.hasNextPage;
-    }
-    return caps;
-  }
-  async fetchObligation(obligationId) {
-    const obj = await this.client.getObject({ id: obligationId, options: { showContent: true } });
-    if (obj.data?.content?.dataType !== "moveObject") {
-      throw new T2000Error("PROTOCOL_UNAVAILABLE", "Failed to read Suilend obligation");
-    }
-    return parseObligation(obj.data.content.fields);
+    return this.sdkClient;
   }
   resolveSymbol(coinType) {
     try {
@@ -1622,371 +1048,217 @@ var SuilendAdapter = class {
     const parts = coinType.split("::");
     return parts[parts.length - 1] || "UNKNOWN";
   }
-  // -- Adapter interface ----------------------------------------------------
   async getRates(asset) {
-    const reserves = await this.loadReserves();
-    const reserve = this.findReserve(reserves, asset);
-    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `Suilend does not support ${asset}`);
-    const { borrowAprPct, depositAprPct } = computeRates(reserve);
-    const rewardApr = computeDepositRewardApr(reserve, reserves);
-    return { asset, saveApy: depositAprPct + rewardApr, borrowApy: borrowAprPct };
+    try {
+      const sdk = await this.getSdkClient();
+      const { reserveMap } = await initialize.initializeSuilend(this.client, sdk);
+      const assetInfo = SUPPORTED_ASSETS[asset];
+      if (!assetInfo) throw new T2000Error("ASSET_NOT_SUPPORTED", `Suilend does not support ${asset}`);
+      const normalized = utils.normalizeStructTag(assetInfo.type);
+      const reserve = Object.values(reserveMap).find((r) => {
+        try {
+          return utils.normalizeStructTag(r.coinType) === normalized;
+        } catch {
+          return false;
+        }
+      });
+      if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `Suilend does not support ${asset}`);
+      return {
+        asset,
+        saveApy: reserve.depositAprPercent.toNumber(),
+        borrowApy: reserve.borrowAprPercent.toNumber()
+      };
+    } catch (err) {
+      if (err instanceof T2000Error) throw err;
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new T2000Error("PROTOCOL_UNAVAILABLE", `Suilend getRates failed: ${msg}`);
+    }
   }
   async getPositions(address) {
     const supplies = [];
     const borrows = [];
-    const caps = await this.fetchObligationCaps(address);
-    if (caps.length === 0) return { supplies, borrows };
-    const [reserves, obligation] = await Promise.all([
-      this.loadReserves(),
-      this.fetchObligation(caps[0].obligationId)
-    ]);
-    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;
-      const { depositAprPct } = computeRates(reserve);
-      const rewardApr = computeDepositRewardApr(reserve, reserves);
-      supplies.push({ asset: this.resolveSymbol(dep.coinType), amount, apy: depositAprPct + rewardApr });
-    }
-    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;
-      const compounded = posRate > 0 ? rawAmount * (reserveRate / posRate) : rawAmount;
-      const { borrowAprPct } = computeRates(reserve);
-      borrows.push({ asset: this.resolveSymbol(bor.coinType), amount: compounded, apy: borrowAprPct });
+    try {
+      const sdk = await this.getSdkClient();
+      const { reserveMap, refreshedRawReserves } = await initialize.initializeSuilend(this.client, sdk);
+      const { obligations, obligationOwnerCaps } = await initialize.initializeObligations(
+        this.client,
+        sdk,
+        refreshedRawReserves,
+        reserveMap,
+        address
+      );
+      if (obligationOwnerCaps.length === 0 || obligations.length === 0) {
+        return { supplies, borrows };
+      }
+      const obligation = obligations[0];
+      for (const dep of obligation.deposits) {
+        const symbol = this.resolveSymbol(dep.coinType);
+        const amount = dep.depositedAmount.toNumber();
+        const amountUsd = dep.depositedAmountUsd.toNumber();
+        const apy = dep.reserve.depositAprPercent.toNumber();
+        if (amount > 1e-4) {
+          supplies.push({ asset: symbol, amount, amountUsd, apy });
+        }
+      }
+      for (const bor of obligation.borrows) {
+        const symbol = this.resolveSymbol(bor.coinType);
+        const amount = bor.borrowedAmount.toNumber();
+        const amountUsd = bor.borrowedAmountUsd.toNumber();
+        const apy = bor.reserve.borrowAprPercent.toNumber();
+        if (amount > 1e-4) {
+          borrows.push({ asset: symbol, amount, amountUsd, apy });
+        }
+      }
+    } catch (err) {
+      if (err instanceof T2000Error) throw err;
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new T2000Error("PROTOCOL_UNAVAILABLE", `Suilend getPositions failed: ${msg}`);
     }
     return { supplies, borrows };
   }
   async getHealth(address) {
-    const caps = await this.fetchObligationCaps(address);
-    if (caps.length === 0) {
+    try {
+      const sdk = await this.getSdkClient();
+      const { reserveMap, refreshedRawReserves } = await initialize.initializeSuilend(this.client, sdk);
+      const { obligations, obligationOwnerCaps } = await initialize.initializeObligations(
+        this.client,
+        sdk,
+        refreshedRawReserves,
+        reserveMap,
+        address
+      );
+      if (obligationOwnerCaps.length === 0 || obligations.length === 0) {
+        return { healthFactor: Infinity, supplied: 0, borrowed: 0, maxBorrow: 0, liquidationThreshold: 0 };
+      }
+      const ob = obligations[0];
+      const supplied = ob.depositedAmountUsd.toNumber();
+      const borrowed = ob.borrowedAmountUsd.toNumber();
+      const borrowLimit = ob.borrowLimitUsd.toNumber();
+      const unhealthy = ob.unhealthyBorrowValueUsd.toNumber();
+      const liqThreshold = supplied > 0 ? unhealthy / supplied : 0.75;
+      const healthFactor = borrowed > 0 ? unhealthy / borrowed : Infinity;
+      const maxBorrow = Math.max(0, borrowLimit - borrowed);
+      return { healthFactor, supplied, borrowed, maxBorrow, liquidationThreshold: liqThreshold };
+    } catch {
       return { healthFactor: Infinity, supplied: 0, borrowed: 0, maxBorrow: 0, liquidationThreshold: 0 };
     }
-    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 - borrowed);
-    return { healthFactor, supplied, borrowed, maxBorrow, liquidationThreshold: liqThreshold };
   }
   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 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 sdk = await this.getSdkClient();
+    const caps = await client.SuilendClient.getObligationOwnerCaps(address, [client.LENDING_MARKET_TYPE], this.client);
     const tx = new transactions.Transaction();
     tx.setSender(address);
-    let capRef;
     if (caps.length === 0) {
-      const [newCap] = tx.moveCall({
-        target: `${pkg}::lending_market::create_obligation`,
-        typeArguments: [LENDING_MARKET_TYPE],
-        arguments: [tx.object(LENDING_MARKET_ID)]
-      });
-      capRef = newCap;
-    } else {
-      capRef = caps[0].id;
+      const newCap = sdk.createObligation(tx);
+      tx.transferObjects([newCap], address);
     }
-    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 = stableToRaw(amount, assetInfo.decimals).toString();
-    const [depositCoin] = tx.splitCoins(tx.object(primaryCoinId), [rawAmount]);
+    const rawValue = stableToRaw(amount, assetInfo.decimals).toString();
     if (options?.collectFee) {
+      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 [depositCoin] = tx.splitCoins(tx.object(primaryCoinId), [rawValue]);
       addCollectFeeToTx(tx, depositCoin, "save");
     }
-    const [ctokens] = tx.moveCall({
-      target: `${pkg}::lending_market::deposit_liquidity_and_mint_ctokens`,
-      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        tx.object(CLOCK2),
-        depositCoin
-      ]
-    });
-    tx.moveCall({
-      target: `${pkg}::lending_market::deposit_ctokens_into_obligation`,
-      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        typeof capRef === "string" ? tx.object(capRef) : capRef,
-        tx.object(CLOCK2),
-        ctokens
-      ]
-    });
-    if (typeof capRef !== "string") {
-      tx.transferObjects([capRef], address);
+    if (caps.length > 0) {
+      await sdk.depositIntoObligation(address, assetInfo.type, rawValue, tx, caps[0].id);
+    } else {
+      await sdk.depositIntoObligation(address, assetInfo.type, rawValue, tx, tx.object(caps[0]?.id ?? ""));
     }
     return { tx };
   }
   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 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);
+    const sdk = await this.getSdkClient();
+    const caps = await client.SuilendClient.getObligationOwnerCaps(address, [client.LENDING_MARKET_TYPE], this.client);
     if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend position found");
-    const obligation = await this.fetchObligation(caps[0].obligationId);
-    const dep = obligation.deposits.find((d) => d.reserveIdx === reserve.arrayIndex);
-    const ratio = cTokenRatio(reserve);
-    const deposited = dep ? dep.ctokenAmount * ratio / 10 ** reserve.mintDecimals : 0;
+    const positions = await this.getPositions(address);
+    const dep = positions.supplies.find((s) => s.asset === assetKey);
+    const deposited = dep?.amount ?? 0;
     const effectiveAmount = Math.min(amount, deposited);
     if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", `Nothing to withdraw for ${assetInfo.displayName} on Suilend`);
-    const U64_MAX = "18446744073709551615";
-    const isFullWithdraw = dep && effectiveAmount >= deposited * 0.999;
-    const withdrawArg = isFullWithdraw ? U64_MAX : String(Math.floor(effectiveAmount * 10 ** reserve.mintDecimals / ratio));
+    const rawValue = stableToRaw(effectiveAmount, assetInfo.decimals).toString();
     const tx = new transactions.Transaction();
     tx.setSender(address);
-    const [ctokens] = tx.moveCall({
-      target: `${pkg}::lending_market::withdraw_ctokens`,
-      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", BigInt(withdrawArg))
-      ]
-    });
-    const coin = this.redeemCtokens(tx, pkg, reserve, assetInfo.type, assetKey, ctokens);
-    tx.transferObjects([coin], address);
+    await sdk.withdrawAndSendToUser(address, caps[0].id, caps[0].obligationId, assetInfo.type, rawValue, tx);
     return { tx, effectiveAmount };
   }
   async addWithdrawToTx(tx, 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 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);
+    const sdk = await this.getSdkClient();
+    const caps = await client.SuilendClient.getObligationOwnerCaps(address, [client.LENDING_MARKET_TYPE], this.client);
     if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend position found");
-    const obligation = await this.fetchObligation(caps[0].obligationId);
-    const dep = obligation.deposits.find((d) => d.reserveIdx === reserve.arrayIndex);
-    const ratio = cTokenRatio(reserve);
-    const deposited = dep ? dep.ctokenAmount * ratio / 10 ** reserve.mintDecimals : 0;
+    const positions = await this.getPositions(address);
+    const dep = positions.supplies.find((s) => s.asset === assetKey);
+    const deposited = dep?.amount ?? 0;
     const effectiveAmount = Math.min(amount, deposited);
     if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", `Nothing to withdraw for ${assetInfo.displayName} on Suilend`);
-    const ctokenAmount = dep && effectiveAmount >= deposited * 0.999 ? dep.ctokenAmount : Math.floor(effectiveAmount * 10 ** reserve.mintDecimals / ratio);
-    const [ctokens] = tx.moveCall({
-      target: `${pkg}::lending_market::withdraw_ctokens`,
-      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(ctokenAmount)
-      ]
-    });
-    const coin = this.redeemCtokens(tx, pkg, reserve, assetInfo.type, assetKey, ctokens);
+    const rawValue = stableToRaw(effectiveAmount, assetInfo.decimals).toString();
+    const coin = await sdk.withdraw(caps[0].id, caps[0].obligationId, assetInfo.type, rawValue, tx);
     return { coin, effectiveAmount };
   }
-  /**
-   * 3-step cToken redemption matching the official Suilend SDK flow:
-   * 1. redeem_ctokens_and_withdraw_liquidity_request — creates a LiquidityRequest
-   * 2. unstake_sui_from_staker — (SUI only) unstakes from validators to replenish available_liquidity
-   * 3. fulfill_liquidity_request — splits underlying tokens from the reserve
-   */
-  redeemCtokens(tx, pkg, reserve, coinType, assetKey, ctokens) {
-    const exemptionType = `${SUILEND_PACKAGE}::lending_market::RateLimiterExemption<${LENDING_MARKET_TYPE}, ${coinType}>`;
-    const [none] = tx.moveCall({
-      target: "0x1::option::none",
-      typeArguments: [exemptionType]
-    });
-    const [liquidityRequest] = tx.moveCall({
-      target: `${pkg}::lending_market::redeem_ctokens_and_withdraw_liquidity_request`,
-      typeArguments: [LENDING_MARKET_TYPE, coinType],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        tx.object(CLOCK2),
-        ctokens,
-        none
-      ]
-    });
-    if (assetKey === "SUI") {
-      tx.moveCall({
-        target: `${pkg}::lending_market::unstake_sui_from_staker`,
-        typeArguments: [LENDING_MARKET_TYPE],
-        arguments: [
-          tx.object(LENDING_MARKET_ID),
-          tx.pure.u64(reserve.arrayIndex),
-          liquidityRequest,
-          tx.object(SUI_SYSTEM_STATE2)
-        ]
-      });
-    }
-    const [coin] = tx.moveCall({
-      target: `${pkg}::lending_market::fulfill_liquidity_request`,
-      typeArguments: [LENDING_MARKET_TYPE, coinType],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        liquidityRequest
-      ]
-    });
-    return coin;
-  }
   async addSaveToTx(tx, address, coin, 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`);
-    const caps = await this.fetchObligationCaps(address);
+    const sdk = await this.getSdkClient();
+    const caps = await client.SuilendClient.getObligationOwnerCaps(address, [client.LENDING_MARKET_TYPE], this.client);
     let capRef;
     if (caps.length === 0) {
-      const [newCap] = tx.moveCall({
-        target: `${pkg}::lending_market::create_obligation`,
-        typeArguments: [LENDING_MARKET_TYPE],
-        arguments: [tx.object(LENDING_MARKET_ID)]
-      });
+      const newCap = sdk.createObligation(tx);
       capRef = newCap;
+      tx.transferObjects([newCap], address);
     } else {
       capRef = caps[0].id;
     }
     if (options?.collectFee) {
       addCollectFeeToTx(tx, coin, "save");
     }
-    const [ctokens] = tx.moveCall({
-      target: `${pkg}::lending_market::deposit_liquidity_and_mint_ctokens`,
-      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        tx.object(CLOCK2),
-        coin
-      ]
-    });
-    tx.moveCall({
-      target: `${pkg}::lending_market::deposit_ctokens_into_obligation`,
-      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        typeof capRef === "string" ? tx.object(capRef) : capRef,
-        tx.object(CLOCK2),
-        ctokens
-      ]
-    });
-    if (typeof capRef !== "string") {
-      tx.transferObjects([capRef], address);
-    }
+    sdk.deposit(coin, assetInfo.type, capRef, tx);
   }
   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);
+    const sdk = await this.getSdkClient();
+    const caps = await client.SuilendClient.getObligationOwnerCaps(address, [client.LENDING_MARKET_TYPE], this.client);
     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 rawValue = stableToRaw(amount, assetInfo.decimals).toString();
     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) {
+      const coin = await sdk.borrow(caps[0].id, caps[0].obligationId, assetInfo.type, rawValue, tx);
       addCollectFeeToTx(tx, coin, "borrow");
+      tx.transferObjects([coin], address);
+    } else {
+      await sdk.borrowAndSendToUser(address, caps[0].id, caps[0].obligationId, assetInfo.type, rawValue, tx);
     }
-    tx.transferObjects([coin], address);
     return { tx };
   }
   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);
+    const sdk = await this.getSdkClient();
+    const caps = await client.SuilendClient.getObligationOwnerCaps(address, [client.LENDING_MARKET_TYPE], this.client);
     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 rawValue = stableToRaw(amount, assetInfo.decimals).toString();
     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
-      ]
-    });
+    await sdk.repayIntoObligation(address, caps[0].obligationId, assetInfo.type, rawValue, tx);
     return { tx };
   }
   async addRepayToTx(tx, address, coin, 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);
+    const sdk = await this.getSdkClient();
+    const caps = await client.SuilendClient.getObligationOwnerCaps(address, [client.LENDING_MARKET_TYPE], this.client);
     if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend obligation found");
-    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),
-        coin
-      ]
-    });
+    sdk.repay(caps[0].obligationId, assetInfo.type, coin, tx);
   }
   async maxWithdraw(address, _asset) {
     const health = await this.getHealth(address);
@@ -2002,8 +1274,7 @@ var SuilendAdapter = class {
   }
   async maxBorrow(address, _asset) {
     const health = await this.getHealth(address);
-    const maxAmount = health.maxBorrow;
-    return { maxAmount, healthFactorAfter: MIN_HEALTH_FACTOR2, currentHF: health.healthFactor };
+    return { maxAmount: health.maxBorrow, healthFactorAfter: MIN_HEALTH_FACTOR2, currentHF: health.healthFactor };
   }
   async fetchAllCoins(owner, coinType) {
     const all = [];
@@ -2017,88 +1288,79 @@ var SuilendAdapter = class {
     }
     return all;
   }
-  // -- Claim Rewards --------------------------------------------------------
-  isClaimableReward(coinType) {
-    const ct = coinType.toLowerCase();
-    return ct.includes("spring_sui") || ct.includes("deep::deep") || ct.includes("cert::cert");
-  }
   async getPendingRewards(address) {
-    const caps = await this.fetchObligationCaps(address);
-    if (caps.length === 0) return [];
-    const [reserves, obligation] = await Promise.all([
-      this.loadReserves(true),
-      this.fetchObligation(caps[0].obligationId)
-    ]);
-    const rewards = [];
-    for (const dep of obligation.deposits) {
-      const reserve = reserves[dep.reserveIdx];
-      if (!reserve) continue;
-      for (const rw of reserve.depositPoolRewards) {
-        if (!this.isClaimableReward(rw.coinType)) continue;
-        const durationMs = rw.endTimeMs - rw.startTimeMs;
-        if (durationMs <= 0) continue;
-        const assetSymbol = this.resolveSymbol(dep.coinType);
-        if (!(assetSymbol in SUPPORTED_ASSETS)) continue;
-        rewards.push({
-          protocol: "suilend",
-          asset: assetSymbol,
-          coinType: rw.coinType,
-          symbol: rw.coinType.includes("spring_sui") ? "sSUI" : rw.coinType.includes("deep::") ? "DEEP" : rw.coinType.split("::").pop() ?? "UNKNOWN",
-          amount: 0,
-          estimatedValueUsd: 0
-        });
+    try {
+      const sdk = await this.getSdkClient();
+      const { reserveMap, refreshedRawReserves } = await initialize.initializeSuilend(this.client, sdk);
+      const { obligations, obligationOwnerCaps } = await initialize.initializeObligations(
+        this.client,
+        sdk,
+        refreshedRawReserves,
+        reserveMap,
+        address
+      );
+      if (obligationOwnerCaps.length === 0 || obligations.length === 0) return [];
+      const ob = obligations[0];
+      const rewards = [];
+      for (const dep of ob.deposits) {
+        for (const rw of dep.reserve.depositsPoolRewardManager.poolRewards) {
+          if (rw.endTimeMs <= Date.now()) continue;
+          const symbol = rw.symbol || rw.coinType.split("::").pop() || "UNKNOWN";
+          rewards.push({
+            protocol: "suilend",
+            asset: this.resolveSymbol(dep.coinType),
+            coinType: rw.coinType,
+            symbol,
+            amount: 0,
+            estimatedValueUsd: 0
+          });
+        }
       }
+      return rewards;
+    } catch {
+      return [];
     }
-    return rewards;
   }
   async addClaimRewardsToTx(tx, address) {
-    const caps = await this.fetchObligationCaps(address);
-    if (caps.length === 0) return [];
-    const [pkg, reserves, obligation] = await Promise.all([
-      this.resolvePackage(),
-      this.loadReserves(true),
-      this.fetchObligation(caps[0].obligationId)
-    ]);
-    const claimsByToken = /* @__PURE__ */ new Map();
-    const claimed = [];
-    for (const dep of obligation.deposits) {
-      const reserve = reserves[dep.reserveIdx];
-      if (!reserve) continue;
-      for (const rw of reserve.depositPoolRewards) {
-        if (!this.isClaimableReward(rw.coinType)) continue;
-        const [coin] = tx.moveCall({
-          target: `${pkg}::lending_market::claim_rewards`,
-          typeArguments: [LENDING_MARKET_TYPE, rw.coinType],
-          arguments: [
-            tx.object(LENDING_MARKET_ID),
-            tx.object(caps[0].id),
-            tx.object(CLOCK2),
-            tx.pure.u64(reserve.arrayIndex),
-            tx.pure.u64(rw.rewardIndex),
-            tx.pure.bool(true)
-          ]
-        });
-        const existing = claimsByToken.get(rw.coinType) ?? [];
-        existing.push(coin);
-        claimsByToken.set(rw.coinType, existing);
-      }
-    }
-    for (const [coinType, coins] of claimsByToken) {
-      if (coins.length > 1) {
-        tx.mergeCoins(coins[0], coins.slice(1));
+    try {
+      const sdk = await this.getSdkClient();
+      const caps = await client.SuilendClient.getObligationOwnerCaps(address, [client.LENDING_MARKET_TYPE], this.client);
+      if (caps.length === 0) return [];
+      const { reserveMap, refreshedRawReserves } = await initialize.initializeSuilend(this.client, sdk);
+      const { obligations } = await initialize.initializeObligations(
+        this.client,
+        sdk,
+        refreshedRawReserves,
+        reserveMap,
+        address
+      );
+      if (obligations.length === 0) return [];
+      const ob = obligations[0];
+      const claimRewards = [];
+      for (const dep of ob.deposits) {
+        for (const rw of dep.reserve.depositsPoolRewardManager.poolRewards) {
+          if (rw.endTimeMs <= Date.now()) continue;
+          claimRewards.push({
+            reserveArrayIndex: dep.reserveArrayIndex,
+            rewardIndex: BigInt(rw.rewardIndex),
+            rewardCoinType: rw.coinType,
+            side: types.Side.DEPOSIT
+          });
+        }
       }
-      tx.transferObjects([coins[0]], address);
-      const symbol = coinType.includes("spring_sui") ? "SPRING_SUI" : coinType.includes("deep::") ? "DEEP" : coinType.split("::").pop() ?? "UNKNOWN";
-      claimed.push({
+      if (claimRewards.length === 0) return [];
+      sdk.claimRewardsAndSendToUser(address, caps[0].id, claimRewards, tx);
+      return claimRewards.map((r) => ({
         protocol: "suilend",
         asset: "",
-        coinType,
-        symbol,
+        coinType: r.rewardCoinType,
+        symbol: r.rewardCoinType.split("::").pop() ?? "UNKNOWN",
         amount: 0,
         estimatedValueUsd: 0
-      });
+      }));
+    } catch {
+      return [];
     }
-    return claimed;
   }
 };
 var descriptor4 = {