@t2000/sdk 0.18.41 → 0.18.42

package/dist/index.cjs

@@ -56766,6 +56766,19 @@ var PortfolioManager = class {
     if (!bucket) return false;
     return Object.values(bucket).some((p) => p.totalAmount > 0);
   }
+  closeStrategyPosition(strategyKey, asset) {
+    this.load();
+    const bucket = this.data.strategies[strategyKey];
+    if (!bucket?.[asset]) return;
+    bucket[asset].totalAmount = 0;
+    bucket[asset].costBasis = 0;
+    bucket[asset].avgPrice = 0;
+    const hasPositions = Object.values(bucket).some((p) => p.totalAmount > 0);
+    if (!hasPositions) {
+      delete this.data.strategies[strategyKey];
+    }
+    this.save();
+  }
 };
 function emptyData2() {
   return { strategies: {} };
@@ -58116,16 +58129,14 @@ To sell investment: t2000 invest sell ${params.amount} ${fromAsset}`,
     if (!(params.asset in INVESTMENT_ASSETS)) {
       throw new T2000Error("ASSET_NOT_SUPPORTED", `${params.asset} is not available for investment`);
     }
-    const pos = this.portfolio.getPosition(params.asset);
-    if (!pos || pos.totalAmount <= 0) {
-      throw new T2000Error("INSUFFICIENT_INVESTMENT", `No ${params.asset} position to sell`);
-    }
-    const didAutoWithdraw = !!(pos.earning && pos.earningProtocol);
+    let pos = this.portfolio.getPosition(params.asset);
+    const didAutoWithdraw = !!(pos?.earning && pos.earningProtocol);
     if (didAutoWithdraw) {
       const unearnResult = await this.investUnearn({ asset: params.asset });
       if (unearnResult.tx) {
         await this.client.waitForTransaction({ digest: unearnResult.tx, options: { showEffects: true } });
       }
+      pos = this.portfolio.getPosition(params.asset);
     }
     const assetInfo = SUPPORTED_ASSETS[params.asset];
     const gasReserve = params.asset === "SUI" ? GAS_RESERVE_MIN : 0;
@@ -58140,16 +58151,20 @@ To sell investment: t2000 invest sell ${params.amount} ${fromAsset}`,
       await new Promise((r) => setTimeout(r, 1500));
     }
     const maxSellable = Math.max(0, walletAmount - gasReserve);
+    const trackedAmount = pos && pos.totalAmount > 0 ? pos.totalAmount : maxSellable;
+    if (trackedAmount <= 0) {
+      throw new T2000Error("INSUFFICIENT_INVESTMENT", `No ${params.asset} position to sell`);
+    }
     let sellAmountAsset;
     if (params.usdAmount === "all") {
-      sellAmountAsset = Math.min(pos.totalAmount, maxSellable);
+      sellAmountAsset = Math.min(trackedAmount, maxSellable);
     } else {
       const swapAdapter = this.registry.listSwap()[0];
       if (!swapAdapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", "No swap adapter available");
       const quote = await swapAdapter.getQuote("USDC", params.asset, 1);
       const assetPrice = 1 / quote.expectedOutput;
       sellAmountAsset = params.usdAmount / assetPrice;
-      const maxPosition = params._strategyOnly ? maxSellable : pos.totalAmount;
+      const maxPosition = params._strategyOnly ? maxSellable : trackedAmount;
       sellAmountAsset = Math.min(sellAmountAsset, maxPosition);
       if (sellAmountAsset > maxSellable) {
         throw new T2000Error(
@@ -58184,17 +58199,21 @@ To sell investment: t2000 invest sell ${params.amount} ${fromAsset}`,
       }
     }
     const price = swapResult.toAmount / sellAmountAsset;
-    const realizedPnL = this.portfolio.recordSell({
-      id: `inv_${Date.now()}`,
-      type: "sell",
-      asset: params.asset,
-      amount: sellAmountAsset,
-      price,
-      usdValue: swapResult.toAmount,
-      fee: swapResult.fee,
-      tx: swapResult.tx,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
+    let realizedPnL = 0;
+    try {
+      realizedPnL = this.portfolio.recordSell({
+        id: `inv_${Date.now()}`,
+        type: "sell",
+        asset: params.asset,
+        amount: sellAmountAsset,
+        price,
+        usdValue: swapResult.toAmount,
+        fee: swapResult.fee,
+        tx: swapResult.tx,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch {
+    }
     if (params.usdAmount === "all" && !params._strategyOnly) {
       this.portfolio.closePosition(params.asset);
     }
@@ -58697,34 +58716,47 @@ To sell investment: t2000 invest sell ${params.amount} ${fromAsset}`,
     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()}_${meta.asset}`,
-        type: "sell",
-        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
-      });
+      let pnl = 0;
+      try {
+        pnl = this.portfolio.recordStrategySell(params.strategy, {
+          id: `strat_sell_${Date.now()}_${meta.asset}`,
+          type: "sell",
+          asset: meta.asset,
+          amount: meta.amount,
+          price,
+          usdValue,
+          fee: 0,
+          tx: digest,
+          timestamp: now
+        });
+      } catch {
+      }
+      try {
+        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
+        });
+      } catch {
+      }
       sells.push({ asset: meta.asset, amount: meta.amount, usdValue, realizedPnL: pnl, tx: digest });
       totalProceeds += usdValue;
       totalPnL += pnl;
     }
-    if (unearnFailures.length === 0 && this.portfolio.hasStrategyPositions(params.strategy)) {
-      this.portfolio.clearStrategy(params.strategy);
+    if (this.portfolio.hasStrategyPositions(params.strategy)) {
+      if (unearnFailures.length === 0) {
+        this.portfolio.clearStrategy(params.strategy);
+      } else {
+        for (const s of sells) {
+          this.portfolio.closeStrategyPosition(params.strategy, s.asset);
+        }
+      }
     }
     const failed = unearnFailures.map((f) => ({ asset: f.asset, reason: f.error }));
     return {