@t2000/sdk 0.13.0 → 0.14.0

package/dist/index.cjs

@@ -58,6 +58,18 @@ var SUPPORTED_ASSETS = {
     decimals: 9,
     symbol: "SUI",
     displayName: "SUI"
+  },
+  BTC: {
+    type: "0xaafb102dd0902f5055cadecd687fb5b71ca82ef0e0285d90afde828ec58ca96b::btc::BTC",
+    decimals: 8,
+    symbol: "BTC",
+    displayName: "Bitcoin"
+  },
+  ETH: {
+    type: "0xd0e89b2af5e4910726fbcd8b8dd37bb79b29e5f83f7491bca830e94f7f226d29::eth::ETH",
+    decimals: 8,
+    symbol: "ETH",
+    displayName: "Ethereum"
   }
 };
 var STABLE_ASSETS = ["USDC", "USDT", "USDe", "USDsui"];
@@ -70,6 +82,15 @@ var DEFAULT_KEY_PATH = "~/.t2000/wallet.key";
 var API_BASE_URL = process.env.T2000_API_URL ?? "https://api.t2000.ai";
 var CETUS_USDC_SUI_POOL = "0x51e883ba7c0b566a26cbc8a94cd33eb0abd418a77cc1e60ad22fd9b1f29cd2ab";
 var CETUS_PACKAGE = "0x1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb";
