@t2000/sdk 0.16.0 → 0.16.2

package/dist/index.cjs

@@ -3097,15 +3097,14 @@ var StrategyManager = class {
     }
   }
   validateMinAmount(allocations, totalUsd) {
-    const assetCount = Object.keys(allocations).length;
-    for (const [asset, pct] of Object.entries(allocations)) {
-      const assetUsd = totalUsd * (pct / 100);
-      if (assetUsd < 1) {
-        throw new T2000Error(
-          "STRATEGY_MIN_AMOUNT",
-          `Minimum $1 per asset in strategy. Need at least $${assetCount} for ${assetCount}-asset strategy.`
-        );
-      }
+    const smallestPct = Math.min(...Object.values(allocations));
+    const minRequired = Math.ceil(100 / smallestPct);
+    if (totalUsd < minRequired) {
+      const smallestAsset = Object.entries(allocations).find(([, p]) => p === smallestPct)?.[0] ?? "?";
+      throw new T2000Error(
+        "STRATEGY_MIN_AMOUNT",
+        `Minimum $${minRequired} for this strategy (${smallestAsset} at ${smallestPct}% needs at least $1)`
+      );
     }
   }
 };
@@ -4341,20 +4340,22 @@ To sell investment: t2000 invest sell ${params.amount} ${fromAsset}`,
     if (!params.usdAmount || params.usdAmount <= 0) {
       throw new T2000Error("INVALID_AMOUNT", "Strategy investment must be > $0");
     }
+    this.enforcer.check({ operation: "invest", amount: params.usdAmount });
     const bal = await queryBalance(this.client, this._address);
     if (bal.available < params.usdAmount) {
       throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient balance. Available: $${bal.available.toFixed(2)}, requested: $${params.usdAmount.toFixed(2)}`);
     }
     const buys = [];
+    const allocEntries = Object.entries(definition.allocations);
     if (params.dryRun) {
-      const swapAdapter = this.registry.listSwap()[0];
-      for (const [asset, pct] of Object.entries(definition.allocations)) {
+      const swapAdapter2 = this.registry.listSwap()[0];
+      for (const [asset, pct] of allocEntries) {
         const assetUsd = params.usdAmount * (pct / 100);
         let estAmount = 0;
         let estPrice = 0;
         try {
-          if (swapAdapter) {
-            const quote = await swapAdapter.getQuote("USDC", asset, assetUsd);
+          if (swapAdapter2) {
+            const quote = await swapAdapter2.getQuote("USDC", asset, assetUsd);
             estAmount = quote.expectedOutput;
             estPrice = assetUsd / estAmount;
           }
@@ -4364,27 +4365,76 @@ To sell investment: t2000 invest sell ${params.amount} ${fromAsset}`,
       }
       return { success: true, strategy: params.strategy, totalInvested: params.usdAmount, buys, gasCost: 0, gasMethod: "self-funded" };
     }
-    let totalGas = 0;
-    let gasMethod = "self-funded";
-    for (const [asset, pct] of Object.entries(definition.allocations)) {
-      const assetUsd = params.usdAmount * (pct / 100);
-      const result = await this.investBuy({ asset, usdAmount: assetUsd });
+    const swapAdapter = this.registry.listSwap()[0];
+    if (!swapAdapter?.addSwapToTx) {
+      throw new T2000Error("PROTOCOL_UNAVAILABLE", "Swap adapter does not support composable PTB");
+    }
+    const swapMetas = [];
+    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      const tx = new transactions.Transaction();
+      tx.setSender(this._address);
+      const usdcCoins = await this._fetchCoins(SUPPORTED_ASSETS.USDC.type);
+      if (usdcCoins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins found");
+      const mergedUsdc = this._mergeCoinsInTx(tx, usdcCoins);
+      const splitAmounts = allocEntries.map(
+        ([, pct]) => BigInt(Math.floor(params.usdAmount * (pct / 100) * 10 ** SUPPORTED_ASSETS.USDC.decimals))
+      );
+      const splitCoins = tx.splitCoins(mergedUsdc, splitAmounts);
+      const outputCoins = [];
+      for (let i = 0; i < allocEntries.length; i++) {
+        const [asset] = allocEntries[i];
+        const assetUsd = params.usdAmount * (allocEntries[i][1] / 100);
+        const { outputCoin, estimatedOut, toDecimals } = await swapAdapter.addSwapToTx(
+          tx,
+          this._address,
+          splitCoins[i],
+          "USDC",
+          asset,
+          assetUsd
+        );
+        outputCoins.push(outputCoin);
+        swapMetas.push({ asset, usdAmount: assetUsd, estimatedOut, toDecimals });
+      }
+      tx.transferObjects(outputCoins, this._address);
+      return tx;
+    });
+    const digest = gasResult.digest;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const meta of swapMetas) {
+      const amount = meta.estimatedOut / 10 ** meta.toDecimals;
+      const price = meta.usdAmount / amount;
+      this.portfolio.recordBuy({
+        id: `inv_${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_${Date.now()}_${asset}`,
+        id: `strat_${Date.now()}_${meta.asset}`,
         type: "buy",
-        asset,
-        amount: result.amount,
-        price: result.price,
-        usdValue: assetUsd,
-        fee: result.fee,
-        tx: result.tx,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        asset: meta.asset,
+        amount,
+        price,
+        usdValue: meta.usdAmount,
+        fee: 0,
+        tx: digest,
+        timestamp: now
       });
-      buys.push({ asset, usdAmount: assetUsd, amount: result.amount, price: result.price, tx: result.tx });
-      totalGas += result.gasCost;
-      gasMethod = result.gasMethod;
+      buys.push({ asset: meta.asset, usdAmount: meta.usdAmount, amount, price, tx: digest });
     }
-    return { success: true, strategy: params.strategy, totalInvested: params.usdAmount, buys, gasCost: totalGas, gasMethod };
+    return {
+      success: true,
+      strategy: params.strategy,
+      totalInvested: params.usdAmount,
+      buys,
+      gasCost: gasResult.gasCostSui,
+      gasMethod: gasResult.gasMethod
+    };
   }
   async sellStrategy(params) {
     this.enforcer.assertNotLocked();