@t2000/sdk 0.13.0 → 0.14.1

package/dist/index.js

@@ -56,6 +56,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"];
@@ -68,6 +80,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",
@@ -300,6 +321,11 @@ function formatSui(amount) {
   if (amount < 1e-3) return `${amount.toFixed(6)} SUI`;
   return `${amount.toFixed(3)} SUI`;
 }
+function formatAssetAmount(amount, asset) {
+  if (asset === "BTC") return amount.toFixed(8);
+  if (asset === "ETH") return amount.toFixed(6);
+  return amount.toFixed(4);
+}
 var ASSET_LOOKUP = /* @__PURE__ */ new Map();
 for (const [key, info] of Object.entries(SUPPORTED_ASSETS)) {
   ASSET_LOOKUP.set(key.toUpperCase(), key);
@@ -404,6 +430,8 @@ async function queryBalance(client, address) {
     available: totalStables,
     savings,
     debt: 0,
+    investment: 0,
+    investmentPnL: 0,
     gasReserve: {
       sui: suiAmount,
       usdEquiv
@@ -1682,10 +1710,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 });
@@ -2774,6 +2802,76 @@ var ContactManager = class {
     }
   }
 };
+function emptyData() {
+  return { positions: {}, realizedPnL: 0 };
+}
+var PortfolioManager = class {
+  data = emptyData();
+  filePath;
+  dir;
+  constructor(configDir) {
+    this.dir = configDir ?? join(homedir(), ".t2000");
+    this.filePath = join(this.dir, "portfolio.json");
+    this.load();
+  }
+  load() {
+    try {
+      if (existsSync(this.filePath)) {
+        this.data = JSON.parse(readFileSync(this.filePath, "utf-8"));
+      }
+    } catch {
+      this.data = emptyData();
+    }
+  }
+  save() {
+    if (!existsSync(this.dir)) mkdirSync(this.dir, { recursive: true });
+    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 = join(homedir(), ".t2000");
 var T2000 = class _T2000 extends EventEmitter {
   keypair;
@@ -2782,6 +2880,7 @@ var T2000 = class _T2000 extends EventEmitter {
   registry;
   enforcer;
   contacts;
+  portfolio;
   constructor(keypair, client, registry, configDir) {
     super();
     this.keypair = keypair;
@@ -2791,6 +2890,7 @@ var T2000 = class _T2000 extends 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();
@@ -2870,6 +2970,19 @@ var T2000 = class _T2000 extends 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;
@@ -2902,9 +3015,52 @@ var T2000 = class _T2000 extends 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) {
@@ -3467,6 +3623,19 @@ var T2000 = class _T2000 extends 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);
@@ -3518,6 +3687,222 @@ var T2000 = class _T2000 extends 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);
@@ -3845,6 +4230,17 @@ var T2000 = class _T2000 extends 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);
@@ -3993,6 +4389,6 @@ var allDescriptors = [
   descriptor
 ];
 
-export { BPS_DENOMINATOR, CLOCK_ID, CetusAdapter, ContactManager, DEFAULT_NETWORK, DEFAULT_SAFEGUARD_CONFIG, MIST_PER_SUI, NaviAdapter, OUTBOUND_OPS, ProtocolRegistry, SENTINEL, SUI_DECIMALS, SUPPORTED_ASSETS, SafeguardEnforcer, SafeguardError, SuilendAdapter, T2000, T2000Error, USDC_DECIMALS, addCollectFeeToTx, allDescriptors, calculateFee, descriptor3 as cetusDescriptor, executeAutoTopUp, executeWithGas, exportPrivateKey, 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 { 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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map