@t2000/sdk 0.15.3 → 0.16.0

package/dist/index.cjs

@@ -87,6 +87,26 @@ var INVESTMENT_ASSETS = {
   BTC: SUPPORTED_ASSETS.BTC,
   ETH: SUPPORTED_ASSETS.ETH
 };
+var DEFAULT_STRATEGIES = {
+  bluechip: {
+    name: "Bluechip / Large-Cap",
+    allocations: { BTC: 50, ETH: 30, SUI: 20 },
+    description: "Large-cap crypto index",
+    custom: false
+  },
+  layer1: {
+    name: "Smart Contract Platforms",
+    allocations: { ETH: 50, SUI: 50 },
+    description: "Smart contract platforms",
+    custom: false
+  },
+  "sui-heavy": {
+    name: "Sui-Weighted Portfolio",
+    allocations: { BTC: 20, ETH: 20, SUI: 60 },
+    description: "Sui-weighted portfolio",
+    custom: false
+  }
+};
 var PERPS_MARKETS = ["SUI-PERP"];
 var DEFAULT_MAX_LEVERAGE = 5;
 var DEFAULT_MAX_POSITION_SIZE = 1e3;
@@ -2818,7 +2838,7 @@ var ContactManager = class {
   }
 };
 function emptyData() {
-  return { positions: {}, realizedPnL: 0 };
+  return { positions: {}, strategies: {}, realizedPnL: 0 };
 }
 var PortfolioManager = class {
   data = emptyData();
@@ -2833,6 +2853,7 @@ var PortfolioManager = class {
     try {
       if (fs.existsSync(this.filePath)) {
         this.data = JSON.parse(fs.readFileSync(this.filePath, "utf-8"));
+        if (!this.data.strategies) this.data.strategies = {};
       }
     } catch {
       this.data = emptyData();
@@ -2918,6 +2939,299 @@ var PortfolioManager = class {
     this.load();
     return this.data.realizedPnL;
   }
+  // --- Strategy position tracking ---
+  recordStrategyBuy(strategyKey, trade) {
+    this.load();
+    if (!this.data.strategies[strategyKey]) {
+      this.data.strategies[strategyKey] = {};
+    }
+    const bucket = this.data.strategies[strategyKey];
+    const pos = bucket[trade.asset] ?? { totalAmount: 0, costBasis: 0, avgPrice: 0, trades: [] };
+    pos.totalAmount += trade.amount;
+    pos.costBasis += trade.usdValue;
+    pos.avgPrice = pos.costBasis / pos.totalAmount;
+    pos.trades.push(trade);
+    bucket[trade.asset] = pos;
+    this.save();
+  }
+  recordStrategySell(strategyKey, trade) {
+    this.load();
+    const bucket = this.data.strategies[strategyKey];
+    if (!bucket) {
+      throw new T2000Error("STRATEGY_NOT_FOUND", `No positions for strategy '${strategyKey}'`);
+    }
+    const pos = bucket[trade.asset];
+    if (!pos || pos.totalAmount <= 0) {
+      throw new T2000Error("INSUFFICIENT_INVESTMENT", `No ${trade.asset} position in strategy '${strategyKey}'`);
+    }
+    const sellAmount = Math.min(trade.amount, pos.totalAmount);
+    const costOfSold = pos.avgPrice * sellAmount;
+    const realizedPnL = trade.usdValue - costOfSold;
+    pos.totalAmount -= sellAmount;
+    pos.costBasis -= costOfSold;
+    if (pos.totalAmount < 1e-6) {
+      pos.totalAmount = 0;
+      pos.costBasis = 0;
+      pos.avgPrice = 0;
+    }
+    pos.trades.push(trade);
+    this.data.realizedPnL += realizedPnL;
+    bucket[trade.asset] = pos;
+    const hasPositions = Object.values(bucket).some((p) => p.totalAmount > 0);
+    if (!hasPositions) {
+      delete this.data.strategies[strategyKey];
+    }
+    this.save();
+    return realizedPnL;
+  }
+  getStrategyPositions(strategyKey) {
+    this.load();
+    const bucket = this.data.strategies[strategyKey];
+    if (!bucket) return [];
+    return Object.entries(bucket).filter(([, pos]) => pos.totalAmount > 0).map(([asset, pos]) => ({ asset, ...pos }));
+  }
+  getAllStrategyKeys() {
+    this.load();
+    return Object.keys(this.data.strategies);
+  }
+  hasStrategyPositions(strategyKey) {
+    this.load();
+    const bucket = this.data.strategies[strategyKey];
+    if (!bucket) return false;
+    return Object.values(bucket).some((p) => p.totalAmount > 0);
+  }
+};
+function emptyData2() {
+  return { strategies: {} };
+}
+var StrategyManager = class {
+  data = emptyData2();
+  filePath;
+  dir;
+  seeded = false;
+  constructor(configDir) {
+    this.dir = configDir ?? path.join(os.homedir(), ".t2000");
+    this.filePath = path.join(this.dir, "strategies.json");
+    this.load();
+  }
+  load() {
+    try {
+      if (fs.existsSync(this.filePath)) {
+        this.data = JSON.parse(fs.readFileSync(this.filePath, "utf-8"));
+      }
+    } catch {
+      this.data = emptyData2();
+    }
+    if (!this.seeded) {
+      this.seedDefaults();
+    }
+  }
+  save() {
+    if (!fs.existsSync(this.dir)) fs.mkdirSync(this.dir, { recursive: true });
+    fs.writeFileSync(this.filePath, JSON.stringify(this.data, null, 2));
+  }
+  seedDefaults() {
+    this.seeded = true;
+    let changed = false;
+    for (const [key, def] of Object.entries(DEFAULT_STRATEGIES)) {
+      if (!this.data.strategies[key]) {
+        this.data.strategies[key] = { ...def, allocations: { ...def.allocations } };
+        changed = true;
+      }
+    }
+    if (changed) this.save();
+  }
+  getAll() {
+    this.load();
+    return { ...this.data.strategies };
+  }
+  get(name) {
+    this.load();
+    const strategy = this.data.strategies[name];
+    if (!strategy) {
+      throw new T2000Error("STRATEGY_NOT_FOUND", `Strategy '${name}' not found`);
+    }
+    return strategy;
+  }
+  create(params) {
+    this.load();
+    const key = params.name.toLowerCase().replace(/\s+/g, "-");
+    if (this.data.strategies[key]) {
+      throw new T2000Error("STRATEGY_INVALID_ALLOCATIONS", `Strategy '${key}' already exists`);
+    }
+    this.validateAllocations(params.allocations);
+    const definition = {
+      name: params.name,
+      allocations: { ...params.allocations },
+      description: params.description ?? `Custom strategy: ${params.name}`,
+      custom: true
+    };
+    this.data.strategies[key] = definition;
+    this.save();
+    return definition;
+  }
+  delete(name) {
+    this.load();
+    const strategy = this.data.strategies[name];
+    if (!strategy) {
+      throw new T2000Error("STRATEGY_NOT_FOUND", `Strategy '${name}' not found`);
+    }
+    if (!strategy.custom) {
+      throw new T2000Error("STRATEGY_BUILTIN", `Cannot delete built-in strategy '${name}'`);
+    }
+    delete this.data.strategies[name];
+    this.save();
+  }
+  validateAllocations(allocations) {
+    const total = Object.values(allocations).reduce((sum, pct) => sum + pct, 0);
+    if (Math.abs(total - 100) > 0.01) {
+      throw new T2000Error("STRATEGY_INVALID_ALLOCATIONS", `Allocations must sum to 100 (got ${total})`);
+    }
+    for (const asset of Object.keys(allocations)) {
+      if (!(asset in INVESTMENT_ASSETS)) {
+        throw new T2000Error("STRATEGY_INVALID_ALLOCATIONS", `${asset} is not an investment asset`);
+      }
+      if (allocations[asset] <= 0) {
+        throw new T2000Error("STRATEGY_INVALID_ALLOCATIONS", `Allocation for ${asset} must be > 0`);
+      }
+    }
+  }
+  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.`
+        );
+      }
+    }
+  }
+};
+function emptyData3() {
+  return { schedules: [] };
+}
+function computeNextRun(frequency, dayOfWeek, dayOfMonth, from) {
+  const base = /* @__PURE__ */ new Date();
+  const next = new Date(base);
+  switch (frequency) {
+    case "daily":
+      next.setDate(next.getDate() + 1);
+      next.setHours(0, 0, 0, 0);
+      break;
+    case "weekly": {
+      const dow = dayOfWeek ?? 1;
+      next.setDate(next.getDate() + ((7 - next.getDay() + dow) % 7 || 7));
+      next.setHours(0, 0, 0, 0);
+      break;
+    }
+    case "monthly": {
+      const dom = dayOfMonth ?? 1;
+      next.setMonth(next.getMonth() + 1, dom);
+      next.setHours(0, 0, 0, 0);
+      break;
+    }
+  }
+  return next.toISOString();
+}
+var AutoInvestManager = class {
+  data = emptyData3();
+  filePath;
+  dir;
+  constructor(configDir) {
+    this.dir = configDir ?? path.join(os.homedir(), ".t2000");
+    this.filePath = path.join(this.dir, "auto-invest.json");
+    this.load();
+  }
+  load() {
+    try {
+      if (fs.existsSync(this.filePath)) {
+        this.data = JSON.parse(fs.readFileSync(this.filePath, "utf-8"));
+      }
+    } catch {
+      this.data = emptyData3();
+    }
+    if (!this.data.schedules) {
+      this.data.schedules = [];
+    }
+  }
+  save() {
+    if (!fs.existsSync(this.dir)) fs.mkdirSync(this.dir, { recursive: true });
+    fs.writeFileSync(this.filePath, JSON.stringify(this.data, null, 2));
+  }
+  setup(params) {
+    this.load();
+    if (!params.strategy && !params.asset) {
+      throw new T2000Error("AUTO_INVEST_NOT_FOUND", "Either strategy or asset must be specified");
+    }
+    if (params.amount < 1) {
+      throw new T2000Error("AUTO_INVEST_INSUFFICIENT", "Auto-invest amount must be at least $1");
+    }
+    const schedule = {
+      id: crypto.randomUUID().slice(0, 8),
+      strategy: params.strategy,
+      asset: params.asset,
+      amount: params.amount,
+      frequency: params.frequency,
+      dayOfWeek: params.dayOfWeek,
+      dayOfMonth: params.dayOfMonth,
+      nextRun: computeNextRun(params.frequency, params.dayOfWeek, params.dayOfMonth),
+      enabled: true,
+      totalInvested: 0,
+      runCount: 0
+    };
+    this.data.schedules.push(schedule);
+    this.save();
+    return schedule;
+  }
+  getStatus() {
+    this.load();
+    const now = /* @__PURE__ */ new Date();
+    const pending = this.data.schedules.filter(
+      (s) => s.enabled && new Date(s.nextRun) <= now
+    );
+    return {
+      schedules: [...this.data.schedules],
+      pendingRuns: pending
+    };
+  }
+  getSchedule(id) {
+    this.load();
+    const schedule = this.data.schedules.find((s) => s.id === id);
+    if (!schedule) {
+      throw new T2000Error("AUTO_INVEST_NOT_FOUND", `Schedule '${id}' not found`);
+    }
+    return schedule;
+  }
+  recordRun(id, amountInvested) {
+    this.load();
+    const schedule = this.data.schedules.find((s) => s.id === id);
+    if (!schedule) return;
+    schedule.lastRun = (/* @__PURE__ */ new Date()).toISOString();
+    schedule.nextRun = computeNextRun(schedule.frequency, schedule.dayOfWeek, schedule.dayOfMonth);
+    schedule.totalInvested += amountInvested;
+    schedule.runCount += 1;
+    this.save();
+  }
+  stop(id) {
+    this.load();
+    const schedule = this.data.schedules.find((s) => s.id === id);
+    if (!schedule) {
+      throw new T2000Error("AUTO_INVEST_NOT_FOUND", `Schedule '${id}' not found`);
+    }
+    schedule.enabled = false;
+    this.save();
+  }
+  remove(id) {
+    this.load();
+    const idx = this.data.schedules.findIndex((s) => s.id === id);
+    if (idx === -1) {
+      throw new T2000Error("AUTO_INVEST_NOT_FOUND", `Schedule '${id}' not found`);
+    }
+    this.data.schedules.splice(idx, 1);
+    this.save();
+  }
 };
 var DEFAULT_CONFIG_DIR = path.join(os.homedir(), ".t2000");
 var T2000 = class _T2000 extends eventemitter3.EventEmitter {
@@ -2928,6 +3242,8 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
   enforcer;
   contacts;
   portfolio;
+  strategies;
+  autoInvest;
   constructor(keypair, client, registry, configDir) {
     super();
     this.keypair = keypair;
@@ -2938,6 +3254,8 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     this.enforcer.load();
     this.contacts = new ContactManager(configDir);
     this.portfolio = new PortfolioManager(configDir);
+    this.strategies = new StrategyManager(configDir);
+    this.autoInvest = new AutoInvestManager(configDir);
   }
   static createDefaultRegistry(client) {
     const registry = new ProtocolRegistry();
@@ -3111,6 +3429,14 @@ To access invested funds: t2000 invest sell ${params.amount} ${asset}`,
           investmentCostBasis += pos.costBasis;
         }
       }
+      for (const key of this.portfolio.getAllStrategyKeys()) {
+        for (const sp of this.portfolio.getStrategyPositions(key)) {
+          if (!(sp.asset in INVESTMENT_ASSETS)) continue;
+          const price = assetPrices[sp.asset] ?? 0;
+          investmentValue += sp.totalAmount * price;
+          investmentCostBasis += sp.costBasis;
+        }
+      }
       bal.investment = investmentValue;
       bal.investmentPnL = investmentValue - investmentCostBasis;
     } catch {
@@ -4007,6 +4333,252 @@ To sell investment: t2000 invest sell ${params.amount} ${fromAsset}`,
       gasMethod: gasResult.gasMethod
     };
   }
+  // -- Strategies --
+  async investStrategy(params) {
+    this.enforcer.assertNotLocked();
+    const definition = this.strategies.get(params.strategy);
+    this.strategies.validateMinAmount(definition.allocations, params.usdAmount);
+    if (!params.usdAmount || params.usdAmount <= 0) {
+      throw new T2000Error("INVALID_AMOUNT", "Strategy investment must be > $0");
+    }
+    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 = [];
+    if (params.dryRun) {
+      const swapAdapter = this.registry.listSwap()[0];
+      for (const [asset, pct] of Object.entries(definition.allocations)) {
+        const assetUsd = params.usdAmount * (pct / 100);
+        let estAmount = 0;
+        let estPrice = 0;
+        try {
+          if (swapAdapter) {
+            const quote = await swapAdapter.getQuote("USDC", asset, assetUsd);
+            estAmount = quote.expectedOutput;
+            estPrice = assetUsd / estAmount;
+          }
+        } catch {
+        }
+        buys.push({ asset, usdAmount: assetUsd, amount: estAmount, price: estPrice, tx: "" });
+      }
+      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 });
+      this.portfolio.recordStrategyBuy(params.strategy, {
+        id: `strat_${Date.now()}_${asset}`,
+        type: "buy",
+        asset,
+        amount: result.amount,
+        price: result.price,
+        usdValue: assetUsd,
+        fee: result.fee,
+        tx: result.tx,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      buys.push({ asset, usdAmount: assetUsd, amount: result.amount, price: result.price, tx: result.tx });
+      totalGas += result.gasCost;
+      gasMethod = result.gasMethod;
+    }
+    return { success: true, strategy: params.strategy, totalInvested: params.usdAmount, buys, gasCost: totalGas, gasMethod };
+  }
+  async sellStrategy(params) {
+    this.enforcer.assertNotLocked();
+    this.strategies.get(params.strategy);
+    const stratPositions = this.portfolio.getStrategyPositions(params.strategy);
+    if (stratPositions.length === 0) {
+      throw new T2000Error("INSUFFICIENT_INVESTMENT", `No positions in strategy '${params.strategy}'`);
+    }
+    const sells = [];
+    let totalProceeds = 0;
+    let totalPnL = 0;
+    let totalGas = 0;
+    let gasMethod = "self-funded";
+    for (const pos of stratPositions) {
+      const result = await this.investSell({ asset: pos.asset, usdAmount: "all" });
+      const pnl = this.portfolio.recordStrategySell(params.strategy, {
+        id: `strat_sell_${Date.now()}_${pos.asset}`,
+        type: "sell",
+        asset: pos.asset,
+        amount: result.amount,
+        price: result.price,
+        usdValue: result.usdValue,
+        fee: result.fee,
+        tx: result.tx,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      sells.push({ asset: pos.asset, amount: result.amount, usdValue: result.usdValue, realizedPnL: pnl, tx: result.tx });
+      totalProceeds += result.usdValue;
+      totalPnL += pnl;
+      totalGas += result.gasCost;
+      gasMethod = result.gasMethod;
+    }
+    return { success: true, strategy: params.strategy, totalProceeds, realizedPnL: totalPnL, sells, gasCost: totalGas, gasMethod };
+  }
+  async rebalanceStrategy(params) {
+    this.enforcer.assertNotLocked();
+    const definition = this.strategies.get(params.strategy);
+    const stratPositions = this.portfolio.getStrategyPositions(params.strategy);
+    if (stratPositions.length === 0) {
+      throw new T2000Error("INSUFFICIENT_INVESTMENT", `No positions in strategy '${params.strategy}'`);
+    }
+    const swapAdapter = this.registry.listSwap()[0];
+    const prices = {};
+    for (const pos of stratPositions) {
+      try {
+        if (pos.asset === "SUI" && swapAdapter) {
+          prices[pos.asset] = await swapAdapter.getPoolPrice();
+        } else if (swapAdapter) {
+          const q = await swapAdapter.getQuote("USDC", pos.asset, 1);
+          prices[pos.asset] = q.expectedOutput > 0 ? 1 / q.expectedOutput : 0;
+        }
+      } catch {
+        prices[pos.asset] = 0;
+      }
+    }
+    const totalValue = stratPositions.reduce((s, p) => s + p.totalAmount * (prices[p.asset] ?? 0), 0);
+    if (totalValue <= 0) {
+      throw new T2000Error("INSUFFICIENT_INVESTMENT", "Strategy has no value to rebalance");
+    }
+    const currentWeights = {};
+    const beforeWeights = {};
+    for (const pos of stratPositions) {
+      const w = pos.totalAmount * (prices[pos.asset] ?? 0) / totalValue * 100;
+      currentWeights[pos.asset] = w;
+      beforeWeights[pos.asset] = w;
+    }
+    const trades = [];
+    const threshold = 3;
+    for (const [asset, targetPct] of Object.entries(definition.allocations)) {
+      const currentPct = currentWeights[asset] ?? 0;
+      const diff = targetPct - currentPct;
+      if (Math.abs(diff) < threshold) continue;
+      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 });
+      } else {
+        const result = await this.investSell({ asset, usdAmount: usdDiff });
+        this.portfolio.recordStrategySell(params.strategy, {
+          id: `strat_rebal_${Date.now()}_${asset}`,
+          type: "sell",
+          asset,
+          amount: result.amount,
+          price: result.price,
+          usdValue: result.usdValue,
+          fee: result.fee,
+          tx: result.tx,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        trades.push({ action: "sell", asset, usdAmount: result.usdValue, amount: result.amount, tx: result.tx });
+      }
+    }
+    const afterWeights = {};
+    const updatedPositions = this.portfolio.getStrategyPositions(params.strategy);
+    const newTotal = updatedPositions.reduce((s, p) => s + p.totalAmount * (prices[p.asset] ?? 0), 0);
+    for (const p of updatedPositions) {
+      afterWeights[p.asset] = newTotal > 0 ? p.totalAmount * (prices[p.asset] ?? 0) / newTotal * 100 : 0;
+    }
+    return { success: true, strategy: params.strategy, trades, beforeWeights, afterWeights, targetWeights: { ...definition.allocations } };
+  }
+  async getStrategyStatus(name) {
+    const definition = this.strategies.get(name);
+    const stratPositions = this.portfolio.getStrategyPositions(name);
+    const swapAdapter = this.registry.listSwap()[0];
+    const prices = {};
+    for (const asset of Object.keys(definition.allocations)) {
+      try {
+        if (asset === "SUI" && swapAdapter) {
+          prices[asset] = await swapAdapter.getPoolPrice();
+        } else if (swapAdapter) {
+          const q = await swapAdapter.getQuote("USDC", asset, 1);
+          prices[asset] = q.expectedOutput > 0 ? 1 / q.expectedOutput : 0;
+        }
+      } catch {
+        prices[asset] = 0;
+      }
+    }
+    const positions = stratPositions.map((sp) => {
+      const price = prices[sp.asset] ?? 0;
+      const currentValue = sp.totalAmount * price;
+      const pnl = currentValue - sp.costBasis;
+      return {
+        asset: sp.asset,
+        totalAmount: sp.totalAmount,
+        costBasis: sp.costBasis,
+        avgPrice: sp.avgPrice,
+        currentPrice: price,
+        currentValue,
+        unrealizedPnL: pnl,
+        unrealizedPnLPct: sp.costBasis > 0 ? pnl / sp.costBasis * 100 : 0,
+        trades: sp.trades
+      };
+    });
+    const totalValue = positions.reduce((s, p) => s + p.currentValue, 0);
+    const currentWeights = {};
+    for (const p of positions) {
+      currentWeights[p.asset] = totalValue > 0 ? p.currentValue / totalValue * 100 : 0;
+    }
+    return { definition, positions, currentWeights, totalValue };
+  }
+  // -- Auto-Invest --
+  setupAutoInvest(params) {
+    if (params.strategy) this.strategies.get(params.strategy);
+    if (params.asset && !(params.asset in INVESTMENT_ASSETS)) {
+      throw new T2000Error("ASSET_NOT_SUPPORTED", `${params.asset} is not an investment asset`);
+    }
+    return this.autoInvest.setup(params);
+  }
+  getAutoInvestStatus() {
+    return this.autoInvest.getStatus();
+  }
+  async runAutoInvest() {
+    this.enforcer.assertNotLocked();
+    const status = this.autoInvest.getStatus();
+    const executed = [];
+    const skipped = [];
+    for (const schedule of status.pendingRuns) {
+      try {
+        const bal = await queryBalance(this.client, this._address);
+        if (bal.available < schedule.amount) {
+          skipped.push({ scheduleId: schedule.id, reason: `Insufficient balance ($${bal.available.toFixed(2)} < $${schedule.amount})` });
+          continue;
+        }
+        if (schedule.strategy) {
+          const result = await this.investStrategy({ strategy: schedule.strategy, usdAmount: schedule.amount });
+          this.autoInvest.recordRun(schedule.id, schedule.amount);
+          executed.push({ scheduleId: schedule.id, strategy: schedule.strategy, amount: schedule.amount, result });
+        } else if (schedule.asset) {
+          const result = await this.investBuy({ asset: schedule.asset, usdAmount: schedule.amount });
+          this.autoInvest.recordRun(schedule.id, schedule.amount);
+          executed.push({ scheduleId: schedule.id, asset: schedule.asset, amount: schedule.amount, result });
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        skipped.push({ scheduleId: schedule.id, reason: msg });
+      }
+    }
+    return { executed, skipped };
+  }
+  stopAutoInvest(id) {
+    this.autoInvest.stop(id);
+  }
   async getPortfolio() {
     const positions = this.portfolio.getPositions();
     const realizedPnL = this.portfolio.getRealizedPnL();
@@ -4024,12 +4596,11 @@ To sell investment: t2000 invest sell ${params.amount} ${fromAsset}`,
         prices[asset] = 0;
       }
     }
