@t2000/sdk 0.4.0 → 0.4.2

package/dist/index.cjs

@@ -1116,6 +1116,306 @@ var CetusAdapter = class {
     return getPoolPrice(this.client);
   }
 };
+var USDC_TYPE2 = SUPPORTED_ASSETS.USDC.type;
+SUPPORTED_ASSETS.USDC.decimals;
+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;
+  initPromise = null;
+  async init(client) {
+    this.client = client;
+    await this.lazyInit();
+  }
+  initSync(client) {
+    this.client = client;
+  }
+  async lazyInit() {
+    if (this.initialized) return;
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = (async () => {
+      let sdk;
+      try {
+        sdk = await import('@suilend/sdk');
+      } catch {
+        throw new T2000Error(
+          "PROTOCOL_UNAVAILABLE",
+          "Suilend SDK not installed. Run: npm install @suilend/sdk@^1"
+        );
+      }
+      this.lendingMarketType = sdk.LENDING_MARKET_TYPE;
+      try {
+        this.suilend = await sdk.SuilendClient.initialize(
+          sdk.LENDING_MARKET_ID,
+          sdk.LENDING_MARKET_TYPE,
+          this.client
+        );
+      } catch (err) {
+        this.initPromise = null;
+        throw new T2000Error(
+          "PROTOCOL_UNAVAILABLE",
+          `Failed to initialize Suilend: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      this.initialized = true;
+    })();
+    return this.initPromise;
+  }
+  async ensureInit() {
+    if (!this.initialized) {
+      await this.lazyInit();
+    }
+  }
+  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) {
+    await this.ensureInit();
+    const reserve = this.findReserve(asset);
+    if (!reserve) {
+      throw new T2000Error("ASSET_NOT_SUPPORTED", `Suilend does not support ${asset}`);
+    }
+    const { borrowAprPct, depositAprPct } = computeRatesFromReserve(reserve);
+    return {
+      asset,
+      saveApy: depositAprPct,
+      borrowApy: borrowAprPct
+    };
+  }
+  async getPositions(address) {
+    await 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) {
+    await 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) {
+    await 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) {
+    await 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) {
+    await this.ensureInit();
+    const health = await this.getHealth(address);
+    let maxAmount;
+    if (health.borrowed === 0) {
+      maxAmount = health.supplied;
+    } else {
+      maxAmount = Math.max(
+        0,
+        health.supplied - health.borrowed * MIN_HEALTH_FACTOR2 / health.liquidationThreshold
+      );
+    }
+    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;
+  }
+};
 function hasLeadingZeroBits(hash, bits) {
   const fullBytes = Math.floor(bits / 8);
   const remainingBits = bits % 8;
@@ -1364,6 +1664,9 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     const cetusAdapter = new CetusAdapter();
     cetusAdapter.initSync(client);
     registry.registerSwap(cetusAdapter);
+    const suilendAdapter = new SuilendAdapter();
+    suilendAdapter.initSync(client);
+    registry.registerLending(suilendAdapter);
     return registry;
   }
   static async create(options = {}) {
@@ -1538,667 +1841,378 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     };
   }
   async withdraw(params) {
-    const asset = (params.asset ?? "USDC").toUpperCase();
-    if (asset !== "USDC") {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `Only USDC is supported for withdraw. Got: ${asset}`);
-    }
-    const adapter = await this.resolveLending(params.protocol, asset, "withdraw");
-    let amount;
-    if (params.amount === "all") {
-      const maxResult = await adapter.maxWithdraw(this._address, asset);
-      amount = maxResult.maxAmount;
-      if (amount <= 0) {
-        throw new T2000Error("NO_COLLATERAL", "No savings to withdraw");
-      }
-    } else {
-      amount = params.amount;
-      const hf = await adapter.getHealth(this._address);
-      if (hf.borrowed > 0) {
-        const maxResult = await adapter.maxWithdraw(this._address, asset);
-        if (amount > maxResult.maxAmount) {
-          throw new T2000Error(
-            "WITHDRAW_WOULD_LIQUIDATE",
-            `Withdrawing $${amount.toFixed(2)} would drop health factor below 1.5`,
-            {
-              safeWithdrawAmount: maxResult.maxAmount,
-              currentHF: maxResult.currentHF,
-              projectedHF: maxResult.healthFactorAfter
-            }
-          );
-        }
-      }
-    }
-    const withdrawAmount = amount;
-    let effectiveAmount = withdrawAmount;
-    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
-      const built = await adapter.buildWithdrawTx(this._address, withdrawAmount, asset);
-      effectiveAmount = built.effectiveAmount;
-      return built.tx;
-    });
-    this.emitBalanceChange("USDC", effectiveAmount, "withdraw", gasResult.digest);
-    return {
-      success: true,
-      tx: gasResult.digest,
-      amount: effectiveAmount,
-      gasCost: gasResult.gasCostSui,
-      gasMethod: gasResult.gasMethod
-    };
-  }
-  async maxWithdraw() {
-    const adapter = await this.resolveLending(void 0, "USDC", "withdraw");
-    return adapter.maxWithdraw(this._address, "USDC");
-  }
-  // -- Borrowing --
-  async borrow(params) {
-    const asset = (params.asset ?? "USDC").toUpperCase();
-    if (asset !== "USDC") {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `Only USDC is supported for borrow. Got: ${asset}`);
-    }
-    const adapter = await this.resolveLending(params.protocol, asset, "borrow");
-    const maxResult = await adapter.maxBorrow(this._address, asset);
-    if (params.amount > maxResult.maxAmount) {
-      throw new T2000Error("HEALTH_FACTOR_TOO_LOW", `Max safe borrow: $${maxResult.maxAmount.toFixed(2)}`, {
-        maxBorrow: maxResult.maxAmount,
-        currentHF: maxResult.currentHF
-      });
-    }
-    const fee = calculateFee("borrow", params.amount);
-    const borrowAmount = params.amount;
-    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
-      const { tx } = await adapter.buildBorrowTx(this._address, borrowAmount, asset, { collectFee: true });
-      return tx;
-    });
-    const hf = await adapter.getHealth(this._address);
-    reportFee(this._address, "borrow", fee.amount, fee.rate, gasResult.digest);
-    this.emitBalanceChange("USDC", borrowAmount, "borrow", gasResult.digest);
-    return {
-      success: true,
-      tx: gasResult.digest,
-      amount: borrowAmount,
-      fee: fee.amount,
-      healthFactor: hf.healthFactor,
-      gasCost: gasResult.gasCostSui,
-      gasMethod: gasResult.gasMethod
-    };
-  }
-  async repay(params) {
-    const asset = (params.asset ?? "USDC").toUpperCase();
-    if (asset !== "USDC") {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `Only USDC is supported for repay. Got: ${asset}`);
-    }
-    const adapter = await this.resolveLending(params.protocol, asset, "repay");
-    let amount;
-    if (params.amount === "all") {
-      const hf2 = await adapter.getHealth(this._address);
-      amount = hf2.borrowed;
-      if (amount <= 0) {
-        throw new T2000Error("NO_COLLATERAL", "No outstanding borrow to repay");
-      }
-    } else {
-      amount = params.amount;
-    }
-    const repayAmount = amount;
-    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
-      const { tx } = await adapter.buildRepayTx(this._address, repayAmount, asset);
-      return tx;
-    });
-    const hf = await adapter.getHealth(this._address);
-    this.emitBalanceChange("USDC", repayAmount, "repay", gasResult.digest);
-    return {
-      success: true,
-      tx: gasResult.digest,
-      amount: repayAmount,
-      remainingDebt: hf.borrowed,
-      gasCost: gasResult.gasCostSui,
-      gasMethod: gasResult.gasMethod
-    };
-  }
-  async maxBorrow() {
-    const adapter = await this.resolveLending(void 0, "USDC", "borrow");
-    return adapter.maxBorrow(this._address, "USDC");
-  }
-  async healthFactor() {
-    const adapter = await this.resolveLending(void 0, "USDC", "save");
-    const hf = await adapter.getHealth(this._address);
-    if (hf.healthFactor < 1.2) {
-      this.emit("healthCritical", { healthFactor: hf.healthFactor, threshold: 1.5, severity: "critical" });
-    } else if (hf.healthFactor < 2) {
-      this.emit("healthWarning", { healthFactor: hf.healthFactor, threshold: 2, severity: "warning" });
-    }
-    return hf;
-  }
-  // -- Swap --
-  async swap(params) {
-    const fromAsset = params.from.toUpperCase();
-    const toAsset = params.to.toUpperCase();
-    if (!(fromAsset in SUPPORTED_ASSETS) || !(toAsset in SUPPORTED_ASSETS)) {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `Swap pair ${fromAsset}/${toAsset} is not supported`);
-    }
-    if (fromAsset === toAsset) {
-      throw new T2000Error("INVALID_AMOUNT", "Cannot swap same asset");
-    }
-    let adapter;
-    if (params.protocol) {
-      const found = this.registry.getSwap(params.protocol);
-      if (!found) throw new T2000Error("ASSET_NOT_SUPPORTED", `Swap adapter '${params.protocol}' not found`);
-      adapter = found;
+    const asset = (params.asset ?? "USDC").toUpperCase();
+    if (asset !== "USDC") {
+      throw new T2000Error("ASSET_NOT_SUPPORTED", `Only USDC is supported for withdraw. Got: ${asset}`);
+    }
+    const adapter = await this.resolveLending(params.protocol, asset, "withdraw");
+    let amount;
+    if (params.amount === "all") {
+      const maxResult = await adapter.maxWithdraw(this._address, asset);
+      amount = maxResult.maxAmount;
+      if (amount <= 0) {
+        throw new T2000Error("NO_COLLATERAL", "No savings to withdraw");
+      }
     } else {
-      const best = await this.registry.bestSwapQuote(fromAsset, toAsset, params.amount);
-      adapter = best.adapter;
+      amount = params.amount;
+      const hf = await adapter.getHealth(this._address);
+      if (hf.borrowed > 0) {
+        const maxResult = await adapter.maxWithdraw(this._address, asset);
+        if (amount > maxResult.maxAmount) {
+          throw new T2000Error(
+            "WITHDRAW_WOULD_LIQUIDATE",
+            `Withdrawing $${amount.toFixed(2)} would drop health factor below 1.5`,
+            {
+              safeWithdrawAmount: maxResult.maxAmount,
+              currentHF: maxResult.currentHF,
+              projectedHF: maxResult.healthFactorAfter
+            }
+          );
+        }
+      }
     }
-    const fee = calculateFee("swap", params.amount);
-    const swapAmount = params.amount;
-    const slippageBps = params.maxSlippage ? params.maxSlippage * 100 : void 0;
-    let swapMeta = { estimatedOut: 0, toDecimals: 0 };
+    const withdrawAmount = amount;
+    let effectiveAmount = withdrawAmount;
     const gasResult = await executeWithGas(this.client, this.keypair, async () => {
-      const built = await adapter.buildSwapTx(this._address, fromAsset, toAsset, swapAmount, slippageBps);
-      swapMeta = { estimatedOut: built.estimatedOut, toDecimals: built.toDecimals };
+      const built = await adapter.buildWithdrawTx(this._address, withdrawAmount, asset);
+      effectiveAmount = built.effectiveAmount;
       return built.tx;
     });
-    const toInfo = SUPPORTED_ASSETS[toAsset];
-    const txDetail = await this.client.getTransactionBlock({
-      digest: gasResult.digest,
-      options: { showBalanceChanges: true }
-    });
-    let actualReceived = 0;
-    if (txDetail.balanceChanges) {
-      for (const change of txDetail.balanceChanges) {
-        if (change.coinType === toInfo.type && change.owner && typeof change.owner === "object" && "AddressOwner" in change.owner && change.owner.AddressOwner === this._address) {
-          const amt = Number(change.amount) / 10 ** toInfo.decimals;
-          if (amt > 0) actualReceived += amt;
-        }
-      }
-    }
-    const expectedOutput = swapMeta.estimatedOut / 10 ** swapMeta.toDecimals;
-    if (actualReceived === 0) actualReceived = expectedOutput;
-    const priceImpact = expectedOutput > 0 ? Math.abs(actualReceived - expectedOutput) / expectedOutput : 0;
-    reportFee(this._address, "swap", fee.amount, fee.rate, gasResult.digest);
-    this.emitBalanceChange(fromAsset, swapAmount, "swap", gasResult.digest);
+    this.emitBalanceChange("USDC", effectiveAmount, "withdraw", gasResult.digest);
     return {
       success: true,
       tx: gasResult.digest,
-      fromAmount: swapAmount,
-      fromAsset,
-      toAmount: actualReceived,
-      toAsset,
-      priceImpact,
-      fee: fee.amount,
+      amount: effectiveAmount,
       gasCost: gasResult.gasCostSui,
       gasMethod: gasResult.gasMethod
     };
   }
-  async swapQuote(params) {
-    const fromAsset = params.from.toUpperCase();
-    const toAsset = params.to.toUpperCase();
-    const best = await this.registry.bestSwapQuote(fromAsset, toAsset, params.amount);
-    const fee = calculateFee("swap", params.amount);
-    return { ...best.quote, fee: { amount: fee.amount, rate: fee.rate } };
-  }
-  // -- Info --
-  async positions() {
-    const allPositions = await this.registry.allPositions(this._address);
-    const positions = allPositions.flatMap(
-      (p) => [
-        ...p.positions.supplies.map((s) => ({
-          protocol: p.protocolId,
-          asset: s.asset,
-          type: "save",
-          amount: s.amount,
-          apy: s.apy
-        })),
-        ...p.positions.borrows.map((b) => ({
-          protocol: p.protocolId,
-          asset: b.asset,
-          type: "borrow",
-          amount: b.amount,
-          apy: b.apy
-        }))
-      ]
-    );
-    return { positions };
-  }
-  async rates() {
-    return getRates(this.client);
-  }
-  async allRates(asset = "USDC") {
-    return this.registry.allRates(asset);
-  }
-  async earnings() {
-    const result = await getEarnings(this.client, this.keypair);
-    if (result.totalYieldEarned > 0) {
-      this.emit("yield", {
-        earned: result.dailyEarning,
-        total: result.totalYieldEarned,
-        apy: result.currentApy / 100,
-        timestamp: Date.now()
-      });
-    }
-    return result;
-  }
-  async fundStatus() {
-    return getFundStatus(this.client, this.keypair);
-  }
-  // -- Sentinel --
-  async sentinelList() {
-    return listSentinels();
-  }
-  async sentinelInfo(id) {
-    return getSentinelInfo(this.client, id);
-  }
-  async sentinelAttack(id, prompt, fee) {
-    return attack(this.client, this.keypair, id, prompt, fee);
+  async maxWithdraw() {
+    const adapter = await this.resolveLending(void 0, "USDC", "withdraw");
+    return adapter.maxWithdraw(this._address, "USDC");
   }
-  // -- Helpers --
-  async resolveLending(protocol, asset, capability) {
-    if (protocol) {
-      const adapter = this.registry.getLending(protocol);
-      if (!adapter) throw new T2000Error("ASSET_NOT_SUPPORTED", `Lending adapter '${protocol}' not found`);
-      return adapter;
-    }
-    if (capability === "save") {
-      const { adapter } = await this.registry.bestSaveRate(asset);
-      return adapter;
-    }
-    if (capability === "borrow" || capability === "repay") {
-      const adapters2 = this.registry.listLending().filter(
-        (a) => a.supportedAssets.includes(asset) && a.capabilities.includes(capability) && (capability !== "borrow" || a.supportsSameAssetBorrow)
-      );
-      if (adapters2.length === 0) throw new T2000Error("ASSET_NOT_SUPPORTED", `No adapter supports ${capability} ${asset}`);
-      return adapters2[0];
+  // -- Borrowing --
+  async borrow(params) {
+    const asset = (params.asset ?? "USDC").toUpperCase();
+    if (asset !== "USDC") {
+      throw new T2000Error("ASSET_NOT_SUPPORTED", `Only USDC is supported for borrow. Got: ${asset}`);
     }
-    const adapters = this.registry.listLending().filter(
-      (a) => a.supportedAssets.includes(asset) && a.capabilities.includes(capability)
-    );
-    if (adapters.length === 0) throw new T2000Error("ASSET_NOT_SUPPORTED", `No adapter supports ${capability} ${asset}`);
-    return adapters[0];
-  }
-  emitBalanceChange(asset, amount, cause, tx) {
-    this.emit("balanceChange", { asset, previous: 0, current: 0, cause, tx });
-  }
-};
-async function callSponsorApi(address, name) {
-  const res = await fetch(`${API_BASE_URL}/api/sponsor`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ address, name })
-  });
-  if (res.status === 429) {
-    const data = await res.json();
-    if (data.challenge) {
-      const proof = solveHashcash(data.challenge);
-      const retry = await fetch(`${API_BASE_URL}/api/sponsor`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ address, name, proof })
+    const adapter = await this.resolveLending(params.protocol, asset, "borrow");
+    const maxResult = await adapter.maxBorrow(this._address, asset);
+    if (params.amount > maxResult.maxAmount) {
+      throw new T2000Error("HEALTH_FACTOR_TOO_LOW", `Max safe borrow: $${maxResult.maxAmount.toFixed(2)}`, {
+        maxBorrow: maxResult.maxAmount,
+        currentHF: maxResult.currentHF
       });
-      if (!retry.ok) throw new T2000Error("SPONSOR_RATE_LIMITED", "Sponsor rate limited");
-      return;
     }
-  }
-  if (!res.ok) {
-    throw new T2000Error("SPONSOR_FAILED", "Sponsor API unavailable");
-  }
-}
-
-// src/utils/simulate.ts
-async function simulateTransaction(client, tx, sender) {
-  tx.setSender(sender);
-  try {
-    const txBytes = await tx.build({ client });
-    const dryRun = await client.dryRunTransactionBlock({
-      transactionBlock: Buffer.from(txBytes).toString("base64")
+    const fee = calculateFee("borrow", params.amount);
+    const borrowAmount = params.amount;
+    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      const { tx } = await adapter.buildBorrowTx(this._address, borrowAmount, asset, { collectFee: true });
+      return tx;
     });
-    const status = dryRun.effects?.status;
-    const gasUsed = dryRun.effects?.gasUsed;
-    const gasEstimateSui = gasUsed ? (Number(gasUsed.computationCost) + Number(gasUsed.storageCost) - Number(gasUsed.storageRebate)) / 1e9 : 0;
-    if (status?.status === "failure") {
-      const rawError = status.error ?? "Unknown simulation error";
-      const parsed = parseMoveAbort(rawError);
-      return {
-        success: false,
-        gasEstimateSui,
-        error: {
-          moveAbortCode: parsed.abortCode,
-          moveModule: parsed.module,
-          reason: parsed.reason,
-          rawError
-        }
-      };
-    }
-    return { success: true, gasEstimateSui };
-  } catch (err) {
-    const rawError = err instanceof Error ? err.message : String(err);
+    const hf = await adapter.getHealth(this._address);
+    reportFee(this._address, "borrow", fee.amount, fee.rate, gasResult.digest);
+    this.emitBalanceChange("USDC", borrowAmount, "borrow", gasResult.digest);
     return {
-      success: false,
-      gasEstimateSui: 0,
-      error: {
-        reason: "Simulation failed: " + rawError,
-        rawError
-      }
-    };
-  }
-}
-function throwIfSimulationFailed(sim) {
-  if (sim.success) return;
-  throw new T2000Error(
-    "SIMULATION_FAILED",
-    sim.error?.reason ?? "Transaction simulation failed",
-    {
-      moveAbortCode: sim.error?.moveAbortCode,
-      moveModule: sim.error?.moveModule,
-      reason: sim.error?.reason,
-      rawError: sim.error?.rawError
-    }
-  );
-}
-function parseMoveAbort(errorStr) {
-  const abortMatch = errorStr.match(/MoveAbort\([^,]*,\s*(\d+)\)/);
-  const moduleMatch = errorStr.match(/name:\s*Identifier\("([^"]+)"\)/);
-  if (abortMatch) {
-    const code = parseInt(abortMatch[1], 10);
-    const module = moduleMatch?.[1];
-    const reason = mapMoveAbortCode(code);
-    return { abortCode: code, module, reason };
+      success: true,
+      tx: gasResult.digest,
+      amount: borrowAmount,
+      fee: fee.amount,
+      healthFactor: hf.healthFactor,
+      gasCost: gasResult.gasCostSui,
+      gasMethod: gasResult.gasMethod
+    };
   }
-  if (errorStr.includes("MovePrimitiveRuntimeError")) {
-    const module = moduleMatch?.[1];
+  async repay(params) {
+    const asset = (params.asset ?? "USDC").toUpperCase();
+    if (asset !== "USDC") {
+      throw new T2000Error("ASSET_NOT_SUPPORTED", `Only USDC is supported for repay. Got: ${asset}`);
+    }
+    const adapter = await this.resolveLending(params.protocol, asset, "repay");
+    let amount;
+    if (params.amount === "all") {
+      const hf2 = await adapter.getHealth(this._address);
+      amount = hf2.borrowed;
+      if (amount <= 0) {
+        throw new T2000Error("NO_COLLATERAL", "No outstanding borrow to repay");
+      }
+    } else {
+      amount = params.amount;
+    }
+    const repayAmount = amount;
+    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      const { tx } = await adapter.buildRepayTx(this._address, repayAmount, asset);
+      return tx;
+    });
+    const hf = await adapter.getHealth(this._address);
+    this.emitBalanceChange("USDC", repayAmount, "repay", gasResult.digest);
     return {
-      module,
-      reason: `Move runtime error in ${module ?? "unknown"} module`
+      success: true,
+      tx: gasResult.digest,
+      amount: repayAmount,
+      remainingDebt: hf.borrowed,
+      gasCost: gasResult.gasCostSui,
+      gasMethod: gasResult.gasMethod
     };
   }
-  return { reason: errorStr };
-}
-var USDC_TYPE2 = SUPPORTED_ASSETS.USDC.type;
-SUPPORTED_ASSETS.USDC.decimals;
-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];
+  async maxBorrow() {
+    const adapter = await this.resolveLending(void 0, "USDC", "borrow");
+    return adapter.maxBorrow(this._address, "USDC");
   }
-  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]);
+  async healthFactor() {
+    const adapter = await this.resolveLending(void 0, "USDC", "save");
+    const hf = await adapter.getHealth(this._address);
+    if (hf.healthFactor < 1.2) {
+      this.emit("healthCritical", { healthFactor: hf.healthFactor, threshold: 1.5, severity: "critical" });
+    } else if (hf.healthFactor < 2) {
+      this.emit("healthWarning", { healthFactor: hf.healthFactor, threshold: 2, severity: "warning" });
     }
+    return hf;
   }
-  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)}`
-      );
+  // -- Swap --
+  async swap(params) {
+    const fromAsset = params.from.toUpperCase();
+    const toAsset = params.to.toUpperCase();
+    if (!(fromAsset in SUPPORTED_ASSETS) || !(toAsset in SUPPORTED_ASSETS)) {
+      throw new T2000Error("ASSET_NOT_SUPPORTED", `Swap pair ${fromAsset}/${toAsset} is not supported`);
     }
-    this.initialized = true;
-  }
-  ensureInit() {
-    if (!this.initialized) {
-      throw new T2000Error(
-        "PROTOCOL_UNAVAILABLE",
-        "SuilendAdapter not initialized. Call init() first."
-      );
+    if (fromAsset === toAsset) {
+      throw new T2000Error("INVALID_AMOUNT", "Cannot swap same asset");
     }
-  }
-  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;
+    let adapter;
+    if (params.protocol) {
+      const found = this.registry.getSwap(params.protocol);
+      if (!found) throw new T2000Error("ASSET_NOT_SUPPORTED", `Swap adapter '${params.protocol}' not found`);
+      adapter = found;
+    } else {
+      const best = await this.registry.bestSwapQuote(fromAsset, toAsset, params.amount);
+      adapter = best.adapter;
     }
-  }
-  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 fee = calculateFee("swap", params.amount);
+    const swapAmount = params.amount;
+    const slippageBps = params.maxSlippage ? params.maxSlippage * 100 : void 0;
+    let swapMeta = { estimatedOut: 0, toDecimals: 0 };
+    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      const built = await adapter.buildSwapTx(this._address, fromAsset, toAsset, swapAmount, slippageBps);
+      swapMeta = { estimatedOut: built.estimatedOut, toDecimals: built.toDecimals };
+      return built.tx;
+    });
+    const toInfo = SUPPORTED_ASSETS[toAsset];
+    await this.client.waitForTransaction({ digest: gasResult.digest });
+    const txDetail = await this.client.getTransactionBlock({
+      digest: gasResult.digest,
+      options: { showBalanceChanges: true }
+    });
+    let actualReceived = 0;
+    if (txDetail.balanceChanges) {
+      for (const change of txDetail.balanceChanges) {
+        if (change.coinType === toInfo.type && change.owner && typeof change.owner === "object" && "AddressOwner" in change.owner && change.owner.AddressOwner === this._address) {
+          const amt = Number(change.amount) / 10 ** toInfo.decimals;
+          if (amt > 0) actualReceived += amt;
+        }
+      }
     }
-    const { borrowAprPct, depositAprPct } = computeRatesFromReserve(reserve);
+    const expectedOutput = swapMeta.estimatedOut / 10 ** swapMeta.toDecimals;
+    if (actualReceived === 0) actualReceived = expectedOutput;
+    const priceImpact = expectedOutput > 0 ? Math.abs(actualReceived - expectedOutput) / expectedOutput : 0;
+    reportFee(this._address, "swap", fee.amount, fee.rate, gasResult.digest);
+    this.emitBalanceChange(fromAsset, swapAmount, "swap", gasResult.digest);
     return {
-      asset,
-      saveApy: depositAprPct,
-      borrowApy: borrowAprPct
+      success: true,
+      tx: gasResult.digest,
+      fromAmount: swapAmount,
+      fromAsset,
+      toAmount: actualReceived,
+      toAsset,
+      priceImpact,
+      fee: fee.amount,
+      gasCost: gasResult.gasCostSui,
+      gasMethod: gasResult.gasMethod
     };
   }
-  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 swapQuote(params) {
+    const fromAsset = params.from.toUpperCase();
+    const toAsset = params.to.toUpperCase();
+    const best = await this.registry.bestSwapQuote(fromAsset, toAsset, params.amount);
+    const fee = calculateFee("swap", params.amount);
+    return { ...best.quote, fee: { amount: fee.amount, rate: fee.rate } };
+  }
+  // -- Info --
+  async positions() {
+    const allPositions = await this.registry.allPositions(this._address);
+    const positions = allPositions.flatMap(
+      (p) => [
+        ...p.positions.supplies.map((s) => ({
+          protocol: p.protocolId,
+          asset: s.asset,
+          type: "save",
+          amount: s.amount,
+          apy: s.apy
+        })),
+        ...p.positions.borrows.map((b) => ({
+          protocol: p.protocolId,
+          asset: b.asset,
+          type: "borrow",
+          amount: b.amount,
+          apy: b.apy
+        }))
+      ]
+    );
+    return { positions };
   }
-  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 };
+  async rates() {
+    return getRates(this.client);
+  }
+  async allRates(asset = "USDC") {
+    return this.registry.allRates(asset);
+  }
+  async earnings() {
+    const result = await getEarnings(this.client, this.keypair);
+    if (result.totalYieldEarned > 0) {
+      this.emit("yield", {
+        earned: result.dailyEarning,
+        total: result.totalYieldEarned,
+        apy: result.currentApy / 100,
+        timestamp: Date.now()
+      });
     }
-    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 };
+    return result;
   }
