@t2000/sdk 0.9.1 → 0.9.4

package/dist/index.js

@@ -1,4 +1,5 @@
 import { EventEmitter } from 'eventemitter3';
+import { Transaction } from '@mysten/sui/transactions';
 import { SuiJsonRpcClient } from '@mysten/sui/jsonRpc';
 import { normalizeSuiAddress, isValidSuiAddress, normalizeStructTag } from '@mysten/sui/utils';
 import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
@@ -7,7 +8,6 @@ import { createHash, randomBytes, createCipheriv, createDecipheriv, scryptSync }
 import { access, mkdir, writeFile, readFile } from 'fs/promises';
 import { dirname, resolve } from 'path';
 import { homedir } from 'os';
-import { Transaction } from '@mysten/sui/transactions';
 import { bcs } from '@mysten/sui/bcs';
 import { AggregatorClient, Env } from '@cetusprotocol/aggregator-sdk';
 
@@ -126,7 +126,9 @@ function mapMoveAbortCode(code) {
     // NAVI Protocol abort codes
     1502: "Oracle price is stale \u2014 try again in a moment",
     1600: "Health factor too low \u2014 withdrawal would risk liquidation",
-    1605: "Asset borrowing is disabled or at capacity on this protocol"
+    1605: "Asset borrowing is disabled or at capacity on this protocol",
+    // Cetus DEX abort codes
+    46001: "Swap failed \u2014 the DEX pool rejected the trade (liquidity or routing issue). Try again."
   };
   return abortMessages[code] ?? `Move abort code: ${code}`;
 }
@@ -137,7 +139,12 @@ function parseMoveAbortMessage(msg) {
   const abortMatch = msg.match(/abort code:\s*(\d+)/i) ?? msg.match(/MoveAbort[^,]*,\s*(\d+)/);
   if (abortMatch) {
     const code = parseInt(abortMatch[1], 10);
-    return mapMoveAbortCode(code);
+    const mapped = mapMoveAbortCode(code);
+    if (mapped.startsWith("Move abort code:")) {
+      const moduleMatch = msg.match(/in '([^']+)'/);
+      if (moduleMatch) return `${mapped} (in ${moduleMatch[1]})`;
+    }
+    return mapped;
   }
   return msg;
 }
@@ -744,6 +751,94 @@ async function buildWithdrawTx(client, address, amount, options = {}) {
   tx.transferObjects([coin], address);
   return { tx, effectiveAmount };
 }
