@t2000/sdk 0.19.24 → 0.20.0

package/dist/adapters/index.cjs

@@ -2,15 +2,9 @@
 
 var transactions = require('@mysten/sui/transactions');
 var lending = require('@naviprotocol/lending');
-var aggregatorSdk = require('@cetusprotocol/aggregator-sdk');
-var utils = require('@mysten/sui/utils');
-var client = require('@suilend/sdk/client');
-var initialize = require('@suilend/sdk/lib/initialize');
-var types = require('@suilend/sdk/lib/types');
 
 // src/constants.ts
 var SAVE_FEE_BPS = 10n;
-var SWAP_FEE_BPS = 0n;
 var BORROW_FEE_BPS = 5n;
 var SUPPORTED_ASSETS = {
   USDC: {
@@ -42,39 +36,13 @@ var SUPPORTED_ASSETS = {
     decimals: 9,
     symbol: "SUI",
     displayName: "SUI"
-  },
-  BTC: {
-    type: "0x0041f9f9344cac094454cd574e333c4fdb132d7bcc9379bcd4aab485b2a63942::wbtc::WBTC",
-    decimals: 8,
-    symbol: "BTC",
-    displayName: "Bitcoin"
-  },
-  ETH: {
-    type: "0xd0e89b2af5e4910726fbcd8b8dd37bb79b29e5f83f7491bca830e94f7f226d29::eth::ETH",
-    decimals: 8,
-    symbol: "ETH",
-    displayName: "Ethereum"
-  },
-  GOLD: {
-    type: "0x9d297676e7a4b771ab023291377b2adfaa4938fb9080b8d12430e4b108b836a9::xaum::XAUM",
-    decimals: 9,
-    symbol: "GOLD",
-    displayName: "Gold"
   }
 };
-var STABLE_ASSETS = ["USDC", "USDT", "USDe", "USDsui"];
+var STABLE_ASSETS = ["USDC"];
 var T2000_PACKAGE_ID = process.env.T2000_PACKAGE_ID ?? "0xab92e9f1fe549ad3d6a52924a73181b45791e76120b975138fac9ec9b75db9f3";
 var T2000_CONFIG_ID = process.env.T2000_CONFIG_ID ?? "0x408add9aa9322f93cfd87523d8f603006eb8713894f4c460283c58a6888dae8a";
 var T2000_TREASURY_ID = process.env.T2000_TREASURY_ID ?? "0x3bb501b8300125dca59019247941a42af6b292a150ce3cfcce9449456be2ec91";
 process.env.T2000_API_URL ?? "https://api.t2000.ai";
-var CETUS_USDC_SUI_POOL = "0x51e883ba7c0b566a26cbc8a94cd33eb0abd418a77cc1e60ad22fd9b1f29cd2ab";
-var CETUS_PACKAGE = "0x1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb";
-var INVESTMENT_ASSETS = {
-  SUI: SUPPORTED_ASSETS.SUI,
-  BTC: SUPPORTED_ASSETS.BTC,
-  ETH: SUPPORTED_ASSETS.ETH,
-  GOLD: SUPPORTED_ASSETS.GOLD
-};
 
 // src/errors.ts
 var T2000Error = class extends Error {
@@ -101,13 +69,9 @@ var T2000Error = class extends Error {
 // 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()) {
@@ -143,23 +107,6 @@ var ProtocolRegistry = class {
     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) {
@@ -181,9 +128,8 @@ var ProtocolRegistry = class {
   }
   async allRatesAcrossAssets() {
     const results = [];
-    const allAssets = [...STABLE_ASSETS, ...Object.keys(INVESTMENT_ASSETS)];
     const seen = /* @__PURE__ */ new Set();
-    for (const asset of allAssets) {
+    for (const asset of STABLE_ASSETS) {
       if (seen.has(asset)) continue;
       seen.add(asset);
       for (const adapter of this.lending.values()) {
@@ -232,15 +178,9 @@ var ProtocolRegistry = class {
   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
@@ -261,12 +201,10 @@ function normalizeAsset(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) {
@@ -691,7 +629,6 @@ async function addClaimRewardsToTx(tx, client, address) {
 }
 
 // src/adapters/descriptors.ts
-var SUILEND_PACKAGE = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf";
 var naviDescriptor = {
   id: "navi",
   name: "NAVI Protocol",
@@ -708,39 +645,8 @@ var naviDescriptor = {
     "incentive_v3::repay": "repay"
   }
 };
-var suilendDescriptor = {
-  id: "suilend",
-  name: "Suilend",
-  packages: [SUILEND_PACKAGE],
-  actionMap: {
-    "lending_market::deposit_liquidity_and_mint_ctokens": "save",
-    "lending_market::deposit_ctokens_into_obligation": "save",
-    "lending_market::create_obligation": "save",
-    "lending_market::withdraw_ctokens": "withdraw",
-    "lending_market::redeem_ctokens_and_withdraw_liquidity": "withdraw",
-    "lending_market::redeem_ctokens_and_withdraw_liquidity_request": "withdraw",
-    "lending_market::fulfill_liquidity_request": "withdraw",
-    "lending_market::unstake_sui_from_staker": "withdraw",
-    "lending_market::borrow": "borrow",
-    "lending_market::repay": "repay"
-  }
-};
-var cetusDescriptor = {
-  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 allDescriptors = [
-  naviDescriptor,
-  suilendDescriptor,
-  cetusDescriptor
+  naviDescriptor
 ];
 
 // src/adapters/navi.ts
@@ -824,658 +730,10 @@ var NaviAdapter = class {
     return addClaimRewardsToTx(tx, 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];
-  if (!fromInfo || !toInfo) {
-    throw new T2000Error("ASSET_NOT_SUPPORTED", `Swap pair ${fromAsset}/${toAsset} is not supported`);
-  }
-  const rawAmount = BigInt(Math.floor(amount * 10 ** fromInfo.decimals));
-  const aggClient = createAggregatorClient(client, address);
-  const _origLog = console.log;
-  console.log = () => {
-  };
-  let result;
-  try {
-    result = await aggClient.findRouters({
-      from: fromInfo.type,
-      target: toInfo.type,
-      amount: rawAmount,
-      byAmountIn: true
-    });
-  } finally {
-    console.log = _origLog;
-  }
-  if (!result || result.insufficientLiquidity) {
-    throw new T2000Error(
-      "ASSET_NOT_SUPPORTED",
-      `No swap route found for ${fromAsset} \u2192 ${toAsset}`
-    );
-  }
-  const tx = new transactions.Transaction();
-  const slippage = maxSlippageBps / 1e4;
-  console.log = () => {
-  };
-  try {
-    await aggClient.fastRouterSwap({
-      router: result,
-      txb: tx,
-      slippage
-    });
-  } finally {
-    console.log = _origLog;
-  }
-  const estimatedOut = Number(result.amountOut.toString());
-  return {
-    tx,
-    estimatedOut,
-    toDecimals: toInfo.decimals
-  };
-}
-async function addSwapToTx(params) {
-  const { tx, client, address, inputCoin, fromAsset, toAsset, amount, maxSlippageBps = DEFAULT_SLIPPAGE_BPS } = params;
-  const fromInfo = SUPPORTED_ASSETS[fromAsset];
-  const toInfo = SUPPORTED_ASSETS[toAsset];
-  if (!fromInfo || !toInfo) {
-    throw new T2000Error("ASSET_NOT_SUPPORTED", `Swap pair ${fromAsset}/${toAsset} is not supported`);
-  }
-  const rawAmount = BigInt(Math.floor(amount * 10 ** fromInfo.decimals));
-  const aggClient = createAggregatorClient(client, address);
-  const _origLog = console.log;
-  console.log = () => {
-  };
-  let result;
-  try {
-    result = await aggClient.findRouters({
-      from: fromInfo.type,
-      target: toInfo.type,
-      amount: rawAmount,
-      byAmountIn: true
-    });
-  } finally {
-    console.log = _origLog;
-  }
-  if (!result || result.insufficientLiquidity) {
-    throw new T2000Error(
-      "ASSET_NOT_SUPPORTED",
-      `No swap route found for ${fromAsset} \u2192 ${toAsset}`
-    );
-  }
-  const slippage = maxSlippageBps / 1e4;
-  console.log = () => {
-  };
-  let outputCoin;
-  try {
-    outputCoin = await aggClient.routerSwap({
-      router: result,
-      txb: tx,
-      inputCoin,
-      slippage
-    });
-  } finally {
-    console.log = _origLog;
-  }
-  const estimatedOut = Number(result.amountOut.toString());
-  return {
-    outputCoin,
-    estimatedOut,
-    toDecimals: toInfo.decimals
-  };
-}
-async function getPoolPrice(client) {
-  try {
-    const pool = await client.getObject({
-      id: CETUS_USDC_SUI_POOL,
-      options: { showContent: true }
-    });
-    if (pool.data?.content?.dataType === "moveObject") {
-      const fields = pool.data.content.fields;
-      const currentSqrtPrice = BigInt(String(fields.current_sqrt_price ?? "0"));
-      if (currentSqrtPrice > 0n) {
-        const Q64 = 2n ** 64n;
-        const sqrtPriceFloat = Number(currentSqrtPrice) / Number(Q64);
-        const rawPrice = sqrtPriceFloat * sqrtPriceFloat;
-        const suiPriceUsd = 1e3 / rawPrice;
-        if (suiPriceUsd > 0.01 && suiPriceUsd < 1e3) return suiPriceUsd;
-      }
-    }
-  } catch {
-  }
-  return 3.5;
-}
-async function getSwapQuote(client, fromAsset, toAsset, amount) {
-  const fromInfo = SUPPORTED_ASSETS[fromAsset];
-  const toInfo = SUPPORTED_ASSETS[toAsset];
-  if (!fromInfo || !toInfo) {
-    throw new T2000Error("ASSET_NOT_SUPPORTED", `Swap pair ${fromAsset}/${toAsset} is not supported`);
-  }
-  const rawAmount = BigInt(Math.floor(amount * 10 ** fromInfo.decimals));
-  const poolPrice = await getPoolPrice(client);
-  try {
-    const aggClient = createAggregatorClient(client);
-    const result = await aggClient.findRouters({
-      from: fromInfo.type,
-      target: toInfo.type,
-      amount: rawAmount,
-      byAmountIn: true
-    });
-    if (!result || result.insufficientLiquidity) {
-      return fallbackQuote(fromAsset, amount, poolPrice);
-    }
-    const expectedOutput = Number(result.amountOut.toString()) / 10 ** toInfo.decimals;
-    const priceImpact = result.deviationRatio ?? 0;
-    return { expectedOutput, priceImpact, poolPrice };
-  } catch {
-    return fallbackQuote(fromAsset, amount, poolPrice);
-  }
-}
-function fallbackQuote(fromAsset, amount, poolPrice) {
-  const expectedOutput = fromAsset === "USDC" ? amount / poolPrice : amount * poolPrice;
-  return { expectedOutput, priceImpact: 0, poolPrice };
-}
-
-// src/adapters/cetus.ts
-var 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 MIN_HEALTH_FACTOR2 = 1.5;
-async function quietSuilend(fn) {
-  const origLog = console.log;
-  const origWarn = console.warn;
-  const filter = (...args) => typeof args[0] === "string" && (args[0].includes("PythEndpoint") || args[0].includes("PythConnection"));
-  console.log = (...args) => {
-    if (!filter(...args)) origLog.apply(console, args);
-  };
-  console.warn = (...args) => {
-    if (!filter(...args)) origWarn.apply(console, args);
-  };
-  return fn().finally(() => {
-    console.log = origLog;
-    console.warn = origWarn;
-  });
-}
-var SuilendAdapter = class {
-  id = "suilend";
-  name = "Suilend";
-  version = "3.0.0";
-  capabilities = ["save", "withdraw", "borrow", "repay"];
-  supportedAssets = [...STABLE_ASSETS, "SUI", "ETH", "BTC", "GOLD"];
-  supportsSameAssetBorrow = false;
-  client;
-  sdkClient = null;
-  async init(client) {
-    this.client = client;
-  }
-  initSync(client) {
-    this.client = client;
-  }
-  async getSdkClient() {
-    if (!this.sdkClient) {
-      this.sdkClient = await client.SuilendClient.initialize(
-        client.LENDING_MARKET_ID,
-        client.LENDING_MARKET_TYPE,
-        this.client,
-        false
-      );
-    }
-    return this.sdkClient;
-  }
-  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";
-  }
-  async getRates(asset) {
-    try {
-      const sdk = await this.getSdkClient();
-      const { reserveMap } = await quietSuilend(() => initialize.initializeSuilend(this.client, sdk));
-      const assetInfo = SUPPORTED_ASSETS[asset];
-      if (!assetInfo) throw new T2000Error("ASSET_NOT_SUPPORTED", `Suilend does not support ${asset}`);
-      const normalized = utils.normalizeStructTag(assetInfo.type);
-      const reserve = Object.values(reserveMap).find((r) => {
-        try {
-          return utils.normalizeStructTag(r.coinType) === normalized;
-        } catch {
-          return false;
-        }
-      });
-      if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `Suilend does not support ${asset}`);
-      return {
-        asset,
-        saveApy: reserve.depositAprPercent.toNumber(),
-        borrowApy: reserve.borrowAprPercent.toNumber()
-      };
-    } catch (err) {
-      if (err instanceof T2000Error) throw err;
-      const msg = err instanceof Error ? err.message : String(err);
-      throw new T2000Error("PROTOCOL_UNAVAILABLE", `Suilend getRates failed: ${msg}`);
-    }
-  }
-  async getPositions(address) {
-    const supplies = [];
-    const borrows = [];
-    try {
-      const sdk = await this.getSdkClient();
-      const { reserveMap, refreshedRawReserves } = await quietSuilend(() => initialize.initializeSuilend(this.client, sdk));
-      const { obligations, obligationOwnerCaps } = await initialize.initializeObligations(
-        this.client,
-        sdk,
-        refreshedRawReserves,
-        reserveMap,
-        address
-      );
-      if (obligationOwnerCaps.length === 0 || obligations.length === 0) {
-        return { supplies, borrows };
-      }
-      const obligation = obligations[0];
-      for (const dep of obligation.deposits) {
-        const symbol = this.resolveSymbol(dep.coinType);
-        const amount = dep.depositedAmount.toNumber();
-        const amountUsd = dep.depositedAmountUsd.toNumber();
-        const apy = dep.reserve.depositAprPercent.toNumber();
-        if (amountUsd > 0.01) {
-          supplies.push({ asset: symbol, amount, amountUsd, apy });
-        }
-      }
-      for (const bor of obligation.borrows) {
-        const symbol = this.resolveSymbol(bor.coinType);
-        const amount = bor.borrowedAmount.toNumber();
-        const amountUsd = bor.borrowedAmountUsd.toNumber();
-        const apy = bor.reserve.borrowAprPercent.toNumber();
-        if (amountUsd > 0.01) {
-          borrows.push({ asset: symbol, amount, amountUsd, apy });
-        }
-      }
-    } catch (err) {
-      if (err instanceof T2000Error) throw err;
-      const msg = err instanceof Error ? err.message : String(err);
-      throw new T2000Error("PROTOCOL_UNAVAILABLE", `Suilend getPositions failed: ${msg}`);
-    }
-    return { supplies, borrows };
-  }
-  async getHealth(address) {
-    try {
-      const sdk = await this.getSdkClient();
-      const { reserveMap, refreshedRawReserves } = await quietSuilend(() => initialize.initializeSuilend(this.client, sdk));
-      const { obligations, obligationOwnerCaps } = await initialize.initializeObligations(
-        this.client,
-        sdk,
-        refreshedRawReserves,
-        reserveMap,
-        address
-      );
-      if (obligationOwnerCaps.length === 0 || obligations.length === 0) {
-        return { healthFactor: Infinity, supplied: 0, borrowed: 0, maxBorrow: 0, liquidationThreshold: 0 };
-      }
-      const ob = obligations[0];
-      const supplied = ob.depositedAmountUsd.toNumber();
-      const borrowed = ob.borrowedAmountUsd.toNumber();
-      const borrowLimit = ob.borrowLimitUsd.toNumber();
-      const unhealthy = ob.unhealthyBorrowValueUsd.toNumber();
-      const liqThreshold = supplied > 0 ? unhealthy / supplied : 0.75;
-      const healthFactor = borrowed > 0 ? unhealthy / borrowed : Infinity;
-      const maxBorrow = Math.max(0, borrowLimit - borrowed);
-      return { healthFactor, supplied, borrowed, maxBorrow, liquidationThreshold: liqThreshold };
-    } catch {
-      return { healthFactor: Infinity, supplied: 0, borrowed: 0, maxBorrow: 0, liquidationThreshold: 0 };
-    }
-  }
-  async buildSaveTx(address, amount, asset, options) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const sdk = await this.getSdkClient();
-    const caps = await client.SuilendClient.getObligationOwnerCaps(address, [client.LENDING_MARKET_TYPE], this.client);
-    const tx = new transactions.Transaction();
-    tx.setSender(address);
-    const rawValue = stableToRaw(amount, assetInfo.decimals).toString();
-    if (caps.length > 0) {
-      if (options?.collectFee) {
-        const allCoins = await this.fetchAllCoins(address, assetInfo.type);
-        if (allCoins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} coins found`);
-        const primaryCoinId = allCoins[0].coinObjectId;
-        if (allCoins.length > 1) {
-          tx.mergeCoins(tx.object(primaryCoinId), allCoins.slice(1).map((c) => tx.object(c.coinObjectId)));
-        }
-        const [depositCoin] = tx.splitCoins(tx.object(primaryCoinId), [rawValue]);
-        addCollectFeeToTx(tx, depositCoin, "save");
-      }
-      await sdk.depositIntoObligation(address, assetInfo.type, rawValue, tx, caps[0].id);
-    } else {
-      const newCap = sdk.createObligation(tx);
-      let depositCoin;
-      if (assetKey === "SUI") {
-        [depositCoin] = tx.splitCoins(tx.gas, [rawValue]);
-      } else {
-        const allCoins = await this.fetchAllCoins(address, assetInfo.type);
-        if (allCoins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} coins found`);
-        const primaryCoin = tx.object(allCoins[0].coinObjectId);
-        if (allCoins.length > 1) {
-          tx.mergeCoins(primaryCoin, allCoins.slice(1).map((c) => tx.object(c.coinObjectId)));
-        }
-        [depositCoin] = tx.splitCoins(primaryCoin, [rawValue]);
-      }
-      if (options?.collectFee) {
-        addCollectFeeToTx(tx, depositCoin, "save");
-      }
-      sdk.deposit(depositCoin, assetInfo.type, newCap, tx);
-      tx.transferObjects([newCap], address);
-    }
-    return { tx };
-  }
-  async buildWithdrawTx(address, amount, asset) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const sdk = await this.getSdkClient();
-    const caps = await client.SuilendClient.getObligationOwnerCaps(address, [client.LENDING_MARKET_TYPE], this.client);
-    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend position found");
-    const { ctokenRaw, effectiveAmount, obligationIndex } = await this.resolveWithdrawCTokens(sdk, address, assetKey, assetInfo, amount);
-    const cap = caps[obligationIndex] ?? caps[0];
-    const tx = new transactions.Transaction();
-    tx.setSender(address);
-    await sdk.withdrawAndSendToUser(address, cap.id, cap.obligationId, assetInfo.type, ctokenRaw, tx);
-    return { tx, effectiveAmount };
-  }
-  async addWithdrawToTx(tx, address, amount, asset) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const sdk = await this.getSdkClient();
-    const caps = await client.SuilendClient.getObligationOwnerCaps(address, [client.LENDING_MARKET_TYPE], this.client);
-    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend position found");
-    const { ctokenRaw, effectiveAmount, obligationIndex } = await this.resolveWithdrawCTokens(sdk, address, assetKey, assetInfo, amount);
-    const cap = caps[obligationIndex] ?? caps[0];
-    const coin = await sdk.withdraw(cap.id, cap.obligationId, assetInfo.type, ctokenRaw, tx);
-    return { coin, effectiveAmount };
-  }
-  async addSaveToTx(tx, address, coin, asset, options) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const sdk = await this.getSdkClient();
-    const caps = await client.SuilendClient.getObligationOwnerCaps(address, [client.LENDING_MARKET_TYPE], this.client);
-    let capRef;
-    if (caps.length === 0) {
-      const newCap = sdk.createObligation(tx);
-      capRef = newCap;
-      tx.transferObjects([newCap], address);
-    } else {
-      capRef = caps[0].id;
-    }
-    if (options?.collectFee) {
-      addCollectFeeToTx(tx, coin, "save");
-    }
-    sdk.deposit(coin, assetInfo.type, capRef, tx);
-  }
-  async buildBorrowTx(address, amount, asset, options) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const sdk = await this.getSdkClient();
-    const caps = await client.SuilendClient.getObligationOwnerCaps(address, [client.LENDING_MARKET_TYPE], this.client);
-    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend position found. Deposit collateral first with: t2000 save <amount>");
-    const rawValue = stableToRaw(amount, assetInfo.decimals).toString();
-    const tx = new transactions.Transaction();
-    tx.setSender(address);
-    if (options?.collectFee) {
-      const coin = await sdk.borrow(caps[0].id, caps[0].obligationId, assetInfo.type, rawValue, tx);
-      addCollectFeeToTx(tx, coin, "borrow");
-      tx.transferObjects([coin], address);
-    } else {
-      await sdk.borrowAndSendToUser(address, caps[0].id, caps[0].obligationId, assetInfo.type, rawValue, tx);
-    }
-    return { tx };
-  }
-  async buildRepayTx(address, amount, asset) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const sdk = await this.getSdkClient();
-    const caps = await client.SuilendClient.getObligationOwnerCaps(address, [client.LENDING_MARKET_TYPE], this.client);
-    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend obligation found");
-    const rawValue = stableToRaw(amount, assetInfo.decimals).toString();
-    const tx = new transactions.Transaction();
-    tx.setSender(address);
-    await sdk.repayIntoObligation(address, caps[0].obligationId, assetInfo.type, rawValue, tx);
-    return { tx };
-  }
-  async addRepayToTx(tx, address, coin, asset) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const sdk = await this.getSdkClient();
-    const caps = await client.SuilendClient.getObligationOwnerCaps(address, [client.LENDING_MARKET_TYPE], this.client);
-    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend obligation found");
-    sdk.repay(caps[0].obligationId, assetInfo.type, coin, tx);
-  }
-  async resolveWithdrawCTokens(sdk, address, assetKey, assetInfo, amount) {
-    const { reserveMap, refreshedRawReserves } = await quietSuilend(() => initialize.initializeSuilend(this.client, sdk));
-    const { obligations } = await initialize.initializeObligations(
-      this.client,
-      sdk,
-      refreshedRawReserves,
-      reserveMap,
-      address
-    );
-    if (obligations.length === 0) throw new T2000Error("NO_COLLATERAL", `Nothing to withdraw for ${assetInfo.displayName} on Suilend \u2014 no obligations found`);
-    let dep;
-    let matchedObligation = 0;
-    for (let oi = 0; oi < obligations.length; oi++) {
-      dep = obligations[oi].deposits.find((d) => {
-        const resolved = this.resolveSymbol(d.coinType);
-        if (resolved === assetKey) return true;
-        try {
-          return utils.normalizeStructTag(d.coinType) === utils.normalizeStructTag(assetInfo.type);
-        } catch {
-          return false;
-        }
-      });
-      if (dep && dep.depositedAmount.toNumber() > 1e-10) {
-        matchedObligation = oi;
-        break;
-      }
-      dep = void 0;
-    }
-    if (!dep) {
-      const foundDeposits = obligations.flatMap(
-        (o, i) => o.deposits.map((d) => `ob${i}:${this.resolveSymbol(d.coinType)}=${d.depositedAmount.toFixed(8)}`)
-      );
-      throw new T2000Error(
-        "NO_COLLATERAL",
-        `Nothing to withdraw for ${assetInfo.displayName} (${assetKey}) on Suilend. Found deposits: [${foundDeposits.join(", ")}]`
-      );
-    }
-    const deposited = dep.depositedAmount.toNumber();
-    const effectiveAmount = Math.min(amount, deposited);
-    const proportion = effectiveAmount / deposited;
-    const ctokenRaw = proportion >= 0.999 ? dep.depositedCtokenAmount.toFixed(0) : dep.depositedCtokenAmount.times(proportion).integerValue(1).toFixed(0);
-    return { ctokenRaw, effectiveAmount, obligationIndex: matchedObligation };
-  }
-  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);
-    return { maxAmount: health.maxBorrow, 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;
-  }
-  async getPendingRewards(address) {
-    try {
-      const sdk = await this.getSdkClient();
-      const { reserveMap, refreshedRawReserves } = await quietSuilend(() => initialize.initializeSuilend(this.client, sdk));
-      const { obligations, obligationOwnerCaps } = await initialize.initializeObligations(
-        this.client,
-        sdk,
-        refreshedRawReserves,
-        reserveMap,
-        address
-      );
-      if (obligationOwnerCaps.length === 0 || obligations.length === 0) return [];
-      const ob = obligations[0];
-      const rewards = [];
-      const WAD = 1e18;
-      for (const dep of ob.deposits) {
-        const urm = dep.userRewardManager;
-        for (const rw of dep.reserve.depositsPoolRewardManager?.poolRewards ?? []) {
-          if (rw.endTimeMs <= Date.now()) continue;
-          let claimableAmount = 0;
-          const userReward = urm?.rewards?.[rw.rewardIndex];
-          if (userReward?.earnedRewards) {
-            claimableAmount = Number(BigInt(userReward.earnedRewards.value.toString())) / WAD / 10 ** rw.mintDecimals;
-          }
-          const symbol = rw.symbol || rw.coinType.split("::").pop() || "UNKNOWN";
-          rewards.push({
-            protocol: "suilend",
-            asset: this.resolveSymbol(dep.coinType),
-            coinType: rw.coinType,
-            symbol,
-            amount: claimableAmount,
-            estimatedValueUsd: 0
-          });
-        }
-      }
-      return rewards;
-    } catch {
-      return [];
-    }
-  }
-  async addClaimRewardsToTx(tx, address) {
-    try {
-      const sdk = await this.getSdkClient();
-      const caps = await client.SuilendClient.getObligationOwnerCaps(address, [client.LENDING_MARKET_TYPE], this.client);
-      if (caps.length === 0) return [];
-      const { reserveMap, refreshedRawReserves } = await quietSuilend(() => initialize.initializeSuilend(this.client, sdk));
-      const { obligations } = await initialize.initializeObligations(
-        this.client,
-        sdk,
-        refreshedRawReserves,
-        reserveMap,
-        address
-      );
-      if (obligations.length === 0) return [];
-      const ob = obligations[0];
-      const claimRewards = [];
-      for (const dep of ob.deposits) {
-        for (const rw of dep.reserve.depositsPoolRewardManager.poolRewards) {
-          if (rw.endTimeMs <= Date.now()) continue;
-          claimRewards.push({
-            reserveArrayIndex: dep.reserveArrayIndex,
-            rewardIndex: BigInt(rw.rewardIndex),
-            rewardCoinType: rw.coinType,
-            side: types.Side.DEPOSIT
-          });
-        }
-      }
-      if (claimRewards.length === 0) return [];
-      sdk.claimRewardsAndSendToUser(address, caps[0].id, claimRewards, tx);
-      return claimRewards.map((r) => ({
-        protocol: "suilend",
-        asset: "",
-        coinType: r.rewardCoinType,
-        symbol: r.rewardCoinType.split("::").pop() ?? "UNKNOWN",
-        amount: 0,
-        estimatedValueUsd: 0
-      }));
-    } catch {
-      return [];
-    }
-  }
-};
 
-exports.CetusAdapter = CetusAdapter;
 exports.NaviAdapter = NaviAdapter;
 exports.ProtocolRegistry = ProtocolRegistry;
-exports.SuilendAdapter = SuilendAdapter;
 exports.allDescriptors = allDescriptors;
-exports.cetusDescriptor = cetusDescriptor;
 exports.naviDescriptor = naviDescriptor;
-exports.suilendDescriptor = suilendDescriptor;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map