-  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;
+  async fundStatus() {
+    return getFundStatus(this.client, this.keypair);
+  }
+  // -- Sentinel --
+  async sentinelList() {
+    return listSentinels();
+  }
+  async sentinelInfo(id) {
+    return getSentinelInfo(this.client, id);
+  }
+  async sentinelAttack(id, prompt, fee) {
+    return attack(this.client, this.keypair, id, prompt, fee);
+  }
+  // -- Helpers --
+  async resolveLending(protocol, asset, capability) {
+    if (protocol) {
+      const adapter = this.registry.getLending(protocol);
+      if (!adapter) throw new T2000Error("ASSET_NOT_SUPPORTED", `Lending adapter '${protocol}' not found`);
+      return adapter;
     }
-    const allCoins = await this.fetchAllCoins(address, USDC_TYPE2);
-    if (allCoins.length === 0) {
-      throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins found");
+    if (capability === "save") {
+      const { adapter } = await this.registry.bestSaveRate(asset);
+      return adapter;
     }
-    const primaryCoinId = allCoins[0].coinObjectId;
-    if (allCoins.length > 1) {
-      tx.mergeCoins(
-        tx.object(primaryCoinId),
-        allCoins.slice(1).map((c) => tx.object(c.coinObjectId))
+    if (capability === "borrow" || capability === "repay") {
+      const adapters2 = this.registry.listLending().filter(
+        (a) => a.supportedAssets.includes(asset) && a.capabilities.includes(capability) && (capability !== "borrow" || a.supportsSameAssetBorrow)
       );
+      if (adapters2.length === 0) throw new T2000Error("ASSET_NOT_SUPPORTED", `No adapter supports ${capability} ${asset}`);
+      return adapters2[0];
     }
-    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
+    const adapters = this.registry.listLending().filter(
+      (a) => a.supportedAssets.includes(asset) && a.capabilities.includes(capability)
     );
-    return { tx, effectiveAmount };
+    if (adapters.length === 0) throw new T2000Error("ASSET_NOT_SUPPORTED", `No adapter supports ${capability} ${asset}`);
+    return adapters[0];
   }
-  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."
-    );
+  emitBalanceChange(asset, amount, cause, tx) {
+    this.emit("balanceChange", { asset, previous: 0, current: 0, cause, tx });
   }
-  async buildRepayTx(_address, _amount, _asset) {
-    throw new T2000Error(
-      "ASSET_NOT_SUPPORTED",
-      "SuilendAdapter.buildRepayTx() not available \u2014 deferred to Phase 10."
-    );
+};
+async function callSponsorApi(address, name) {
+  const res = await fetch(`${API_BASE_URL}/api/sponsor`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ address, name })
+  });
+  if (res.status === 429) {
+    const data = await res.json();
+    if (data.challenge) {
+      const proof = solveHashcash(data.challenge);
+      const retry = await fetch(`${API_BASE_URL}/api/sponsor`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ address, name, proof })
+      });
+      if (!retry.ok) throw new T2000Error("SPONSOR_RATE_LIMITED", "Sponsor rate limited");
+      return;
+    }
   }
