@t2000/sdk 0.4.2 → 0.5.0

package/dist/adapters/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-var lending = require('@naviprotocol/lending');
 var transactions = require('@mysten/sui/transactions');
+var bcs = require('@mysten/sui/bcs');
 var aggregatorSdk = require('@cetusprotocol/aggregator-sdk');
 var utils = require('@mysten/sui/utils');
 
@@ -183,15 +183,59 @@ function addCollectFeeToTx(tx, paymentCoin, operation) {
 }
 
 // src/protocols/navi.ts
-var ENV = { env: "prod" };
 var USDC_TYPE = SUPPORTED_ASSETS.USDC.type;
 var RATE_DECIMALS = 27;
 var LTV_DECIMALS = 27;
 var MIN_HEALTH_FACTOR = 1.5;
 var WITHDRAW_DUST_BUFFER = 1e-3;
+var CLOCK = "0x06";
+var SUI_SYSTEM_STATE = "0x05";
 var NAVI_BALANCE_DECIMALS = 9;
-function clientOpt(client, fresh = false) {
-  return { client, ...ENV, ...fresh ? { disableCache: true } : {} };
+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";
+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 getConfig(fresh = false) {
+  if (configCache && !fresh && Date.now() - configCache.ts < CACHE_TTL) return configCache.data;
+  const data = await fetchJson(CONFIG_API);
+  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;
+}
+async function getUsdcPool() {
+  const pools = await getPools();
+  const usdc = pools.find(
+    (p) => p.token?.symbol === "USDC" || p.coinType?.toLowerCase().includes("usdc")
+  );
+  if (!usdc) throw new T2000Error("PROTOCOL_UNAVAILABLE", "USDC pool not found on NAVI");
+  return usdc;
 }
 function rateToApy(rawRate) {
   if (!rawRate || rawRate === "0") return 0;
@@ -207,59 +251,146 @@ function parseLiqThreshold(val) {
   if (n > 1) return Number(BigInt(val)) / 10 ** LTV_DECIMALS;
   return n;
 }
-function findUsdcPosition(state) {
-  return state.find(
-    (p) => p.pool.token.symbol === "USDC" || p.pool.coinType.toLowerCase().includes("usdc")
-  );
+function normalizeHealthFactor(raw) {
+  const v = raw / 10 ** RATE_DECIMALS;
+  return v > 1e5 ? Infinity : v;
 }
-async function updateOracle(tx, client, address) {
-  try {
-    const [feeds, state] = await Promise.all([
-      lending.getPriceFeeds(ENV),
-      lending.getLendingState(address, clientOpt(client))
-    ]);
-    const relevant = lending.filterPriceFeeds(feeds, { lendingState: state });
-    if (relevant.length > 0) {
-      await lending.updateOraclePricesPTB(tx, relevant, { ...ENV, updatePythPriceFeeds: true });
-    }
-  } catch {
+function compoundBalance(rawBalance, currentIndex) {
+  if (!rawBalance || !currentIndex || currentIndex === "0") return 0;
+  const scale = BigInt("1" + "0".repeat(RATE_DECIMALS));
+  const half = scale / 2n;
+  const result = (rawBalance * scale + half) / BigInt(currentIndex);
+  return Number(result) / 10 ** NAVI_BALANCE_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 [];
+  return decoded.map((s) => ({
+    assetId: s.asset_id,
+    supplyBalance: toBigInt(s.supply_balance),
+    borrowBalance: toBigInt(s.borrow_balance)
+  })).filter((s) => s.supplyBalance !== 0n || s.borrowBalance !== 0n);
+}
+async function fetchCoins(client, owner, coinType) {
+  const all = [];
+  let cursor;
+  let hasNext = true;
+  while (hasNext) {
+    const page = await client.getCoins({ owner, coinType, cursor: cursor ?? void 0 });
+    all.push(...page.data.map((c) => ({ coinObjectId: c.coinObjectId, balance: c.balance })));
+    cursor = page.nextCursor;
+    hasNext = page.hasNextPage;
+  }
+  return all;
+}
+function mergeCoinsPtb(tx, coins, amount) {
+  if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No coins to merge");
+  const primary = tx.object(coins[0].coinObjectId);
+  if (coins.length > 1) {
+    tx.mergeCoins(primary, coins.slice(1).map((c) => tx.object(c.coinObjectId)));
   }
+  const [split] = tx.splitCoins(primary, [amount]);
+  return split;
 }
 async function buildSaveTx(client, address, amount, options = {}) {
   const rawAmount = Number(usdcToRaw(amount));
-  const coins = await lending.getCoins(address, { coinType: USDC_TYPE, client });
-  if (!coins || coins.length === 0) {
-    throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins found");
-  }
+  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 tx = new transactions.Transaction();
   tx.setSender(address);
-  const coinObj = lending.mergeCoinsPTB(tx, coins, { balance: rawAmount });
+  const coinObj = mergeCoinsPtb(tx, coins, rawAmount);
   if (options.collectFee) {
     addCollectFeeToTx(tx, coinObj, "save");
   }
-  await lending.depositCoinPTB(tx, USDC_TYPE, coinObj, ENV);
+  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]
+  });
   return tx;
 }
 async function buildWithdrawTx(client, address, amount) {
-  const state = await lending.getLendingState(address, clientOpt(client, true));
-  const usdcPos = findUsdcPosition(state);
-  const deposited = usdcPos ? Number(usdcPos.supplyBalance) / 10 ** NAVI_BALANCE_DECIMALS : 0;
+  const [config, pool, pools, states] = await Promise.all([
+    getConfig(),
+    getUsdcPool(),
+    getPools(),
+    getUserState(client, address)
+  ]);
+  const usdcState = states.find((s) => s.assetId === pool.id);
+  const deposited = usdcState ? compoundBalance(usdcState.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));
   const tx = new transactions.Transaction();
   tx.setSender(address);
-  await updateOracle(tx, client, address);
-  const withdrawnCoin = await lending.withdrawCoinPTB(tx, USDC_TYPE, rawAmount, ENV);
-  tx.transferObjects([withdrawnCoin], address);
+  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);
   return { tx, effectiveAmount };
 }
 async function buildBorrowTx(client, address, amount, options = {}) {
   const rawAmount = Number(usdcToRaw(amount));
+  const [config, pool] = await Promise.all([getConfig(), getUsdcPool()]);
   const tx = new transactions.Transaction();
   tx.setSender(address);
-  await updateOracle(tx, client, address);
-  const borrowedCoin = await lending.borrowCoinPTB(tx, USDC_TYPE, rawAmount, ENV);
+  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");
   }