-    const enriched = [];
-    for (const pos of positions) {
+    const enrichPosition = async (pos, adjustWallet) => {
       const currentPrice = prices[pos.asset] ?? 0;
       let totalAmount = pos.totalAmount;
       let costBasis = pos.costBasis;
-      if (pos.asset in INVESTMENT_ASSETS && !pos.earning) {
+      if (adjustWallet && pos.asset in INVESTMENT_ASSETS && !pos.earning) {
         try {
           const assetInfo = SUPPORTED_ASSETS[pos.asset];
           const bal = await this.client.getBalance({ owner: this._address, coinType: assetInfo.type });
@@ -4047,7 +4618,7 @@ To sell investment: t2000 invest sell ${params.amount} ${fromAsset}`,
       const currentValue = totalAmount * currentPrice;
       const unrealizedPnL = currentPrice > 0 ? currentValue - costBasis : 0;
       const unrealizedPnLPct = currentPrice > 0 && costBasis > 0 ? unrealizedPnL / costBasis * 100 : 0;
-      enriched.push({
+      return {
         asset: pos.asset,
         totalAmount,
         costBasis,
@@ -4060,13 +4631,29 @@ To sell investment: t2000 invest sell ${params.amount} ${fromAsset}`,
         earning: pos.earning,
         earningProtocol: pos.earningProtocol,
         earningApy: pos.earningApy
-      });
+      };
+    };
+    const enriched = [];
+    for (const pos of positions) {
+      enriched.push(await enrichPosition(pos, true));
+    }
+    const strategyPositions = {};
+    for (const key of this.portfolio.getAllStrategyKeys()) {
+      const sps = this.portfolio.getStrategyPositions(key);
+      const enrichedStrat = [];
+      for (const sp of sps) {
+        enrichedStrat.push(await enrichPosition(sp, false));
+      }
+      if (enrichedStrat.length > 0) {
+        strategyPositions[key] = enrichedStrat;
+      }
     }
-    const totalInvested = enriched.reduce((sum, p) => sum + p.costBasis, 0);
-    const totalValue = enriched.reduce((sum, p) => sum + p.currentValue, 0);
+    const allPositions = [...enriched, ...Object.values(strategyPositions).flat()];
+    const totalInvested = allPositions.reduce((sum, p) => sum + p.costBasis, 0);
+    const totalValue = allPositions.reduce((sum, p) => sum + p.currentValue, 0);
     const totalUnrealizedPnL = totalValue - totalInvested;
     const totalUnrealizedPnLPct = totalInvested > 0 ? totalUnrealizedPnL / totalInvested * 100 : 0;
-    return {
+    const result = {
       positions: enriched,
       totalInvested,
       totalValue,
@@ -4074,6 +4661,10 @@ To sell investment: t2000 invest sell ${params.amount} ${fromAsset}`,
       unrealizedPnLPct: totalUnrealizedPnLPct,
       realizedPnL
     };
+    if (Object.keys(strategyPositions).length > 0) {
+      result.strategyPositions = strategyPositions;
+    }
+    return result;
   }
   // -- Info --
   async positions() {
@@ -4564,6 +5155,7 @@ var allDescriptors = [
   descriptor
 ];
 
+exports.AutoInvestManager = AutoInvestManager;
 exports.BPS_DENOMINATOR = BPS_DENOMINATOR;
 exports.CLOCK_ID = CLOCK_ID;
 exports.CetusAdapter = CetusAdapter;
@@ -4572,6 +5164,7 @@ exports.DEFAULT_MAX_LEVERAGE = DEFAULT_MAX_LEVERAGE;
 exports.DEFAULT_MAX_POSITION_SIZE = DEFAULT_MAX_POSITION_SIZE;
 exports.DEFAULT_NETWORK = DEFAULT_NETWORK;
 exports.DEFAULT_SAFEGUARD_CONFIG = DEFAULT_SAFEGUARD_CONFIG;
+exports.DEFAULT_STRATEGIES = DEFAULT_STRATEGIES;
 exports.GAS_RESERVE_MIN = GAS_RESERVE_MIN;
 exports.INVESTMENT_ASSETS = INVESTMENT_ASSETS;
 exports.MIST_PER_SUI = MIST_PER_SUI;
@@ -4585,6 +5178,7 @@ exports.SUI_DECIMALS = SUI_DECIMALS;
 exports.SUPPORTED_ASSETS = SUPPORTED_ASSETS;
 exports.SafeguardEnforcer = SafeguardEnforcer;
 exports.SafeguardError = SafeguardError;
+exports.StrategyManager = StrategyManager;
 exports.SuilendAdapter = SuilendAdapter;
 exports.T2000 = T2000;
 exports.T2000Error = T2000Error;