-  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
-      );
+  if (!res.ok) {
+    throw new T2000Error("SPONSOR_FAILED", "Sponsor API unavailable");
+  }
+}
+
+// src/utils/simulate.ts
+async function simulateTransaction(client, tx, sender) {
+  tx.setSender(sender);
+  try {
+    const txBytes = await tx.build({ client });
+    const dryRun = await client.dryRunTransactionBlock({
+      transactionBlock: Buffer.from(txBytes).toString("base64")
+    });
+    const status = dryRun.effects?.status;
+    const gasUsed = dryRun.effects?.gasUsed;
+    const gasEstimateSui = gasUsed ? (Number(gasUsed.computationCost) + Number(gasUsed.storageCost) - Number(gasUsed.storageRebate)) / 1e9 : 0;
+    if (status?.status === "failure") {
+      const rawError = status.error ?? "Unknown simulation error";
+      const parsed = parseMoveAbort(rawError);
+      return {
+        success: false,
+        gasEstimateSui,
+        error: {
+          moveAbortCode: parsed.abortCode,
+          moveModule: parsed.module,
+          reason: parsed.reason,
+          rawError
+        }
+      };
     }
-    const remainingSupply = health.supplied - maxAmount;
-    const hfAfter = health.borrowed > 0 ? remainingSupply * health.liquidationThreshold / health.borrowed : Infinity;
+    return { success: true, gasEstimateSui };
+  } catch (err) {
+    const rawError = err instanceof Error ? err.message : String(err);
     return {
-      maxAmount,
-      healthFactorAfter: hfAfter,
-      currentHF: health.healthFactor
+      success: false,
+      gasEstimateSui: 0,
+      error: {
+        reason: "Simulation failed: " + rawError,
+        rawError
+      }
     };
   }
-  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;
+}
+function throwIfSimulationFailed(sim) {
+  if (sim.success) return;
+  throw new T2000Error(
+    "SIMULATION_FAILED",
+    sim.error?.reason ?? "Transaction simulation failed",
+    {
+      moveAbortCode: sim.error?.moveAbortCode,
+      moveModule: sim.error?.moveModule,
+      reason: sim.error?.reason,
+      rawError: sim.error?.rawError
     }
-    return all;
+  );
+}
+function parseMoveAbort(errorStr) {
+  const abortMatch = errorStr.match(/MoveAbort\([^,]*,\s*(\d+)\)/);
+  const moduleMatch = errorStr.match(/name:\s*Identifier\("([^"]+)"\)/);
+  if (abortMatch) {
+    const code = parseInt(abortMatch[1], 10);
+    const module = moduleMatch?.[1];
+    const reason = mapMoveAbortCode(code);
+    return { abortCode: code, module, reason };
   }
-};
+  if (errorStr.includes("MovePrimitiveRuntimeError")) {
+    const module = moduleMatch?.[1];
+    return {
+      module,
+      reason: `Move runtime error in ${module ?? "unknown"} module`
+    };
+  }
+  return { reason: errorStr };
+}
 
 exports.BPS_DENOMINATOR = BPS_DENOMINATOR;
 exports.CLOCK_ID = CLOCK_ID;