@@ -268,31 +399,79 @@ async function buildBorrowTx(client, address, amount, options = {}) {
 }
 async function buildRepayTx(client, address, amount) {
   const rawAmount = Number(usdcToRaw(amount));
-  const coins = await lending.getCoins(address, { coinType: USDC_TYPE, client });
-  if (!coins || coins.length === 0) {
-    throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins to repay with");
-  }
+  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 tx = new transactions.Transaction();
   tx.setSender(address);
-  const coinObj = lending.mergeCoinsPTB(tx, coins, { balance: rawAmount });
-  await lending.repayCoinPTB(tx, USDC_TYPE, coinObj, { ...ENV, amount: rawAmount });
+  const coinObj = mergeCoinsPtb(tx, coins, rawAmount);
+  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 [healthFactor, state, pool] = await Promise.all([
-    lending.getHealthFactor(address, clientOpt(client, true)),
-    lending.getLendingState(address, clientOpt(client, true)),
-    lending.getPool(USDC_TYPE, ENV)
+  const [config, pool, states] = await Promise.all([
+    getConfig(),
+    getUsdcPool(),
+    getUserState(client, address)
   ]);
-  const usdcPos = findUsdcPosition(state);
-  const supplied = usdcPos ? Number(usdcPos.supplyBalance) / 10 ** NAVI_BALANCE_DECIMALS : 0;
-  const borrowed = usdcPos ? Number(usdcPos.borrowBalance) / 10 ** NAVI_BALANCE_DECIMALS : 0;
+  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);
   const maxBorrowVal = Math.max(0, supplied * ltv - borrowed);
+  let healthFactor;
+  if (borrowed <= 0) {
+    healthFactor = Infinity;
+  } else {
+    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(pool.id),
+          tx.pure.address(address),
+          tx.pure.u8(pool.id),
+          tx.pure.u64(0),
+          tx.pure.u64(0),
+          tx.pure.bool(false)
+        ],
+        typeArguments: [pool.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 = borrowed > 0 ? supplied * liqThreshold / borrowed : Infinity;
+      }
+    } catch {
+      healthFactor = borrowed > 0 ? supplied * liqThreshold / borrowed : Infinity;
+    }
+  }
   return {
-    healthFactor: borrowed > 0 ? healthFactor : Infinity,
+    healthFactor,
     supplied,
     borrowed,
     maxBorrow: maxBorrowVal,
@@ -301,7 +480,7 @@ async function getHealthFactor(client, addressOrKeypair) {
 }
 async function getRates(client) {
   try {
-    const pool = await lending.getPool(USDC_TYPE, ENV);
+    const pool = await getUsdcPool();
     let saveApy = rateToApy(pool.currentSupplyRate);
     let borrowApy = rateToApy(pool.currentBorrowRate);
     if (saveApy <= 0 || saveApy > 100) saveApy = 4;
@@ -313,19 +492,21 @@ async function getRates(client) {
 }
 async function getPositions(client, addressOrKeypair) {
   const address = typeof addressOrKeypair === "string" ? addressOrKeypair : addressOrKeypair.getPublicKey().toSuiAddress();
-  const state = await lending.getLendingState(address, clientOpt(client, true));
+  const [states, pools] = await Promise.all([getUserState(client, address), getPools()]);
   const positions = [];
-  for (const pos of state) {
-    const symbol = pos.pool.token?.symbol ?? "UNKNOWN";
-    const supplyBal = Number(pos.supplyBalance) / 10 ** NAVI_BALANCE_DECIMALS;
-    const borrowBal = Number(pos.borrowBalance) / 10 ** NAVI_BALANCE_DECIMALS;
+  for (const state of states) {
+    const pool = pools.find((p) => p.id === state.assetId);
+    if (!pool) continue;
+    const symbol = pool.token?.symbol ?? "UNKNOWN";
+    const supplyBal = compoundBalance(state.supplyBalance, pool.currentSupplyIndex);
+    const borrowBal = compoundBalance(state.borrowBalance, pool.currentBorrowIndex);
     if (supplyBal > 1e-4) {
       positions.push({
         protocol: "navi",
         asset: symbol,
         type: "save",
         amount: supplyBal,
-        apy: rateToApy(pos.pool.currentSupplyRate)
+        apy: rateToApy(pool.currentSupplyRate)
       });
     }
     if (borrowBal > 1e-4) {
@@ -334,7 +515,7 @@ async function getPositions(client, addressOrKeypair) {
         asset: symbol,
         type: "borrow",
         amount: borrowBal,
-        apy: rateToApy(pos.pool.currentBorrowRate)
+        apy: rateToApy(pool.currentBorrowRate)
       });
     }
   }
@@ -351,21 +532,13 @@ async function maxWithdrawAmount(client, addressOrKeypair) {
   }
   const remainingSupply = hf.supplied - maxAmount;
   const hfAfter = hf.borrowed > 0 ? remainingSupply / hf.borrowed : Infinity;
-  return {
-    maxAmount,
-    healthFactorAfter: hfAfter,
-    currentHF: hf.healthFactor
-  };
+  return { maxAmount, healthFactorAfter: hfAfter, currentHF: hf.healthFactor };
 }
 async function maxBorrowAmount(client, addressOrKeypair) {
   const hf = await getHealthFactor(client, addressOrKeypair);
   const ltv = hf.liquidationThreshold > 0 ? hf.liquidationThreshold : 0.75;
   const maxAmount = Math.max(0, hf.supplied * ltv / MIN_HEALTH_FACTOR - hf.borrowed);
-  return {
-    maxAmount,
-    healthFactorAfter: MIN_HEALTH_FACTOR,
-    currentHF: hf.healthFactor
-  };
+  return { maxAmount, healthFactorAfter: MIN_HEALTH_FACTOR, currentHF: hf.healthFactor };
 }
 
 // src/adapters/navi.ts
@@ -561,6 +734,12 @@ var CetusAdapter = class {
 var USDC_TYPE2 = SUPPORTED_ASSETS.USDC.type;
 var WAD = 1e18;
 var MIN_HEALTH_FACTOR2 = 1.5;
+var CLOCK2 = "0x6";
+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 = "0xd2a67633ccb8de063163e25bcfca242929caf5cf1a26c2929dab519ee0b8f331";
 function interpolateRate(utilBreakpoints, aprBreakpoints, utilizationPct) {
   if (utilBreakpoints.length === 0) return 0;
   if (utilizationPct <= utilBreakpoints[0]) return aprBreakpoints[0];
@@ -575,85 +754,121 @@ function interpolateRate(utilBreakpoints, aprBreakpoints, utilizationPct) {
   }
   return aprBreakpoints[aprBreakpoints.length - 1];
 }
-function computeRatesFromReserve(reserve) {
-  const decimals = reserve.mintDecimals;
-  const available = Number(reserve.availableAmount) / 10 ** decimals;
-  const borrowed = Number(reserve.borrowedAmount.value) / WAD / 10 ** decimals;
+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;
-  const config = reserve.config.element;
-  if (!config) return { borrowAprPct: 0, depositAprPct: 0, utilizationPct: 0 };
-  const utils = config.interestRateUtils.map(Number);
-  const aprs = config.interestRateAprs.map((a) => Number(a) / 100);
-  const borrowAprPct = interpolateRate(utils, aprs, utilizationPct);
-  const spreadFeeBps = Number(config.spreadFeeBps);
-  const depositAprPct = utilizationPct / 100 * (borrowAprPct / 100) * (1 - spreadFeeBps / 1e4) * 100;
-  return { borrowAprPct, depositAprPct, utilizationPct };
+  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 };
 }
 function cTokenRatio(reserve) {
-  if (reserve.ctokenSupply === 0n) return 1;
-  const available = Number(reserve.availableAmount);
-  const borrowed = Number(reserve.borrowedAmount.value) / WAD;
-  const spreadFees = Number(reserve.unclaimedSpreadFees.value) / WAD;
-  const totalSupply = available + borrowed - spreadFees;
-  return totalSupply / Number(reserve.ctokenSupply);
+  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);
+  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
+  };
+}
+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 = "1.0.0";
+  version = "2.0.0";
   capabilities = ["save", "withdraw"];
   supportedAssets = ["USDC"];
   supportsSameAssetBorrow = false;
   client;
-  suilend;
-  lendingMarketType;
-  initialized = false;
-  initPromise = null;
+  publishedAt = null;
+  reserveCache = null;
   async init(client) {
     this.client = client;
-    await this.lazyInit();
   }
   initSync(client) {
     this.client = client;
   }
-  async lazyInit() {
-    if (this.initialized) return;
-    if (this.initPromise) return this.initPromise;
-    this.initPromise = (async () => {
-      let sdk;
-      try {
-        sdk = await import('@suilend/sdk');
-      } catch {
-        throw new T2000Error(
-          "PROTOCOL_UNAVAILABLE",
-          "Suilend SDK not installed. Run: npm install @suilend/sdk@^1"
-        );
-      }
-      this.lendingMarketType = sdk.LENDING_MARKET_TYPE;
-      try {
-        this.suilend = await sdk.SuilendClient.initialize(
-          sdk.LENDING_MARKET_ID,
-          sdk.LENDING_MARKET_TYPE,
-          this.client
-        );
-      } catch (err) {
-        this.initPromise = null;
-        throw new T2000Error(
-          "PROTOCOL_UNAVAILABLE",
-          `Failed to initialize Suilend: ${err instanceof Error ? err.message : String(err)}`
-        );
+  // -- 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;
       }
-      this.initialized = true;
-    })();
-    return this.initPromise;
+    } catch {
+    }
+    this.publishedAt = FALLBACK_PUBLISHED_AT;
+    return this.publishedAt;
   }