+async function addWithdrawToTx(tx, client, address, amount, options = {}) {
+  const asset = options.asset ?? "USDC";
+  const assetInfo = SUPPORTED_ASSETS[asset];
+  const [config, pool, pools, states] = await Promise.all([
+    getConfig(),
+    getPool(asset),
+    getPools(),
+    getUserState(client, address)
+  ]);
+  const assetState = states.find((s) => s.assetId === pool.id);
+  const deposited = assetState ? compoundBalance(assetState.supplyBalance, pool.currentSupplyIndex) : 0;
+  const effectiveAmount = Math.min(amount, Math.max(0, deposited - WITHDRAW_DUST_BUFFER));
+  if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", `Nothing to withdraw for ${assetInfo.displayName} on NAVI`);
+  const rawAmount = Number(stableToRaw(effectiveAmount, assetInfo.decimals));
+  addOracleUpdatesForPositions(tx, config, pools, states, pool);
+  const [balance] = tx.moveCall({
+    target: `${config.package}::incentive_v3::withdraw_v2`,
+    arguments: [
+      tx.object(CLOCK),
+      tx.object(config.oracle.priceOracle),
+      tx.object(config.storage),
+      tx.object(pool.contract.pool),
+      tx.pure.u8(pool.id),
+      tx.pure.u64(rawAmount),
+      tx.object(config.incentiveV2),
+      tx.object(config.incentiveV3),
+      tx.object(SUI_SYSTEM_STATE)
+    ],
+    typeArguments: [pool.suiCoinType]
+  });
+  const [coin] = tx.moveCall({
+    target: "0x2::coin::from_balance",
+    arguments: [balance],
+    typeArguments: [pool.suiCoinType]
+  });
+  return { coin, effectiveAmount };
+}
+async function addSaveToTx(tx, _client, _address, coin, options = {}) {
+  const asset = options.asset ?? "USDC";
+  const [config, pool] = await Promise.all([getConfig(), getPool(asset)]);
+  if (options.collectFee) {
+    addCollectFeeToTx(tx, coin, "save");
+  }
+  const [coinValue] = tx.moveCall({
+    target: "0x2::coin::value",
+    typeArguments: [pool.suiCoinType],
+    arguments: [coin]
+  });
+  tx.moveCall({
+    target: `${config.package}::incentive_v3::entry_deposit`,
+    arguments: [
+      tx.object(CLOCK),
+      tx.object(config.storage),
+      tx.object(pool.contract.pool),
+      tx.pure.u8(pool.id),
+      coin,
+      coinValue,
+      tx.object(config.incentiveV2),
+      tx.object(config.incentiveV3)
+    ],
+    typeArguments: [pool.suiCoinType]
+  });
+}
+async function addRepayToTx(tx, client, _address, coin, options = {}) {
+  const asset = options.asset ?? "USDC";
+  const [config, pool] = await Promise.all([getConfig(), getPool(asset)]);
+  addOracleUpdate(tx, config, pool);
+  const [coinValue] = tx.moveCall({
+    target: "0x2::coin::value",
+    typeArguments: [pool.suiCoinType],
+    arguments: [coin]
+  });
+  tx.moveCall({
+    target: `${config.package}::incentive_v3::entry_repay`,
+    arguments: [
+      tx.object(CLOCK),
+      tx.object(config.oracle.priceOracle),
+      tx.object(config.storage),
+      tx.object(pool.contract.pool),
+      tx.pure.u8(pool.id),
+      coin,
+      coinValue,
+      tx.object(config.incentiveV2),
+      tx.object(config.incentiveV3)
+    ],
+    typeArguments: [pool.suiCoinType]
+  });
+}
 async function buildBorrowTx(client, address, amount, options = {}) {
   if (!amount || amount <= 0 || !Number.isFinite(amount)) {
     throw new T2000Error("INVALID_AMOUNT", "Borrow amount must be a positive number");
@@ -1391,6 +1486,18 @@ var NaviAdapter = class {
   async maxBorrow(address, _asset) {
     return maxBorrowAmount(this.client, address);
   }
+  async addWithdrawToTx(tx, address, amount, asset) {
+    const stableAsset = normalizeAsset(asset);
+    return addWithdrawToTx(tx, this.client, address, amount, { asset: stableAsset });
+  }
+  async addSaveToTx(tx, address, coin, asset, options) {
+    const stableAsset = normalizeAsset(asset);
+    return addSaveToTx(tx, this.client, address, coin, { ...options, asset: stableAsset });
+  }
+  async addRepayToTx(tx, address, coin, asset) {
+    const stableAsset = normalizeAsset(asset);
+    return addRepayToTx(tx, this.client, address, coin, { asset: stableAsset });
+  }
 };
 var DEFAULT_SLIPPAGE_BPS = 300;
 function createAggregatorClient(client, signer) {
@@ -1435,6 +1542,41 @@ async function buildSwapTx(params) {
     toDecimals: toInfo.decimals
   };
 }
+async function addSwapToTx(params) {
+  const { tx, client, address, inputCoin, fromAsset, toAsset, amount, maxSlippageBps = DEFAULT_SLIPPAGE_BPS } = params;
+  const fromInfo = SUPPORTED_ASSETS[fromAsset];
+  const toInfo = SUPPORTED_ASSETS[toAsset];
+  if (!fromInfo || !toInfo) {
+    throw new T2000Error("ASSET_NOT_SUPPORTED", `Swap pair ${fromAsset}/${toAsset} is not supported`);
+  }
+  const rawAmount = BigInt(Math.floor(amount * 10 ** fromInfo.decimals));
+  const aggClient = createAggregatorClient(client, address);
+  const result = await aggClient.findRouters({
+    from: fromInfo.type,
+    target: toInfo.type,
+    amount: rawAmount,
+    byAmountIn: true
+  });
+  if (!result || result.insufficientLiquidity) {
+    throw new T2000Error(
+      "ASSET_NOT_SUPPORTED",
+      `No swap route found for ${fromAsset} \u2192 ${toAsset}`
+    );
+  }
+  const slippage = maxSlippageBps / 1e4;
+  const outputCoin = await aggClient.routerSwap({
+    router: result,
+    txb: tx,
+    inputCoin,
+    slippage
+  });
+  const estimatedOut = Number(result.amountOut.toString());
+  return {
+    outputCoin,
+    estimatedOut,
+    toDecimals: toInfo.decimals
+  };
+}
 async function getPoolPrice(client) {
   try {
     const pool = await client.getObject({
@@ -1545,6 +1687,18 @@ var CetusAdapter = class {
   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
+    });
+  }
 };
 SUPPORTED_ASSETS.USDC.type;
 var WAD = 1e18;
@@ -1941,6 +2095,95 @@ var SuilendAdapter = class {
     tx.transferObjects([coin], address);
     return { tx, effectiveAmount };
   }
+  async addWithdrawToTx(tx, address, amount, asset) {
+    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
+    const assetInfo = SUPPORTED_ASSETS[assetKey];
+    const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves(true)]);
+    const reserve = this.findReserve(reserves, assetKey);
+    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend`);
+    const caps = await this.fetchObligationCaps(address);
+    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend position found");
+    const positions = await this.getPositions(address);
+    const deposited = positions.supplies.find((s) => s.asset === assetKey)?.amount ?? 0;
+    const effectiveAmount = Math.min(amount, deposited);
+    if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", `Nothing to withdraw for ${assetInfo.displayName} on Suilend`);
+    const ratio = cTokenRatio(reserve);
+    const ctokenAmount = Math.ceil(effectiveAmount * 10 ** reserve.mintDecimals / ratio);
+    const [ctokens] = tx.moveCall({
+      target: `${pkg}::lending_market::withdraw_ctokens`,
+      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
+      arguments: [
+        tx.object(LENDING_MARKET_ID),
+        tx.pure.u64(reserve.arrayIndex),
+        tx.object(caps[0].id),
+        tx.object(CLOCK2),
+        tx.pure.u64(ctokenAmount)
+      ]
+    });
+    const exemptionType = `${SUILEND_PACKAGE}::lending_market::RateLimiterExemption<${LENDING_MARKET_TYPE}, ${assetInfo.type}>`;
+    const [none] = tx.moveCall({
+      target: "0x1::option::none",
+      typeArguments: [exemptionType]
+    });
+    const [coin] = tx.moveCall({
+      target: `${pkg}::lending_market::redeem_ctokens_and_withdraw_liquidity`,
+      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
+      arguments: [
+        tx.object(LENDING_MARKET_ID),
+        tx.pure.u64(reserve.arrayIndex),
+        tx.object(CLOCK2),
+        ctokens,
+        none
+      ]
+    });
+    return { coin, effectiveAmount };
+  }
+  async addSaveToTx(tx, address, coin, asset, options) {
+    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
+    const assetInfo = SUPPORTED_ASSETS[assetKey];
+    const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves()]);
+    const reserve = this.findReserve(reserves, assetKey);
+    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend`);
+    const caps = await this.fetchObligationCaps(address);
+    let capRef;
+    if (caps.length === 0) {
+      const [newCap] = tx.moveCall({
+        target: `${pkg}::lending_market::create_obligation`,
+        typeArguments: [LENDING_MARKET_TYPE],
+        arguments: [tx.object(LENDING_MARKET_ID)]
+      });
+      capRef = newCap;
+    } else {
+      capRef = caps[0].id;
+    }
+    if (options?.collectFee) {
+      addCollectFeeToTx(tx, coin, "save");
+    }
+    const [ctokens] = tx.moveCall({
+      target: `${pkg}::lending_market::deposit_liquidity_and_mint_ctokens`,
+      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
+      arguments: [
+        tx.object(LENDING_MARKET_ID),
+        tx.pure.u64(reserve.arrayIndex),
+        tx.object(CLOCK2),
+        coin
+      ]
+    });
+    tx.moveCall({
+      target: `${pkg}::lending_market::deposit_ctokens_into_obligation`,
+      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
+      arguments: [
+        tx.object(LENDING_MARKET_ID),
+        tx.pure.u64(reserve.arrayIndex),
+        typeof capRef === "string" ? tx.object(capRef) : capRef,
+        tx.object(CLOCK2),
+        ctokens
+      ]
+    });
+    if (typeof capRef !== "string") {
+      tx.transferObjects([capRef], address);
+    }
+  }
   async buildBorrowTx(address, amount, asset, options) {
     const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
     const assetInfo = SUPPORTED_ASSETS[assetKey];
@@ -2000,6 +2243,26 @@ var SuilendAdapter = class {
     });
     return { tx };
   }
