@t2000/sdk 0.15.3 → 0.16.1

package/dist/index.js

@@ -4,7 +4,7 @@ import { SuiJsonRpcClient } from '@mysten/sui/jsonRpc';
 import { normalizeSuiAddress, isValidSuiAddress, normalizeStructTag } from '@mysten/sui/utils';
 import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
 import { decodeSuiPrivateKey } from '@mysten/sui/cryptography';
-import { createHash, randomBytes, createCipheriv, createDecipheriv, scryptSync } from 'crypto';
+import { createHash, randomUUID, randomBytes, createCipheriv, createDecipheriv, scryptSync } from 'crypto';
 import { access, mkdir, writeFile, readFile } from 'fs/promises';
 import { join, dirname, resolve } from 'path';
 import { homedir } from 'os';
@@ -85,6 +85,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;
@@ -2816,7 +2836,7 @@ var ContactManager = class {
   }
 };
 function emptyData() {
-  return { positions: {}, realizedPnL: 0 };
+  return { positions: {}, strategies: {}, realizedPnL: 0 };
 }
 var PortfolioManager = class {
   data = emptyData();
@@ -2831,6 +2851,7 @@ var PortfolioManager = class {
     try {
       if (existsSync(this.filePath)) {
         this.data = JSON.parse(readFileSync(this.filePath, "utf-8"));
+        if (!this.data.strategies) this.data.strategies = {};
       }
     } catch {
       this.data = emptyData();
@@ -2916,6 +2937,298 @@ 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 ?? join(homedir(), ".t2000");
+    this.filePath = join(this.dir, "strategies.json");
+    this.load();
+  }
+  load() {
+    try {
+      if (existsSync(this.filePath)) {
+        this.data = JSON.parse(readFileSync(this.filePath, "utf-8"));
+      }
+    } catch {
+      this.data = emptyData2();
+    }
+    if (!this.seeded) {
+      this.seedDefaults();
+    }
+  }
+  save() {
+    if (!existsSync(this.dir)) mkdirSync(this.dir, { recursive: true });
+    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 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)`
+      );
+    }
+  }
+};
+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 ?? join(homedir(), ".t2000");
+    this.filePath = join(this.dir, "auto-invest.json");
+    this.load();
+  }
+  load() {
+    try {
+      if (existsSync(this.filePath)) {
+        this.data = JSON.parse(readFileSync(this.filePath, "utf-8"));
+      }
+    } catch {
+      this.data = emptyData3();
+    }
+    if (!this.data.schedules) {
+      this.data.schedules = [];
+    }
+  }
+  save() {
+    if (!existsSync(this.dir)) mkdirSync(this.dir, { recursive: true });
+    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: 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 = join(homedir(), ".t2000");
 var T2000 = class _T2000 extends EventEmitter {
@@ -2926,6 +3239,8 @@ var T2000 = class _T2000 extends EventEmitter {
   enforcer;
   contacts;
   portfolio;
+  strategies;
+  autoInvest;
   constructor(keypair, client, registry, configDir) {
     super();
     this.keypair = keypair;
@@ -2936,6 +3251,8 @@ var T2000 = class _T2000 extends 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();
@@ -3109,6 +3426,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 {
@@ -4005,6 +4330,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();
@@ -4022,12 +4593,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 });
@@ -4045,7 +4615,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,
@@ -4058,13 +4628,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,
@@ -4072,6 +4658,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() {
@@ -4562,6 +5152,6 @@ var allDescriptors = [
   descriptor
 ];
 
-export { BPS_DENOMINATOR, CLOCK_ID, CetusAdapter, ContactManager, DEFAULT_MAX_LEVERAGE, DEFAULT_MAX_POSITION_SIZE, DEFAULT_NETWORK, DEFAULT_SAFEGUARD_CONFIG, GAS_RESERVE_MIN, INVESTMENT_ASSETS, MIST_PER_SUI, NaviAdapter, OUTBOUND_OPS, PERPS_MARKETS, PortfolioManager, ProtocolRegistry, SENTINEL, SUI_DECIMALS, SUPPORTED_ASSETS, SafeguardEnforcer, SafeguardError, SuilendAdapter, T2000, T2000Error, USDC_DECIMALS, addCollectFeeToTx, allDescriptors, calculateFee, descriptor3 as cetusDescriptor, executeAutoTopUp, executeWithGas, exportPrivateKey, formatAssetAmount, formatSui, formatUsd, generateKeypair, getAddress, getDecimals, getGasStatus, getPoolPrice, getRates, getSentinelInfo, keypairFromPrivateKey, listSentinels, loadKey, mapMoveAbortCode, mapWalletError, mistToSui, descriptor2 as naviDescriptor, rawToStable, rawToUsdc, requestAttack, saveKey, attack as sentinelAttack, descriptor as sentinelDescriptor, settleAttack, shouldAutoTopUp, simulateTransaction, solveHashcash, stableToRaw, submitPrompt, suiToMist, descriptor4 as suilendDescriptor, throwIfSimulationFailed, truncateAddress, usdcToRaw, validateAddress, walletExists };
+export { AutoInvestManager, BPS_DENOMINATOR, CLOCK_ID, CetusAdapter, ContactManager, DEFAULT_MAX_LEVERAGE, DEFAULT_MAX_POSITION_SIZE, DEFAULT_NETWORK, DEFAULT_SAFEGUARD_CONFIG, DEFAULT_STRATEGIES, GAS_RESERVE_MIN, INVESTMENT_ASSETS, MIST_PER_SUI, NaviAdapter, OUTBOUND_OPS, PERPS_MARKETS, PortfolioManager, ProtocolRegistry, SENTINEL, SUI_DECIMALS, SUPPORTED_ASSETS, SafeguardEnforcer, SafeguardError, StrategyManager, SuilendAdapter, T2000, T2000Error, USDC_DECIMALS, addCollectFeeToTx, allDescriptors, calculateFee, descriptor3 as cetusDescriptor, executeAutoTopUp, executeWithGas, exportPrivateKey, formatAssetAmount, formatSui, formatUsd, generateKeypair, getAddress, getDecimals, getGasStatus, getPoolPrice, getRates, getSentinelInfo, keypairFromPrivateKey, listSentinels, loadKey, mapMoveAbortCode, mapWalletError, mistToSui, descriptor2 as naviDescriptor, rawToStable, rawToUsdc, requestAttack, saveKey, attack as sentinelAttack, descriptor as sentinelDescriptor, settleAttack, shouldAutoTopUp, simulateTransaction, solveHashcash, stableToRaw, submitPrompt, suiToMist, descriptor4 as suilendDescriptor, throwIfSimulationFailed, truncateAddress, usdcToRaw, validateAddress, walletExists };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map