@t2000/sdk 0.17.5 → 0.17.8

package/dist/adapters/index.d.cts

@@ -1,4 +1,4 @@
-export { w as AdapterCapability, x as AdapterPositions, y as AdapterTxResult, C as CetusAdapter, K as HealthInfo, L as LendingAdapter, s as LendingRates, N as NaviAdapter, O as PerpsAdapter, X as ProtocolDescriptor, Y as ProtocolRegistry, $ as SuilendAdapter, d as SwapAdapter, a0 as SwapQuote, a3 as allDescriptors, a4 as cetusDescriptor, a7 as naviDescriptor, aa as sentinelDescriptor, ad as suilendDescriptor } from '../index-BzQsrfrc.cjs';
+export { w as AdapterCapability, x as AdapterPositions, y as AdapterTxResult, C as CetusAdapter, K as HealthInfo, L as LendingAdapter, s as LendingRates, N as NaviAdapter, O as PerpsAdapter, X as ProtocolDescriptor, Y as ProtocolRegistry, $ as SuilendAdapter, d as SwapAdapter, a0 as SwapQuote, a3 as allDescriptors, a4 as cetusDescriptor, a7 as naviDescriptor, aa as sentinelDescriptor, ad as suilendDescriptor } from '../index-D4cFY__D.cjs';
 import '@mysten/sui/transactions';
 import '@mysten/sui/jsonRpc';
 import '@mysten/sui/keypairs/ed25519';

package/dist/adapters/index.d.ts

@@ -1,4 +1,4 @@
-export { w as AdapterCapability, x as AdapterPositions, y as AdapterTxResult, C as CetusAdapter, K as HealthInfo, L as LendingAdapter, s as LendingRates, N as NaviAdapter, O as PerpsAdapter, X as ProtocolDescriptor, Y as ProtocolRegistry, $ as SuilendAdapter, d as SwapAdapter, a0 as SwapQuote, a3 as allDescriptors, a4 as cetusDescriptor, a7 as naviDescriptor, aa as sentinelDescriptor, ad as suilendDescriptor } from '../index-BzQsrfrc.js';
+export { w as AdapterCapability, x as AdapterPositions, y as AdapterTxResult, C as CetusAdapter, K as HealthInfo, L as LendingAdapter, s as LendingRates, N as NaviAdapter, O as PerpsAdapter, X as ProtocolDescriptor, Y as ProtocolRegistry, $ as SuilendAdapter, d as SwapAdapter, a0 as SwapQuote, a3 as allDescriptors, a4 as cetusDescriptor, a7 as naviDescriptor, aa as sentinelDescriptor, ad as suilendDescriptor } from '../index-D4cFY__D.js';
 import '@mysten/sui/transactions';
 import '@mysten/sui/jsonRpc';
 import '@mysten/sui/keypairs/ed25519';

package/dist/{index-BzQsrfrc.d.cts → index-D4cFY__D.d.cts}

@@ -291,6 +291,10 @@ interface StrategySellResult {
         realizedPnL: number;
         tx: string;
     }>;
+    failed?: Array<{
+        asset: string;
+        reason: string;
+    }>;
     gasCost: number;
     gasMethod: GasMethod;
 }

package/dist/{index-BzQsrfrc.d.ts → index-D4cFY__D.d.ts}

@@ -291,6 +291,10 @@ interface StrategySellResult {
         realizedPnL: number;
         tx: string;
     }>;
+    failed?: Array<{
+        asset: string;
+        reason: string;
+    }>;
     gasCost: number;
     gasMethod: GasMethod;
 }

package/dist/index.cjs