+  async addRepayToTx(tx, address, coin, asset) {
+    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
+    const assetInfo = SUPPORTED_ASSETS[assetKey];
+    const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves()]);
+    const reserve = this.findReserve(reserves, assetKey);
+    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend`);
+    const caps = await this.fetchObligationCaps(address);
+    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend obligation found");
+    tx.moveCall({
+      target: `${pkg}::lending_market::repay`,
+      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
+      arguments: [
+        tx.object(LENDING_MARKET_ID),
+        tx.pure.u64(reserve.arrayIndex),
+        tx.object(caps[0].id),
+        tx.object(CLOCK2),
+        coin
+      ]
+    });
+  }
   async maxWithdraw(address, _asset) {
     const health = await this.getHealth(address);
     let maxAmount;
@@ -2416,31 +2679,73 @@ var T2000 = class _T2000 extends EventEmitter {
     const asset = "USDC";
     const bal = await queryBalance(this.client, this._address);
     const usdcBalance = bal.stables.USDC ?? 0;
+    const needsAutoConvert = params.amount === "all" ? Object.entries(bal.stables).some(([k, v]) => k !== "USDC" && v > 0.01) : typeof params.amount === "number" && params.amount > usdcBalance;
     let amount;
     if (params.amount === "all") {
-      await this._convertWalletStablesToUsdc(bal);
-      const refreshedBal = await queryBalance(this.client, this._address);
-      amount = (refreshedBal.stables.USDC ?? 0) - 1;
+      amount = (bal.available ?? 0) - 1;
       if (amount <= 0) {
         throw new T2000Error("INSUFFICIENT_BALANCE", "Balance too low to save after $1 gas reserve", {
           reason: "gas_reserve_required",
-          available: refreshedBal.stables.USDC ?? 0
+          available: bal.available ?? 0
         });
       }
     } else {
       amount = params.amount;
-      if (amount > usdcBalance) {
-        const totalStables = bal.available;
-        if (amount > totalStables) {
-          throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient balance. Available: $${totalStables.toFixed(2)}, requested: $${amount.toFixed(2)}`);
-        }
-        await this._convertWalletStablesToUsdc(bal, amount - usdcBalance);
+      if (amount > (bal.available ?? 0)) {
+        throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient balance. Available: $${(bal.available ?? 0).toFixed(2)}, requested: $${amount.toFixed(2)}`);
       }
     }
     const fee = calculateFee("save", amount);
     const saveAmount = amount;
     const adapter = await this.resolveLending(params.protocol, asset, "save");
+    const swapAdapter = this.registry.listSwap()[0];
+    const canPTB = adapter.addSaveToTx && (!needsAutoConvert || swapAdapter?.addSwapToTx);
     const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      if (canPTB && needsAutoConvert) {
+        const tx2 = new Transaction();
+        tx2.setSender(this._address);
+        const usdcCoins = [];
+        for (const [stableAsset, stableAmount] of Object.entries(bal.stables)) {
+          if (stableAsset === "USDC" || stableAmount <= 0.01) continue;
+          const assetInfo = SUPPORTED_ASSETS[stableAsset];
+          if (!assetInfo) continue;
+          const coins = await this._fetchCoins(assetInfo.type);
+          if (coins.length === 0) continue;
+          const merged = this._mergeCoinsInTx(tx2, coins);
+          const { outputCoin } = await swapAdapter.addSwapToTx(
+            tx2,
+            this._address,
+            merged,
+            stableAsset,
+            "USDC",
+            stableAmount
+          );
+          usdcCoins.push(outputCoin);
+        }
+        const existingUsdc = await this._fetchCoins(SUPPORTED_ASSETS.USDC.type);
+        if (existingUsdc.length > 0) {
+          usdcCoins.push(this._mergeCoinsInTx(tx2, existingUsdc));
+        }
+        if (usdcCoins.length > 1) {
+          tx2.mergeCoins(usdcCoins[0], usdcCoins.slice(1));
+        }
+        await adapter.addSaveToTx(tx2, this._address, usdcCoins[0], asset, { collectFee: true });
+        return tx2;
+      }
+      if (canPTB && !needsAutoConvert) {
+        const tx2 = new Transaction();
+        tx2.setSender(this._address);
+        const existingUsdc = await this._fetchCoins(SUPPORTED_ASSETS.USDC.type);
+        if (existingUsdc.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins found");
+        const merged = this._mergeCoinsInTx(tx2, existingUsdc);
+        const rawAmount = BigInt(Math.floor(saveAmount * 10 ** SUPPORTED_ASSETS.USDC.decimals));
+        const [depositCoin] = tx2.splitCoins(merged, [rawAmount]);
+        await adapter.addSaveToTx(tx2, this._address, depositCoin, asset, { collectFee: true });
+        return tx2;
+      }
+      if (needsAutoConvert) {
+        await this._convertWalletStablesToUsdc(bal, params.amount === "all" ? void 0 : amount - usdcBalance);
+      }
       const { tx } = await adapter.buildSaveTx(this._address, saveAmount, asset, { collectFee: true });
       return tx;
     });
@@ -2509,35 +2814,41 @@ var T2000 = class _T2000 extends EventEmitter {
       }
     }
     const withdrawAmount = amount;
-    let effectiveAmount = withdrawAmount;
+    let finalAmount = withdrawAmount;
+    const swapAdapter = target.asset !== "USDC" ? this.registry.listSwap()[0] : void 0;
+    const canPTB = adapter.addWithdrawToTx && (!swapAdapter || swapAdapter.addSwapToTx);
     const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      if (canPTB) {
+        const tx = new Transaction();
+        tx.setSender(this._address);
+        const { coin, effectiveAmount } = await adapter.addWithdrawToTx(tx, this._address, withdrawAmount, target.asset);
+        finalAmount = effectiveAmount;
+        if (target.asset !== "USDC" && swapAdapter?.addSwapToTx) {
+          const { outputCoin, estimatedOut, toDecimals } = await swapAdapter.addSwapToTx(
+            tx,
+            this._address,
+            coin,
+            target.asset,
+            "USDC",
+            effectiveAmount
+          );
+          finalAmount = estimatedOut / 10 ** toDecimals;
+          tx.transferObjects([outputCoin], this._address);
+        } else {
+          tx.transferObjects([coin], this._address);
+        }
+        return tx;
+      }
       const built = await adapter.buildWithdrawTx(this._address, withdrawAmount, target.asset);
-      effectiveAmount = built.effectiveAmount;
+      finalAmount = built.effectiveAmount;
       return built.tx;
     });
-    let totalGasCost = gasResult.gasCostSui;
-    let finalAmount = effectiveAmount;
-    let lastDigest = gasResult.digest;
-    if (target.asset !== "USDC") {
-      try {
-        const swapResult = await this._swapToUsdc(target.asset, effectiveAmount);
-        finalAmount = swapResult.usdcReceived;
-        lastDigest = swapResult.digest;
-        totalGasCost += swapResult.gasCost;
-      } catch (err) {
-        throw new T2000Error(
-          "SWAP_FAILED",
-          `Withdrew $${effectiveAmount.toFixed(2)} ${target.asset} but swap to USDC failed. Your ${target.asset} is safe in your wallet.`,
-          { withdrawDigest: gasResult.digest, originalError: err instanceof Error ? err.message : String(err) }
-        );
-      }
-    }
-    this.emitBalanceChange("USDC", finalAmount, "withdraw", lastDigest);
+    this.emitBalanceChange("USDC", finalAmount, "withdraw", gasResult.digest);
     return {
       success: true,
-      tx: lastDigest,
+      tx: gasResult.digest,
       amount: finalAmount,
-      gasCost: totalGasCost,
+      gasCost: gasResult.gasCostSui,
       gasMethod: gasResult.gasMethod
     };
   }
@@ -2554,49 +2865,94 @@ var T2000 = class _T2000 extends EventEmitter {
     if (withdrawable.length === 0) {
       throw new T2000Error("NO_COLLATERAL", "No savings to withdraw across any protocol");
     }
-    let totalUsdcReceived = 0;
-    let lastDigest = "";
-    let totalGasCost = 0;
-    let lastGasMethod = "self-funded";
+    const entries = [];
     for (const entry of withdrawable) {
       const adapter = this.registry.getLending(entry.protocolId);
       if (!adapter) continue;
       const maxResult = await adapter.maxWithdraw(this._address, entry.asset);
-      if (maxResult.maxAmount <= 1e-3) continue;
-      let effectiveAmount = maxResult.maxAmount;
-      const gasResult = await executeWithGas(this.client, this.keypair, async () => {
-        const built = await adapter.buildWithdrawTx(this._address, maxResult.maxAmount, entry.asset);
-        effectiveAmount = built.effectiveAmount;
-        return built.tx;
-      });
-      lastDigest = gasResult.digest;
-      totalGasCost += gasResult.gasCostSui;
-      lastGasMethod = gasResult.gasMethod;
-      this.emitBalanceChange(entry.asset, effectiveAmount, "withdraw", gasResult.digest);
-      if (entry.asset !== "USDC") {
-        try {
-          const swapResult = await this._swapToUsdc(entry.asset, effectiveAmount);
-          totalUsdcReceived += swapResult.usdcReceived;
-          lastDigest = swapResult.digest;
-          totalGasCost += swapResult.gasCost;
-        } catch {
-          totalUsdcReceived += effectiveAmount;
-        }
-      } else {
-        totalUsdcReceived += effectiveAmount;
+      if (maxResult.maxAmount > 1e-3) {
+        entries.push({ ...entry, maxAmount: maxResult.maxAmount, adapter });
       }
     }
+    if (entries.length === 0) {
+      throw new T2000Error("NO_COLLATERAL", "No savings to withdraw across any protocol");
+    }
+    const swapAdapter = this.registry.listSwap()[0];
+    const canPTB = entries.every((e) => e.adapter.addWithdrawToTx) && (!swapAdapter || swapAdapter.addSwapToTx);
+    let totalUsdcReceived = 0;
+    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      if (canPTB) {
+        const tx = new Transaction();
+        tx.setSender(this._address);
+        const usdcCoins = [];
+        for (const entry of entries) {
+          const { coin, effectiveAmount } = await entry.adapter.addWithdrawToTx(
+            tx,
+            this._address,
+            entry.maxAmount,
+            entry.asset
+          );
+          if (entry.asset !== "USDC" && swapAdapter?.addSwapToTx) {
+            const { outputCoin, estimatedOut, toDecimals } = await swapAdapter.addSwapToTx(
+              tx,
+              this._address,
+              coin,
+              entry.asset,
+              "USDC",
+              effectiveAmount
+            );
+            totalUsdcReceived += estimatedOut / 10 ** toDecimals;
+            usdcCoins.push(outputCoin);
+          } else {
+            totalUsdcReceived += effectiveAmount;
+            usdcCoins.push(coin);
+          }
+        }
+        if (usdcCoins.length > 1) {
+          tx.mergeCoins(usdcCoins[0], usdcCoins.slice(1));
+        }
+        tx.transferObjects([usdcCoins[0]], this._address);
+        return tx;
+      }
+      let lastTx;
+      for (const entry of entries) {
+        const built = await entry.adapter.buildWithdrawTx(this._address, entry.maxAmount, entry.asset);
+        totalUsdcReceived += built.effectiveAmount;
+        lastTx = built.tx;
+      }
+      return lastTx;
+    });
     if (totalUsdcReceived <= 0) {
       throw new T2000Error("NO_COLLATERAL", "No savings to withdraw across any protocol");
     }
     return {
       success: true,
-      tx: lastDigest,
+      tx: gasResult.digest,
       amount: totalUsdcReceived,
-      gasCost: totalGasCost,
-      gasMethod: lastGasMethod
+      gasCost: gasResult.gasCostSui,
+      gasMethod: gasResult.gasMethod
     };
   }
+  async _fetchCoins(coinType) {
+    const all = [];
+    let cursor;
+    let hasNext = true;
+    while (hasNext) {
+      const page = await this.client.getCoins({ owner: this._address, 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;
+  }
+  _mergeCoinsInTx(tx, coins) {
+    if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No coins to merge");
+    const primary = tx.object(coins[0].coinObjectId);
+    if (coins.length > 1) {
+      tx.mergeCoins(primary, coins.slice(1).map((c) => tx.object(c.coinObjectId)));
+    }
+    return primary;
+  }
   async _swapToUsdc(asset, amount) {
     const swapAdapter = this.registry.listSwap()[0];
     if (!swapAdapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", "No swap adapter available");
@@ -2701,72 +3057,122 @@ var T2000 = class _T2000 extends EventEmitter {
     const adapter = this.registry.getLending(target.protocolId);
     if (!adapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", `Protocol ${target.protocolId} not found`);
     const repayAmount = Math.min(params.amount, target.amount);
-    let totalGasCost = 0;
-    let lastDigest = "";
-    if (target.asset !== "USDC") {
-      const buffer = repayAmount * 1.005;
-      const swapResult = await this._swapFromUsdc(target.asset, buffer);
-      totalGasCost += swapResult.gasCost;
-      lastDigest = swapResult.digest;
-    }
+    const swapAdapter = target.asset !== "USDC" ? this.registry.listSwap()[0] : void 0;
+    const canPTB = adapter.addRepayToTx && (!swapAdapter || swapAdapter.addSwapToTx);
     const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      if (canPTB && target.asset !== "USDC" && swapAdapter?.addSwapToTx) {
+        const tx2 = new Transaction();
+        tx2.setSender(this._address);
+        const buffer = repayAmount * 1.005;
+        const usdcCoins = await this._fetchCoins(SUPPORTED_ASSETS.USDC.type);
+        if (usdcCoins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins for swap");
+        const merged = this._mergeCoinsInTx(tx2, usdcCoins);
+        const rawSwap = BigInt(Math.floor(buffer * 10 ** SUPPORTED_ASSETS.USDC.decimals));
+        const [splitCoin] = tx2.splitCoins(merged, [rawSwap]);
+        const { outputCoin } = await swapAdapter.addSwapToTx(
+          tx2,
+          this._address,
+          splitCoin,
+          "USDC",
+          target.asset,
+          buffer
+        );
+        await adapter.addRepayToTx(tx2, this._address, outputCoin, target.asset);
+        return tx2;
+      }
+      if (canPTB && target.asset === "USDC") {
+        const tx2 = new Transaction();
+        tx2.setSender(this._address);
+        const usdcCoins = await this._fetchCoins(SUPPORTED_ASSETS.USDC.type);
+        if (usdcCoins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins");
+        const merged = this._mergeCoinsInTx(tx2, usdcCoins);
+        const raw = BigInt(Math.floor(repayAmount * 10 ** SUPPORTED_ASSETS.USDC.decimals));
+        const [repayCoin] = tx2.splitCoins(merged, [raw]);
+        await adapter.addRepayToTx(tx2, this._address, repayCoin, target.asset);
+        return tx2;
+      }
+      if (target.asset !== "USDC") {
+        await this._swapFromUsdc(target.asset, repayAmount * 1.005);
+      }
       const { tx } = await adapter.buildRepayTx(this._address, repayAmount, target.asset);
       return tx;
     });
-    totalGasCost += gasResult.gasCostSui;
-    lastDigest = gasResult.digest;
     const hf = await adapter.getHealth(this._address);
-    this.emitBalanceChange("USDC", repayAmount, "repay", lastDigest);
+    this.emitBalanceChange("USDC", repayAmount, "repay", gasResult.digest);
     return {
       success: true,
-      tx: lastDigest,
+      tx: gasResult.digest,
       amount: repayAmount,
       remainingDebt: hf.borrowed,
-      gasCost: totalGasCost,
+      gasCost: gasResult.gasCostSui,
       gasMethod: gasResult.gasMethod
     };
   }
   async _repayAllBorrows(borrows) {
-    let totalRepaid = 0;
-    let totalGasCost = 0;
-    let lastDigest = "";
-    let lastGasMethod = "self-funded";
     borrows.sort((a, b) => b.apy - a.apy);
+    const entries = [];
     for (const borrow of borrows) {
       const adapter = this.registry.getLending(borrow.protocolId);
-      if (!adapter) continue;
-      if (borrow.asset !== "USDC") {
-        try {
-          const buffer = borrow.amount * 1.005;
-          const swapResult = await this._swapFromUsdc(borrow.asset, buffer);
-          totalGasCost += swapResult.gasCost;
-        } catch (err) {
-          throw new T2000Error(
-            "SWAP_FAILED",
-            `Could not convert USDC to ${borrow.asset} for repayment. Try again later.`,
-            { originalError: err instanceof Error ? err.message : String(err) }
-          );
+      if (adapter) entries.push({ borrow, adapter });
+    }
+    const swapAdapter = this.registry.listSwap()[0];
+    const canPTB = entries.every((e) => e.adapter.addRepayToTx) && (entries.every((e) => e.borrow.asset === "USDC") || swapAdapter?.addSwapToTx);
+    let totalRepaid = 0;
+    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      if (canPTB) {
+        const tx = new Transaction();
+        tx.setSender(this._address);
+        const usdcCoins = await this._fetchCoins(SUPPORTED_ASSETS.USDC.type);
+        let usdcMerged;
+        if (usdcCoins.length > 0) {
+          usdcMerged = this._mergeCoinsInTx(tx, usdcCoins);
+        }
+        for (const { borrow, adapter } of entries) {
+          if (borrow.asset !== "USDC" && swapAdapter?.addSwapToTx) {
+            const buffer = borrow.amount * 1.005;
+            const rawSwap = BigInt(Math.floor(buffer * 10 ** SUPPORTED_ASSETS.USDC.decimals));
+            if (!usdcMerged) throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC for swap");
+            const [splitCoin] = tx.splitCoins(usdcMerged, [rawSwap]);
+            const { outputCoin } = await swapAdapter.addSwapToTx(
+              tx,
+              this._address,
+              splitCoin,
+              "USDC",
+              borrow.asset,
+              buffer
+            );
+            await adapter.addRepayToTx(tx, this._address, outputCoin, borrow.asset);
+          } else {
+            const raw = BigInt(Math.floor(borrow.amount * 10 ** SUPPORTED_ASSETS.USDC.decimals));
+            if (!usdcMerged) throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC for repayment");
+            const [repayCoin] = tx.splitCoins(usdcMerged, [raw]);
+            await adapter.addRepayToTx(tx, this._address, repayCoin, borrow.asset);
+          }
+          totalRepaid += borrow.amount;
         }
+        return tx;
       }
-      const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      let lastTx;
+      for (const { borrow, adapter } of entries) {
+        if (borrow.asset !== "USDC") {
+          await this._swapFromUsdc(borrow.asset, borrow.amount * 1.005);
+        }
         const { tx } = await adapter.buildRepayTx(this._address, borrow.amount, borrow.asset);
-        return tx;
-      });
-      totalRepaid += borrow.amount;
-      totalGasCost += gasResult.gasCostSui;
-      lastDigest = gasResult.digest;
-      lastGasMethod = gasResult.gasMethod;
-    }
-    const firstAdapter = this.registry.getLending(borrows[0].protocolId);
+        lastTx = tx;
+        totalRepaid += borrow.amount;
+      }
+      return lastTx;
+    });
+    const firstAdapter = entries[0]?.adapter;
     const hf = firstAdapter ? await firstAdapter.getHealth(this._address) : { borrowed: 0 };
-    this.emitBalanceChange("USDC", totalRepaid, "repay", lastDigest);
+    this.emitBalanceChange("USDC", totalRepaid, "repay", gasResult.digest);
     return {
       success: true,
-      tx: lastDigest,
+      tx: gasResult.digest,
       amount: totalRepaid,
       remainingDebt: hf.borrowed,
-      gasCost: totalGasCost,
-      gasMethod: lastGasMethod
+      gasCost: gasResult.gasCostSui,
+      gasMethod: gasResult.gasMethod
     };
   }
   async maxBorrow() {
@@ -2849,14 +3255,14 @@ var T2000 = class _T2000 extends EventEmitter {
     const allPositions = await this.registry.allPositions(this._address);
     const positions = allPositions.flatMap(
       (p) => [
-        ...p.positions.supplies.map((s) => ({
+        ...p.positions.supplies.filter((s) => s.amount > 5e-3).map((s) => ({
           protocol: p.protocolId,
           asset: s.asset,
           type: "save",
           amount: s.amount,
           apy: s.apy
         })),
-        ...p.positions.borrows.map((b) => ({
+        ...p.positions.borrows.filter((b) => b.amount > 5e-3).map((b) => ({
           protocol: p.protocolId,
           asset: b.asset,
           type: "borrow",
@@ -3056,35 +3462,76 @@ var T2000 = class _T2000 extends EventEmitter {
         totalGasCost: 0
       };
     }
-    const txDigests = [];
-    let totalGasCost = 0;
     if (!withdrawAdapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", `Protocol ${current.protocolId} not found`);
-    const withdrawResult = await executeWithGas(this.client, this.keypair, async () => {
-      const built = await withdrawAdapter.buildWithdrawTx(this._address, current.amount, current.asset);
-      amountToDeposit = isSameAsset ? built.effectiveAmount : built.effectiveAmount;
-      return built.tx;
-    });
-    txDigests.push(withdrawResult.digest);
-    totalGasCost += withdrawResult.gasCostSui;
-    if (!isSameAsset) {
-      const swapAdapter = this.registry.listSwap()[0];
-      if (!swapAdapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", "No swap adapter available");
-      const swapResult = await executeWithGas(this.client, this.keypair, async () => {
-        const built = await swapAdapter.buildSwapTx(this._address, current.asset, bestRate.asset, amountToDeposit);
-        amountToDeposit = built.estimatedOut / 10 ** built.toDecimals;
+    const depositAdapter = this.registry.getLending(bestRate.protocolId);
+    if (!depositAdapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", `Protocol ${bestRate.protocolId} not found`);
+    const canComposePTB = withdrawAdapter.addWithdrawToTx && depositAdapter.addSaveToTx && (isSameAsset || this.registry.listSwap()[0]?.addSwapToTx);
+    let txDigests;
+    let totalGasCost;
+    if (canComposePTB) {
+      const result = await executeWithGas(this.client, this.keypair, async () => {
+        const tx = new Transaction();
+        tx.setSender(this._address);
+        const { coin: withdrawnCoin, effectiveAmount } = await withdrawAdapter.addWithdrawToTx(
+          tx,
+          this._address,
+          current.amount,
+          current.asset
+        );
+        amountToDeposit = effectiveAmount;
+        let depositCoin = withdrawnCoin;
+        if (!isSameAsset) {
+          const swapAdapter = this.registry.listSwap()[0];
+          const { outputCoin, estimatedOut, toDecimals } = await swapAdapter.addSwapToTx(
+            tx,
+            this._address,
+            withdrawnCoin,
+            current.asset,
+            bestRate.asset,
+            amountToDeposit
+          );
+          depositCoin = outputCoin;
+          amountToDeposit = estimatedOut / 10 ** toDecimals;
+        }
+        await depositAdapter.addSaveToTx(
+          tx,
+          this._address,
+          depositCoin,
+          bestRate.asset,
+          { collectFee: bestRate.asset === "USDC" }
+        );
+        return tx;
+      });
+      txDigests = [result.digest];
+      totalGasCost = result.gasCostSui;
+    } else {
+      txDigests = [];
+      totalGasCost = 0;
+      const withdrawResult = await executeWithGas(this.client, this.keypair, async () => {
+        const built = await withdrawAdapter.buildWithdrawTx(this._address, current.amount, current.asset);
+        amountToDeposit = built.effectiveAmount;
         return built.tx;
       });
-      txDigests.push(swapResult.digest);
-      totalGasCost += swapResult.gasCostSui;
+      txDigests.push(withdrawResult.digest);
+      totalGasCost += withdrawResult.gasCostSui;
+      if (!isSameAsset) {
+        const swapAdapter = this.registry.listSwap()[0];
+        if (!swapAdapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", "No swap adapter available");
+        const swapResult = await executeWithGas(this.client, this.keypair, async () => {
+          const built = await swapAdapter.buildSwapTx(this._address, current.asset, bestRate.asset, amountToDeposit);
+          amountToDeposit = built.estimatedOut / 10 ** built.toDecimals;
+          return built.tx;
+        });
+        txDigests.push(swapResult.digest);
+        totalGasCost += swapResult.gasCostSui;
+      }
+      const depositResult = await executeWithGas(this.client, this.keypair, async () => {
+        const { tx } = await depositAdapter.buildSaveTx(this._address, amountToDeposit, bestRate.asset, { collectFee: bestRate.asset === "USDC" });
+        return tx;
+      });
+      txDigests.push(depositResult.digest);
+      totalGasCost += depositResult.gasCostSui;
     }
-    const depositAdapter = this.registry.getLending(bestRate.protocolId);
-    if (!depositAdapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", `Protocol ${bestRate.protocolId} not found`);
-    const depositResult = await executeWithGas(this.client, this.keypair, async () => {
-      const { tx } = await depositAdapter.buildSaveTx(this._address, amountToDeposit, bestRate.asset, { collectFee: bestRate.asset === "USDC" });
-      return tx;
-    });
-    txDigests.push(depositResult.digest);
-    totalGasCost += depositResult.gasCostSui;
     return {
       executed: true,
       steps,