@t2000/sdk 0.8.7 → 0.9.1

package/dist/index.js

@@ -1315,24 +1315,6 @@ var ProtocolRegistry = class {
   listSwap() {
     return [...this.swap.values()];
   }
-  isSupportedAsset(asset, capability) {
-    for (const adapter of this.lending.values()) {
-      if (!adapter.supportedAssets.includes(asset)) continue;
-      if (capability && !adapter.capabilities.includes(capability)) continue;
-      return true;
-    }
-    return false;
-  }
-  getSupportedAssets(capability) {
-    const assets = /* @__PURE__ */ new Set();
-    for (const adapter of this.lending.values()) {
-      if (capability && !adapter.capabilities.includes(capability)) continue;
-      for (const a of adapter.supportedAssets) {
-        assets.add(a);
-      }
-    }
-    return [...assets];
-  }
 };
 
 // src/adapters/navi.ts
@@ -2431,43 +2413,39 @@ var T2000 = class _T2000 extends EventEmitter {
   }
   // -- Savings --
   async save(params) {
-    const asset = normalizeAsset(params.asset ?? "USDC");
-    if (!this.registry.isSupportedAsset(asset, "save")) {
-      const supported = this.registry.getSupportedAssets("save").join(", ");
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `${asset} is not supported for save. Supported: ${supported}`);
-    }
+    const asset = "USDC";
+    const bal = await queryBalance(this.client, this._address);
+    const usdcBalance = bal.stables.USDC ?? 0;
     let amount;
     if (params.amount === "all") {
-      const bal = await queryBalance(this.client, this._address);
-      const assetBalance = bal.stables[asset] ?? 0;
-      const reserve = asset === "USDC" ? 1 : 0;
-      amount = assetBalance - reserve;
+      await this._convertWalletStablesToUsdc(bal);
+      const refreshedBal = await queryBalance(this.client, this._address);
+      amount = (refreshedBal.stables.USDC ?? 0) - 1;
       if (amount <= 0) {
-        throw new T2000Error("INSUFFICIENT_BALANCE", `Balance too low to save${asset === "USDC" ? " after $1 gas reserve" : ""}`, {
-          reason: asset === "USDC" ? "gas_reserve_required" : "zero_balance",
-          available: assetBalance
+        throw new T2000Error("INSUFFICIENT_BALANCE", "Balance too low to save after $1 gas reserve", {
+          reason: "gas_reserve_required",
+          available: refreshedBal.stables.USDC ?? 0
         });
       }
     } else {
       amount = params.amount;
-      const bal = await queryBalance(this.client, this._address);
-      const assetBalance = bal.stables[asset] ?? 0;
-      if (amount > assetBalance) {
-        throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient ${asset}. Available: $${assetBalance.toFixed(2)}, requested: $${amount.toFixed(2)}`);
+      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);
       }
     }
-    const shouldCollectFee = asset === "USDC";
-    const fee = shouldCollectFee ? calculateFee("save", amount) : { amount: 0, rate: 0};
+    const fee = calculateFee("save", amount);
     const saveAmount = amount;
     const adapter = await this.resolveLending(params.protocol, asset, "save");
     const gasResult = await executeWithGas(this.client, this.keypair, async () => {
-      const { tx } = await adapter.buildSaveTx(this._address, saveAmount, asset, { collectFee: shouldCollectFee });
+      const { tx } = await adapter.buildSaveTx(this._address, saveAmount, asset, { collectFee: true });
       return tx;
     });
     const rates = await adapter.getRates(asset);
-    if (shouldCollectFee) {
-      reportFee(this._address, "save", fee.amount, fee.rate, gasResult.digest);
-    }
+    reportFee(this._address, "save", fee.amount, fee.rate, gasResult.digest);
     this.emitBalanceChange(asset, saveAmount, "save", gasResult.digest);
     let savingsBalance = saveAmount;
     try {
@@ -2479,7 +2457,6 @@ var T2000 = class _T2000 extends EventEmitter {
       success: true,
       tx: gasResult.digest,
       amount: saveAmount,
-      asset,
       apy: rates.saveApy,
       fee: fee.amount,
       gasCost: gasResult.gasCostSui,
@@ -2488,14 +2465,27 @@ var T2000 = class _T2000 extends EventEmitter {
     };
   }
   async withdraw(params) {
-    const asset = normalizeAsset(params.asset ?? "USDC");
     if (params.amount === "all" && !params.protocol) {
-      return this.withdrawAllProtocols(asset);
+      return this.withdrawAllProtocols();
+    }
+    const allPositions = await this.registry.allPositions(this._address);
+    const supplies = [];
+    for (const pos of allPositions) {
+      if (params.protocol && pos.protocolId !== params.protocol) continue;
+      for (const s of pos.positions.supplies) {
+        if (s.amount > 1e-3) supplies.push({ protocolId: pos.protocolId, asset: s.asset, amount: s.amount, apy: s.apy });
+      }
     }
-    const adapter = await this.resolveLending(params.protocol, asset, "withdraw");
+    if (supplies.length === 0) {
+      throw new T2000Error("NO_COLLATERAL", "No savings to withdraw");
+    }
+    supplies.sort((a, b) => a.apy - b.apy);
+    const target = supplies[0];
+    const adapter = this.registry.getLending(target.protocolId);
+    if (!adapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", `Protocol ${target.protocolId} not found`);
     let amount;
     if (params.amount === "all") {
-      const maxResult = await adapter.maxWithdraw(this._address, asset);
+      const maxResult = await adapter.maxWithdraw(this._address, target.asset);
       amount = maxResult.maxAmount;
       if (amount <= 0) {
         throw new T2000Error("NO_COLLATERAL", "No savings to withdraw");
@@ -2504,7 +2494,7 @@ var T2000 = class _T2000 extends EventEmitter {
       amount = params.amount;
       const hf = await adapter.getHealth(this._address);
       if (hf.borrowed > 0) {
-        const maxResult = await adapter.maxWithdraw(this._address, asset);
+        const maxResult = await adapter.maxWithdraw(this._address, target.asset);
         if (amount > maxResult.maxAmount) {
           throw new T2000Error(
             "WITHDRAW_WOULD_LIQUIDATE",
@@ -2521,20 +2511,37 @@ var T2000 = class _T2000 extends EventEmitter {
     const withdrawAmount = amount;
     let effectiveAmount = withdrawAmount;
     const gasResult = await executeWithGas(this.client, this.keypair, async () => {
-      const built = await adapter.buildWithdrawTx(this._address, withdrawAmount, asset);
+      const built = await adapter.buildWithdrawTx(this._address, withdrawAmount, target.asset);
       effectiveAmount = built.effectiveAmount;
       return built.tx;
     });
-    this.emitBalanceChange(asset, effectiveAmount, "withdraw", gasResult.digest);
+    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);
     return {
       success: true,
-      tx: gasResult.digest,
-      amount: effectiveAmount,
-      gasCost: gasResult.gasCostSui,
+      tx: lastDigest,
+      amount: finalAmount,
+      gasCost: totalGasCost,
       gasMethod: gasResult.gasMethod
     };
   }
-  async withdrawAllProtocols(_asset) {
+  async withdrawAllProtocols() {
     const allPositions = await this.registry.allPositions(this._address);
     const withdrawable = [];
     for (const pos of allPositions) {
@@ -2547,7 +2554,7 @@ var T2000 = class _T2000 extends EventEmitter {
     if (withdrawable.length === 0) {
       throw new T2000Error("NO_COLLATERAL", "No savings to withdraw across any protocol");
     }
-    let totalWithdrawn = 0;
+    let totalUsdcReceived = 0;
     let lastDigest = "";
     let totalGasCost = 0;
     let lastGasMethod = "self-funded";
@@ -2562,30 +2569,88 @@ var T2000 = class _T2000 extends EventEmitter {
         effectiveAmount = built.effectiveAmount;
         return built.tx;
       });
-      totalWithdrawn += effectiveAmount;
       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 (totalWithdrawn <= 0) {
+    if (totalUsdcReceived <= 0) {
       throw new T2000Error("NO_COLLATERAL", "No savings to withdraw across any protocol");
     }
     return {
       success: true,
       tx: lastDigest,
-      amount: totalWithdrawn,
+      amount: totalUsdcReceived,
       gasCost: totalGasCost,
       gasMethod: lastGasMethod
     };
   }
+  async _swapToUsdc(asset, amount) {
+    const swapAdapter = this.registry.listSwap()[0];
+    if (!swapAdapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", "No swap adapter available");
+    let estimatedOut = 0;
+    let toDecimals = 6;
+    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      const built = await swapAdapter.buildSwapTx(this._address, asset, "USDC", amount);
+      estimatedOut = built.estimatedOut;
+      toDecimals = built.toDecimals;
+      return built.tx;
+    });
+    const usdcReceived = estimatedOut / 10 ** toDecimals;
+    return { usdcReceived, digest: gasResult.digest, gasCost: gasResult.gasCostSui };
+  }
+  async _swapFromUsdc(toAsset, amount) {
+    const swapAdapter = this.registry.listSwap()[0];
+    if (!swapAdapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", "No swap adapter available");
+    let estimatedOut = 0;
+    let toDecimals = 6;
+    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      const built = await swapAdapter.buildSwapTx(this._address, "USDC", toAsset, amount);
+      estimatedOut = built.estimatedOut;
+      toDecimals = built.toDecimals;
+      return built.tx;
+    });
+    const received = estimatedOut / 10 ** toDecimals;
+    return { received, digest: gasResult.digest, gasCost: gasResult.gasCostSui };
+  }
+  async _convertWalletStablesToUsdc(bal, amountNeeded) {
+    const nonUsdcStables = [];
+    for (const [asset, amount] of Object.entries(bal.stables)) {
+      if (asset !== "USDC" && amount > 0.01) {
+        nonUsdcStables.push({ asset, amount });
+      }
+    }
+    if (nonUsdcStables.length === 0) return;
+    nonUsdcStables.sort((a, b) => b.amount - a.amount);
+    let converted = 0;
+    for (const entry of nonUsdcStables) {
+      if (amountNeeded !== void 0 && converted >= amountNeeded) break;
+      try {
+        await this._swapToUsdc(entry.asset, entry.amount);
+        converted += entry.amount;
+      } catch {
+      }
+    }
+  }
   async maxWithdraw() {
     const adapter = await this.resolveLending(void 0, "USDC", "withdraw");
     return adapter.maxWithdraw(this._address, "USDC");
   }
   // -- Borrowing --
   async borrow(params) {
-    const asset = normalizeAsset(params.asset ?? "USDC");
+    const asset = "USDC";
     const adapter = await this.resolveLending(params.protocol, asset, "borrow");
     const maxResult = await adapter.maxBorrow(this._address, asset);
     if (maxResult.maxAmount <= 0) {
@@ -2597,17 +2662,14 @@ var T2000 = class _T2000 extends EventEmitter {
         currentHF: maxResult.currentHF
       });
     }
-    const shouldCollectFee = asset === "USDC";
-    const fee = shouldCollectFee ? calculateFee("borrow", params.amount) : { amount: 0, rate: 0};
+    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: shouldCollectFee });
+      const { tx } = await adapter.buildBorrowTx(this._address, borrowAmount, asset, { collectFee: true });
       return tx;
     });
     const hf = await adapter.getHealth(this._address);
-    if (shouldCollectFee) {
-      reportFee(this._address, "borrow", fee.amount, fee.rate, gasResult.digest);
-    }
+    reportFee(this._address, "borrow", fee.amount, fee.rate, gasResult.digest);
     this.emitBalanceChange(asset, borrowAmount, "borrow", gasResult.digest);
     return {
       success: true,
@@ -2620,34 +2682,93 @@ var T2000 = class _T2000 extends EventEmitter {
     };
   }
   async repay(params) {
-    const asset = normalizeAsset(params.asset ?? "USDC");
-    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");
+    const allPositions = await this.registry.allPositions(this._address);
+    const borrows = [];
+    for (const pos of allPositions) {
+      if (params.protocol && pos.protocolId !== params.protocol) continue;
+      for (const b of pos.positions.borrows) {
+        if (b.amount > 1e-3) borrows.push({ protocolId: pos.protocolId, asset: b.asset, amount: b.amount, apy: b.apy });
       }
-    } else {
-      amount = params.amount;
     }
-    const repayAmount = amount;
+    if (borrows.length === 0) {
+      throw new T2000Error("NO_COLLATERAL", "No outstanding borrow to repay");
+    }
+    if (params.amount === "all") {
+      return this._repayAllBorrows(borrows);
+    }
+    borrows.sort((a, b) => b.apy - a.apy);
+    const target = borrows[0];
+    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 gasResult = await executeWithGas(this.client, this.keypair, async () => {
-      const { tx } = await adapter.buildRepayTx(this._address, repayAmount, asset);
+      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(asset, repayAmount, "repay", gasResult.digest);
+    this.emitBalanceChange("USDC", repayAmount, "repay", lastDigest);
     return {
       success: true,
-      tx: gasResult.digest,
+      tx: lastDigest,
       amount: repayAmount,
       remainingDebt: hf.borrowed,
-      gasCost: gasResult.gasCostSui,
+      gasCost: totalGasCost,
       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);
+    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) }
+          );
+        }
+      }
+      const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+        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);
+    const hf = firstAdapter ? await firstAdapter.getHealth(this._address) : { borrowed: 0 };
+    this.emitBalanceChange("USDC", totalRepaid, "repay", lastDigest);
+    return {
+      success: true,
+      tx: lastDigest,
+      amount: totalRepaid,
+      remainingDebt: hf.borrowed,
+      gasCost: totalGasCost,
+      gasMethod: lastGasMethod
+    };
+  }
   async maxBorrow() {
     const adapter = await this.resolveLending(void 0, "USDC", "borrow");
     return adapter.maxBorrow(this._address, "USDC");
@@ -2662,25 +2783,18 @@ var T2000 = class _T2000 extends EventEmitter {
     }
     return hf;
   }
-  // -- Swap --
-  async swap(params) {
-    const fromAsset = normalizeAsset(params.from);
-    const toAsset = normalizeAsset(params.to);
+  // -- Swap (internal — used by rebalance and withdraw auto-swap) --
+  async _swap(params) {
+    const fromAsset = params.from;
+    const toAsset = params.to;
     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;
-    } else {
-      const best = await this.registry.bestSwapQuote(fromAsset, toAsset, params.amount);
-      adapter = best.adapter;
-    }
+    const best = await this.registry.bestSwapQuote(fromAsset, toAsset, params.amount);
+    const adapter = best.adapter;
     const fee = calculateFee("swap", params.amount);
     const swapAmount = params.amount;
     const slippageBps = params.maxSlippage ? params.maxSlippage * 100 : void 0;
@@ -2723,9 +2837,9 @@ var T2000 = class _T2000 extends EventEmitter {
       gasMethod: gasResult.gasMethod
     };
   }
-  async swapQuote(params) {
-    const fromAsset = normalizeAsset(params.from);
-    const toAsset = normalizeAsset(params.to);
+  async _swapQuote(params) {
+    const fromAsset = params.from;
+    const toAsset = params.to;
     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 } };
@@ -3162,6 +3276,6 @@ var allDescriptors = [
   descriptor
 ];
 
-export { BPS_DENOMINATOR, CLOCK_ID, CetusAdapter, DEFAULT_NETWORK, MIST_PER_SUI, NaviAdapter, ProtocolRegistry, SENTINEL, STABLE_ASSETS, SUI_DECIMALS, SUPPORTED_ASSETS, SuilendAdapter, T2000, T2000Error, USDC_DECIMALS, addCollectFeeToTx, allDescriptors, calculateFee, descriptor3 as cetusDescriptor, executeAutoTopUp, executeWithGas, exportPrivateKey, formatSui, formatUsd, generateKeypair, getAddress, getDecimals, getGasStatus, getPoolPrice, getRates, getSentinelInfo, getSwapQuote, keypairFromPrivateKey, listSentinels, loadKey, mapMoveAbortCode, mapWalletError, mistToSui, descriptor2 as naviDescriptor, normalizeAsset, rawToStable, rawToUsdc, requestAttack, saveKey, attack as sentinelAttack, descriptor as sentinelDescriptor, settleAttack, shouldAutoTopUp, simulateTransaction, solveHashcash, stableToRaw, submitPrompt, suiToMist, descriptor4 as suilendDescriptor, throwIfSimulationFailed, truncateAddress, usdcToRaw, validateAddress, walletExists };
+export { BPS_DENOMINATOR, CLOCK_ID, CetusAdapter, DEFAULT_NETWORK, MIST_PER_SUI, NaviAdapter, ProtocolRegistry, SENTINEL, SUI_DECIMALS, SUPPORTED_ASSETS, SuilendAdapter, T2000, T2000Error, USDC_DECIMALS, addCollectFeeToTx, allDescriptors, calculateFee, descriptor3 as cetusDescriptor, executeAutoTopUp, executeWithGas, exportPrivateKey, formatSui, formatUsd, generateKeypair, getAddress, getDecimals, getGasStatus, getPoolPrice, getRates, getSentinelInfo, keypairFromPrivateKey, listSentinels, loadKey, mapMoveAbortCode, mapWalletError, mistToSui, descriptor2 as naviDescriptor, rawToStable, rawToUsdc, requestAttack, saveKey, attack as sentinelAttack, descriptor as sentinelDescriptor, settleAttack, shouldAutoTopUp, simulateTransaction, solveHashcash, stableToRaw, submitPrompt, suiToMist, descriptor4 as suilendDescriptor, throwIfSimulationFailed, truncateAddress, usdcToRaw, validateAddress, walletExists };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map