@t2000/sdk 0.14.1 → 0.15.0

package/dist/adapters/index.cjs

@@ -1,1742 +0,0 @@
-'use strict';
-
-var transactions = require('@mysten/sui/transactions');
-var bcs = require('@mysten/sui/bcs');
-var aggregatorSdk = require('@cetusprotocol/aggregator-sdk');
-var utils = require('@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: "0xaafb102dd0902f5055cadecd687fb5b71ca82ef0e0285d90afde828ec58ca96b::btc::BTC",
-    decimals: 8,
-    symbol: "BTC",
-    displayName: "Bitcoin"
-  },
-  ETH: {
-    type: "0xd0e89b2af5e4910726fbcd8b8dd37bb79b29e5f83f7491bca830e94f7f226d29::eth::ETH",
-    decimals: 8,
-    symbol: "ETH",
-    displayName: "Ethereum"
-  }
-};
-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
-};
-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 = [];
-    for (const asset of STABLE_ASSETS) {
-      for (const adapter of this.lending.values()) {
-        if (!adapter.supportedAssets.includes(asset)) continue;
-        try {
-          const rates = await adapter.getRates(asset);
-          if (rates.saveApy > 0 || rates.borrowApy > 0) {
-            results.push({ protocol: adapter.name, protocolId: adapter.id, asset, rates });
-          }
-        } catch {
-        }
-      }
-    }
-    return results;
-  }
-  async allRates(asset) {
-    const results = [];
-    for (const adapter of this.lending.values()) {
-      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;
-var WITHDRAW_DUST_BUFFER = 1e-3;
-var CLOCK = "0x06";
-var SUI_SYSTEM_STATE = "0x05";
-var NAVI_BALANCE_DECIMALS = 9;
-var CONFIG_API = "https://open-api.naviprotocol.io/api/navi/config?env=prod";
-var POOLS_API = "https://open-api.naviprotocol.io/api/navi/pools?env=prod";
-var PACKAGE_API = "https://open-api.naviprotocol.io/api/package";
-var packageCache = null;
-function toBigInt(v) {
-  if (typeof v === "bigint") return v;
-  return BigInt(String(v));
-}
-var UserStateInfo = bcs.bcs.struct("UserStateInfo", {
-  asset_id: bcs.bcs.u8(),
-  borrow_balance: bcs.bcs.u256(),
-  supply_balance: bcs.bcs.u256()
-});
-function decodeDevInspect(result, schema) {
-  const rv = result.results?.[0]?.returnValues?.[0];
-  if (result.error || !rv) return void 0;
-  const bytes = Uint8Array.from(rv[0]);
-  return schema.parse(bytes);
-}
-var configCache = null;
-var poolsCache = null;
-var CACHE_TTL = 5 * 6e4;
-async function fetchJson(url) {
-  const res = await fetch(url);
-  if (!res.ok) throw new T2000Error("PROTOCOL_UNAVAILABLE", `NAVI API error: ${res.status}`);
-  const json = await res.json();
-  return json.data ?? json;
-}
-async function getLatestPackageId() {
-  if (packageCache && Date.now() - packageCache.ts < CACHE_TTL) return packageCache.id;
-  const res = await fetch(PACKAGE_API);
-  if (!res.ok) throw new T2000Error("PROTOCOL_UNAVAILABLE", `NAVI package API error: ${res.status}`);
-  const json = await res.json();
-  if (!json.packageId) throw new T2000Error("PROTOCOL_UNAVAILABLE", "NAVI package API returned no packageId");
-  packageCache = { id: json.packageId, ts: Date.now() };
-  return json.packageId;
-}
-async function getConfig(fresh = false) {
-  if (configCache && !fresh && Date.now() - configCache.ts < CACHE_TTL) return configCache.data;
-  const [data, latestPkg] = await Promise.all([
-    fetchJson(CONFIG_API),
-    getLatestPackageId()
-  ]);
-  data.package = latestPkg;
-  configCache = { data, ts: Date.now() };
-  return data;
-}
-async function getPools(fresh = false) {
-  if (poolsCache && !fresh && Date.now() - poolsCache.ts < CACHE_TTL) return poolsCache.data;
-  const data = await fetchJson(POOLS_API);
-  poolsCache = { data, ts: Date.now() };
-  return data;
-}
-function matchesCoinType(poolType, targetType) {
-  const poolSuffix = poolType.split("::").slice(1).join("::").toLowerCase();
-  const targetSuffix = targetType.split("::").slice(1).join("::").toLowerCase();
-  return poolSuffix === targetSuffix;
-}
-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";
-}
-async function getPool(asset = "USDC") {
-  const pools = await getPools();
-  const targetType = SUPPORTED_ASSETS[asset].type;
-  const pool = pools.find(
-    (p) => matchesCoinType(p.suiCoinType || p.coinType || "", targetType)
-  );
-  if (!pool) {
-    throw new T2000Error(
-      "ASSET_NOT_SUPPORTED",
-      `${SUPPORTED_ASSETS[asset].displayName} pool not found on NAVI. Try: ${STABLE_ASSETS.filter((a) => a !== asset).join(", ")}`
-    );
-  }
-  return pool;
-}
-function addOracleUpdate(tx, config, pool) {
-  const feed = config.oracle.feeds?.find((f2) => f2.assetId === pool.id);
-  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 refreshStableOracles(tx, config, pools) {
-  const stableTypes = STABLE_ASSETS.map((a) => SUPPORTED_ASSETS[a].type);
-  const stablePools = pools.filter((p) => {
-    const ct = p.suiCoinType || p.coinType || "";
-    return stableTypes.some((t) => matchesCoinType(ct, t));
-  });
-  for (const pool of stablePools) {
-    addOracleUpdate(tx, config, pool);
-  }
-}
-function rateToApy(rawRate) {
-  if (!rawRate || rawRate === "0") return 0;
-  return Number(BigInt(rawRate)) / 10 ** RATE_DECIMALS * 100;
-}
-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 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 * BigInt(currentIndex) + half) / scale;
-  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 [];
-  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 = SUPPORTED_ASSETS[asset];
-  const rawAmount = Number(stableToRaw(amount, assetInfo.decimals));
-  const [config, pool] = await Promise.all([getConfig(), getPool(asset)]);
-  const coins = await fetchCoins(client, address, assetInfo.type);
-  if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} coins found`);
-  const tx = new transactions.Transaction();
-  tx.setSender(address);
-  const coinObj = mergeCoins(tx, coins);
-  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 = SUPPORTED_ASSETS[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) : 0;
-  const effectiveAmount = Math.min(amount, Math.max(0, deposited - WITHDRAW_DUST_BUFFER));
-  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 transactions.Transaction();
-  tx.setSender(address);
-  refreshStableOracles(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 = SUPPORTED_ASSETS[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) : 0;
-  const effectiveAmount = Math.min(amount, Math.max(0, deposited - WITHDRAW_DUST_BUFFER));
-  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 };
-  }
-  refreshStableOracles(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 = SUPPORTED_ASSETS[asset];
-  const rawAmount = Number(stableToRaw(amount, assetInfo.decimals));
-  const [config, pool, pools] = await Promise.all([
-    getConfig(),
-    getPool(asset),
-    getPools()
-  ]);
-  const tx = new transactions.Transaction();
-  tx.setSender(address);
-  refreshStableOracles(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 = SUPPORTED_ASSETS[asset];
-  const rawAmount = Number(stableToRaw(amount, assetInfo.decimals));
-  const [config, pool] = await Promise.all([getConfig(), getPool(asset)]);
-  const coins = await fetchCoins(client, address, assetInfo.type);
-  if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} coins to repay with`);
-  const tx = new transactions.Transaction();
-  tx.setSender(address);
-  addOracleUpdate(tx, config, pool);
-  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);
-    const borrowBal = compoundBalance(state.borrowBalance, pool.currentBorrowIndex);
-    const price = pool.token?.price ?? 1;
-    supplied += supplyBal * price;
-    borrowed += borrowBal * price;
-    if (supplyBal > 0) {
-      weightedLtv += supplyBal * price * parseLtv(pool.ltv);
-      weightedLiqThreshold += supplyBal * price * parseLiqThreshold(pool.liquidationFactor.threshold);
-    }
-  }
-  const ltv = supplied > 0 ? weightedLtv / supplied : 0.75;
-  const liqThreshold = supplied > 0 ? weightedLiqThreshold / supplied : 0.75;
-  const maxBorrowVal = Math.max(0, supplied * ltv - borrowed);
-  const usdcPool = pools.find((p) => matchesCoinType(p.suiCoinType || p.coinType || "", SUPPORTED_ASSETS.USDC.type));
-  let healthFactor;
-  if (borrowed <= 0) {
-    healthFactor = Infinity;
-  } else if (usdcPool) {
-    try {
-      const tx = new transactions.Transaction();
-      tx.moveCall({
-        target: `${config.uiGetter}::calculator_unchecked::dynamic_health_factor`,
-        arguments: [
-          tx.object(CLOCK),
-          tx.object(config.storage),
-          tx.object(config.oracle.priceOracle),
-          tx.pure.u8(usdcPool.id),
-          tx.pure.address(address),
-          tx.pure.u8(usdcPool.id),
-          tx.pure.u64(0),
-          tx.pure.u64(0),
-          tx.pure.bool(false)
-        ],
-        typeArguments: [usdcPool.suiCoinType]
-      });
-      const result = await client.devInspectTransactionBlock({
-        transactionBlock: tx,
-        sender: address
-      });
-      const decoded = decodeDevInspect(result, bcs.bcs.u256());
-      if (decoded !== void 0) {
-        healthFactor = normalizeHealthFactor(Number(decoded));
-      } else {
-        healthFactor = supplied * liqThreshold / borrowed;
-      }
-    } catch {
-      healthFactor = supplied * liqThreshold / borrowed;
-    }
-  } else {
-    healthFactor = supplied * liqThreshold / borrowed;
-  }
-  return {
-    healthFactor,
-    supplied,
-    borrowed,
-    maxBorrow: maxBorrowVal,
-    liquidationThreshold: liqThreshold
-  };
-}
-async function getRates(client) {
-  try {
-    const pools = await getPools();
-    const result = {};
-    for (const asset of STABLE_ASSETS) {
-      const targetType = SUPPORTED_ASSETS[asset].type;
-      const pool = pools.find((p) => matchesCoinType(p.suiCoinType || p.coinType || "", targetType));
-      if (!pool) continue;
-      let saveApy = rateToApy(pool.currentSupplyRate);
-      let borrowApy = rateToApy(pool.currentBorrowRate);
-      if (saveApy <= 0 || saveApy > 100) saveApy = 0;
-      if (borrowApy <= 0 || borrowApy > 100) borrowApy = 0;
-      result[asset] = { saveApy, borrowApy };
-    }
-    if (!result.USDC) result.USDC = { saveApy: 4, borrowApy: 6 };
-    return result;
-  } catch {
-    return { USDC: { saveApy: 4, borrowApy: 6 } };
-  }
-}
-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);
-    const borrowBal = compoundBalance(state.borrowBalance, pool.currentBorrowIndex);
-    if (supplyBal > 1e-4) {
-      positions.push({
-        protocol: "navi",
-        asset: symbol,
-        type: "save",
-        amount: supplyBal,
-        apy: rateToApy(pool.currentSupplyRate)
-      });
-    }
-    if (borrowBal > 1e-4) {
-      positions.push({
-        protocol: "navi",
-        asset: symbol,
-        type: "borrow",
-        amount: borrowBal,
-        apy: rateToApy(pool.currentBorrowRate)
-      });
-    }
-  }
-  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 / 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 };
-}
-
-// 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];
-  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 stableAsset = normalizeAsset(asset);
-    const tx = await buildSaveTx(this.client, address, amount, { ...options, asset: stableAsset });
-    return { tx };
-  }
-  async buildWithdrawTx(address, amount, asset) {
-    const stableAsset = normalizeAsset(asset);
-    const result = await buildWithdrawTx(this.client, address, amount, { asset: stableAsset });
-    return { tx: result.tx, effectiveAmount: result.effectiveAmount };
-  }
-  async buildBorrowTx(address, amount, asset, options) {
-    const stableAsset = normalizeAsset(asset);
-    const tx = await buildBorrowTx(this.client, address, amount, { ...options, asset: stableAsset });
-    return { tx };
-  }
-  async buildRepayTx(address, amount, asset) {
-    const stableAsset = normalizeAsset(asset);
-    const tx = await buildRepayTx(this.client, address, amount, { asset: stableAsset });
-    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 stableAsset = normalizeAsset(asset);
-    return addWithdrawToTx(tx, this.client, address, amount, { asset: stableAsset });
-  }
-  async addSaveToTx(tx, address, coin, asset, options) {
-    const stableAsset = normalizeAsset(asset);
-    return addSaveToTx(tx, this.client, address, coin, { ...options, asset: stableAsset });
-  }
-  async addRepayToTx(tx, address, coin, asset) {
-    const stableAsset = normalizeAsset(asset);
-    return addRepayToTx(tx, this.client, address, coin, { asset: stableAsset });
-  }
-};
-var DEFAULT_SLIPPAGE_BPS = 300;
-function createAggregatorClient(client, signer) {
-  return new aggregatorSdk.AggregatorClient({
-    client,
-    signer,
-    env: aggregatorSdk.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 result = await aggClient.findRouters({
-    from: fromInfo.type,
-    target: toInfo.type,
-    amount: rawAmount,
-    byAmountIn: true
-  });
-  if (!result || result.insufficientLiquidity) {
-    throw new T2000Error(
-      "ASSET_NOT_SUPPORTED",
-      `No swap route found for ${fromAsset} \u2192 ${toAsset}`
-    );
-  }
-  const tx = new transactions.Transaction();
-  const slippage = maxSlippageBps / 1e4;
-  await aggClient.fastRouterSwap({
-    router: result,
-    txb: tx,
-    slippage
-  });
-  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 result = await aggClient.findRouters({
-    from: fromInfo.type,
-    target: toInfo.type,
-    amount: rawAmount,
-    byAmountIn: true
-  });
-  if (!result || result.insufficientLiquidity) {
-    throw new T2000Error(
-      "ASSET_NOT_SUPPORTED",
-      `No swap route found for ${fromAsset} \u2192 ${toAsset}`
-    );
-  }
-  const slippage = maxSlippageBps / 1e4;
-  const outputCoin = await aggClient.routerSwap({
-    router: result,
-    txb: tx,
-    inputCoin,
-    slippage
-  });
-  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 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::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 };
-}
-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);
-  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 = "2.0.0";
-  capabilities = ["save", "withdraw", "borrow", "repay"];
-  supportedAssets = [...STABLE_ASSETS];
-  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 = utils.normalizeStructTag(coinType);
-      return reserves.find((r) => {
-        try {
-          return utils.normalizeStructTag(r.coinType) === normalized;
-        } catch {
-          return false;
-        }
-      });
-    } catch {
-      return void 0;
-    }
-  }
-  async fetchObligationCaps(address) {
-    const capType = `${SUILEND_PACKAGE}::lending_market::ObligationOwnerCap<${LENDING_MARKET_TYPE}>`;
-    const caps = [];
-    let cursor;
-    let hasNext = true;
-    while (hasNext) {
-      const page = await this.client.getOwnedObjects({
-        owner: address,
-        filter: { StructType: capType },
-        options: { showContent: true },
-        cursor: cursor ?? void 0
-      });
-      for (const item of page.data) {
-        if (item.data?.content?.dataType !== "moveObject") continue;
-        const fields = item.data.content.fields;
-        caps.push({
-          id: item.data.objectId,
-          obligationId: str(fields.obligation_id)
-        });
-      }
-      cursor = page.nextCursor;
-      hasNext = page.hasNextPage;
-    }
-    return caps;
-  }
-  async fetchObligation(obligationId) {
-    const obj = await this.client.getObject({ id: obligationId, options: { showContent: true } });
-    if (obj.data?.content?.dataType !== "moveObject") {
-      throw new T2000Error("PROTOCOL_UNAVAILABLE", "Failed to read Suilend obligation");
-    }
-    return parseObligation(obj.data.content.fields);
-  }
-  resolveSymbol(coinType) {
-    try {
-      const normalized = utils.normalizeStructTag(coinType);
-      for (const [key, info] of Object.entries(SUPPORTED_ASSETS)) {
-        try {
-          if (utils.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);
-    return { asset, saveApy: depositAprPct, 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);
-      supplies.push({ asset: this.resolveSymbol(dep.coinType), amount, apy: depositAprPct });
-    }
-    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 transactions.Transaction();
-    tx.setSender(address);
-    let capRef;
-    if (caps.length === 0) {
-      const [newCap] = tx.moveCall({
-        target: `${pkg}::lending_market::create_obligation`,
-        typeArguments: [LENDING_MARKET_TYPE],
-        arguments: [tx.object(LENDING_MARKET_ID)]
-      });
-      capRef = newCap;
-    } else {
-      capRef = caps[0].id;
-    }
-    const 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 positions = await this.getPositions(address);
-    const deposited = positions.supplies.find((s) => s.asset === assetKey)?.amount ?? 0;
-    const effectiveAmount = Math.min(amount, deposited);
-    if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", `Nothing to withdraw for ${assetInfo.displayName} on Suilend`);
-    const ratio = cTokenRatio(reserve);
-    const ctokenAmount = Math.ceil(effectiveAmount * 10 ** reserve.mintDecimals / ratio);
-    const tx = new transactions.Transaction();
-    tx.setSender(address);
-    const [ctokens] = tx.moveCall({
-      target: `${pkg}::lending_market::withdraw_ctokens`,
-      typeArguments: [LENDING_MARKET_TYPE, 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 exemptionType = `${SUILEND_PACKAGE}::lending_market::RateLimiterExemption<${LENDING_MARKET_TYPE}, ${assetInfo.type}>`;
-    const [none] = tx.moveCall({
-      target: "0x1::option::none",
-      typeArguments: [exemptionType]
-    });
-    const [coin] = tx.moveCall({
-      target: `${pkg}::lending_market::redeem_ctokens_and_withdraw_liquidity`,
-      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        tx.object(CLOCK2),
-        ctokens,
-        none
-      ]
-    });
-    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 positions = await this.getPositions(address);
-    const deposited = positions.supplies.find((s) => s.asset === assetKey)?.amount ?? 0;
-    const effectiveAmount = Math.min(amount, deposited);
-    if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", `Nothing to withdraw for ${assetInfo.displayName} on Suilend`);
-    const ratio = cTokenRatio(reserve);
-    const ctokenAmount = Math.ceil(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 exemptionType = `${SUILEND_PACKAGE}::lending_market::RateLimiterExemption<${LENDING_MARKET_TYPE}, ${assetInfo.type}>`;
-    const [none] = tx.moveCall({
-      target: "0x1::option::none",
-      typeArguments: [exemptionType]
-    });
-    const [coin] = tx.moveCall({
-      target: `${pkg}::lending_market::redeem_ctokens_and_withdraw_liquidity`,
-      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        tx.object(CLOCK2),
-        ctokens,
-        none
-      ]
-    });
-    return { coin, effectiveAmount };
-  }
-  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 transactions.Transaction();
-    tx.setSender(address);
-    const [coin] = tx.moveCall({
-      target: `${pkg}::lending_market::borrow`,
-      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        tx.object(caps[0].id),
-        tx.object(CLOCK2),
-        tx.pure.u64(rawAmount)
-      ]
-    });
-    if (options?.collectFee) {
-      addCollectFeeToTx(tx, coin, "borrow");
-    }
-    tx.transferObjects([coin], address);
-    return { tx };
-  }
-  async buildRepayTx(address, amount, asset) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves()]);
-    const reserve = this.findReserve(reserves, assetKey);
-    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend`);
-    const caps = await this.fetchObligationCaps(address);
-    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend obligation found");
-    const allCoins = await this.fetchAllCoins(address, assetInfo.type);
-    if (allCoins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} coins to repay with`);
-    const rawAmount = stableToRaw(amount, assetInfo.decimals);
-    const tx = new transactions.Transaction();
-    tx.setSender(address);
-    const primaryCoinId = allCoins[0].coinObjectId;
-    if (allCoins.length > 1) {
-      tx.mergeCoins(tx.object(primaryCoinId), allCoins.slice(1).map((c) => tx.object(c.coinObjectId)));
-    }
-    const [repayCoin] = tx.splitCoins(tx.object(primaryCoinId), [rawAmount.toString()]);
-    tx.moveCall({
-      target: `${pkg}::lending_market::repay`,
-      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        tx.object(caps[0].id),
-        tx.object(CLOCK2),
-        repayCoin
-      ]
-    });
-    return { tx };
-  }
-  async 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;
-  }
-};
-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
-];
-
-exports.CetusAdapter = CetusAdapter;
-exports.NaviAdapter = NaviAdapter;
-exports.ProtocolRegistry = ProtocolRegistry;
-exports.SuilendAdapter = SuilendAdapter;
-exports.allDescriptors = allDescriptors;
-exports.cetusDescriptor = descriptor2;
-exports.naviDescriptor = descriptor;
-exports.sentinelDescriptor = descriptor4;
-exports.suilendDescriptor = descriptor3;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map