@t2000/sdk 0.17.29 → 0.18.3

package/dist/adapters/index.js

@@ -1,17 +1,2109 @@
-export { ProtocolRegistry } from './registry.js';
-export { NaviAdapter, descriptor as naviDescriptor } from './navi.js';
-export { CetusAdapter, descriptor as cetusDescriptor } from './cetus.js';
-export { SuilendAdapter, descriptor as suilendDescriptor } from './suilend.js';
-export { descriptor as sentinelDescriptor } from '../protocols/sentinel.js';
-import { descriptor as naviDescriptor } from './navi.js';
-import { descriptor as cetusDescriptor } from './cetus.js';
-import { descriptor as suilendDescriptor } from './suilend.js';
-import { descriptor as sentinelDescriptor } from '../protocols/sentinel.js';
-/** All registered protocol descriptors — used by the indexer for event classification */
-export const allDescriptors = [
-    naviDescriptor,
-    suilendDescriptor,
-    cetusDescriptor,
-    sentinelDescriptor,
+import { Transaction } from '@mysten/sui/transactions';
+import { bcs } from '@mysten/sui/bcs';
+import { AggregatorClient, Env } from '@cetusprotocol/aggregator-sdk';
+import { normalizeStructTag } from '@mysten/sui/utils';
+
+// src/constants.ts
+var SAVE_FEE_BPS = 10n;
+var SWAP_FEE_BPS = 0n;
+var BORROW_FEE_BPS = 5n;
+var SUPPORTED_ASSETS = {
+  USDC: {
+    type: "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
+    decimals: 6,
+    symbol: "USDC",
+    displayName: "USDC"
+  },
+  USDT: {
+    type: "0x375f70cf2ae4c00bf37117d0c85a2c71545e6ee05c4a5c7d282cd66a4504b068::usdt::USDT",
+    decimals: 6,
+    symbol: "USDT",
+    displayName: "suiUSDT"
+  },
+  USDe: {
+    type: "0x41d587e5336f1c86cad50d38a7136db99333bb9bda91cea4ba69115defeb1402::sui_usde::SUI_USDE",
+    decimals: 6,
+    symbol: "USDe",
+    displayName: "suiUSDe"
+  },
+  USDsui: {
+    type: "0x44f838219cf67b058f3b37907b655f226153c18e33dfcd0da559a844fea9b1c1::usdsui::USDSUI",
+    decimals: 6,
+    symbol: "USDsui",
+    displayName: "USDsui"
+  },
+  SUI: {
+    type: "0x2::sui::SUI",
+    decimals: 9,
+    symbol: "SUI",
+    displayName: "SUI"
+  },
+  BTC: {
+    type: "0x0041f9f9344cac094454cd574e333c4fdb132d7bcc9379bcd4aab485b2a63942::wbtc::WBTC",
+    decimals: 8,
+    symbol: "BTC",
+    displayName: "Bitcoin"
+  },
+  ETH: {
+    type: "0xd0e89b2af5e4910726fbcd8b8dd37bb79b29e5f83f7491bca830e94f7f226d29::eth::ETH",
+    decimals: 8,
+    symbol: "ETH",
+    displayName: "Ethereum"
+  },
+  GOLD: {
+    type: "0x9d297676e7a4b771ab023291377b2adfaa4938fb9080b8d12430e4b108b836a9::xaum::XAUM",
+    decimals: 9,
+    symbol: "GOLD",
+    displayName: "Gold"
+  }
+};
+var STABLE_ASSETS = ["USDC", "USDT", "USDe", "USDsui"];
+var T2000_PACKAGE_ID = process.env.T2000_PACKAGE_ID ?? "0xab92e9f1fe549ad3d6a52924a73181b45791e76120b975138fac9ec9b75db9f3";
+var T2000_CONFIG_ID = process.env.T2000_CONFIG_ID ?? "0x408add9aa9322f93cfd87523d8f603006eb8713894f4c460283c58a6888dae8a";
+var T2000_TREASURY_ID = process.env.T2000_TREASURY_ID ?? "0x3bb501b8300125dca59019247941a42af6b292a150ce3cfcce9449456be2ec91";
+process.env.T2000_API_URL ?? "https://api.t2000.ai";
+var CETUS_USDC_SUI_POOL = "0x51e883ba7c0b566a26cbc8a94cd33eb0abd418a77cc1e60ad22fd9b1f29cd2ab";
+var CETUS_PACKAGE = "0x1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb";
+var INVESTMENT_ASSETS = {
+  SUI: SUPPORTED_ASSETS.SUI,
+  BTC: SUPPORTED_ASSETS.BTC,
+  ETH: SUPPORTED_ASSETS.ETH,
+  GOLD: SUPPORTED_ASSETS.GOLD
+};
+var SENTINEL = {
+  PACKAGE: "0x88b83f36dafcd5f6dcdcf1d2cb5889b03f61264ab3cee9cae35db7aa940a21b7"};
+
+// src/errors.ts
+var T2000Error = class extends Error {
+  code;
+  data;
+  retryable;
+  constructor(code, message, data, retryable = false) {
+    super(message);
+    this.name = "T2000Error";
+    this.code = code;
+    this.data = data;
+    this.retryable = retryable;
+  }
+  toJSON() {
+    return {
+      error: this.code,
+      message: this.message,
+      ...this.data && { data: this.data },
+      retryable: this.retryable
+    };
+  }
+};
+
+// src/adapters/registry.ts
+var ProtocolRegistry = class {
+  lending = /* @__PURE__ */ new Map();
+  swap = /* @__PURE__ */ new Map();
+  registerLending(adapter) {
+    this.lending.set(adapter.id, adapter);
+  }
+  registerSwap(adapter) {
+    this.swap.set(adapter.id, adapter);
+  }
+  async bestSaveRate(asset) {
+    const candidates = [];
+    for (const adapter of this.lending.values()) {
+      if (!adapter.supportedAssets.includes(asset)) continue;
+      if (!adapter.capabilities.includes("save")) continue;
+      try {
+        const rate = await adapter.getRates(asset);
+        candidates.push({ adapter, rate });
+      } catch {
+      }
+    }
+    if (candidates.length === 0) {
+      throw new T2000Error("ASSET_NOT_SUPPORTED", `No lending adapter supports saving ${asset}`);
+    }
+    candidates.sort((a, b) => b.rate.saveApy - a.rate.saveApy);
+    return candidates[0];
+  }
+  async bestBorrowRate(asset, opts) {
+    const candidates = [];
+    for (const adapter of this.lending.values()) {
+      if (!adapter.supportedAssets.includes(asset)) continue;
+      if (!adapter.capabilities.includes("borrow")) continue;
+      if (opts?.requireSameAssetBorrow && !adapter.supportsSameAssetBorrow) continue;
+      try {
+        const rate = await adapter.getRates(asset);
+        candidates.push({ adapter, rate });
+      } catch {
+      }
+    }
+    if (candidates.length === 0) {
+      throw new T2000Error("ASSET_NOT_SUPPORTED", `No lending adapter supports borrowing ${asset}`);
+    }
+    candidates.sort((a, b) => a.rate.borrowApy - b.rate.borrowApy);
+    return candidates[0];
+  }
+  async bestSwapQuote(from, to, amount) {
+    const candidates = [];
+    for (const adapter of this.swap.values()) {
+      const pairs = adapter.getSupportedPairs();
+      if (!pairs.some((p) => p.from === from && p.to === to)) continue;
+      try {
+        const quote = await adapter.getQuote(from, to, amount);
+        candidates.push({ adapter, quote });
+      } catch {
+      }
+    }
+    if (candidates.length === 0) {
+      throw new T2000Error("ASSET_NOT_SUPPORTED", `No swap adapter supports ${from} \u2192 ${to}`);
+    }
+    candidates.sort((a, b) => b.quote.expectedOutput - a.quote.expectedOutput);
+    return candidates[0];
+  }
+  async bestSaveRateAcrossAssets() {
+    const candidates = [];
+    for (const asset of STABLE_ASSETS) {
+      for (const adapter of this.lending.values()) {
+        if (!adapter.supportedAssets.includes(asset)) continue;
+        if (!adapter.capabilities.includes("save")) continue;
+        try {
+          const rate = await adapter.getRates(asset);
+          candidates.push({ adapter, rate, asset });
+        } catch {
+        }
+      }
+    }
+    if (candidates.length === 0) {
+      throw new T2000Error("ASSET_NOT_SUPPORTED", "No lending adapter found for any stablecoin");
+    }
+    candidates.sort((a, b) => b.rate.saveApy - a.rate.saveApy);
+    return candidates[0];
+  }
+  async allRatesAcrossAssets() {
+    const results = [];
+    const allAssets = [...STABLE_ASSETS, ...Object.keys(INVESTMENT_ASSETS)];
+    const seen = /* @__PURE__ */ new Set();
+    for (const asset of allAssets) {
+      if (seen.has(asset)) continue;
+      seen.add(asset);
+      for (const adapter of this.lending.values()) {
+        if (!adapter.supportedAssets.includes(asset)) continue;
+        try {
+          const rates = await adapter.getRates(asset);
+          if (rates.saveApy > 0 || rates.borrowApy > 0) {
+            results.push({ protocol: adapter.name, protocolId: adapter.id, asset, rates });
+          }
+        } catch {
+        }
+      }
+    }
+    return results;
+  }
+  async allRates(asset) {
+    const results = [];
+    for (const adapter of this.lending.values()) {
+      if (!adapter.supportedAssets.includes(asset)) continue;
+      try {
+        const rates = await adapter.getRates(asset);
+        results.push({ protocol: adapter.name, protocolId: adapter.id, rates });
+      } catch {
+      }
+    }
+    return results;
+  }
+  async allPositions(address) {
+    const results = [];
+    for (const adapter of this.lending.values()) {
+      try {
+        const positions = await adapter.getPositions(address);
+        if (positions.supplies.length > 0 || positions.borrows.length > 0) {
+          results.push({ protocol: adapter.name, protocolId: adapter.id, positions });
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+  getLending(id) {
+    return this.lending.get(id);
+  }
+  getSwap(id) {
+    return this.swap.get(id);
+  }
+  listLending() {
+    return [...this.lending.values()];
+  }
+  listSwap() {
+    return [...this.swap.values()];
+  }
+};
+
+// src/utils/format.ts
+function stableToRaw(amount, decimals) {
+  return BigInt(Math.round(amount * 10 ** decimals));
+}
+var ASSET_LOOKUP = /* @__PURE__ */ new Map();
+for (const [key, info] of Object.entries(SUPPORTED_ASSETS)) {
+  ASSET_LOOKUP.set(key.toUpperCase(), key);
+  if (info.displayName && info.displayName.toUpperCase() !== key.toUpperCase()) {
+    ASSET_LOOKUP.set(info.displayName.toUpperCase(), key);
+  }
+}
+function normalizeAsset(input) {
+  return ASSET_LOOKUP.get(input.toUpperCase()) ?? input;
+}
+
+// src/protocols/protocolFee.ts
+var FEE_RATES = {
+  save: SAVE_FEE_BPS,
+  swap: SWAP_FEE_BPS,
+  borrow: BORROW_FEE_BPS
+};
+var OP_CODES = {
+  save: 0,
+  swap: 1,
+  borrow: 2
+};
+function addCollectFeeToTx(tx, paymentCoin, operation) {
+  const bps = FEE_RATES[operation];
+  if (bps <= 0n) return;
+  tx.moveCall({
+    target: `${T2000_PACKAGE_ID}::treasury::collect_fee`,
+    typeArguments: [SUPPORTED_ASSETS.USDC.type],
+    arguments: [
+      tx.object(T2000_TREASURY_ID),
+      tx.object(T2000_CONFIG_ID),
+      paymentCoin,
+      tx.pure.u8(OP_CODES[operation])
+    ]
+  });
+}
+var RATE_DECIMALS = 27;
+var LTV_DECIMALS = 27;
+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.struct("UserStateInfo", {
+  asset_id: bcs.u8(),
+  borrow_balance: bcs.u256(),
+  supply_balance: 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;
+}
+function resolvePoolSymbol(pool) {
+  const coinType = pool.suiCoinType || pool.coinType || "";
+  for (const [key, info] of Object.entries(SUPPORTED_ASSETS)) {
+    if (matchesCoinType(coinType, info.type)) return key;
+  }
+  return pool.token?.symbol ?? "UNKNOWN";
+}
+function resolveAssetInfo(asset) {
+  if (asset in SUPPORTED_ASSETS) {
+    const info = SUPPORTED_ASSETS[asset];
+    return { type: info.type, decimals: info.decimals, displayName: info.displayName };
+  }
+  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 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.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;
+  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 mergeCoins(tx, coins) {
+  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)));
+  }
+  return primary;
+}
+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 Transaction();
+  tx.setSender(address);
+  const coinObj = mergeCoins(tx, coins);
+  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]
+  });
+  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)));
+  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`);
+  }
+  const tx = new 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);
+  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)));
+  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({
+      target: "0x2::coin::zero",
+      typeArguments: [pool.suiCoinType]
+    });
+    return { coin: coin2, effectiveAmount: 0 };
+  }
+  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)]);
+  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]
+  });
+}
+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]
+  });
+}
+async function buildBorrowTx(client, address, amount, options = {}) {
+  if (!amount || amount <= 0 || !Number.isFinite(amount)) {
+    throw new T2000Error("INVALID_AMOUNT", "Borrow amount must be a positive number");
+  }
+  const 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 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");
+  }
+  tx.transferObjects([borrowedCoin], address);
+  return tx;
+}
+async function buildRepayTx(client, address, amount, options = {}) {
+  if (!amount || amount <= 0 || !Number.isFinite(amount)) {
+    throw new T2000Error("INVALID_AMOUNT", "Repay amount must be a positive number");
+  }
+  const 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 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 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.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) {
+  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, pools] = await Promise.all([getUserState(client, address), getPools()]);
+  const positions = [];
+  for (const state of states) {
+    const pool = pools.find((p) => p.id === state.assetId);
+    if (!pool) 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)
+      });
+    }
+  }
+  return { positions };
+}
+async function maxWithdrawAmount(client, addressOrKeypair) {
+  const hf = await getHealthFactor(client, addressOrKeypair);
+  const ltv = hf.liquidationThreshold > 0 ? hf.liquidationThreshold : 0.75;
+  let maxAmount;
+  if (hf.borrowed === 0) {
+    maxAmount = hf.supplied;
+  } else {
+    maxAmount = Math.max(0, hf.supplied - hf.borrowed * MIN_HEALTH_FACTOR / ltv);
+  }
+  const remainingSupply = hf.supplied - maxAmount;
+  const hfAfter = hf.borrowed > 0 ? remainingSupply * ltv / hf.borrowed : Infinity;
+  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 };
+}
+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
+    });
+  }
+  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.vector(bcs.string()).serialize(assets)),
+        tx.pure(bcs.vector(bcs.Address).serialize(ruleIds))
+      ]
+    });
+    const [coin] = tx.moveCall({
+      target: "0x2::coin::from_balance",
+      typeArguments: [rewardType],
+      arguments: [balance]
+    });
+    tx.transferObjects([coin], address);
+    claimed.push({
+      protocol: "navi",
+      asset: assets.join(", "),
+      coinType: rewardType,
+      symbol: REWARD_SYMBOLS[rewardType] ?? "UNKNOWN",
+      amount: 0,
+      estimatedValueUsd: 0
+    });
+  }
+  return claimed;
+}
+
+// src/adapters/navi.ts
+var descriptor = {
+  id: "navi",
+  name: "NAVI Protocol",
+  packages: [],
+  dynamicPackageId: true,
+  actionMap: {
+    "incentive_v3::entry_deposit": "save",
+    "incentive_v3::deposit": "save",
+    "incentive_v3::withdraw_v2": "withdraw",
+    "incentive_v3::entry_withdraw": "withdraw",
+    "incentive_v3::borrow_v2": "borrow",
+    "incentive_v3::entry_borrow": "borrow",
+    "incentive_v3::entry_repay": "repay",
+    "incentive_v3::repay": "repay"
+  }
+};
+var NaviAdapter = class {
+  id = "navi";
+  name = "NAVI Protocol";
+  version = "1.0.0";
+  capabilities = ["save", "withdraw", "borrow", "repay"];
+  supportedAssets = [...STABLE_ASSETS, "SUI", "ETH", "GOLD"];
+  supportsSameAssetBorrow = true;
+  client;
+  async init(client) {
+    this.client = client;
+  }
+  initSync(client) {
+    this.client = client;
+  }
+  async getRates(asset) {
+    const rates = await getRates(this.client);
+    const normalized = normalizeAsset(asset);
+    const r = rates[normalized];
+    if (!r) throw new T2000Error("ASSET_NOT_SUPPORTED", `NAVI does not support ${asset}`);
+    return { asset: normalized, saveApy: r.saveApy, borrowApy: r.borrowApy };
+  }
+  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 }))
+    };
+  }
+  async getHealth(address) {
+    return getHealthFactor(this.client, address);
+  }
+  async buildSaveTx(address, amount, asset, options) {
+    const normalized = normalizeAsset(asset);
+    const tx = await buildSaveTx(this.client, address, amount, { ...options, asset: normalized });
+    return { tx };
+  }
+  async buildWithdrawTx(address, amount, asset) {
+    const normalized = normalizeAsset(asset);
+    const result = await buildWithdrawTx(this.client, address, amount, { asset: normalized });
+    return { tx: result.tx, effectiveAmount: result.effectiveAmount };
+  }
+  async buildBorrowTx(address, amount, asset, options) {
+    const normalized = normalizeAsset(asset);
+    const tx = await buildBorrowTx(this.client, address, amount, { ...options, asset: normalized });
+    return { tx };
+  }
+  async buildRepayTx(address, amount, asset) {
+    const normalized = normalizeAsset(asset);
+    const tx = await buildRepayTx(this.client, address, amount, { asset: normalized });
+    return { tx };
+  }
+  async maxWithdraw(address, _asset) {
+    return maxWithdrawAmount(this.client, address);
+  }
+  async maxBorrow(address, _asset) {
+    return maxBorrowAmount(this.client, address);
+  }
+  async addWithdrawToTx(tx, address, amount, asset) {
+    const normalized = normalizeAsset(asset);
+    return addWithdrawToTx(tx, this.client, address, amount, { asset: normalized });
+  }
+  async addSaveToTx(tx, address, coin, asset, options) {
+    const normalized = normalizeAsset(asset);
+    return addSaveToTx(tx, this.client, address, coin, { ...options, asset: normalized });
+  }
+  async addRepayToTx(tx, address, coin, asset) {
+    const normalized = normalizeAsset(asset);
+    return addRepayToTx(tx, this.client, address, coin, { asset: normalized });
+  }
+  async getPendingRewards(address) {
+    return getPendingRewards(this.client, address);
+  }
+  async addClaimRewardsToTx(tx, address) {
+    return addClaimRewardsToTx(tx, this.client, address);
+  }
+};
+var DEFAULT_SLIPPAGE_BPS = 300;
+function createAggregatorClient(client, signer) {
+  return new AggregatorClient({
+    client,
+    signer,
+    env: Env.Mainnet
+  });
+}
+async function buildSwapTx(params) {
+  const { client, address, fromAsset, toAsset, amount, maxSlippageBps = DEFAULT_SLIPPAGE_BPS } = params;
+  const fromInfo = SUPPORTED_ASSETS[fromAsset];
+  const toInfo = SUPPORTED_ASSETS[toAsset];
+  if (!fromInfo || !toInfo) {
+    throw new T2000Error("ASSET_NOT_SUPPORTED", `Swap pair ${fromAsset}/${toAsset} is not supported`);
+  }
+  const rawAmount = BigInt(Math.floor(amount * 10 ** fromInfo.decimals));
+  const aggClient = createAggregatorClient(client, address);
+  const _origLog = console.log;
+  console.log = () => {
+  };
+  let result;
+  try {
+    result = await aggClient.findRouters({
+      from: fromInfo.type,
+      target: toInfo.type,
+      amount: rawAmount,
+      byAmountIn: true
+    });
+  } finally {
+    console.log = _origLog;
+  }
+  if (!result || result.insufficientLiquidity) {
+    throw new T2000Error(
+      "ASSET_NOT_SUPPORTED",
+      `No swap route found for ${fromAsset} \u2192 ${toAsset}`
+    );
+  }
+  const tx = new Transaction();
+  const slippage = maxSlippageBps / 1e4;
+  console.log = () => {
+  };
+  try {
+    await aggClient.fastRouterSwap({
+      router: result,
+      txb: tx,
+      slippage
+    });
+  } finally {
+    console.log = _origLog;
+  }
+  const estimatedOut = Number(result.amountOut.toString());
+  return {
+    tx,
+    estimatedOut,
+    toDecimals: toInfo.decimals
+  };
+}
+async function addSwapToTx(params) {
+  const { tx, client, address, inputCoin, fromAsset, toAsset, amount, maxSlippageBps = DEFAULT_SLIPPAGE_BPS } = params;
+  const fromInfo = SUPPORTED_ASSETS[fromAsset];
+  const toInfo = SUPPORTED_ASSETS[toAsset];
+  if (!fromInfo || !toInfo) {
+    throw new T2000Error("ASSET_NOT_SUPPORTED", `Swap pair ${fromAsset}/${toAsset} is not supported`);
+  }
+  const rawAmount = BigInt(Math.floor(amount * 10 ** fromInfo.decimals));
+  const aggClient = createAggregatorClient(client, address);
+  const _origLog = console.log;
+  console.log = () => {
+  };
+  let result;
+  try {
+    result = await aggClient.findRouters({
+      from: fromInfo.type,
+      target: toInfo.type,
+      amount: rawAmount,
+      byAmountIn: true
+    });
+  } finally {
+    console.log = _origLog;
+  }
+  if (!result || result.insufficientLiquidity) {
+    throw new T2000Error(
+      "ASSET_NOT_SUPPORTED",
+      `No swap route found for ${fromAsset} \u2192 ${toAsset}`
+    );
+  }
+  const slippage = maxSlippageBps / 1e4;
+  console.log = () => {
+  };
+  let outputCoin;
+  try {
+    outputCoin = await aggClient.routerSwap({
+      router: result,
+      txb: tx,
+      inputCoin,
+      slippage
+    });
+  } finally {
+    console.log = _origLog;
+  }
+  const estimatedOut = Number(result.amountOut.toString());
+  return {
+    outputCoin,
+    estimatedOut,
+    toDecimals: toInfo.decimals
+  };
+}
+async function getPoolPrice(client) {
+  try {
+    const pool = await client.getObject({
+      id: CETUS_USDC_SUI_POOL,
+      options: { showContent: true }
+    });
+    if (pool.data?.content?.dataType === "moveObject") {
+      const fields = pool.data.content.fields;
+      const currentSqrtPrice = BigInt(String(fields.current_sqrt_price ?? "0"));
+      if (currentSqrtPrice > 0n) {
+        const Q64 = 2n ** 64n;
+        const sqrtPriceFloat = Number(currentSqrtPrice) / Number(Q64);
+        const rawPrice = sqrtPriceFloat * sqrtPriceFloat;
+        const suiPriceUsd = 1e3 / rawPrice;
+        if (suiPriceUsd > 0.01 && suiPriceUsd < 1e3) return suiPriceUsd;
+      }
+    }
+  } catch {
+  }
+  return 3.5;
+}
+async function getSwapQuote(client, fromAsset, toAsset, amount) {
+  const fromInfo = SUPPORTED_ASSETS[fromAsset];
+  const toInfo = SUPPORTED_ASSETS[toAsset];
+  if (!fromInfo || !toInfo) {
+    throw new T2000Error("ASSET_NOT_SUPPORTED", `Swap pair ${fromAsset}/${toAsset} is not supported`);
+  }
+  const rawAmount = BigInt(Math.floor(amount * 10 ** fromInfo.decimals));
+  const poolPrice = await getPoolPrice(client);
+  try {
+    const aggClient = createAggregatorClient(client);
+    const result = await aggClient.findRouters({
+      from: fromInfo.type,
+      target: toInfo.type,
+      amount: rawAmount,
+      byAmountIn: true
+    });
+    if (!result || result.insufficientLiquidity) {
+      return fallbackQuote(fromAsset, amount, poolPrice);
+    }
+    const expectedOutput = Number(result.amountOut.toString()) / 10 ** toInfo.decimals;
+    const priceImpact = result.deviationRatio ?? 0;
+    return { expectedOutput, priceImpact, poolPrice };
+  } catch {
+    return fallbackQuote(fromAsset, amount, poolPrice);
+  }
+}
+function fallbackQuote(fromAsset, amount, poolPrice) {
+  const expectedOutput = fromAsset === "USDC" ? amount / poolPrice : amount * poolPrice;
+  return { expectedOutput, priceImpact: 0, poolPrice };
+}
+
+// src/adapters/cetus.ts
+var descriptor2 = {
+  id: "cetus",
+  name: "Cetus DEX",
+  packages: [CETUS_PACKAGE],
+  actionMap: {
+    "router::swap": "swap",
+    "router::swap_ab_bc": "swap",
+    "router::swap_ab_cb": "swap",
+    "router::swap_ba_bc": "swap",
+    "router::swap_ba_cb": "swap"
+  }
+};
+var CetusAdapter = class {
+  id = "cetus";
+  name = "Cetus";
+  version = "1.0.0";
+  capabilities = ["swap"];
+  client;
+  async init(client) {
+    this.client = client;
+  }
+  initSync(client) {
+    this.client = client;
+  }
+  async getQuote(from, to, amount) {
+    return getSwapQuote(this.client, from, to, amount);
+  }
+  async buildSwapTx(address, from, to, amount, maxSlippageBps) {
+    const result = await buildSwapTx({
+      client: this.client,
+      address,
+      fromAsset: from,
+      toAsset: to,
+      amount,
+      maxSlippageBps
+    });
+    return {
+      tx: result.tx,
+      estimatedOut: result.estimatedOut,
+      toDecimals: result.toDecimals
+    };
+  }
+  getSupportedPairs() {
+    const pairs = [];
+    for (const asset of Object.keys(INVESTMENT_ASSETS)) {
+      pairs.push({ from: "USDC", to: asset }, { from: asset, to: "USDC" });
+    }
+    for (const a of STABLE_ASSETS) {
+      for (const b of STABLE_ASSETS) {
+        if (a !== b) pairs.push({ from: a, to: b });
+      }
+    }
+    return pairs;
+  }
+  async getPoolPrice() {
+    return getPoolPrice(this.client);
+  }
+  async addSwapToTx(tx, address, inputCoin, from, to, amount, maxSlippageBps) {
+    return addSwapToTx({
+      tx,
+      client: this.client,
+      address,
+      inputCoin,
+      fromAsset: from,
+      toAsset: to,
+      amount,
+      maxSlippageBps
+    });
+  }
+};
+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 descriptor3 = {
+  id: "suilend",
+  name: "Suilend",
+  packages: [SUILEND_PACKAGE],
+  actionMap: {
+    "lending_market::deposit_liquidity_and_mint_ctokens": "save",
+    "lending_market::deposit_ctokens_into_obligation": "save",
+    "lending_market::create_obligation": "save",
+    "lending_market::withdraw_ctokens": "withdraw",
+    "lending_market::redeem_ctokens_and_withdraw_liquidity": "withdraw",
+    "lending_market::redeem_ctokens_and_withdraw_liquidity_request": "withdraw",
+    "lending_market::fulfill_liquidity_request": "withdraw",
+    "lending_market::unstake_sui_from_staker": "withdraw",
+    "lending_market::borrow": "borrow",
+    "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";
+  capabilities = ["save", "withdraw", "borrow", "repay"];
+  supportedAssets = [...STABLE_ASSETS, "SUI", "ETH", "BTC", "GOLD"];
+  supportsSameAssetBorrow = false;
+  client;
+  publishedAt = null;
+  reserveCache = 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 {
+    }
+    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 = normalizeStructTag(coinType);
+      return reserves.find((r) => {
+        try {
+          return 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);
+  }
+  resolveSymbol(coinType) {
+    try {
+      const normalized = normalizeStructTag(coinType);
+      for (const [key, info] of Object.entries(SUPPORTED_ASSETS)) {
+        try {
+          if (normalizeStructTag(info.type) === normalized) return key;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    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 };
+  }
+  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 });
+    }
+    return { supplies, borrows };
+  }
+  async getHealth(address) {
+    const caps = await this.fetchObligationCaps(address);
+    if (caps.length === 0) {
+      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 tx = new 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 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]);
+    if (options?.collectFee) {
+      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);
+    }
+    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);
+    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 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 tx = new 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);
+    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);
+    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 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);
+    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);
+    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;
+    }
+    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);
+    }
+  }
+  async buildBorrowTx(address, amount, asset, options) {
+    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
+    const assetInfo = SUPPORTED_ASSETS[assetKey];
+    const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves()]);
+    const reserve = this.findReserve(reserves, assetKey);
+    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend. Try: NAVI or a different asset.`);
+    const caps = await this.fetchObligationCaps(address);
+    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend position found. Deposit collateral first with: t2000 save <amount>");
+    const rawAmount = stableToRaw(amount, assetInfo.decimals);
+    const tx = new Transaction();
+    tx.setSender(address);
+    const [coin] = tx.moveCall({
+      target: `${pkg}::lending_market::borrow`,
+      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
+      arguments: [
+        tx.object(LENDING_MARKET_ID),
+        tx.pure.u64(reserve.arrayIndex),
+        tx.object(caps[0].id),
+        tx.object(CLOCK2),
+        tx.pure.u64(rawAmount)
+      ]
+    });
+    if (options?.collectFee) {
+      addCollectFeeToTx(tx, coin, "borrow");
+    }
+    tx.transferObjects([coin], address);
+    return { tx };
+  }
+  async buildRepayTx(address, amount, asset) {
+    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
+    const assetInfo = SUPPORTED_ASSETS[assetKey];
+    const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves()]);
+    const reserve = this.findReserve(reserves, assetKey);
+    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend`);
+    const caps = await this.fetchObligationCaps(address);
+    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend obligation found");
+    const allCoins = await this.fetchAllCoins(address, assetInfo.type);
+    if (allCoins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} coins to repay with`);
+    const rawAmount = stableToRaw(amount, assetInfo.decimals);
+    const tx = new Transaction();
+    tx.setSender(address);
+    const primaryCoinId = allCoins[0].coinObjectId;
+    if (allCoins.length > 1) {
+      tx.mergeCoins(tx.object(primaryCoinId), allCoins.slice(1).map((c) => tx.object(c.coinObjectId)));
+    }
+    const [repayCoin] = tx.splitCoins(tx.object(primaryCoinId), [rawAmount.toString()]);
+    tx.moveCall({
+      target: `${pkg}::lending_market::repay`,
+      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
+      arguments: [
+        tx.object(LENDING_MARKET_ID),
+        tx.pure.u64(reserve.arrayIndex),
+        tx.object(caps[0].id),
+        tx.object(CLOCK2),
+        repayCoin
+      ]
+    });
+    return { tx };
+  }
+  async 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);
+    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
+      ]
+    });
+  }
+  async maxWithdraw(address, _asset) {
+    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);
+    }
+    const remainingSupply = health.supplied - maxAmount;
+    const hfAfter = health.borrowed > 0 ? remainingSupply * health.liquidationThreshold / health.borrowed : Infinity;
+    return { maxAmount, healthFactorAfter: hfAfter, currentHF: health.healthFactor };
+  }
+  async maxBorrow(address, _asset) {
+    const health = await this.getHealth(address);
+    const maxAmount = health.maxBorrow;
+    return { maxAmount, healthFactorAfter: MIN_HEALTH_FACTOR2, currentHF: health.healthFactor };
+  }
+  async fetchAllCoins(owner, coinType) {
+    const all = [];
+    let cursor = null;
+    let hasNext = true;
+    while (hasNext) {
+      const page = await this.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;
+  }
+  // -- 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
+        });
+      }
+    }
+    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));
+      }
+      tx.transferObjects([coins[0]], address);
+      const symbol = coinType.includes("spring_sui") ? "SPRING_SUI" : coinType.includes("deep::") ? "DEEP" : coinType.split("::").pop() ?? "UNKNOWN";
+      claimed.push({
+        protocol: "suilend",
+        asset: "",
+        coinType,
+        symbol,
+        amount: 0,
+        estimatedValueUsd: 0
+      });
+    }
+    return claimed;
+  }
+};
+var descriptor4 = {
+  id: "sentinel",
+  name: "Sui Sentinel",
+  packages: [SENTINEL.PACKAGE],
+  actionMap: {
+    "sentinel::request_attack": "sentinel_attack",
+    "sentinel::consume_prompt": "sentinel_settle"
+  }
+};
+
+// src/adapters/index.ts
+var allDescriptors = [
+  descriptor,
+  descriptor3,
+  descriptor2,
+  descriptor4
 ];
+
+export { CetusAdapter, NaviAdapter, ProtocolRegistry, SuilendAdapter, allDescriptors, descriptor2 as cetusDescriptor, descriptor as naviDescriptor, descriptor4 as sentinelDescriptor, descriptor3 as suilendDescriptor };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map