@t2000/sdk 0.9.0 → 0.9.2

package/dist/index.d.cts

@@ -110,6 +110,8 @@ declare class T2000 extends EventEmitter<T2000Events> {
     }): Promise<WithdrawResult>;
     private withdrawAllProtocols;
     private _swapToUsdc;
+    private _swapFromUsdc;
+    private _convertWalletStablesToUsdc;
     maxWithdraw(): Promise<MaxWithdrawResult>;
     borrow(params: {
         amount: number;
@@ -119,6 +121,7 @@ declare class T2000 extends EventEmitter<T2000Events> {
         amount: number | 'all';
         protocol?: string;
     }): Promise<RepayResult>;
+    private _repayAllBorrows;
     maxBorrow(): Promise<MaxBorrowResult>;
     healthFactor(): Promise<HealthFactorResult>;
     private _swap;

package/dist/index.d.ts

@@ -110,6 +110,8 @@ declare class T2000 extends EventEmitter<T2000Events> {
     }): Promise<WithdrawResult>;
     private withdrawAllProtocols;
     private _swapToUsdc;
+    private _swapFromUsdc;
+    private _convertWalletStablesToUsdc;
     maxWithdraw(): Promise<MaxWithdrawResult>;
     borrow(params: {
         amount: number;
@@ -119,6 +121,7 @@ declare class T2000 extends EventEmitter<T2000Events> {
         amount: number | 'all';
         protocol?: string;
     }): Promise<RepayResult>;
+    private _repayAllBorrows;
     maxBorrow(): Promise<MaxBorrowResult>;
     healthFactor(): Promise<HealthFactorResult>;
     private _swap;

package/dist/index.js

@@ -2414,22 +2414,27 @@ var T2000 = class _T2000 extends EventEmitter {
   // -- Savings --
   async save(params) {
     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.USDC ?? 0;
-      amount = assetBalance - 1;
+      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 after $1 gas reserve", {
           reason: "gas_reserve_required",
-          available: assetBalance
+          available: refreshedBal.stables.USDC ?? 0
         });
       }
     } else {
       amount = params.amount;
-      const bal = await queryBalance(this.client, this._address);
-      if (amount > (bal.stables.USDC ?? 0)) {
-        throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient USDC. Available: $${(bal.stables.USDC ?? 0).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 fee = calculateFee("save", amount);
@@ -2606,6 +2611,39 @@ var T2000 = class _T2000 extends EventEmitter {
     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");
@@ -2644,34 +2682,93 @@ var T2000 = class _T2000 extends EventEmitter {
     };
   }
   async repay(params) {
-    const 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");
@@ -2752,14 +2849,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",