@t2000/sdk 0.3.0 → 0.4.1

package/dist/adapters/index.cjs

@@ -0,0 +1,856 @@
+'use strict';
+
+var lending = require('@naviprotocol/lending');
+var transactions = require('@mysten/sui/transactions');
+var aggregatorSdk = require('@cetusprotocol/aggregator-sdk');
+var utils = require('@mysten/sui/utils');
+
+// 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 Error(`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 Error(`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 Error(`No swap adapter supports ${from} \u2192 ${to}`);
+    }
+    candidates.sort((a, b) => b.quote.expectedOutput - a.quote.expectedOutput);
+    return candidates[0];
+  }
+  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/constants.ts
+var USDC_DECIMALS = 6;
+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"
+  },
+  SUI: {
+    type: "0x2::sui::SUI",
+    decimals: 9,
+    symbol: "SUI"
+  }
+};
+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";
+
+// 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/utils/format.ts
+function usdcToRaw(amount) {
+  return BigInt(Math.round(amount * 10 ** USDC_DECIMALS));
+}
+
+// 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])
+    ]
+  });
+}
+
+// src/protocols/navi.ts
+var ENV = { env: "prod" };
+var USDC_TYPE = SUPPORTED_ASSETS.USDC.type;
+var RATE_DECIMALS = 27;
+var LTV_DECIMALS = 27;
+var MIN_HEALTH_FACTOR = 1.5;
+var WITHDRAW_DUST_BUFFER = 1e-3;
+var NAVI_BALANCE_DECIMALS = 9;
+function clientOpt(client, fresh = false) {
+  return { client, ...ENV, ...fresh ? { disableCache: true } : {} };
+}
+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 findUsdcPosition(state) {
+  return state.find(
+    (p) => p.pool.token.symbol === "USDC" || p.pool.coinType.toLowerCase().includes("usdc")
+  );
+}
+async function updateOracle(tx, client, address) {
+  try {
+    const [feeds, state] = await Promise.all([
+      lending.getPriceFeeds(ENV),
+      lending.getLendingState(address, clientOpt(client))
+    ]);
+    const relevant = lending.filterPriceFeeds(feeds, { lendingState: state });
+    if (relevant.length > 0) {
+      await lending.updateOraclePricesPTB(tx, relevant, { ...ENV, updatePythPriceFeeds: true });
+    }
+  } catch {
+  }
+}
+async function buildSaveTx(client, address, amount, options = {}) {
+  const rawAmount = Number(usdcToRaw(amount));
+  const coins = await lending.getCoins(address, { coinType: USDC_TYPE, client });
+  if (!coins || coins.length === 0) {
+    throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins found");
+  }
+  const tx = new transactions.Transaction();
+  tx.setSender(address);
+  const coinObj = lending.mergeCoinsPTB(tx, coins, { balance: rawAmount });
+  if (options.collectFee) {
+    addCollectFeeToTx(tx, coinObj, "save");
+  }
+  await lending.depositCoinPTB(tx, USDC_TYPE, coinObj, ENV);
+  return tx;
+}
+async function buildWithdrawTx(client, address, amount) {
+  const state = await lending.getLendingState(address, clientOpt(client, true));
+  const usdcPos = findUsdcPosition(state);
+  const deposited = usdcPos ? Number(usdcPos.supplyBalance) / 10 ** NAVI_BALANCE_DECIMALS : 0;
+  const effectiveAmount = Math.min(amount, Math.max(0, deposited - WITHDRAW_DUST_BUFFER));
+  if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", "Nothing to withdraw");
+  const rawAmount = Number(usdcToRaw(effectiveAmount));
+  const tx = new transactions.Transaction();
+  tx.setSender(address);
+  await updateOracle(tx, client, address);
+  const withdrawnCoin = await lending.withdrawCoinPTB(tx, USDC_TYPE, rawAmount, ENV);
+  tx.transferObjects([withdrawnCoin], address);
+  return { tx, effectiveAmount };
+}
+async function buildBorrowTx(client, address, amount, options = {}) {
+  const rawAmount = Number(usdcToRaw(amount));
+  const tx = new transactions.Transaction();
+  tx.setSender(address);
+  await updateOracle(tx, client, address);
+  const borrowedCoin = await lending.borrowCoinPTB(tx, USDC_TYPE, rawAmount, ENV);
+  if (options.collectFee) {
+    addCollectFeeToTx(tx, borrowedCoin, "borrow");
+  }
+  tx.transferObjects([borrowedCoin], address);
+  return tx;
+}
+async function buildRepayTx(client, address, amount) {
+  const rawAmount = Number(usdcToRaw(amount));
+  const coins = await lending.getCoins(address, { coinType: USDC_TYPE, client });
+  if (!coins || coins.length === 0) {
+    throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins to repay with");
+  }
+  const tx = new transactions.Transaction();
+  tx.setSender(address);
+  const coinObj = lending.mergeCoinsPTB(tx, coins, { balance: rawAmount });
+  await lending.repayCoinPTB(tx, USDC_TYPE, coinObj, { ...ENV, amount: rawAmount });
+  return tx;
+}
+async function getHealthFactor(client, addressOrKeypair) {
+  const address = typeof addressOrKeypair === "string" ? addressOrKeypair : addressOrKeypair.getPublicKey().toSuiAddress();
+  const [healthFactor, state, pool] = await Promise.all([
+    lending.getHealthFactor(address, clientOpt(client, true)),
+    lending.getLendingState(address, clientOpt(client, true)),
+    lending.getPool(USDC_TYPE, ENV)
+  ]);
+  const usdcPos = findUsdcPosition(state);
+  const supplied = usdcPos ? Number(usdcPos.supplyBalance) / 10 ** NAVI_BALANCE_DECIMALS : 0;
+  const borrowed = usdcPos ? Number(usdcPos.borrowBalance) / 10 ** NAVI_BALANCE_DECIMALS : 0;
+  const ltv = parseLtv(pool.ltv);
+  const liqThreshold = parseLiqThreshold(pool.liquidationFactor.threshold);
+  const maxBorrowVal = Math.max(0, supplied * ltv - borrowed);
+  return {
+    healthFactor: borrowed > 0 ? healthFactor : Infinity,
+    supplied,
+    borrowed,
+    maxBorrow: maxBorrowVal,
+    liquidationThreshold: liqThreshold
+  };
+}
+async function getRates(client) {
+  try {
+    const pool = await lending.getPool(USDC_TYPE, ENV);
+    let saveApy = rateToApy(pool.currentSupplyRate);
+    let borrowApy = rateToApy(pool.currentBorrowRate);
+    if (saveApy <= 0 || saveApy > 100) saveApy = 4;
+    if (borrowApy <= 0 || borrowApy > 100) borrowApy = 6;
+    return { USDC: { saveApy, borrowApy } };
+  } catch {
+    return { USDC: { saveApy: 4, borrowApy: 6 } };
+  }
+}
+async function getPositions(client, addressOrKeypair) {
+  const address = typeof addressOrKeypair === "string" ? addressOrKeypair : addressOrKeypair.getPublicKey().toSuiAddress();
+  const state = await lending.getLendingState(address, clientOpt(client, true));
+  const positions = [];
+  for (const pos of state) {
+    const symbol = pos.pool.token?.symbol ?? "UNKNOWN";
+    const supplyBal = Number(pos.supplyBalance) / 10 ** NAVI_BALANCE_DECIMALS;
+    const borrowBal = Number(pos.borrowBalance) / 10 ** NAVI_BALANCE_DECIMALS;
+    if (supplyBal > 1e-4) {
+      positions.push({
+        protocol: "navi",
+        asset: symbol,
+        type: "save",
+        amount: supplyBal,
+        apy: rateToApy(pos.pool.currentSupplyRate)
+      });
+    }
+    if (borrowBal > 1e-4) {
+      positions.push({
+        protocol: "navi",
+        asset: symbol,
+        type: "borrow",
+        amount: borrowBal,
+        apy: rateToApy(pos.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 NaviAdapter = class {
+  id = "navi";
+  name = "NAVI Protocol";
+  version = "1.0.0";
+  capabilities = ["save", "withdraw", "borrow", "repay"];
+  supportedAssets = ["USDC"];
+  supportsSameAssetBorrow = true;
+  client;
+  async init(client) {
+    this.client = client;
+  }
+  initSync(client) {
+    this.client = client;
+  }
+  async getRates(asset) {
+    const rates = await getRates(this.client);
+    const key = asset.toUpperCase();
+    const r = rates[key];
+    if (!r) throw new Error(`NAVI does not support ${asset}`);
+    return { asset, 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 tx = await buildSaveTx(this.client, address, amount, options);
+    return { tx };
+  }
+  async buildWithdrawTx(address, amount, _asset) {
+    const result = await buildWithdrawTx(this.client, address, amount);
+    return { tx: result.tx, effectiveAmount: result.effectiveAmount };
+  }
+  async buildBorrowTx(address, amount, _asset, options) {
+    const tx = await buildBorrowTx(this.client, address, amount, options);
+    return { tx };
+  }
+  async buildRepayTx(address, amount, _asset) {
+    const tx = await buildRepayTx(this.client, address, amount);
+    return { tx };
+  }
+  async maxWithdraw(address, _asset) {
+    return maxWithdrawAmount(this.client, address);
+  }
+  async maxBorrow(address, _asset) {
+    return maxBorrowAmount(this.client, address);
+  }
+};
+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];
+  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 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];
+  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 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.toUpperCase(),
+      to.toUpperCase(),
+      amount
+    );
+  }
+  async buildSwapTx(address, from, to, amount, maxSlippageBps) {
+    const result = await buildSwapTx({
+      client: this.client,
+      address,
+      fromAsset: from.toUpperCase(),
+      toAsset: to.toUpperCase(),
+      amount,
+      maxSlippageBps
+    });
+    return {
+      tx: result.tx,
+      estimatedOut: result.estimatedOut,
+      toDecimals: result.toDecimals
+    };
+  }
+  getSupportedPairs() {
+    return [
+      { from: "USDC", to: "SUI" },
+      { from: "SUI", to: "USDC" }
+    ];
+  }
+  async getPoolPrice() {
+    return getPoolPrice(this.client);
+  }
+};
+var USDC_TYPE2 = SUPPORTED_ASSETS.USDC.type;
+var WAD = 1e18;
+var MIN_HEALTH_FACTOR2 = 1.5;
+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 computeRatesFromReserve(reserve) {
+  const decimals = reserve.mintDecimals;
+  const available = Number(reserve.availableAmount) / 10 ** decimals;
+  const borrowed = Number(reserve.borrowedAmount.value) / WAD / 10 ** decimals;
+  const totalDeposited = available + borrowed;
+  const utilizationPct = totalDeposited > 0 ? borrowed / totalDeposited * 100 : 0;
+  const config = reserve.config.element;
+  if (!config) return { borrowAprPct: 0, depositAprPct: 0, utilizationPct: 0 };
+  const utils = config.interestRateUtils.map(Number);
+  const aprs = config.interestRateAprs.map((a) => Number(a) / 100);
+  const borrowAprPct = interpolateRate(utils, aprs, utilizationPct);
+  const spreadFeeBps = Number(config.spreadFeeBps);
+  const depositAprPct = utilizationPct / 100 * (borrowAprPct / 100) * (1 - spreadFeeBps / 1e4) * 100;
+  return { borrowAprPct, depositAprPct, utilizationPct };
+}
+function cTokenRatio(reserve) {
+  if (reserve.ctokenSupply === 0n) return 1;
+  const available = Number(reserve.availableAmount);
+  const borrowed = Number(reserve.borrowedAmount.value) / WAD;
+  const spreadFees = Number(reserve.unclaimedSpreadFees.value) / WAD;
+  const totalSupply = available + borrowed - spreadFees;
+  return totalSupply / Number(reserve.ctokenSupply);
+}
+var SuilendAdapter = class {
+  id = "suilend";
+  name = "Suilend";
+  version = "1.0.0";
+  capabilities = ["save", "withdraw"];
+  supportedAssets = ["USDC"];
+  supportsSameAssetBorrow = false;
+  client;
+  suilend;
+  lendingMarketType;
+  initialized = false;
+  async init(client) {
+    let sdk;
+    try {
+      sdk = await import('@suilend/sdk');
+    } catch {
+      throw new T2000Error(
+        "PROTOCOL_UNAVAILABLE",
+        "Suilend SDK not installed. Run: npm install @suilend/sdk@^1"
+      );
+    }
+    this.client = client;
+    this.lendingMarketType = sdk.LENDING_MARKET_TYPE;
+    try {
+      this.suilend = await sdk.SuilendClient.initialize(
+        sdk.LENDING_MARKET_ID,
+        sdk.LENDING_MARKET_TYPE,
+        client
+      );
+    } catch (err) {
+      throw new T2000Error(
+        "PROTOCOL_UNAVAILABLE",
+        `Failed to initialize Suilend: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    this.initialized = true;
+  }
+  ensureInit() {
+    if (!this.initialized) {
+      throw new T2000Error(
+        "PROTOCOL_UNAVAILABLE",
+        "SuilendAdapter not initialized. Call init() first."
+      );
+    }
+  }
+  findReserve(asset) {
+    const upper = asset.toUpperCase();
+    let coinType;
+    if (upper === "USDC") coinType = USDC_TYPE2;
+    else if (upper === "SUI") coinType = "0x2::sui::SUI";
+    else if (asset.includes("::")) coinType = asset;
+    else return void 0;
+    try {
+      const normalized = utils.normalizeStructTag(coinType);
+      return this.suilend.lendingMarket.reserves.find(
+        (r) => utils.normalizeStructTag(r.coinType.name) === normalized
+      );
+    } catch {
+      return void 0;
+    }
+  }
+  async getObligationCaps(address) {
+    const SuilendClientStatic = (await import('@suilend/sdk')).SuilendClient;
+    return SuilendClientStatic.getObligationOwnerCaps(
+      address,
+      [this.lendingMarketType],
+      this.client
+    );
+  }
+  resolveSymbol(coinType) {
+    const normalized = utils.normalizeStructTag(coinType);
+    if (normalized === utils.normalizeStructTag(USDC_TYPE2)) return "USDC";
+    if (normalized === utils.normalizeStructTag("0x2::sui::SUI")) return "SUI";
+    const parts = coinType.split("::");
+    return parts[parts.length - 1] || "UNKNOWN";
+  }
+  async getRates(asset) {
+    this.ensureInit();
+    const reserve = this.findReserve(asset);
+    if (!reserve) {
+      throw new T2000Error("ASSET_NOT_SUPPORTED", `Suilend does not support ${asset}`);
+    }
+    const { borrowAprPct, depositAprPct } = computeRatesFromReserve(reserve);
+    return {
+      asset,
+      saveApy: depositAprPct,
+      borrowApy: borrowAprPct
+    };
+  }
+  async getPositions(address) {
+    this.ensureInit();
+    const supplies = [];
+    const borrows = [];
+    const caps = await this.getObligationCaps(address);
+    if (caps.length === 0) return { supplies, borrows };
+    const obligation = await this.suilend.getObligation(caps[0].obligationId);
+    for (const deposit of obligation.deposits) {
+      const coinType = utils.normalizeStructTag(deposit.coinType.name);
+      const reserve = this.suilend.lendingMarket.reserves.find(
+        (r) => utils.normalizeStructTag(r.coinType.name) === coinType
+      );
+      if (!reserve) continue;
+      const ctokenAmount = Number(deposit.depositedCtokenAmount.toString());
+      const ratio = cTokenRatio(reserve);
+      const amount = ctokenAmount * ratio / 10 ** reserve.mintDecimals;
+      const { depositAprPct } = computeRatesFromReserve(reserve);
+      supplies.push({ asset: this.resolveSymbol(coinType), amount, apy: depositAprPct });
+    }
+    for (const borrow of obligation.borrows) {
+      const coinType = utils.normalizeStructTag(borrow.coinType.name);
+      const reserve = this.suilend.lendingMarket.reserves.find(
+        (r) => utils.normalizeStructTag(r.coinType.name) === coinType
+      );
+      if (!reserve) continue;
+      const rawBorrowed = Number(borrow.borrowedAmount.value.toString()) / WAD;
+      const amount = rawBorrowed / 10 ** reserve.mintDecimals;
+      const reserveRate = Number(reserve.cumulativeBorrowRate.value.toString()) / WAD;
+      const posRate = Number(borrow.cumulativeBorrowRate.value.toString()) / WAD;
+      const compounded = posRate > 0 ? amount * (reserveRate / posRate) : amount;
+      const { borrowAprPct } = computeRatesFromReserve(reserve);
+      borrows.push({ asset: this.resolveSymbol(coinType), amount: compounded, apy: borrowAprPct });
+    }
+    return { supplies, borrows };
+  }
+  async getHealth(address) {
+    this.ensureInit();
+    const caps = await this.getObligationCaps(address);
+    if (caps.length === 0) {
+      return { healthFactor: Infinity, supplied: 0, borrowed: 0, maxBorrow: 0, liquidationThreshold: 0 };
+    }
+    const positions = await this.getPositions(address);
+    const supplied = positions.supplies.reduce((s, p) => s + p.amount, 0);
+    const borrowed = positions.borrows.reduce((s, p) => s + p.amount, 0);
+    const reserve = this.findReserve("USDC");
+    const closeLtv = reserve?.config?.element?.closeLtvPct ?? 75;
+    const openLtv = reserve?.config?.element?.openLtvPct ?? 70;
+    const liqThreshold = closeLtv / 100;
+    const healthFactor = borrowed > 0 ? supplied * liqThreshold / borrowed : Infinity;
+    const maxBorrow = Math.max(0, supplied * (openLtv / 100) - borrowed);
+    return { healthFactor, supplied, borrowed, maxBorrow, liquidationThreshold: liqThreshold };
+  }
+  async buildSaveTx(address, amount, _asset, options) {
+    this.ensureInit();
+    const rawAmount = usdcToRaw(amount).toString();
+    const tx = new transactions.Transaction();
+    tx.setSender(address);
+    const caps = await this.getObligationCaps(address);
+    let capRef;
+    if (caps.length === 0) {
+      const [newCap] = this.suilend.createObligation(tx);
+      capRef = newCap;
+    } else {
+      capRef = caps[0].id;
+    }
+    const allCoins = await this.fetchAllCoins(address, USDC_TYPE2);
+    if (allCoins.length === 0) {
+      throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins found");
+    }
+    const primaryCoinId = allCoins[0].coinObjectId;
+    if (allCoins.length > 1) {
+      tx.mergeCoins(
+        tx.object(primaryCoinId),
+        allCoins.slice(1).map((c) => tx.object(c.coinObjectId))
+      );
+    }
+    const [depositCoin] = tx.splitCoins(tx.object(primaryCoinId), [rawAmount]);
+    if (options?.collectFee) {
+      addCollectFeeToTx(tx, depositCoin, "save");
+    }
+    this.suilend.deposit(depositCoin, USDC_TYPE2, capRef, tx);
+    return { tx };
+  }
+  async buildWithdrawTx(address, amount, _asset) {
+    this.ensureInit();
+    const caps = await this.getObligationCaps(address);
+    if (caps.length === 0) {
+      throw new T2000Error("NO_COLLATERAL", "No Suilend position found");
+    }
+    const positions = await this.getPositions(address);
+    const usdcSupply = positions.supplies.find((s) => s.asset === "USDC");
+    const deposited = usdcSupply?.amount ?? 0;
+    const effectiveAmount = Math.min(amount, deposited);
+    if (effectiveAmount <= 0) {
+      throw new T2000Error("NO_COLLATERAL", "Nothing to withdraw from Suilend");
+    }
+    const rawAmount = usdcToRaw(effectiveAmount).toString();
+    const tx = new transactions.Transaction();
+    tx.setSender(address);
+    await this.suilend.withdrawAndSendToUser(
+      address,
+      caps[0].id,
+      caps[0].obligationId,
+      USDC_TYPE2,
+      rawAmount,
+      tx
+    );
+    return { tx, effectiveAmount };
+  }
+  async buildBorrowTx(_address, _amount, _asset, _options) {
+    throw new T2000Error(
+      "ASSET_NOT_SUPPORTED",
+      "SuilendAdapter.buildBorrowTx() not available \u2014 Suilend requires different collateral/borrow assets. Deferred to Phase 10."
+    );
+  }
+  async buildRepayTx(_address, _amount, _asset) {
+    throw new T2000Error(
+      "ASSET_NOT_SUPPORTED",
+      "SuilendAdapter.buildRepayTx() not available \u2014 deferred to Phase 10."
+    );
+  }
+  async maxWithdraw(address, _asset) {
+    this.ensureInit();
+    const health = await this.getHealth(address);
+    let maxAmount;
+    if (health.borrowed === 0) {
+      maxAmount = health.supplied;
+    } else {
+      maxAmount = Math.max(
+        0,
+        health.supplied - health.borrowed * MIN_HEALTH_FACTOR2 / health.liquidationThreshold
+      );
+    }
+    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) {
+    throw new T2000Error(
+      "ASSET_NOT_SUPPORTED",
+      "SuilendAdapter.maxBorrow() not available \u2014 deferred to Phase 10."
+    );
+  }
+  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;
+  }
+};
+
+exports.CetusAdapter = CetusAdapter;
+exports.NaviAdapter = NaviAdapter;
+exports.ProtocolRegistry = ProtocolRegistry;
+exports.SuilendAdapter = SuilendAdapter;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map