-  async ensureInit() {
-    if (!this.initialized) {
-      await this.lazyInit();
+  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(asset) {
+  findReserve(reserves, asset) {
     const upper = asset.toUpperCase();
     let coinType;
     if (upper === "USDC") coinType = USDC_TYPE2;
@@ -662,187 +877,229 @@ var SuilendAdapter = class {
     else return void 0;
     try {
       const normalized = utils.normalizeStructTag(coinType);
-      return this.suilend.lendingMarket.reserves.find(
-        (r) => utils.normalizeStructTag(r.coinType.name) === normalized
-      );
+      return reserves.find((r) => {
+        try {
+          return utils.normalizeStructTag(r.coinType) === normalized;
+        } catch {
+          return false;
+        }
+      });
     } catch {
       return void 0;
     }
   }
-  async getObligationCaps(address) {
-    const SuilendClientStatic = (await import('@suilend/sdk')).SuilendClient;
-    return SuilendClientStatic.getObligationOwnerCaps(
-      address,
-      [this.lendingMarketType],
-      this.client
-    );
+  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);
   }
   resolveSymbol(coinType) {
-    const normalized = utils.normalizeStructTag(coinType);
-    if (normalized === utils.normalizeStructTag(USDC_TYPE2)) return "USDC";
-    if (normalized === utils.normalizeStructTag("0x2::sui::SUI")) return "SUI";
+    try {
+      const normalized = utils.normalizeStructTag(coinType);
+      if (normalized === utils.normalizeStructTag(USDC_TYPE2)) return "USDC";
+      if (normalized === utils.normalizeStructTag("0x2::sui::SUI")) return "SUI";
+    } catch {
+    }
     const parts = coinType.split("::");
     return parts[parts.length - 1] || "UNKNOWN";
   }
+  // -- Adapter interface ----------------------------------------------------
   async getRates(asset) {
-    await this.ensureInit();
-    const reserve = this.findReserve(asset);
-    if (!reserve) {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `Suilend does not support ${asset}`);
-    }
-    const { borrowAprPct, depositAprPct } = computeRatesFromReserve(reserve);
-    return {
-      asset,
-      saveApy: depositAprPct,
-      borrowApy: borrowAprPct
-    };
+    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);
+    return { asset, saveApy: depositAprPct, borrowApy: borrowAprPct };
   }
   async getPositions(address) {
-    await this.ensureInit();
     const supplies = [];
     const borrows = [];
-    const caps = await this.getObligationCaps(address);
+    const caps = await this.fetchObligationCaps(address);
     if (caps.length === 0) return { supplies, borrows };
-    const obligation = await this.suilend.getObligation(caps[0].obligationId);
-    for (const deposit of obligation.deposits) {
-      const coinType = utils.normalizeStructTag(deposit.coinType.name);
-      const reserve = this.suilend.lendingMarket.reserves.find(
-        (r) => utils.normalizeStructTag(r.coinType.name) === coinType
-      );
+    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 ctokenAmount = Number(deposit.depositedCtokenAmount.toString());
       const ratio = cTokenRatio(reserve);
-      const amount = ctokenAmount * ratio / 10 ** reserve.mintDecimals;
-      const { depositAprPct } = computeRatesFromReserve(reserve);
-      supplies.push({ asset: this.resolveSymbol(coinType), amount, apy: depositAprPct });
+      const amount = dep.ctokenAmount * ratio / 10 ** reserve.mintDecimals;
+      const { depositAprPct } = computeRates(reserve);
+      supplies.push({ asset: this.resolveSymbol(dep.coinType), amount, apy: depositAprPct });
     }
-    for (const borrow of obligation.borrows) {
-      const coinType = utils.normalizeStructTag(borrow.coinType.name);
-      const reserve = this.suilend.lendingMarket.reserves.find(
-        (r) => utils.normalizeStructTag(r.coinType.name) === coinType
-      );
+    for (const bor of obligation.borrows) {
+      const reserve = reserves[bor.reserveIdx];
       if (!reserve) continue;
-      const rawBorrowed = Number(borrow.borrowedAmount.value.toString()) / WAD;
-      const amount = rawBorrowed / 10 ** reserve.mintDecimals;
-      const reserveRate = Number(reserve.cumulativeBorrowRate.value.toString()) / WAD;
-      const posRate = Number(borrow.cumulativeBorrowRate.value.toString()) / WAD;
-      const compounded = posRate > 0 ? amount * (reserveRate / posRate) : amount;
-      const { borrowAprPct } = computeRatesFromReserve(reserve);
-      borrows.push({ asset: this.resolveSymbol(coinType), amount: compounded, apy: borrowAprPct });
+      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 });
     }
     return { supplies, borrows };
   }
   async getHealth(address) {
-    await this.ensureInit();
-    const caps = await this.getObligationCaps(address);
+    const caps = await this.fetchObligationCaps(address);
     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 reserve = this.findReserve("USDC");
-    const closeLtv = reserve?.config?.element?.closeLtvPct ?? 75;
-    const openLtv = reserve?.config?.element?.openLtvPct ?? 70;
+    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 healthFactor = borrowed > 0 ? supplied * liqThreshold / borrowed : Infinity;
     const maxBorrow = Math.max(0, supplied * (openLtv / 100) - borrowed);
     return { healthFactor, supplied, borrowed, maxBorrow, liquidationThreshold: liqThreshold };
   }
   async buildSaveTx(address, amount, _asset, options) {
-    await this.ensureInit();
-    const rawAmount = usdcToRaw(amount).toString();
+    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 caps = await this.fetchObligationCaps(address);
     const tx = new transactions.Transaction();
     tx.setSender(address);
-    const caps = await this.getObligationCaps(address);
     let capRef;
     if (caps.length === 0) {
-      const [newCap] = this.suilend.createObligation(tx);
+      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 allCoins = await this.fetchAllCoins(address, USDC_TYPE2);
-    if (allCoins.length === 0) {
-      throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins found");
-    }
+    if (allCoins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC 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))
-      );
+      tx.mergeCoins(tx.object(primaryCoinId), allCoins.slice(1).map((c) => tx.object(c.coinObjectId)));
     }