+var INVESTMENT_ASSETS = {
+  SUI: SUPPORTED_ASSETS.SUI,
+  BTC: SUPPORTED_ASSETS.BTC,
+  ETH: SUPPORTED_ASSETS.ETH
+};
+var PERPS_MARKETS = ["SUI-PERP"];
+var DEFAULT_MAX_LEVERAGE = 5;
+var DEFAULT_MAX_POSITION_SIZE = 1e3;
+var GAS_RESERVE_MIN = 0.05;
 var SENTINEL = {
   PACKAGE: "0x88b83f36dafcd5f6dcdcf1d2cb5889b03f61264ab3cee9cae35db7aa940a21b7",
   AGENT_REGISTRY: "0xc47564f5f14c12b31e0dfa1a3dc99a6380a1edf8929c28cb0eaa3359c8db36ac",
@@ -406,6 +427,8 @@ async function queryBalance(client, address) {
     available: totalStables,
     savings,
     debt: 0,
+    investment: 0,
+    investmentPnL: 0,
     gasReserve: {
       sui: suiAmount,
       usdEquiv
@@ -1684,10 +1707,10 @@ var CetusAdapter = class {
     };
   }
   getSupportedPairs() {
-    const pairs = [
-      { from: "USDC", to: "SUI" },
-      { from: "SUI", to: "USDC" }
-    ];
+    const pairs = [];
+    for (const asset of Object.keys(INVESTMENT_ASSETS)) {
+      pairs.push({ from: "USDC", to: asset }, { from: asset, to: "USDC" });
+    }
     for (const a of STABLE_ASSETS) {
       for (const b of STABLE_ASSETS) {
         if (a !== b) pairs.push({ from: a, to: b });
@@ -2776,6 +2799,76 @@ var ContactManager = class {
     }
   }
 };
+function emptyData() {
+  return { positions: {}, realizedPnL: 0 };
+}
+var PortfolioManager = class {
+  data = emptyData();
+  filePath;
+  dir;
+  constructor(configDir) {
+    this.dir = configDir ?? path.join(os.homedir(), ".t2000");
+    this.filePath = path.join(this.dir, "portfolio.json");
+    this.load();
+  }
+  load() {
+    try {
+      if (fs.existsSync(this.filePath)) {
+        this.data = JSON.parse(fs.readFileSync(this.filePath, "utf-8"));
+      }
+    } catch {
+      this.data = emptyData();
+    }
+  }
+  save() {
+    if (!fs.existsSync(this.dir)) fs.mkdirSync(this.dir, { recursive: true });
+    fs.writeFileSync(this.filePath, JSON.stringify(this.data, null, 2));
+  }
+  recordBuy(trade) {
+    this.load();
+    const pos = this.data.positions[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);
+    this.data.positions[trade.asset] = pos;
+    this.save();
+  }
+  recordSell(trade) {
+    this.load();
+    const pos = this.data.positions[trade.asset];
+    if (!pos || pos.totalAmount <= 0) {
+      throw new T2000Error("INSUFFICIENT_INVESTMENT", `No ${trade.asset} position to sell`);
+    }
+    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;
+    this.data.positions[trade.asset] = pos;
+    this.save();
+    return realizedPnL;
+  }
+  getPosition(asset) {
+    this.load();
+    return this.data.positions[asset];
+  }
+  getPositions() {
+    this.load();
+    return Object.entries(this.data.positions).filter(([, pos]) => pos.totalAmount > 0).map(([asset, pos]) => ({ asset, ...pos }));
+  }
+  getRealizedPnL() {
+    this.load();
+    return this.data.realizedPnL;
+  }
+};
 var DEFAULT_CONFIG_DIR = path.join(os.homedir(), ".t2000");
 var T2000 = class _T2000 extends eventemitter3.EventEmitter {
   keypair;
@@ -2784,6 +2877,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
   registry;
   enforcer;
   contacts;
+  portfolio;
   constructor(keypair, client, registry, configDir) {
     super();
     this.keypair = keypair;
@@ -2793,6 +2887,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     this.enforcer = new SafeguardEnforcer(configDir);
     this.enforcer.load();
     this.contacts = new ContactManager(configDir);
+    this.portfolio = new PortfolioManager(configDir);
   }
   static createDefaultRegistry(client) {
     const registry = new ProtocolRegistry();
@@ -2872,6 +2967,19 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     if (!(asset in SUPPORTED_ASSETS)) {
       throw new T2000Error("ASSET_NOT_SUPPORTED", `Asset ${asset} is not supported`);
     }
+    if (asset in INVESTMENT_ASSETS) {
+      const free = await this.getFreeBalance(asset);
+      if (params.amount > free) {
+        const pos = this.portfolio.getPosition(asset);
+        const invested = pos?.totalAmount ?? 0;
+        throw new T2000Error(
+          "INVESTMENT_LOCKED",
+          `Cannot send ${params.amount} ${asset} \u2014 ${invested.toFixed(4)} ${asset} is invested. Free ${asset}: ${free.toFixed(4)}
+To access invested funds: t2000 invest sell ${params.amount} ${asset}`,
+          { free, invested, requested: params.amount }
+        );
+      }
+    }
     const resolved = this.contacts.resolve(params.to);
     const sendAmount = params.amount;
     const sendTo = resolved.address;
@@ -2904,9 +3012,52 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
       const debt = positions.positions.filter((p) => p.type === "borrow").reduce((sum, p) => sum + p.amount, 0);
       bal.savings = savings;
       bal.debt = debt;
-      bal.total = bal.available + savings - debt + bal.gasReserve.usdEquiv;
     } catch {
     }
+    try {
+      const portfolioPositions = this.portfolio.getPositions();
+      const suiPrice = bal.gasReserve.sui > 0 ? bal.gasReserve.usdEquiv / bal.gasReserve.sui : 0;
+      const assetPrices = { SUI: suiPrice };
+      const swapAdapter = this.registry.listSwap()[0];
+      for (const pos of portfolioPositions) {
+        if (pos.asset !== "SUI" && pos.asset in INVESTMENT_ASSETS && !(pos.asset in assetPrices)) {
+          try {
+            if (swapAdapter) {
+              const quote = await swapAdapter.getQuote("USDC", pos.asset, 1);
+              assetPrices[pos.asset] = quote.expectedOutput > 0 ? 1 / quote.expectedOutput : 0;
+            }
+          } catch {
+            assetPrices[pos.asset] = 0;
+          }
+        }
+      }
+      let investmentValue = 0;
+      let investmentCostBasis = 0;
+      for (const pos of portfolioPositions) {
+        if (!(pos.asset in INVESTMENT_ASSETS)) continue;
+        const price = assetPrices[pos.asset] ?? 0;
+        if (pos.asset === "SUI") {
+          const actualHeld = Math.min(pos.totalAmount, bal.gasReserve.sui);
+          investmentValue += actualHeld * price;
+          if (actualHeld < pos.totalAmount && pos.totalAmount > 0) {
+            investmentCostBasis += pos.costBasis * (actualHeld / pos.totalAmount);
+          } else {
+            investmentCostBasis += pos.costBasis;
+          }
+          const gasSui = Math.max(0, bal.gasReserve.sui - pos.totalAmount);
+          bal.gasReserve = { sui: gasSui, usdEquiv: gasSui * price };
+        } else {
+          investmentValue += pos.totalAmount * price;
+          investmentCostBasis += pos.costBasis;
+        }
+      }
+      bal.investment = investmentValue;
+      bal.investmentPnL = investmentValue - investmentCostBasis;
+    } catch {
+      bal.investment = 0;
+      bal.investmentPnL = 0;
+    }
+    bal.total = bal.available + bal.savings - bal.debt + bal.investment + bal.gasReserve.usdEquiv;
     return bal;
   }
   async history(params) {
@@ -3469,6 +3620,19 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     if (fromAsset === toAsset) {
       throw new T2000Error("INVALID_AMOUNT", "Cannot swap same asset");
     }
+    if (!params._bypassInvestmentGuard && fromAsset in INVESTMENT_ASSETS) {
+      const free = await this.getFreeBalance(fromAsset);
+      if (params.amount > free) {
+        const pos = this.portfolio.getPosition(fromAsset);
+        const invested = pos?.totalAmount ?? 0;
+        throw new T2000Error(
+          "INVESTMENT_LOCKED",
+          `Cannot exchange ${params.amount} ${fromAsset} \u2014 ${invested.toFixed(4)} ${fromAsset} is invested. Free ${fromAsset}: ${free.toFixed(4)}
+To sell investment: t2000 invest sell ${params.amount} ${fromAsset}`,
+          { free, invested, requested: params.amount }
+        );
+      }
+    }
     const best = await this.registry.bestSwapQuote(fromAsset, toAsset, params.amount);
     const adapter = best.adapter;
     const fee = calculateFee("swap", params.amount);
@@ -3520,6 +3684,222 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     const fee = calculateFee("swap", params.amount);
     return { ...best.quote, fee: { amount: fee.amount, rate: fee.rate } };
   }
+  // -- Investment --
+  async investBuy(params) {
+    this.enforcer.assertNotLocked();
+    if (!params.usdAmount || params.usdAmount <= 0 || !isFinite(params.usdAmount)) {
+      throw new T2000Error("INVALID_AMOUNT", "Investment amount must be greater than $0");
+    }
+    this.enforcer.check({ operation: "invest", amount: params.usdAmount });
+    if (!(params.asset in INVESTMENT_ASSETS)) {
+      throw new T2000Error("ASSET_NOT_SUPPORTED", `${params.asset} is not available for investment`);
+    }
+    const bal = await queryBalance(this.client, this._address);
+    if (bal.available < params.usdAmount) {
+      throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient checking balance. Available: $${bal.available.toFixed(2)}, requested: $${params.usdAmount.toFixed(2)}`);
+    }
+    const swapResult = await this.exchange({
+      from: "USDC",
+      to: params.asset,
+      amount: params.usdAmount,
+      maxSlippage: params.maxSlippage ?? 0.03,
+      _bypassInvestmentGuard: true
+    });
+    if (swapResult.toAmount === 0) {
+      throw new T2000Error("SWAP_FAILED", "Swap returned zero tokens \u2014 try a different amount or check liquidity");
+    }
+    const price = params.usdAmount / swapResult.toAmount;
+    this.portfolio.recordBuy({
+      id: `inv_${Date.now()}`,
+      type: "buy",
+      asset: params.asset,
+      amount: swapResult.toAmount,
+      price,
+      usdValue: params.usdAmount,
+      fee: swapResult.fee,
+      tx: swapResult.tx,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const pos = this.portfolio.getPosition(params.asset);
+    const currentPrice = price;
+    const position = {
+      asset: params.asset,
+      totalAmount: pos?.totalAmount ?? swapResult.toAmount,
+      costBasis: pos?.costBasis ?? params.usdAmount,
+      avgPrice: pos?.avgPrice ?? price,
+      currentPrice,
+      currentValue: (pos?.totalAmount ?? swapResult.toAmount) * currentPrice,
+      unrealizedPnL: 0,
+      unrealizedPnLPct: 0,
+      trades: pos?.trades ?? []
+    };
+    return {
+      success: true,
+      tx: swapResult.tx,
+      type: "buy",
+      asset: params.asset,
+      amount: swapResult.toAmount,
+      price,
+      usdValue: params.usdAmount,
+      fee: swapResult.fee,
+      gasCost: swapResult.gasCost,
+      gasMethod: swapResult.gasMethod,
+      position
+    };
+  }
+  async investSell(params) {
+    this.enforcer.assertNotLocked();
+    if (params.usdAmount !== "all") {
+      if (!params.usdAmount || params.usdAmount <= 0 || !isFinite(params.usdAmount)) {
+        throw new T2000Error("INVALID_AMOUNT", "Sell amount must be greater than $0");
+      }
+    }
+    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 assetInfo = SUPPORTED_ASSETS[params.asset];
+    const assetBalance = await this.client.getBalance({
+      owner: this._address,
+      coinType: assetInfo.type
+    });
+    const walletAmount = Number(assetBalance.totalBalance) / 10 ** assetInfo.decimals;
+    const gasReserve = params.asset === "SUI" ? GAS_RESERVE_MIN : 0;
+    const maxSellable = Math.max(0, walletAmount - gasReserve);
+    let sellAmountAsset;
+    if (params.usdAmount === "all") {
+      sellAmountAsset = Math.min(pos.totalAmount, 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;
+      sellAmountAsset = Math.min(sellAmountAsset, pos.totalAmount);
+      if (sellAmountAsset > maxSellable) {
+        throw new T2000Error(
+          "INSUFFICIENT_INVESTMENT",
+          `Cannot sell $${params.usdAmount.toFixed(2)} \u2014 max sellable: $${(maxSellable * assetPrice).toFixed(2)} (gas reserve: ${gasReserve} ${params.asset})`
+        );
+      }
+    }
+    if (sellAmountAsset <= 0) {
+      throw new T2000Error("INSUFFICIENT_INVESTMENT", "Nothing to sell after gas reserve");
+    }
+    const swapResult = await this.exchange({
+      from: params.asset,
+      to: "USDC",
+      amount: sellAmountAsset,
+      maxSlippage: params.maxSlippage ?? 0.03,
+      _bypassInvestmentGuard: true
+    });
+    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()
+    });
+    const updatedPos = this.portfolio.getPosition(params.asset);
+    const position = {
+      asset: params.asset,
+      totalAmount: updatedPos?.totalAmount ?? 0,
+      costBasis: updatedPos?.costBasis ?? 0,
+      avgPrice: updatedPos?.avgPrice ?? 0,
+      currentPrice: price,
+      currentValue: (updatedPos?.totalAmount ?? 0) * price,
+      unrealizedPnL: 0,
+      unrealizedPnLPct: 0,
+      trades: updatedPos?.trades ?? []
+    };
+    return {
+      success: true,
+      tx: swapResult.tx,
+      type: "sell",
+      asset: params.asset,
+      amount: sellAmountAsset,
+      price,
+      usdValue: swapResult.toAmount,
+      fee: swapResult.fee,
+      gasCost: swapResult.gasCost,
+      gasMethod: swapResult.gasMethod,
+      realizedPnL,
+      position
+    };
+  }
+  async getPortfolio() {
+    const positions = this.portfolio.getPositions();
+    const realizedPnL = this.portfolio.getRealizedPnL();
+    const prices = {};
+    const swapAdapter = this.registry.listSwap()[0];
+    for (const asset of Object.keys(INVESTMENT_ASSETS)) {
+      try {
+        if (asset === "SUI" && swapAdapter) {
+          prices[asset] = await swapAdapter.getPoolPrice();
+        } else if (swapAdapter) {
+          const quote = await swapAdapter.getQuote("USDC", asset, 1);
+          prices[asset] = quote.expectedOutput > 0 ? 1 / quote.expectedOutput : 0;
+        }
+      } catch {
+        prices[asset] = 0;
+      }
+    }
+    const enriched = [];
+    for (const pos of positions) {
+      const currentPrice = prices[pos.asset] ?? 0;
+      let totalAmount = pos.totalAmount;
+      let costBasis = pos.costBasis;
+      if (pos.asset in INVESTMENT_ASSETS) {
+        try {
+          const assetInfo = SUPPORTED_ASSETS[pos.asset];
+          const bal = await this.client.getBalance({ owner: this._address, coinType: assetInfo.type });
+          const walletAmount = Number(bal.totalBalance) / 10 ** assetInfo.decimals;
+          const gasReserve = pos.asset === "SUI" ? GAS_RESERVE_MIN : 0;
+          const actualHeld = Math.max(0, walletAmount - gasReserve);
+          if (actualHeld < totalAmount) {
+            const ratio = totalAmount > 0 ? actualHeld / totalAmount : 0;
+            costBasis *= ratio;
+            totalAmount = actualHeld;
+          }
+        } catch {
+        }
+      }
+      const currentValue = totalAmount * currentPrice;
+      const unrealizedPnL = currentPrice > 0 ? currentValue - costBasis : 0;
+      const unrealizedPnLPct = currentPrice > 0 && costBasis > 0 ? unrealizedPnL / costBasis * 100 : 0;
+      enriched.push({
+        asset: pos.asset,
+        totalAmount,
+        costBasis,
+        avgPrice: pos.avgPrice,
+        currentPrice,
+        currentValue,
+        unrealizedPnL,
+        unrealizedPnLPct,
+        trades: pos.trades
+      });
+    }
+    const totalInvested = enriched.reduce((sum, p) => sum + p.costBasis, 0);
+    const totalValue = enriched.reduce((sum, p) => sum + p.currentValue, 0);
+    const totalUnrealizedPnL = totalValue - totalInvested;
+    const totalUnrealizedPnLPct = totalInvested > 0 ? totalUnrealizedPnL / totalInvested * 100 : 0;
+    return {
+      positions: enriched,
+      totalInvested,
+      totalValue,
+      unrealizedPnL: totalUnrealizedPnL,
+      unrealizedPnLPct: totalUnrealizedPnLPct,
+      realizedPnL
+    };
+  }
   // -- Info --
   async positions() {
     const allPositions = await this.registry.allPositions(this._address);
@@ -3847,6 +4227,17 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     return attack(this.client, this.keypair, id, prompt, fee);
   }
   // -- Helpers --
+  async getFreeBalance(asset) {
+    if (!(asset in INVESTMENT_ASSETS)) return Infinity;
+    const pos = this.portfolio.getPosition(asset);
+    const invested = pos?.totalAmount ?? 0;
+    if (invested <= 0) return Infinity;
+    const assetInfo = SUPPORTED_ASSETS[asset];
+    const balance = await this.client.getBalance({ owner: this._address, coinType: assetInfo.type });
+    const walletAmount = Number(balance.totalBalance) / 10 ** assetInfo.decimals;
+    const gasReserve = asset === "SUI" ? GAS_RESERVE_MIN : 0;
+    return Math.max(0, walletAmount - invested - gasReserve);
+  }
   async resolveLending(protocol, asset, capability) {
     if (protocol) {
       const adapter = this.registry.getLending(protocol);
@@ -3999,11 +4390,17 @@ exports.BPS_DENOMINATOR = BPS_DENOMINATOR;
 exports.CLOCK_ID = CLOCK_ID;
 exports.CetusAdapter = CetusAdapter;
 exports.ContactManager = ContactManager;
+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.GAS_RESERVE_MIN = GAS_RESERVE_MIN;
+exports.INVESTMENT_ASSETS = INVESTMENT_ASSETS;
 exports.MIST_PER_SUI = MIST_PER_SUI;
 exports.NaviAdapter = NaviAdapter;
 exports.OUTBOUND_OPS = OUTBOUND_OPS;
+exports.PERPS_MARKETS = PERPS_MARKETS;
+exports.PortfolioManager = PortfolioManager;
 exports.ProtocolRegistry = ProtocolRegistry;
 exports.SENTINEL = SENTINEL;
 exports.SUI_DECIMALS = SUI_DECIMALS;