@@ -4625,50 +4625,90 @@ To sell investment: t2000 invest sell ${params.amount} ${fromAsset}`,
     if (stratPositions.length === 0) {
       throw new T2000Error("INSUFFICIENT_INVESTMENT", `No positions in strategy '${params.strategy}'`);
     }
+    const swapAdapter = this.registry.listSwap()[0];
+    if (!swapAdapter?.addSwapToTx) {
+      throw new T2000Error("PROTOCOL_UNAVAILABLE", "Swap adapter does not support composable PTB");
+    }
+    let swapMetas = [];
+    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      swapMetas = [];
+      const tx = new transactions.Transaction();
+      tx.setSender(this._address);
+      const usdcOutputs = [];
+      for (const pos of stratPositions) {
+        const assetInfo = SUPPORTED_ASSETS[pos.asset];
+        const coins = await this._fetchCoins(assetInfo.type);
+        if (coins.length === 0) {
+          throw new T2000Error("INSUFFICIENT_BALANCE", `No ${pos.asset} coins in wallet`);
+        }
+        const merged = this._mergeCoinsInTx(tx, coins);
+        const gasReserve = pos.asset === "SUI" ? GAS_RESERVE_MIN : 0;
+        const sellAmount = Math.max(0, pos.totalAmount - gasReserve);
+        const rawAmount = BigInt(Math.floor(sellAmount * 10 ** assetInfo.decimals));
+        const [splitCoin] = tx.splitCoins(merged, [rawAmount]);
+        const assetUsd = sellAmount * (pos.avgPrice || 1);
+        const slippageBps = LOW_LIQUIDITY_ASSETS.has(pos.asset) ? 500 : 300;
+        const { outputCoin, estimatedOut, toDecimals } = await swapAdapter.addSwapToTx(
+          tx,
+          this._address,
+          splitCoin,
+          pos.asset,
+          "USDC",
+          assetUsd,
+          slippageBps
+        );
+        usdcOutputs.push(outputCoin);
+        swapMetas.push({ asset: pos.asset, amount: sellAmount, estimatedOut, toDecimals });
+      }
+      if (usdcOutputs.length > 1) {
+        tx.mergeCoins(usdcOutputs[0], usdcOutputs.slice(1));
+      }
+      tx.transferObjects([usdcOutputs[0]], this._address);
+      return tx;
+    });
+    const digest = gasResult.digest;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
     const sells = [];
     let totalProceeds = 0;
     let totalPnL = 0;
-    let totalGas = 0;
-    let gasMethod = "self-funded";
-    for (const pos of stratPositions) {
-      const fullAmount = pos.totalAmount;
-      const swapAdapter = this.registry.listSwap()[0];
-      let assetPrice = 1;
-      try {
-        if (swapAdapter) {
-          if (pos.asset === "SUI") {
-            assetPrice = await swapAdapter.getPoolPrice();
-          } else {
-            const q = await swapAdapter.getQuote("USDC", pos.asset, 1);
-            assetPrice = q.expectedOutput > 0 ? 1 / q.expectedOutput : 1;
-          }
-        }
-      } catch {
-      }
-      const strategyUsdValue = fullAmount * assetPrice;
-      const result = await this.investSell({
-        asset: pos.asset,
-        usdAmount: strategyUsdValue,
-        _strategyOnly: true
-      });
+    for (const meta of swapMetas) {
+      const usdValue = meta.estimatedOut / 10 ** meta.toDecimals;
+      const price = meta.amount > 0 ? usdValue / meta.amount : 0;
       const pnl = this.portfolio.recordStrategySell(params.strategy, {
-        id: `strat_sell_${Date.now()}_${pos.asset}`,
+        id: `strat_sell_${Date.now()}_${meta.asset}`,
         type: "sell",
-        asset: pos.asset,
-        amount: fullAmount,
-        price: result.price,
-        usdValue: result.usdValue,
-        fee: result.fee,
-        tx: result.tx,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        asset: meta.asset,
+        amount: meta.amount,
+        price,
+        usdValue,
+        fee: 0,
+        tx: digest,
+        timestamp: now
+      });
+      this.portfolio.recordSell({
+        id: `inv_sell_${Date.now()}_${meta.asset}`,
+        type: "sell",
+        asset: meta.asset,
+        amount: meta.amount,
+        price,
+        usdValue,
+        fee: 0,
+        tx: digest,
+        timestamp: now
       });
-      sells.push({ asset: pos.asset, amount: result.amount, usdValue: result.usdValue, realizedPnL: pnl, tx: result.tx });
-      totalProceeds += result.usdValue;
+      sells.push({ asset: meta.asset, amount: meta.amount, usdValue, realizedPnL: pnl, tx: digest });
+      totalProceeds += usdValue;
       totalPnL += pnl;
-      totalGas += result.gasCost;
-      gasMethod = result.gasMethod;
     }
-    return { success: true, strategy: params.strategy, totalProceeds, realizedPnL: totalPnL, sells, gasCost: totalGas, gasMethod };
+    return {
+      success: true,
+      strategy: params.strategy,
+      totalProceeds,
+      realizedPnL: totalPnL,
+      sells,
+      gasCost: gasResult.gasCostSui,
+      gasMethod: gasResult.gasMethod
+    };
   }
   async rebalanceStrategy(params) {
     this.enforcer.assertNotLocked();
@@ -4702,8 +4742,9 @@ To sell investment: t2000 invest sell ${params.amount} ${fromAsset}`,
       currentWeights[pos.asset] = w;
       beforeWeights[pos.asset] = w;
     }