+    const rawAmount = usdcToRaw(amount).toString();
     const [depositCoin] = tx.splitCoins(tx.object(primaryCoinId), [rawAmount]);
     if (options?.collectFee) {
       addCollectFeeToTx(tx, depositCoin, "save");
     }
-    this.suilend.deposit(depositCoin, USDC_TYPE2, capRef, tx);
+    const [ctokens] = tx.moveCall({
+      target: `${pkg}::lending_market::deposit_liquidity_and_mint_ctokens`,
+      typeArguments: [LENDING_MARKET_TYPE, USDC_TYPE2],
+      arguments: [
+        tx.object(LENDING_MARKET_ID),
+        tx.pure.u64(usdcReserve.arrayIndex),
+        tx.object(CLOCK2),
+        depositCoin
+      ]
+    });
+    tx.moveCall({
+      target: `${pkg}::lending_market::deposit_ctokens_into_obligation`,
+      typeArguments: [LENDING_MARKET_TYPE, USDC_TYPE2],
+      arguments: [
+        tx.object(LENDING_MARKET_ID),
+        tx.pure.u64(usdcReserve.arrayIndex),
+        typeof capRef === "string" ? tx.object(capRef) : capRef,
+        tx.object(CLOCK2),
+        ctokens
+      ]
+    });
     return { tx };
   }
   async buildWithdrawTx(address, amount, _asset) {
-    await this.ensureInit();
-    const caps = await this.getObligationCaps(address);
-    if (caps.length === 0) {
-      throw new T2000Error("NO_COLLATERAL", "No Suilend position found");
-    }
+    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 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 usdcSupply = positions.supplies.find((s) => s.asset === "USDC");
-    const deposited = usdcSupply?.amount ?? 0;
+    const deposited = positions.supplies.find((s) => s.asset === "USDC")?.amount ?? 0;
     const effectiveAmount = Math.min(amount, deposited);
-    if (effectiveAmount <= 0) {
-      throw new T2000Error("NO_COLLATERAL", "Nothing to withdraw from Suilend");
-    }
-    const rawAmount = usdcToRaw(effectiveAmount).toString();
+    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);
     const tx = new transactions.Transaction();
     tx.setSender(address);