-    const trades = [];
     const threshold = 3;
+    const sellOps = [];
+    const buyOps = [];
     for (const [asset, targetPct] of Object.entries(definition.allocations)) {
       const currentPct = currentWeights[asset] ?? 0;
       const diff = targetPct - currentPct;
@@ -4711,33 +4752,140 @@ To sell investment: t2000 invest sell ${params.amount} ${fromAsset}`,
       const usdDiff = totalValue * (Math.abs(diff) / 100);
       if (usdDiff < 1) continue;
       if (diff > 0) {
-        const result = await this.investBuy({ asset, usdAmount: usdDiff });
-        this.portfolio.recordStrategyBuy(params.strategy, {
-          id: `strat_rebal_${Date.now()}_${asset}`,
-          type: "buy",
-          asset,
-          amount: result.amount,
-          price: result.price,
-          usdValue: usdDiff,
-          fee: result.fee,
-          tx: result.tx,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        trades.push({ action: "buy", asset, usdAmount: usdDiff, amount: result.amount, tx: result.tx });
+        buyOps.push({ asset, usdAmount: usdDiff });
       } else {
-        const result = await this.investSell({ asset, usdAmount: usdDiff });
+        const price = prices[asset] ?? 1;
+        const assetAmount = price > 0 ? usdDiff / price : 0;
+        sellOps.push({ asset, usdAmount: usdDiff, assetAmount });
+      }
+    }
+    if (sellOps.length === 0 && buyOps.length === 0) {
+      return { success: true, strategy: params.strategy, trades: [], beforeWeights, afterWeights: { ...beforeWeights }, targetWeights: { ...definition.allocations } };
+    }
+    if (!swapAdapter?.addSwapToTx) {
+      throw new T2000Error("PROTOCOL_UNAVAILABLE", "Swap adapter does not support composable PTB");
+    }
+    const tradeMetas = [];
+    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      tradeMetas.length = 0;
+      const tx = new transactions.Transaction();
+      tx.setSender(this._address);
+      const usdcCoins = [];
+      for (const sell of sellOps) {
+        const assetInfo = SUPPORTED_ASSETS[sell.asset];
+        const coins = await this._fetchCoins(assetInfo.type);
+        if (coins.length === 0) continue;
+        const merged = this._mergeCoinsInTx(tx, coins);
+        const gasReserve = sell.asset === "SUI" ? GAS_RESERVE_MIN : 0;
+        const sellAmount = Math.max(0, sell.assetAmount - gasReserve);
+        const rawAmount = BigInt(Math.floor(sellAmount * 10 ** assetInfo.decimals));
+        const [splitCoin] = tx.splitCoins(merged, [rawAmount]);
+        const slippageBps = LOW_LIQUIDITY_ASSETS.has(sell.asset) ? 500 : 300;
+        const { outputCoin, estimatedOut, toDecimals } = await swapAdapter.addSwapToTx(
+          tx,
+          this._address,
+          splitCoin,
+          sell.asset,
+          "USDC",
+          sell.usdAmount,
+          slippageBps
+        );
+        usdcCoins.push(outputCoin);
+        tradeMetas.push({ action: "sell", asset: sell.asset, usdAmount: sell.usdAmount, estimatedOut, toDecimals });
+      }
+      if (buyOps.length > 0) {
+        const walletUsdc = await this._fetchCoins(SUPPORTED_ASSETS.USDC.type);
+        if (walletUsdc.length > 0) {
+          usdcCoins.push(this._mergeCoinsInTx(tx, walletUsdc));
+        }
+        if (usdcCoins.length === 0) {
+          throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC available for rebalance buys");
+        }
+        if (usdcCoins.length > 1) {
+          tx.mergeCoins(usdcCoins[0], usdcCoins.slice(1));
+        }
+        const mergedUsdc = usdcCoins[0];
+        const splitAmounts = buyOps.map(
+          (b) => BigInt(Math.floor(b.usdAmount * 10 ** SUPPORTED_ASSETS.USDC.decimals))
+        );
+        const splitCoins = tx.splitCoins(mergedUsdc, splitAmounts);
+        const outputCoins = [];
+        for (let i = 0; i < buyOps.length; i++) {
+          const buy = buyOps[i];
+          const slippageBps = LOW_LIQUIDITY_ASSETS.has(buy.asset) ? 500 : 300;
+          const { outputCoin, estimatedOut, toDecimals } = await swapAdapter.addSwapToTx(
+            tx,
+            this._address,
+            splitCoins[i],
+            "USDC",
+            buy.asset,
+            buy.usdAmount,
+            slippageBps
+          );
+          outputCoins.push(outputCoin);
+          tradeMetas.push({ action: "buy", asset: buy.asset, usdAmount: buy.usdAmount, estimatedOut, toDecimals });
+        }
+        tx.transferObjects(outputCoins, this._address);
+      }
+      return tx;
+    });
+    const digest = gasResult.digest;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const trades = [];
+    for (const meta of tradeMetas) {
+      const rawAmount = meta.estimatedOut / 10 ** meta.toDecimals;
+      if (meta.action === "sell") {
+        const price = meta.usdAmount > 0 && rawAmount > 0 ? meta.usdAmount / rawAmount : prices[meta.asset] ?? 0;
+        const assetAmount = prices[meta.asset] > 0 ? meta.usdAmount / prices[meta.asset] : 0;
         this.portfolio.recordStrategySell(params.strategy, {
-          id: `strat_rebal_${Date.now()}_${asset}`,
+          id: `strat_rebal_${Date.now()}_${meta.asset}`,
           type: "sell",
-          asset,
-          amount: result.amount,
-          price: result.price,
-          usdValue: result.usdValue,
-          fee: result.fee,
-          tx: result.tx,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          asset: meta.asset,
+          amount: assetAmount,
+          price,
+          usdValue: meta.usdAmount,
+          fee: 0,
+          tx: digest,
+          timestamp: now
+        });
+        this.portfolio.recordSell({
+          id: `inv_rebal_${Date.now()}_${meta.asset}`,
+          type: "sell",
+          asset: meta.asset,
+          amount: assetAmount,
+          price,
+          usdValue: meta.usdAmount,
+          fee: 0,
+          tx: digest,
+          timestamp: now
+        });
+        trades.push({ action: "sell", asset: meta.asset, usdAmount: meta.usdAmount, amount: assetAmount, tx: digest });
+      } else {
+        const amount = rawAmount;
+        const price = meta.usdAmount / amount;
+        this.portfolio.recordBuy({
+          id: `inv_rebal_${Date.now()}_${meta.asset}`,
+          type: "buy",
+          asset: meta.asset,
+          amount,
+          price,
+          usdValue: meta.usdAmount,
+          fee: 0,
+          tx: digest,
+          timestamp: now
+        });
+        this.portfolio.recordStrategyBuy(params.strategy, {
+          id: `strat_rebal_${Date.now()}_${meta.asset}`,
+          type: "buy",
+          asset: meta.asset,
+          amount,
+          price,
+          usdValue: meta.usdAmount,
+          fee: 0,
+          tx: digest,
+          timestamp: now
         });
-        trades.push({ action: "sell", asset, usdAmount: result.usdValue, amount: result.amount, tx: result.tx });
+        trades.push({ action: "buy", asset: meta.asset, usdAmount: meta.usdAmount, amount, tx: digest });
       }
     }
     const afterWeights = {};