-    await this.suilend.withdrawAndSendToUser(
-      address,
-      caps[0].id,
-      caps[0].obligationId,
-      USDC_TYPE2,
-      rawAmount,
-      tx
-    );
+    const [ctokens] = tx.moveCall({
+      target: `${pkg}::lending_market::withdraw_ctokens`,
+      typeArguments: [LENDING_MARKET_TYPE, USDC_TYPE2],
+      arguments: [
+        tx.object(LENDING_MARKET_ID),
+        tx.pure.u64(usdcReserve.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 [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],
+      arguments: [
+        tx.object(LENDING_MARKET_ID),
+        tx.pure.u64(usdcReserve.arrayIndex),
+        tx.object(CLOCK2),
+        ctokens,
+        none
+      ]
+    });
+    tx.transferObjects([coin], address);
     return { tx, effectiveAmount };
   }
   async buildBorrowTx(_address, _amount, _asset, _options) {
-    throw new T2000Error(
-      "ASSET_NOT_SUPPORTED",
-      "SuilendAdapter.buildBorrowTx() not available \u2014 Suilend requires different collateral/borrow assets. Deferred to Phase 10."
-    );
+    throw new T2000Error("ASSET_NOT_SUPPORTED", "Suilend borrow requires different collateral/borrow assets. Deferred to Phase 10.");
   }
   async buildRepayTx(_address, _amount, _asset) {
-    throw new T2000Error(
-      "ASSET_NOT_SUPPORTED",
-      "SuilendAdapter.buildRepayTx() not available \u2014 deferred to Phase 10."
-    );
+    throw new T2000Error("ASSET_NOT_SUPPORTED", "Suilend repay deferred to Phase 10.");
   }
   async maxWithdraw(address, _asset) {
-    await this.ensureInit();
     const health = await this.getHealth(address);
     let maxAmount;
     if (health.borrowed === 0) {
       maxAmount = health.supplied;
     } else {
-      maxAmount = Math.max(
-        0,
-        health.supplied - health.borrowed * MIN_HEALTH_FACTOR2 / health.liquidationThreshold
-      );
+      maxAmount = Math.max(0, health.supplied - health.borrowed * MIN_HEALTH_FACTOR2 / health.liquidationThreshold);
     }
     const remainingSupply = health.supplied - maxAmount;
     const hfAfter = health.borrowed > 0 ? remainingSupply * health.liquidationThreshold / health.borrowed : Infinity;
-    return {
-      maxAmount,
-      healthFactorAfter: hfAfter,
-      currentHF: health.healthFactor
-    };
+    return { maxAmount, healthFactorAfter: hfAfter, currentHF: health.healthFactor };
   }
   async maxBorrow(_address, _asset) {
-    throw new T2000Error(
-      "ASSET_NOT_SUPPORTED",
-      "SuilendAdapter.maxBorrow() not available \u2014 deferred to Phase 10."
-    );
+    throw new T2000Error("ASSET_NOT_SUPPORTED", "Suilend maxBorrow deferred to Phase 10.");
   }
   async fetchAllCoins(owner, coinType) {
     const all = [];