@t2000/sdk 0.19.24 → 0.20.0

package/dist/index.js

@@ -1,159 +1,36 @@
-import { EventEmitter } from 'eventemitter3';
 import { Transaction } from '@mysten/sui/transactions';
+import { AggregatorClient, Env } from '@cetusprotocol/aggregator-sdk';
+import { EventEmitter } from 'eventemitter3';
 import { SuiJsonRpcClient } from '@mysten/sui/jsonRpc';
-import { normalizeSuiAddress, isValidSuiAddress, normalizeStructTag } from '@mysten/sui/utils';
+import { normalizeSuiAddress, isValidSuiAddress } from '@mysten/sui/utils';
 import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
 import { decodeSuiPrivateKey } from '@mysten/sui/cryptography';
-import { createHash, randomUUID, randomBytes, createCipheriv, createDecipheriv, scryptSync } from 'crypto';
+import { createHash, randomBytes, createCipheriv, createDecipheriv, scryptSync } from 'crypto';
 import { access, mkdir, writeFile, readFile } from 'fs/promises';
 import { join, dirname, resolve } from 'path';
 import { homedir } from 'os';
 import { getPools, getLendingPositions, getHealthFactor as getHealthFactor$1, depositCoinPTB, withdrawCoinPTB, borrowCoinPTB, repayCoinPTB, getUserAvailableLendingRewards, summaryLendingRewards, claimLendingRewardsPTB, updateOraclePriceBeforeUserOperationPTB } from '@naviprotocol/lending';
-import { AggregatorClient, Env } from '@cetusprotocol/aggregator-sdk';
-import { SuilendClient, LENDING_MARKET_ID, LENDING_MARKET_TYPE } from '@suilend/sdk/client';
-import { initializeSuilend, initializeObligations } from '@suilend/sdk/lib/initialize';
-import { Side } from '@suilend/sdk/lib/types';
 import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
 
-// src/t2000.ts
-
-// src/constants.ts
-var MIST_PER_SUI = 1000000000n;
-var SUI_DECIMALS = 9;
-var USDC_DECIMALS = 6;
-var BPS_DENOMINATOR = 10000n;
-var AUTO_TOPUP_THRESHOLD = 50000000n;
-var GAS_RESERVE_TARGET = 150000000n;
-var AUTO_TOPUP_AMOUNT = 1000000n;
-var AUTO_TOPUP_MIN_USDC = 2000000n;
-var SAVE_FEE_BPS = 10n;
-var SWAP_FEE_BPS = 0n;
-var BORROW_FEE_BPS = 5n;
-var CLOCK_ID = "0x6";
-var SUPPORTED_ASSETS = {
-  USDC: {
-    type: "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
-    decimals: 6,
-    symbol: "USDC",
-    displayName: "USDC"
-  },
-  USDT: {
-    type: "0x375f70cf2ae4c00bf37117d0c85a2c71545e6ee05c4a5c7d282cd66a4504b068::usdt::USDT",
-    decimals: 6,
-    symbol: "USDT",
-    displayName: "suiUSDT"
-  },
-  USDe: {
-    type: "0x41d587e5336f1c86cad50d38a7136db99333bb9bda91cea4ba69115defeb1402::sui_usde::SUI_USDE",
-    decimals: 6,
-    symbol: "USDe",
-    displayName: "suiUSDe"
-  },
-  USDsui: {
-    type: "0x44f838219cf67b058f3b37907b655f226153c18e33dfcd0da559a844fea9b1c1::usdsui::USDSUI",
-    decimals: 6,
-    symbol: "USDsui",
-    displayName: "USDsui"
-  },
-  SUI: {
-    type: "0x2::sui::SUI",
-    decimals: 9,
-    symbol: "SUI",
-    displayName: "SUI"
-  },
-  BTC: {
-    type: "0x0041f9f9344cac094454cd574e333c4fdb132d7bcc9379bcd4aab485b2a63942::wbtc::WBTC",
-    decimals: 8,
-    symbol: "BTC",
-    displayName: "Bitcoin"
-  },
-  ETH: {
-    type: "0xd0e89b2af5e4910726fbcd8b8dd37bb79b29e5f83f7491bca830e94f7f226d29::eth::ETH",
-    decimals: 8,
-    symbol: "ETH",
-    displayName: "Ethereum"
-  },
-  GOLD: {
-    type: "0x9d297676e7a4b771ab023291377b2adfaa4938fb9080b8d12430e4b108b836a9::xaum::XAUM",
-    decimals: 9,
-    symbol: "GOLD",
-    displayName: "Gold"
-  }
-};
-var STABLE_ASSETS = ["USDC", "USDT", "USDe", "USDsui"];
-var T2000_PACKAGE_ID = process.env.T2000_PACKAGE_ID ?? "0xab92e9f1fe549ad3d6a52924a73181b45791e76120b975138fac9ec9b75db9f3";
-var T2000_CONFIG_ID = process.env.T2000_CONFIG_ID ?? "0x408add9aa9322f93cfd87523d8f603006eb8713894f4c460283c58a6888dae8a";
-var T2000_TREASURY_ID = process.env.T2000_TREASURY_ID ?? "0x3bb501b8300125dca59019247941a42af6b292a150ce3cfcce9449456be2ec91";
-var DEFAULT_NETWORK = "mainnet";
-var DEFAULT_RPC_URL = "https://fullnode.mainnet.sui.io:443";
-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,
-  GOLD: SUPPORTED_ASSETS.GOLD
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-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
-  },
-  "all-weather": {
-    name: "All-Weather Portfolio",
-    allocations: { BTC: 30, ETH: 20, SUI: 20, GOLD: 30 },
-    description: "Crypto and commodities",
-    custom: false
-  },
-  "safe-haven": {
-    name: "Safe Haven",
-    allocations: { BTC: 50, GOLD: 50 },
-    description: "Store-of-value assets",
-    custom: false
-  }
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var PERPS_MARKETS = ["SUI-PERP"];
-var DEFAULT_MAX_LEVERAGE = 5;
-var DEFAULT_MAX_POSITION_SIZE = 1e3;
-var GAS_RESERVE_MIN = 0.05;
 
 // src/errors.ts
-var T2000Error = class extends Error {
-  code;
-  data;
-  retryable;
-  constructor(code, message, data, retryable = false) {
-    super(message);
-    this.name = "T2000Error";
-    this.code = code;
-    this.data = data;
-    this.retryable = retryable;
-  }
-  toJSON() {
-    return {
-      error: this.code,
-      message: this.message,
-      ...this.data && { data: this.data },
-      retryable: this.retryable
-    };
-  }
-};
+var errors_exports = {};
+__export(errors_exports, {
+  T2000Error: () => T2000Error,
+  isMoveAbort: () => isMoveAbort,
+  mapMoveAbortCode: () => mapMoveAbortCode,
+  mapWalletError: () => mapWalletError,
+  parseMoveAbortMessage: () => parseMoveAbortMessage
+});
 function mapWalletError(error) {
   const msg = error instanceof Error ? error.message : String(error);
   if (msg.includes("rejected") || msg.includes("cancelled")) {
@@ -182,9 +59,7 @@ function mapMoveAbortCode(code) {
     1600: "Health factor too low \u2014 withdrawal would risk liquidation",
     1605: "Asset borrowing is disabled or at capacity on this protocol",
     // NAVI utils abort codes
-    46e3: "Insufficient balance to repay \u2014 withdraw some savings first to get cash",
-    // Cetus DEX abort codes
-    46001: "Swap failed \u2014 the DEX pool rejected the trade (liquidity or routing issue). Try again."
+    46e3: "Insufficient balance to repay \u2014 withdraw some savings first to get cash"
   };
   return abortMessages[code] ?? `Move abort code: ${code}`;
 }
@@ -200,7 +75,7 @@ function parseMoveAbortMessage(msg) {
     const context = `${moduleMatch?.[1] ?? ""}${fnMatch ? `::${fnMatch[1]}` : ""}`.toLowerCase();
     const suffix = moduleMatch ? ` [${moduleMatch[1]}${fnMatch ? `::${fnMatch[1]}` : ""}]` : "";
     if (context.includes("slippage")) {
-      return `Swap slippage too high \u2014 price moved during execution${suffix}`;
+      return `Slippage too high \u2014 price moved during execution${suffix}`;
     }
     if (context.includes("balance::split") || context.includes("balance::ENotEnough")) {
       return `Insufficient on-chain balance${suffix}`;
@@ -210,8 +85,296 @@ function parseMoveAbortMessage(msg) {
   }
   return msg;
 }
+var T2000Error;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    T2000Error = class extends Error {
+      code;
+      data;
+      retryable;
+      constructor(code, message, data, retryable = false) {
+        super(message);
+        this.name = "T2000Error";
+        this.code = code;
+        this.data = data;
+        this.retryable = retryable;
+      }
+      toJSON() {
+        return {
+          error: this.code,
+          message: this.message,
+          ...this.data && { data: this.data },
+          retryable: this.retryable
+        };
+      }
+    };
+  }
+});
+
+// src/protocols/volo.ts
+var volo_exports = {};
+__export(volo_exports, {
+  MIN_STAKE_MIST: () => MIN_STAKE_MIST,
+  SUI_SYSTEM_STATE: () => SUI_SYSTEM_STATE,
+  VOLO_METADATA: () => VOLO_METADATA,
+  VOLO_PKG: () => VOLO_PKG,
+  VOLO_POOL: () => VOLO_POOL,
+  VSUI_TYPE: () => VSUI_TYPE,
+  buildStakeVSuiTx: () => buildStakeVSuiTx,
+  buildUnstakeVSuiTx: () => buildUnstakeVSuiTx,
+  getVoloStats: () => getVoloStats
+});
+async function getVoloStats() {
+  const res = await fetch(VOLO_STATS_URL, {
+    signal: AbortSignal.timeout(8e3)
+  });
+  if (!res.ok) {
+    throw new Error(`VOLO stats API error: HTTP ${res.status}`);
+  }
+  const data = await res.json();
+  const d = data.data ?? data;
+  return {
+    apy: d.apy ?? 0,
+    exchangeRate: d.exchange_rate ?? d.exchangeRate ?? 1,
+    tvl: d.tvl ?? 0
+  };
+}
+async function buildStakeVSuiTx(_client, address, amountMist) {
+  if (amountMist < MIN_STAKE_MIST) {
+    throw new Error(`Minimum stake is 1 SUI (${MIN_STAKE_MIST} MIST). Got: ${amountMist}`);
+  }
+  const tx = new Transaction();
+  tx.setSender(address);
+  const [suiCoin] = tx.splitCoins(tx.gas, [amountMist]);
+  const [vSuiCoin] = tx.moveCall({
+    target: `${VOLO_PKG}::stake_pool::stake`,
+    arguments: [
+      tx.object(VOLO_POOL),
+      tx.object(VOLO_METADATA),
+      tx.object(SUI_SYSTEM_STATE),
+      suiCoin
+    ]
+  });
+  tx.transferObjects([vSuiCoin], address);
+  return tx;
+}
+async function buildUnstakeVSuiTx(client, address, amountMist) {
+  const coins = await fetchVSuiCoins(client, address);
+  if (coins.length === 0) {
+    throw new Error("No vSUI found in wallet.");
+  }
+  const tx = new Transaction();
+  tx.setSender(address);
+  const primary = tx.object(coins[0].coinObjectId);
+  if (coins.length > 1) {
+    tx.mergeCoins(primary, coins.slice(1).map((c) => tx.object(c.coinObjectId)));
+  }
+  let vSuiCoin;
+  if (amountMist === "all") {
+    vSuiCoin = primary;
+  } else {
+    [vSuiCoin] = tx.splitCoins(primary, [amountMist]);
+  }
+  const [suiCoin] = tx.moveCall({
+    target: `${VOLO_PKG}::stake_pool::unstake`,
+    arguments: [
+      tx.object(VOLO_POOL),
+      tx.object(VOLO_METADATA),
+      tx.object(SUI_SYSTEM_STATE),
+      vSuiCoin
+    ]
+  });
+  tx.transferObjects([suiCoin], address);
+  return tx;
+}
+async function fetchVSuiCoins(client, address) {
+  const all = [];
+  let cursor;
+  let hasNext = true;
+  while (hasNext) {
+    const page = await client.getCoins({
+      owner: address,
+      coinType: VSUI_TYPE,
+      cursor: cursor ?? void 0
+    });
+    all.push(...page.data.map((c) => ({ coinObjectId: c.coinObjectId, balance: c.balance })));
+    cursor = page.nextCursor;
+    hasNext = page.hasNextPage;
+  }
+  return all;
+}
+var VOLO_PKG, VOLO_POOL, VOLO_METADATA, VSUI_TYPE, SUI_SYSTEM_STATE, MIN_STAKE_MIST, VOLO_STATS_URL;
+var init_volo = __esm({
+  "src/protocols/volo.ts"() {
+    VOLO_PKG = "0x68d22cf8bdbcd11ecba1e094922873e4080d4d11133e2443fddda0bfd11dae20";
+    VOLO_POOL = "0x2d914e23d82fedef1b5f56a32d5c64bdcc3087ccfea2b4d6ea51a71f587840e5";
+    VOLO_METADATA = "0x680cd26af32b2bde8d3361e804c53ec1d1cfe24c7f039eb7f549e8dfde389a60";
+    VSUI_TYPE = "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55::cert::CERT";
+    SUI_SYSTEM_STATE = "0x05";
+    MIN_STAKE_MIST = 1000000000n;
+    VOLO_STATS_URL = "https://open-api.naviprotocol.io/api/volo/stats";
+  }
+});
+
+// src/protocols/cetus-swap.ts
+var cetus_swap_exports = {};
+__export(cetus_swap_exports, {
+  TOKEN_MAP: () => TOKEN_MAP,
+  buildSwapTx: () => buildSwapTx,
+  findSwapRoute: () => findSwapRoute,
+  resolveTokenType: () => resolveTokenType,
+  simulateSwap: () => simulateSwap
+});
+function getClient(walletAddress) {
+  if (clientInstance) return clientInstance;
+  clientInstance = new AggregatorClient({
+    signer: walletAddress,
+    env: Env.Mainnet
+  });
+  return clientInstance;
+}
+async function findSwapRoute(params) {
+  const client = getClient(params.walletAddress);
+  const findParams = {
+    from: params.from,
+    target: params.to,
+    amount: params.amount.toString(),
+    byAmountIn: params.byAmountIn
+  };
+  const routerData = await client.findRouters(findParams);
+  if (!routerData) return null;
+  if (routerData.insufficientLiquidity) {
+    return {
+      routerData,
+      amountIn: routerData.amountIn.toString(),
+      amountOut: routerData.amountOut.toString(),
+      byAmountIn: params.byAmountIn,
+      priceImpact: routerData.deviationRatio,
+      insufficientLiquidity: true
+    };
+  }
+  if (routerData.error) {
+    const { T2000Error: T2000Error2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
+    throw new T2000Error2("SWAP_FAILED", `Cetus routing error: ${routerData.error.msg} (code ${routerData.error.code})`);
+  }
+  return {
+    routerData,
+    amountIn: routerData.amountIn.toString(),
+    amountOut: routerData.amountOut.toString(),
+    byAmountIn: params.byAmountIn,
+    priceImpact: routerData.deviationRatio,
+    insufficientLiquidity: false
+  };
+}
+async function buildSwapTx(params) {
+  const client = getClient(params.walletAddress);
+  const clampedSlippage = Math.max(1e-3, Math.min(params.slippage, 0.05));
+  const outputCoin = await client.routerSwap({
+    router: params.route.routerData,
+    inputCoin: params.inputCoin,
+    slippage: clampedSlippage,
+    txb: params.tx
+  });
+  return outputCoin;
+}
+async function simulateSwap(params) {
+  const client = getClient(params.walletAddress);
+  try {
+    await client.devInspectTransactionBlock(params.tx);
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function resolveTokenType(nameOrType) {
+  if (nameOrType.includes("::")) return nameOrType;
+  return TOKEN_MAP[nameOrType.toUpperCase()] ?? null;
+}
+var clientInstance, TOKEN_MAP;
+var init_cetus_swap = __esm({
+  "src/protocols/cetus-swap.ts"() {
+    clientInstance = null;
+    TOKEN_MAP = {
+      SUI: "0x2::sui::SUI",
+      USDC: "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
+      USDT: "0x375f70cf2ae4c00bf37117d0c85a2c71545e6ee05c4a5c7d282cd66a4504b068::usdt::USDT",
+      CETUS: "0x06864a6f921804860930db6ddbe2e16acdf8504495ea7481637a1c8b9a8fe54b::cetus::CETUS",
+      DEEP: "0xdeeb7a4662eec9f2f3def03fb937a663dddaa2e215b8078a284d026b7946c270::deep::DEEP",
+      NAVX: "0xa99b8952d4f7d947ea77fe0ecdcc9e5fc0bcab2841d6e2a5aa00c3044e5544b5::navx::NAVX",
+      vSUI: "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55::cert::CERT",
+      haSUI: "0xbde4ba4c2e274a60ce15c1cfff9e5c42e136a8bc::hasui::HASUI",
+      afSUI: "0xf325ce1300e8dac124071d3152c5c5ee6174914f8bc2161e88329cf579246efc::afsui::AFSUI",
+      WAL: "0x356a26eb9e012a68958082340d4c4116e7f55615cf27affcff209cf0ae544f59::wal::WAL",
+      ETH: "0xd0e89b2af5e4910726fbcd8b8dd37bb79b29e5f83f7491bca830e94f7f226d29::eth::ETH",
+      wBTC: "0x0041f9f9344cac094454cd574e333c4fdb132d7bcc9379bcd4aab485b2a63942::wbtc::WBTC",
+      FDUSD: "0xf16e6b723f242ec745dfd7634ad072c42d5c1d9ac9d62a39c381303eaa57693a::fdusd::FDUSD",
+      AUSD: "0x2053d08c1e2bd02791056171aab0fd12bd7cd7efad2ab8f6b9c8902f14df2ff2::ausd::AUSD",
+      BUCK: "0xce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::buck::BUCK",
+      USDe: "0x41d587e5336f1c86cad50d38a7136db99333bb9bda91cea4ba69115defeb1402::sui_usde::SUI_USDE",
+      NS: "0x5145494a5f5100e645e4b0aa950fa6b68f614e8c59e17bc5ded3495123a79178::ns::NS",
+      BLUB: "0xfa7ac3951fdca12c1b6d18eb19e1aa2fbc31e4d45773c8e45b4ded3ef8d83f8a::blub::BLUB",
+      SCA: "0x7016aae72cfc67f2fadf55769c0a7dd54291a583b63051a5ed71081cce836ac6::sca::SCA",
+      TURBOS: "0x5d1f47ea69bb0de31c313d7acf89b890dbb8991ea8e03c6c355171f84bb1ba4a::turbos::TURBOS"
+    };
+  }
+});
+
+// src/constants.ts
+var MIST_PER_SUI = 1000000000n;
+var SUI_DECIMALS = 9;
+var USDC_DECIMALS = 6;
+var BPS_DENOMINATOR = 10000n;
+var AUTO_TOPUP_THRESHOLD = 50000000n;
+var GAS_RESERVE_TARGET = 150000000n;
+var AUTO_TOPUP_MIN_USDC = 2000000n;
+var SAVE_FEE_BPS = 10n;
+var BORROW_FEE_BPS = 5n;
+var CLOCK_ID = "0x6";
+var SUPPORTED_ASSETS = {
+  USDC: {
+    type: "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
+    decimals: 6,
+    symbol: "USDC",
+    displayName: "USDC"
+  },
+  USDT: {
+    type: "0x375f70cf2ae4c00bf37117d0c85a2c71545e6ee05c4a5c7d282cd66a4504b068::usdt::USDT",
+    decimals: 6,
+    symbol: "USDT",
+    displayName: "suiUSDT"
+  },
+  USDe: {
+    type: "0x41d587e5336f1c86cad50d38a7136db99333bb9bda91cea4ba69115defeb1402::sui_usde::SUI_USDE",
+    decimals: 6,
+    symbol: "USDe",
+    displayName: "suiUSDe"
+  },
+  USDsui: {
+    type: "0x44f838219cf67b058f3b37907b655f226153c18e33dfcd0da559a844fea9b1c1::usdsui::USDSUI",
+    decimals: 6,
+    symbol: "USDsui",
+    displayName: "USDsui"
+  },
+  SUI: {
+    type: "0x2::sui::SUI",
+    decimals: 9,
+    symbol: "SUI",
+    displayName: "SUI"
+  }
+};
+var STABLE_ASSETS = ["USDC"];
+var T2000_PACKAGE_ID = process.env.T2000_PACKAGE_ID ?? "0xab92e9f1fe549ad3d6a52924a73181b45791e76120b975138fac9ec9b75db9f3";
+var T2000_CONFIG_ID = process.env.T2000_CONFIG_ID ?? "0x408add9aa9322f93cfd87523d8f603006eb8713894f4c460283c58a6888dae8a";
+var T2000_TREASURY_ID = process.env.T2000_TREASURY_ID ?? "0x3bb501b8300125dca59019247941a42af6b292a150ce3cfcce9449456be2ec91";
+var DEFAULT_NETWORK = "mainnet";
+var DEFAULT_RPC_URL = "https://fullnode.mainnet.sui.io:443";
+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 GAS_RESERVE_MIN = 0.05;
 
 // src/utils/sui.ts
+init_errors();
 var cachedClient = null;
 function getSuiClient(rpcUrl) {
   const url = rpcUrl ?? DEFAULT_RPC_URL;
@@ -230,6 +393,9 @@ function truncateAddress(address) {
   if (address.length <= 10) return address;
   return `${address.slice(0, 6)}...${address.slice(-4)}`;
 }
+
+// src/wallet/keyManager.ts
+init_errors();
 var ALGORITHM = "aes-256-gcm";
 var SCRYPT_N = 2 ** 14;
 var SCRYPT_R = 8;
@@ -371,6 +537,7 @@ var ZkLoginSigner = class {
     return currentEpoch >= this.maxEpoch;
   }
 };
+init_errors();
 
 // src/utils/format.ts
 function mistToSui(mist) {
@@ -496,18 +663,11 @@ async function queryBalance(client, address) {
   const stableBalancePromises = STABLE_ASSETS.map(
     (asset) => client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS[asset].type }).then((b) => ({ asset, amount: Number(b.totalBalance) / 10 ** SUPPORTED_ASSETS[asset].decimals })).catch(() => ({ asset, amount: 0 }))
   );
-  const nonSuiInvestmentAssets = Object.keys(INVESTMENT_ASSETS).filter((a) => a !== "SUI");
-  const investBalancePromises = nonSuiInvestmentAssets.map(
-    (asset) => client.getBalance({ owner: address, coinType: INVESTMENT_ASSETS[asset].type }).then((b) => ({ asset, amount: Number(b.totalBalance) / 10 ** INVESTMENT_ASSETS[asset].decimals })).catch(() => ({ asset, amount: 0 }))
-  );
-  const [suiBalance, suiPriceUsd, ...rest] = await Promise.all([
+  const [suiBalance, suiPriceUsd, ...stableResults] = await Promise.all([
     client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.SUI.type }),
     fetchSuiPrice(client),
-    ...stableBalancePromises,
-    ...investBalancePromises
+    ...stableBalancePromises
   ]);
-  const stableResults = rest.slice(0, STABLE_ASSETS.length);
-  const investResults = rest.slice(STABLE_ASSETS.length);
   const stables = {};
   let totalStables = 0;
   for (const { asset, amount } of stableResults) {
@@ -518,27 +678,17 @@ async function queryBalance(client, address) {
   const savings = 0;
   const usdEquiv = suiAmount * suiPriceUsd;
   const total = totalStables + savings + usdEquiv;
-  const assets = {
-    USDC: stables.USDC ?? 0,
-    SUI: suiAmount
-  };
-  for (const { asset, amount } of investResults) {
-    assets[asset] = amount;
-  }
   return {
     available: totalStables,
     savings,
     debt: 0,
-    investment: 0,
-    investmentPnL: 0,
     pendingRewards: 0,
     gasReserve: {
       sui: suiAmount,
       usdEquiv
     },
     total,
-    stables,
-    assets
+    stables
   };
 }
 
@@ -645,12 +795,10 @@ function classifyAction(targets, commandTypes) {
 // src/protocols/protocolFee.ts
 var FEE_RATES = {
   save: SAVE_FEE_BPS,
-  swap: SWAP_FEE_BPS,
   borrow: BORROW_FEE_BPS
 };
 var OP_CODES = {
   save: 0,
-  swap: 1,
   borrow: 2
 };
 function calculateFee(operation, amount) {
@@ -694,6 +842,7 @@ async function reportFee(agentAddress, operation, feeAmount, feeRate, txDigest)
   } catch {
   }
 }
+init_errors();
 var MIN_HEALTH_FACTOR = 1.5;
 var NAVI_SUPPORTED_ASSETS = [...STABLE_ASSETS, "SUI", "ETH", "GOLD"];
 function sdkOptions(client) {
@@ -1127,15 +1276,12 @@ async function getFundStatus(client, address) {
 }
 
 // src/adapters/registry.ts
+init_errors();
 var ProtocolRegistry = class {
   lending = /* @__PURE__ */ new Map();
-  swap = /* @__PURE__ */ new Map();
   registerLending(adapter) {
     this.lending.set(adapter.id, adapter);
   }
-  registerSwap(adapter) {
-    this.swap.set(adapter.id, adapter);
-  }
   async bestSaveRate(asset) {
     const candidates = [];
     for (const adapter of this.lending.values()) {
@@ -1171,23 +1317,6 @@ var ProtocolRegistry = class {
     candidates.sort((a, b) => a.rate.borrowApy - b.rate.borrowApy);
     return candidates[0];
   }
-  async bestSwapQuote(from, to, amount) {
-    const candidates = [];
-    for (const adapter of this.swap.values()) {
-      const pairs = adapter.getSupportedPairs();
-      if (!pairs.some((p) => p.from === from && p.to === to)) continue;
-      try {
-        const quote = await adapter.getQuote(from, to, amount);
-        candidates.push({ adapter, quote });
-      } catch {
-      }
-    }
-    if (candidates.length === 0) {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `No swap adapter supports ${from} \u2192 ${to}`);
-    }
-    candidates.sort((a, b) => b.quote.expectedOutput - a.quote.expectedOutput);
-    return candidates[0];
-  }
   async bestSaveRateAcrossAssets() {
     const candidates = [];
     for (const asset of STABLE_ASSETS) {
@@ -1209,9 +1338,8 @@ var ProtocolRegistry = class {
   }
   async allRatesAcrossAssets() {
     const results = [];
-    const allAssets = [...STABLE_ASSETS, ...Object.keys(INVESTMENT_ASSETS)];
     const seen = /* @__PURE__ */ new Set();
-    for (const asset of allAssets) {
+    for (const asset of STABLE_ASSETS) {
       if (seen.has(asset)) continue;
       seen.add(asset);
       for (const adapter of this.lending.values()) {
@@ -1260,19 +1388,15 @@ var ProtocolRegistry = class {
   getLending(id) {
     return this.lending.get(id);
   }
-  getSwap(id) {
-    return this.swap.get(id);
-  }
   listLending() {
     return [...this.lending.values()];
   }
-  listSwap() {
-    return [...this.swap.values()];
-  }
 };
 
+// src/adapters/navi.ts
+init_errors();
+
 // src/adapters/descriptors.ts
-var SUILEND_PACKAGE = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf";
 var naviDescriptor = {
   id: "navi",
   name: "NAVI Protocol",
@@ -1289,39 +1413,8 @@ var naviDescriptor = {
     "incentive_v3::repay": "repay"
   }
 };
-var suilendDescriptor = {
-  id: "suilend",
-  name: "Suilend",
-  packages: [SUILEND_PACKAGE],
-  actionMap: {
-    "lending_market::deposit_liquidity_and_mint_ctokens": "save",
-    "lending_market::deposit_ctokens_into_obligation": "save",
-    "lending_market::create_obligation": "save",
-    "lending_market::withdraw_ctokens": "withdraw",
-    "lending_market::redeem_ctokens_and_withdraw_liquidity": "withdraw",
-    "lending_market::redeem_ctokens_and_withdraw_liquidity_request": "withdraw",
-    "lending_market::fulfill_liquidity_request": "withdraw",
-    "lending_market::unstake_sui_from_staker": "withdraw",
-    "lending_market::borrow": "borrow",
-    "lending_market::repay": "repay"
-  }
-};
-var cetusDescriptor = {
-  id: "cetus",
-  name: "Cetus DEX",
-  packages: [CETUS_PACKAGE],
-  actionMap: {
-    "router::swap": "swap",
-    "router::swap_ab_bc": "swap",
-    "router::swap_ab_cb": "swap",
-    "router::swap_ba_bc": "swap",
-    "router::swap_ba_cb": "swap"
-  }
-};
 var allDescriptors = [
-  naviDescriptor,
-  suilendDescriptor,
-  cetusDescriptor
+  naviDescriptor
 ];
 
 // src/adapters/navi.ts
@@ -1405,712 +1498,52 @@ var NaviAdapter = class {
     return addClaimRewardsToTx(tx, this.client, address);
   }
 };
-var DEFAULT_SLIPPAGE_BPS = 300;
-function createAggregatorClient(client, signer) {
-  return new AggregatorClient({
-    client,
-    signer,
-    env: Env.Mainnet
-  });
-}
-async function buildSwapTx(params) {
-  const { client, address, fromAsset, toAsset, amount, maxSlippageBps = DEFAULT_SLIPPAGE_BPS } = params;
-  const fromInfo = SUPPORTED_ASSETS[fromAsset];
-  const toInfo = SUPPORTED_ASSETS[toAsset];
-  if (!fromInfo || !toInfo) {
-    throw new T2000Error("ASSET_NOT_SUPPORTED", `Swap pair ${fromAsset}/${toAsset} is not supported`);
-  }
-  const rawAmount = BigInt(Math.floor(amount * 10 ** fromInfo.decimals));
-  const aggClient = createAggregatorClient(client, address);
-  const _origLog = console.log;
-  console.log = () => {
-  };
-  let result;
-  try {
-    result = await aggClient.findRouters({
-      from: fromInfo.type,
-      target: toInfo.type,
-      amount: rawAmount,
-      byAmountIn: true
-    });
-  } finally {
-    console.log = _origLog;
-  }
-  if (!result || result.insufficientLiquidity) {
-    throw new T2000Error(
-      "ASSET_NOT_SUPPORTED",
-      `No swap route found for ${fromAsset} \u2192 ${toAsset}`
-    );
+function hasLeadingZeroBits(hash, bits) {
+  const fullBytes = Math.floor(bits / 8);
+  const remainingBits = bits % 8;
+  for (let i = 0; i < fullBytes; i++) {
+    if (hash[i] !== 0) return false;
   }
-  const tx = new Transaction();
-  const slippage = maxSlippageBps / 1e4;
-  console.log = () => {
-  };
-  try {
-    await aggClient.fastRouterSwap({
-      router: result,
-      txb: tx,
-      slippage
-    });
-  } finally {
-    console.log = _origLog;
+  if (remainingBits > 0) {
+    const mask = 255 << 8 - remainingBits;
+    if ((hash[fullBytes] & mask) !== 0) return false;
   }
-  const estimatedOut = Number(result.amountOut.toString());
-  return {
-    tx,
-    estimatedOut,
-    toDecimals: toInfo.decimals
-  };
+  return true;
 }
-async function addSwapToTx(params) {
-  const { tx, client, address, inputCoin, fromAsset, toAsset, amount, maxSlippageBps = DEFAULT_SLIPPAGE_BPS } = params;
-  const fromInfo = SUPPORTED_ASSETS[fromAsset];
-  const toInfo = SUPPORTED_ASSETS[toAsset];
-  if (!fromInfo || !toInfo) {
-    throw new T2000Error("ASSET_NOT_SUPPORTED", `Swap pair ${fromAsset}/${toAsset} is not supported`);
-  }
-  const rawAmount = BigInt(Math.floor(amount * 10 ** fromInfo.decimals));
-  const aggClient = createAggregatorClient(client, address);
-  const _origLog = console.log;
-  console.log = () => {
-  };
-  let result;
-  try {
-    result = await aggClient.findRouters({
-      from: fromInfo.type,
-      target: toInfo.type,
-      amount: rawAmount,
-      byAmountIn: true
-    });
-  } finally {
-    console.log = _origLog;
+function solveHashcash(challenge) {
+  const bits = parseInt(challenge.split(":")[1], 10);
+  let counter = 0;
+  while (true) {
+    const stamp = `${challenge}${counter.toString(16)}`;
+    const hash = createHash("sha256").update(stamp).digest();
+    if (hasLeadingZeroBits(hash, bits)) return stamp;
+    counter++;
   }
-  if (!result || result.insufficientLiquidity) {
-    throw new T2000Error(
-      "ASSET_NOT_SUPPORTED",
-      `No swap route found for ${fromAsset} \u2192 ${toAsset}`
-    );
-  }
-  const slippage = maxSlippageBps / 1e4;
-  console.log = () => {
-  };
-  let outputCoin;
-  try {
-    outputCoin = await aggClient.routerSwap({
-      router: result,
-      txb: tx,
-      inputCoin,
-      slippage
-    });
-  } finally {
-    console.log = _origLog;
-  }
-  const estimatedOut = Number(result.amountOut.toString());
-  return {
-    outputCoin,
-    estimatedOut,
-    toDecimals: toInfo.decimals
-  };
-}
-async function buildRawSwapTx(params) {
-  const { client, address, fromCoinType, toCoinType, amount, toDecimals, maxSlippageBps = 500 } = params;
-  const aggClient = createAggregatorClient(client, address);
-  const _origLog = console.log;
-  console.log = () => {
-  };
-  let result;
-  try {
-    result = await aggClient.findRouters({
-      from: fromCoinType,
-      target: toCoinType,
-      amount,
-      byAmountIn: true
-    });
-  } finally {
-    console.log = _origLog;
-  }
-  if (!result || result.insufficientLiquidity) {
-    throw new T2000Error("ASSET_NOT_SUPPORTED", `No swap route for reward token \u2192 USDC`);
-  }
-  const tx = new Transaction();
-  const slippage = maxSlippageBps / 1e4;
-  console.log = () => {
-  };
-  try {
-    await aggClient.fastRouterSwap({
-      router: result,
-      txb: tx,
-      slippage
-    });
-  } finally {
-    console.log = _origLog;
-  }
-  return {
-    tx,
-    estimatedOut: Number(result.amountOut.toString()),
-    toDecimals
-  };
-}
-async function getPoolPrice(client) {
-  try {
-    const pool = await client.getObject({
-      id: CETUS_USDC_SUI_POOL,
-      options: { showContent: true }
-    });
-    if (pool.data?.content?.dataType === "moveObject") {
-      const fields = pool.data.content.fields;
-      const currentSqrtPrice = BigInt(String(fields.current_sqrt_price ?? "0"));
-      if (currentSqrtPrice > 0n) {
-        const Q64 = 2n ** 64n;
-        const sqrtPriceFloat = Number(currentSqrtPrice) / Number(Q64);
-        const rawPrice = sqrtPriceFloat * sqrtPriceFloat;
-        const suiPriceUsd = 1e3 / rawPrice;
-        if (suiPriceUsd > 0.01 && suiPriceUsd < 1e3) return suiPriceUsd;
-      }
-    }
-  } catch {
-  }
-  return 3.5;
-}
-async function getSwapQuote(client, fromAsset, toAsset, amount) {
-  const fromInfo = SUPPORTED_ASSETS[fromAsset];
-  const toInfo = SUPPORTED_ASSETS[toAsset];
-  if (!fromInfo || !toInfo) {
-    throw new T2000Error("ASSET_NOT_SUPPORTED", `Swap pair ${fromAsset}/${toAsset} is not supported`);
-  }
-  const rawAmount = BigInt(Math.floor(amount * 10 ** fromInfo.decimals));
-  const poolPrice = await getPoolPrice(client);
-  try {
-    const aggClient = createAggregatorClient(client);
-    const result = await aggClient.findRouters({
-      from: fromInfo.type,
-      target: toInfo.type,
-      amount: rawAmount,
-      byAmountIn: true
-    });
-    if (!result || result.insufficientLiquidity) {
-      return fallbackQuote(fromAsset, amount, poolPrice);
-    }
-    const expectedOutput = Number(result.amountOut.toString()) / 10 ** toInfo.decimals;
-    const priceImpact = result.deviationRatio ?? 0;
-    return { expectedOutput, priceImpact, poolPrice };
-  } catch {
-    return fallbackQuote(fromAsset, amount, poolPrice);
-  }
-}
-function fallbackQuote(fromAsset, amount, poolPrice) {
-  const expectedOutput = fromAsset === "USDC" ? amount / poolPrice : amount * poolPrice;
-  return { expectedOutput, priceImpact: 0, poolPrice };
 }
 
-// src/adapters/cetus.ts
-var CetusAdapter = class {
-  id = "cetus";
-  name = "Cetus";
-  version = "1.0.0";
-  capabilities = ["swap"];
-  client;
-  async init(client) {
-    this.client = client;
-  }
-  initSync(client) {
-    this.client = client;
-  }
-  async getQuote(from, to, amount) {
-    return getSwapQuote(this.client, from, to, amount);
-  }
-  async buildSwapTx(address, from, to, amount, maxSlippageBps) {
-    const result = await buildSwapTx({
-      client: this.client,
-      address,
-      fromAsset: from,
-      toAsset: to,
-      amount,
-      maxSlippageBps
-    });
-    return {
-      tx: result.tx,
-      estimatedOut: result.estimatedOut,
-      toDecimals: result.toDecimals
-    };
-  }
-  getSupportedPairs() {
-    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 });
-      }
-    }
-    return pairs;
-  }
-  async getPoolPrice() {
-    return getPoolPrice(this.client);
-  }
-  async addSwapToTx(tx, address, inputCoin, from, to, amount, maxSlippageBps) {
-    return addSwapToTx({
-      tx,
-      client: this.client,
-      address,
-      inputCoin,
-      fromAsset: from,
-      toAsset: to,
-      amount,
-      maxSlippageBps
-    });
-  }
-};
-var MIN_HEALTH_FACTOR2 = 1.5;
-async function quietSuilend(fn) {
-  const origLog = console.log;
-  const origWarn = console.warn;
-  const filter = (...args) => typeof args[0] === "string" && (args[0].includes("PythEndpoint") || args[0].includes("PythConnection"));
-  console.log = (...args) => {
-    if (!filter(...args)) origLog.apply(console, args);
-  };
-  console.warn = (...args) => {
-    if (!filter(...args)) origWarn.apply(console, args);
-  };
-  return fn().finally(() => {
-    console.log = origLog;
-    console.warn = origWarn;
-  });
-}
-var SuilendAdapter = class {
-  id = "suilend";
-  name = "Suilend";
-  version = "3.0.0";
-  capabilities = ["save", "withdraw", "borrow", "repay"];
-  supportedAssets = [...STABLE_ASSETS, "SUI", "ETH", "BTC", "GOLD"];
-  supportsSameAssetBorrow = false;
-  client;
-  sdkClient = null;
-  async init(client) {
-    this.client = client;
-  }
-  initSync(client) {
-    this.client = client;
-  }
-  async getSdkClient() {
-    if (!this.sdkClient) {
-      this.sdkClient = await SuilendClient.initialize(
-        LENDING_MARKET_ID,
-        LENDING_MARKET_TYPE,
-        this.client,
-        false
-      );
-    }
-    return this.sdkClient;
-  }
-  resolveSymbol(coinType) {
-    try {
-      const normalized = normalizeStructTag(coinType);
-      for (const [key, info] of Object.entries(SUPPORTED_ASSETS)) {
-        try {
-          if (normalizeStructTag(info.type) === normalized) return key;
-        } catch {
-        }
-      }
-    } catch {
-    }
-    const parts = coinType.split("::");
-    return parts[parts.length - 1] || "UNKNOWN";
-  }
-  async getRates(asset) {
-    try {
-      const sdk = await this.getSdkClient();
-      const { reserveMap } = await quietSuilend(() => initializeSuilend(this.client, sdk));
-      const assetInfo = SUPPORTED_ASSETS[asset];
-      if (!assetInfo) throw new T2000Error("ASSET_NOT_SUPPORTED", `Suilend does not support ${asset}`);
-      const normalized = normalizeStructTag(assetInfo.type);
-      const reserve = Object.values(reserveMap).find((r) => {
-        try {
-          return normalizeStructTag(r.coinType) === normalized;
-        } catch {
-          return false;
-        }
-      });
-      if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `Suilend does not support ${asset}`);
-      return {
-        asset,
-        saveApy: reserve.depositAprPercent.toNumber(),
-        borrowApy: reserve.borrowAprPercent.toNumber()
-      };
-    } catch (err) {
-      if (err instanceof T2000Error) throw err;
-      const msg = err instanceof Error ? err.message : String(err);
-      throw new T2000Error("PROTOCOL_UNAVAILABLE", `Suilend getRates failed: ${msg}`);
-    }
-  }
-  async getPositions(address) {
-    const supplies = [];
-    const borrows = [];
-    try {
-      const sdk = await this.getSdkClient();
-      const { reserveMap, refreshedRawReserves } = await quietSuilend(() => initializeSuilend(this.client, sdk));
-      const { obligations, obligationOwnerCaps } = await initializeObligations(
-        this.client,
-        sdk,
-        refreshedRawReserves,
-        reserveMap,
-        address
-      );
-      if (obligationOwnerCaps.length === 0 || obligations.length === 0) {
-        return { supplies, borrows };
-      }
-      const obligation = obligations[0];
-      for (const dep of obligation.deposits) {
-        const symbol = this.resolveSymbol(dep.coinType);
-        const amount = dep.depositedAmount.toNumber();
-        const amountUsd = dep.depositedAmountUsd.toNumber();
-        const apy = dep.reserve.depositAprPercent.toNumber();
-        if (amountUsd > 0.01) {
-          supplies.push({ asset: symbol, amount, amountUsd, apy });
-        }
-      }
-      for (const bor of obligation.borrows) {
-        const symbol = this.resolveSymbol(bor.coinType);
-        const amount = bor.borrowedAmount.toNumber();
-        const amountUsd = bor.borrowedAmountUsd.toNumber();
-        const apy = bor.reserve.borrowAprPercent.toNumber();
-        if (amountUsd > 0.01) {
-          borrows.push({ asset: symbol, amount, amountUsd, apy });
-        }
-      }
-    } catch (err) {
-      if (err instanceof T2000Error) throw err;
-      const msg = err instanceof Error ? err.message : String(err);
-      throw new T2000Error("PROTOCOL_UNAVAILABLE", `Suilend getPositions failed: ${msg}`);
-    }
-    return { supplies, borrows };
-  }
-  async getHealth(address) {
-    try {
-      const sdk = await this.getSdkClient();
-      const { reserveMap, refreshedRawReserves } = await quietSuilend(() => initializeSuilend(this.client, sdk));
-      const { obligations, obligationOwnerCaps } = await initializeObligations(
-        this.client,
-        sdk,
-        refreshedRawReserves,
-        reserveMap,
-        address
-      );
-      if (obligationOwnerCaps.length === 0 || obligations.length === 0) {
-        return { healthFactor: Infinity, supplied: 0, borrowed: 0, maxBorrow: 0, liquidationThreshold: 0 };
-      }
-      const ob = obligations[0];
-      const supplied = ob.depositedAmountUsd.toNumber();
-      const borrowed = ob.borrowedAmountUsd.toNumber();
-      const borrowLimit = ob.borrowLimitUsd.toNumber();
-      const unhealthy = ob.unhealthyBorrowValueUsd.toNumber();
-      const liqThreshold = supplied > 0 ? unhealthy / supplied : 0.75;
-      const healthFactor = borrowed > 0 ? unhealthy / borrowed : Infinity;
-      const maxBorrow = Math.max(0, borrowLimit - borrowed);
-      return { healthFactor, supplied, borrowed, maxBorrow, liquidationThreshold: liqThreshold };
-    } catch {
-      return { healthFactor: Infinity, supplied: 0, borrowed: 0, maxBorrow: 0, liquidationThreshold: 0 };
-    }
-  }
-  async buildSaveTx(address, amount, asset, options) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const sdk = await this.getSdkClient();
-    const caps = await SuilendClient.getObligationOwnerCaps(address, [LENDING_MARKET_TYPE], this.client);
-    const tx = new Transaction();
-    tx.setSender(address);
-    const rawValue = stableToRaw(amount, assetInfo.decimals).toString();
-    if (caps.length > 0) {
-      if (options?.collectFee) {
-        const allCoins = await this.fetchAllCoins(address, assetInfo.type);
-        if (allCoins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} coins found`);
-        const primaryCoinId = allCoins[0].coinObjectId;
-        if (allCoins.length > 1) {
-          tx.mergeCoins(tx.object(primaryCoinId), allCoins.slice(1).map((c) => tx.object(c.coinObjectId)));
-        }
-        const [depositCoin] = tx.splitCoins(tx.object(primaryCoinId), [rawValue]);
-        addCollectFeeToTx(tx, depositCoin, "save");
-      }
-      await sdk.depositIntoObligation(address, assetInfo.type, rawValue, tx, caps[0].id);
-    } else {
-      const newCap = sdk.createObligation(tx);
-      let depositCoin;
-      if (assetKey === "SUI") {
-        [depositCoin] = tx.splitCoins(tx.gas, [rawValue]);
-      } else {
-        const allCoins = await this.fetchAllCoins(address, assetInfo.type);
-        if (allCoins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} coins found`);
-        const primaryCoin = tx.object(allCoins[0].coinObjectId);
-        if (allCoins.length > 1) {
-          tx.mergeCoins(primaryCoin, allCoins.slice(1).map((c) => tx.object(c.coinObjectId)));
-        }
-        [depositCoin] = tx.splitCoins(primaryCoin, [rawValue]);
-      }
-      if (options?.collectFee) {
-        addCollectFeeToTx(tx, depositCoin, "save");
-      }
-      sdk.deposit(depositCoin, assetInfo.type, newCap, tx);
-      tx.transferObjects([newCap], address);
-    }
-    return { tx };
-  }
-  async buildWithdrawTx(address, amount, asset) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const sdk = await this.getSdkClient();
-    const caps = await SuilendClient.getObligationOwnerCaps(address, [LENDING_MARKET_TYPE], this.client);
-    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend position found");
-    const { ctokenRaw, effectiveAmount, obligationIndex } = await this.resolveWithdrawCTokens(sdk, address, assetKey, assetInfo, amount);
-    const cap = caps[obligationIndex] ?? caps[0];
-    const tx = new Transaction();
-    tx.setSender(address);
-    await sdk.withdrawAndSendToUser(address, cap.id, cap.obligationId, assetInfo.type, ctokenRaw, tx);
-    return { tx, effectiveAmount };
-  }
-  async addWithdrawToTx(tx, address, amount, asset) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const sdk = await this.getSdkClient();
-    const caps = await SuilendClient.getObligationOwnerCaps(address, [LENDING_MARKET_TYPE], this.client);
-    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend position found");
-    const { ctokenRaw, effectiveAmount, obligationIndex } = await this.resolveWithdrawCTokens(sdk, address, assetKey, assetInfo, amount);
-    const cap = caps[obligationIndex] ?? caps[0];
-    const coin = await sdk.withdraw(cap.id, cap.obligationId, assetInfo.type, ctokenRaw, tx);
-    return { coin, effectiveAmount };
-  }
-  async addSaveToTx(tx, address, coin, asset, options) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const sdk = await this.getSdkClient();
-    const caps = await SuilendClient.getObligationOwnerCaps(address, [LENDING_MARKET_TYPE], this.client);
-    let capRef;
-    if (caps.length === 0) {
-      const newCap = sdk.createObligation(tx);
-      capRef = newCap;
-      tx.transferObjects([newCap], address);
-    } else {
-      capRef = caps[0].id;
-    }
-    if (options?.collectFee) {
-      addCollectFeeToTx(tx, coin, "save");
-    }
-    sdk.deposit(coin, assetInfo.type, capRef, tx);
-  }
-  async buildBorrowTx(address, amount, asset, options) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const sdk = await this.getSdkClient();
-    const caps = await SuilendClient.getObligationOwnerCaps(address, [LENDING_MARKET_TYPE], this.client);
-    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend position found. Deposit collateral first with: t2000 save <amount>");
-    const rawValue = stableToRaw(amount, assetInfo.decimals).toString();
-    const tx = new Transaction();
-    tx.setSender(address);
-    if (options?.collectFee) {
-      const coin = await sdk.borrow(caps[0].id, caps[0].obligationId, assetInfo.type, rawValue, tx);
-      addCollectFeeToTx(tx, coin, "borrow");
-      tx.transferObjects([coin], address);
-    } else {
-      await sdk.borrowAndSendToUser(address, caps[0].id, caps[0].obligationId, assetInfo.type, rawValue, tx);
-    }
-    return { tx };
-  }
-  async buildRepayTx(address, amount, asset) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const sdk = await this.getSdkClient();
-    const caps = await SuilendClient.getObligationOwnerCaps(address, [LENDING_MARKET_TYPE], this.client);
-    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend obligation found");
-    const rawValue = stableToRaw(amount, assetInfo.decimals).toString();
-    const tx = new Transaction();
-    tx.setSender(address);
-    await sdk.repayIntoObligation(address, caps[0].obligationId, assetInfo.type, rawValue, tx);
-    return { tx };
-  }
-  async addRepayToTx(tx, address, coin, asset) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const sdk = await this.getSdkClient();
-    const caps = await SuilendClient.getObligationOwnerCaps(address, [LENDING_MARKET_TYPE], this.client);
-    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend obligation found");
-    sdk.repay(caps[0].obligationId, assetInfo.type, coin, tx);
-  }
-  async resolveWithdrawCTokens(sdk, address, assetKey, assetInfo, amount) {
-    const { reserveMap, refreshedRawReserves } = await quietSuilend(() => initializeSuilend(this.client, sdk));
-    const { obligations } = await initializeObligations(
-      this.client,
-      sdk,
-      refreshedRawReserves,
-      reserveMap,
-      address
-    );
-    if (obligations.length === 0) throw new T2000Error("NO_COLLATERAL", `Nothing to withdraw for ${assetInfo.displayName} on Suilend \u2014 no obligations found`);
-    let dep;
-    let matchedObligation = 0;
-    for (let oi = 0; oi < obligations.length; oi++) {
-      dep = obligations[oi].deposits.find((d) => {
-        const resolved = this.resolveSymbol(d.coinType);
-        if (resolved === assetKey) return true;
-        try {
-          return normalizeStructTag(d.coinType) === normalizeStructTag(assetInfo.type);
-        } catch {
-          return false;
-        }
-      });
-      if (dep && dep.depositedAmount.toNumber() > 1e-10) {
-        matchedObligation = oi;
-        break;
-      }
-      dep = void 0;
-    }
-    if (!dep) {
-      const foundDeposits = obligations.flatMap(
-        (o, i) => o.deposits.map((d) => `ob${i}:${this.resolveSymbol(d.coinType)}=${d.depositedAmount.toFixed(8)}`)
-      );
-      throw new T2000Error(
-        "NO_COLLATERAL",
-        `Nothing to withdraw for ${assetInfo.displayName} (${assetKey}) on Suilend. Found deposits: [${foundDeposits.join(", ")}]`
-      );
-    }
-    const deposited = dep.depositedAmount.toNumber();
-    const effectiveAmount = Math.min(amount, deposited);
-    const proportion = effectiveAmount / deposited;
-    const ctokenRaw = proportion >= 0.999 ? dep.depositedCtokenAmount.toFixed(0) : dep.depositedCtokenAmount.times(proportion).integerValue(1).toFixed(0);
-    return { ctokenRaw, effectiveAmount, obligationIndex: matchedObligation };
-  }
-  async maxWithdraw(address, _asset) {
-    const health = await this.getHealth(address);
-    let maxAmount;
-    if (health.borrowed === 0) {
-      maxAmount = health.supplied;
-    } else {
-      maxAmount = Math.max(0, health.supplied - health.borrowed * MIN_HEALTH_FACTOR2 / health.liquidationThreshold);
-    }
-    const remainingSupply = health.supplied - maxAmount;
-    const hfAfter = health.borrowed > 0 ? remainingSupply * health.liquidationThreshold / health.borrowed : Infinity;
-    return { maxAmount, healthFactorAfter: hfAfter, currentHF: health.healthFactor };
-  }
-  async maxBorrow(address, _asset) {
-    const health = await this.getHealth(address);
-    return { maxAmount: health.maxBorrow, healthFactorAfter: MIN_HEALTH_FACTOR2, currentHF: health.healthFactor };
-  }
-  async fetchAllCoins(owner, coinType) {
-    const all = [];
-    let cursor = null;
-    let hasNext = true;
-    while (hasNext) {
-      const page = await this.client.getCoins({ owner, coinType, cursor: cursor ?? void 0 });
-      all.push(...page.data.map((c) => ({ coinObjectId: c.coinObjectId, balance: c.balance })));
-      cursor = page.nextCursor;
-      hasNext = page.hasNextPage;
-    }
-    return all;
-  }
-  async getPendingRewards(address) {
-    try {
-      const sdk = await this.getSdkClient();
-      const { reserveMap, refreshedRawReserves } = await quietSuilend(() => initializeSuilend(this.client, sdk));
-      const { obligations, obligationOwnerCaps } = await initializeObligations(
-        this.client,
-        sdk,
-        refreshedRawReserves,
-        reserveMap,
-        address
-      );
-      if (obligationOwnerCaps.length === 0 || obligations.length === 0) return [];
-      const ob = obligations[0];
-      const rewards = [];
-      const WAD = 1e18;
-      for (const dep of ob.deposits) {
-        const urm = dep.userRewardManager;
-        for (const rw of dep.reserve.depositsPoolRewardManager?.poolRewards ?? []) {
-          if (rw.endTimeMs <= Date.now()) continue;
-          let claimableAmount = 0;
-          const userReward = urm?.rewards?.[rw.rewardIndex];
-          if (userReward?.earnedRewards) {
-            claimableAmount = Number(BigInt(userReward.earnedRewards.value.toString())) / WAD / 10 ** rw.mintDecimals;
-          }
-          const symbol = rw.symbol || rw.coinType.split("::").pop() || "UNKNOWN";
-          rewards.push({
-            protocol: "suilend",
-            asset: this.resolveSymbol(dep.coinType),
-            coinType: rw.coinType,
-            symbol,
-            amount: claimableAmount,
-            estimatedValueUsd: 0
-          });
-        }
-      }
-      return rewards;
-    } catch {
-      return [];
-    }
-  }
-  async addClaimRewardsToTx(tx, address) {
-    try {
-      const sdk = await this.getSdkClient();
-      const caps = await SuilendClient.getObligationOwnerCaps(address, [LENDING_MARKET_TYPE], this.client);
-      if (caps.length === 0) return [];
-      const { reserveMap, refreshedRawReserves } = await quietSuilend(() => initializeSuilend(this.client, sdk));
-      const { obligations } = await initializeObligations(
-        this.client,
-        sdk,
-        refreshedRawReserves,
-        reserveMap,
-        address
-      );
-      if (obligations.length === 0) return [];
-      const ob = obligations[0];
-      const claimRewards = [];
-      for (const dep of ob.deposits) {
-        for (const rw of dep.reserve.depositsPoolRewardManager.poolRewards) {
-          if (rw.endTimeMs <= Date.now()) continue;
-          claimRewards.push({
-            reserveArrayIndex: dep.reserveArrayIndex,
-            rewardIndex: BigInt(rw.rewardIndex),
-            rewardCoinType: rw.coinType,
-            side: Side.DEPOSIT
-          });
-        }
-      }
-      if (claimRewards.length === 0) return [];
-      sdk.claimRewardsAndSendToUser(address, caps[0].id, claimRewards, tx);
-      return claimRewards.map((r) => ({
-        protocol: "suilend",
-        asset: "",
-        coinType: r.rewardCoinType,
-        symbol: r.rewardCoinType.split("::").pop() ?? "UNKNOWN",
-        amount: 0,
-        estimatedValueUsd: 0
-      }));
-    } catch {
-      return [];
-    }
-  }
-};
-function hasLeadingZeroBits(hash, bits) {
-  const fullBytes = Math.floor(bits / 8);
-  const remainingBits = bits % 8;
-  for (let i = 0; i < fullBytes; i++) {
-    if (hash[i] !== 0) return false;
-  }
-  if (remainingBits > 0) {
-    const mask = 255 << 8 - remainingBits;
-    if ((hash[fullBytes] & mask) !== 0) return false;
+// src/gas/manager.ts
+init_errors();
+
+// src/gas/autoTopUp.ts
+async function shouldAutoTopUp(client, address) {
+  const [suiBalance, usdcBalance] = await Promise.all([
+    client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.SUI.type }),
+    client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.USDC.type })
+  ]);
+  const suiRaw = BigInt(suiBalance.totalBalance);
+  const usdcRaw = BigInt(usdcBalance.totalBalance);
+  if (suiRaw < GAS_RESERVE_TARGET && usdcRaw >= AUTO_TOPUP_MIN_USDC) {
+    return false;
   }
-  return true;
+  return false;
 }
-function solveHashcash(challenge) {
-  const bits = parseInt(challenge.split(":")[1], 10);
-  let counter = 0;
-  while (true) {
-    const stamp = `${challenge}${counter.toString(16)}`;
-    const hash = createHash("sha256").update(stamp).digest();
-    if (hasLeadingZeroBits(hash, bits)) return stamp;
-    counter++;
-  }
+async function executeAutoTopUp(_client, _signer) {
+  return { success: false, tx: "", usdcSpent: 0, suiReceived: 0 };
 }
 
+// src/gas/gasStation.ts
+init_errors();
+
 // src/utils/base64.ts
 function toBase64(bytes) {
   let binary = "";
@@ -2186,92 +1619,6 @@ async function getGasStatus(address) {
   return await res.json();
 }
 
-// src/gas/autoTopUp.ts
-async function shouldAutoTopUp(client, address) {
-  const [suiBalance, usdcBalance] = await Promise.all([
-    client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.SUI.type }),
-    client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.USDC.type })
-  ]);
-  const suiRaw = BigInt(suiBalance.totalBalance);
-  const usdcRaw = BigInt(usdcBalance.totalBalance);
-  return suiRaw < GAS_RESERVE_TARGET && usdcRaw >= AUTO_TOPUP_MIN_USDC;
-}
-async function executeAutoTopUp(client, signer) {
-  const address = signer.getAddress();
-  const topupAmountHuman = Number(AUTO_TOPUP_AMOUNT) / 1e6;
-  const { tx } = await buildSwapTx({
-    client,
-    address,
-    fromAsset: "USDC",
-    toAsset: "SUI",
-    amount: topupAmountHuman
-  });
-  tx.setSender(address);
-  let result;
-  try {
-    const builtBytes = await tx.build({ client });
-    const { signature } = await signer.signTransaction(builtBytes);
-    result = await client.executeTransactionBlock({
-      transactionBlock: toBase64(builtBytes),
-      signature: [signature],
-      options: { showEffects: true, showBalanceChanges: true }
-    });
-  } catch {
-    const { tx: freshTx } = await buildSwapTx({
-      client,
-      address,
-      fromAsset: "USDC",
-      toAsset: "SUI",
-      amount: topupAmountHuman
-    });
-    freshTx.setSender(address);
-    let txJson;
-    let txBcsBase64;
-    try {
-      txJson = freshTx.serialize();
-    } catch {
-      const bcsBytes = await freshTx.build({ client });
-      txBcsBase64 = toBase64(bcsBytes);
-    }
-    const sponsored = await requestGasSponsorship(
-      txJson ?? "",
-      address,
-      "auto-topup",
-      txBcsBase64
-    );
-    const sponsoredTxBytes = fromBase64(sponsored.txBytes);
-    const { signature: agentSig } = await signer.signTransaction(sponsoredTxBytes);
-    result = await client.executeTransactionBlock({
-      transactionBlock: sponsored.txBytes,
-      signature: [agentSig, sponsored.sponsorSignature],
-      options: { showEffects: true, showBalanceChanges: true }
-    });
-    reportGasUsage(address, result.digest, 0, 0, "auto-topup");
-  }
-  await client.waitForTransaction({ digest: result.digest });
-  const eff = result.effects;
-  if (eff?.status?.status === "failure") {
-    throw new T2000Error(
-      "TRANSACTION_FAILED",
-      `Auto-topup swap failed on-chain: ${eff.status.error ?? "unknown"}`
-    );
-  }
-  let suiReceived = 0;
-  if (result.balanceChanges) {
-    for (const change of result.balanceChanges) {
-      if (change.coinType === SUPPORTED_ASSETS.SUI.type && change.owner && typeof change.owner === "object" && "AddressOwner" in change.owner && change.owner.AddressOwner === address) {
-        suiReceived += Number(change.amount) / Number(MIST_PER_SUI);
-      }
-    }
-  }
-  return {
-    success: true,
-    tx: result.digest,
-    usdcSpent: topupAmountHuman,
-    suiReceived: Math.abs(suiReceived)
-  };
-}
-
 // src/gas/manager.ts
 function extractGasCost(effects) {
   if (!effects?.gasUsed) return 0;
@@ -2317,7 +1664,7 @@ async function tryAutoTopUpThenSelfFund(client, signer, buildTx) {
   const address = signer.getAddress();
   const canTopUp = await shouldAutoTopUp(client, address);
   if (!canTopUp) return null;
-  await executeAutoTopUp(client, signer);
+  await executeAutoTopUp();
   const tx = await buildTx();
   tx.setSender(address);
   const suiAfterTopUp = await getSuiBalance(client, address);
@@ -2482,6 +1829,9 @@ async function resolveGas(client, signer, buildTx) {
   );
 }
 
+// src/t2000.ts
+init_errors();
+
 // src/safeguards/types.ts
 var OUTBOUND_OPS = /* @__PURE__ */ new Set([
   "send",
@@ -2496,6 +1846,7 @@ var DEFAULT_SAFEGUARD_CONFIG = {
 };
 
 // src/safeguards/errors.ts
+init_errors();
 var SafeguardError = class extends T2000Error {
   rule;
   details;
@@ -2642,6 +1993,7 @@ var SafeguardEnforcer = class {
     }
   }
 };
+init_errors();
 var RESERVED_NAMES = /* @__PURE__ */ new Set(["to", "all", "address"]);
 var ContactManager = class {
   contacts = {};
@@ -2719,489 +2071,6 @@ var ContactManager = class {
     }
   }
 };
-var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function emptyData() {
-  return { positions: {}, strategies: {}, 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"));
-        if (!this.data.strategies) this.data.strategies = {};
-      }
-    } 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 effectiveUsdValue = trade.amount > 0 && sellAmount < trade.amount ? trade.usdValue * (sellAmount / trade.amount) : trade.usdValue;
-    const costOfSold = pos.avgPrice * sellAmount;
-    const realizedPnL = effectiveUsdValue - 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 }));
-  }
-  recordEarn(asset, protocol, apy) {
-    this.load();
-    const pos = this.data.positions[asset];
-    if (!pos || pos.totalAmount <= 0) {
-      throw new T2000Error("INSUFFICIENT_INVESTMENT", `No ${asset} position to earn on`);
-    }
-    pos.earning = true;
-    pos.earningProtocol = protocol;
-    pos.earningApy = apy;
-    this.data.positions[asset] = pos;
-    this.save();
-  }
-  recordUnearn(asset) {
-    this.load();
-    const pos = this.data.positions[asset];
-    if (!pos || !pos.earning) {
-      throw new T2000Error("INVEST_NOT_EARNING", `${asset} is not currently earning`);
-    }
-    pos.earning = false;
-    pos.earningProtocol = void 0;
-    pos.earningApy = void 0;
-    this.data.positions[asset] = pos;
-    this.save();
-  }
-  getStrategyAmountForAsset(asset) {
-    this.load();
-    let total = 0;
-    for (const bucket of Object.values(this.data.strategies)) {
-      const pos = bucket[asset];
-      if (pos && pos.totalAmount > 0) total += pos.totalAmount;
-    }
-    return total;
-  }
-  getDirectAmount(asset) {
-    this.load();
-    const aggregate = this.data.positions[asset]?.totalAmount ?? 0;
-    const strategyAmount = this.getStrategyAmountForAsset(asset);
-    return Math.max(0, aggregate - strategyAmount);
-  }
-  deductFromStrategies(asset, amount) {
-    this.load();
-    let remaining = amount;
-    for (const [stratKey, bucket] of Object.entries(this.data.strategies)) {
-      if (remaining <= 0) break;
-      const pos = bucket[asset];
-      if (!pos || pos.totalAmount <= 0) continue;
-      const deduct = Math.min(pos.totalAmount, remaining);
-      const costDeduct = pos.avgPrice * deduct;
-      pos.totalAmount -= deduct;
-      pos.costBasis -= costDeduct;
-      if (pos.totalAmount < 1e-6) {
-        pos.totalAmount = 0;
-        pos.costBasis = 0;
-        pos.avgPrice = 0;
-      }
-      remaining -= deduct;
-      const hasPositions = Object.values(bucket).some((p) => p.totalAmount > 0);
-      if (!hasPositions) {
-        delete this.data.strategies[stratKey];
-      }
-    }
-    this.save();
-  }
-  closePosition(asset) {
-    this.load();
-    const pos = this.data.positions[asset];
-    if (pos) {
-      pos.totalAmount = 0;
-      pos.costBasis = 0;
-      pos.avgPrice = 0;
-      pos.earning = false;
-      pos.earningProtocol = void 0;
-      pos.earningApy = void 0;
-      this.data.positions[asset] = pos;
-      this.save();
-    }
-  }
-  isEarning(asset) {
-    this.load();
-    const pos = this.data.positions[asset];
-    return pos?.earning === true;
-  }
-  getRealizedPnL() {
-    this.load();
-    return this.data.realizedPnL;
-  }
-  // --- Strategy position tracking ---
-  recordStrategyBuy(strategyKey, trade) {
-    if (UNSAFE_KEYS.has(strategyKey) || UNSAFE_KEYS.has(trade.asset)) {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", "Invalid strategy key or asset name");
-    }
-    this.load();
-    if (!Object.hasOwn(this.data.strategies, strategyKey)) {
-      this.data.strategies[strategyKey] = /* @__PURE__ */ Object.create(null);
-    }
-    const bucket = this.data.strategies[strategyKey];
-    const pos = Object.hasOwn(bucket, trade.asset) ? 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);
-    Object.defineProperty(bucket, trade.asset, { value: pos, writable: true, enumerable: true, configurable: true });
-    this.save();
-  }
-  recordStrategySell(strategyKey, trade) {
-    if (UNSAFE_KEYS.has(strategyKey) || UNSAFE_KEYS.has(trade.asset)) {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", "Invalid strategy key or asset name");
-    }
-    this.load();
-    const bucket = this.data.strategies[strategyKey];
-    if (!bucket) {
-      throw new T2000Error("STRATEGY_NOT_FOUND", `No positions for strategy '${strategyKey}'`);
-    }
-    if (!Object.hasOwn(bucket, trade.asset)) {
-      throw new T2000Error("INSUFFICIENT_INVESTMENT", `No ${trade.asset} position in 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 effectiveUsdValue = trade.amount > 0 && sellAmount < trade.amount ? trade.usdValue * (sellAmount / trade.amount) : trade.usdValue;
-    const costOfSold = pos.avgPrice * sellAmount;
-    const realizedPnL = effectiveUsdValue - 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);
-    Object.defineProperty(bucket, trade.asset, { value: pos, writable: true, enumerable: true, configurable: true });
-    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);
-  }
-  clearStrategy(strategyKey) {
-    this.load();
-    delete this.data.strategies[strategyKey];
-    this.save();
-  }
-  hasStrategyPositions(strategyKey) {
-    this.load();
-    const bucket = this.data.strategies[strategyKey];
-    if (!bucket) return false;
-    return Object.values(bucket).some((p) => p.totalAmount > 0);
-  }
-  closeStrategyPosition(strategyKey, asset) {
-    this.load();
-    const bucket = this.data.strategies[strategyKey];
-    if (!bucket?.[asset]) return;
-    bucket[asset].totalAmount = 0;
-    bucket[asset].costBasis = 0;
-    bucket[asset].avgPrice = 0;
-    const hasPositions = Object.values(bucket).some((p) => p.totalAmount > 0);
-    if (!hasPositions) {
-      delete this.data.strategies[strategyKey];
-    }
-    this.save();
-  }
-};
-function emptyData2() {
-  return { strategies: {} };
-}
-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 LOW_LIQUIDITY_ASSETS = /* @__PURE__ */ new Set(["GOLD"]);
-var REWARD_TOKEN_DECIMALS = {
-  "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55::cert::CERT": 9,
-  "0xdeeb7a4662eec9f2f3def03fb937a663dddaa2e215b8078a284d026b7946c270::deep::DEEP": 6,
-  "0x83556891f4a0f233ce7b05cfe7f957d4020492a34f5405b2cb9377d060bef4bf::spring_sui::SPRING_SUI": 9
-};
-function defaultSlippage(asset) {
-  return LOW_LIQUIDITY_ASSETS.has(asset) ? 0.05 : 0.03;
-}
 var DEFAULT_CONFIG_DIR = join(homedir(), ".t2000");
 var T2000 = class _T2000 extends EventEmitter {
   _signer;
@@ -3211,9 +2080,6 @@ var T2000 = class _T2000 extends EventEmitter {
   registry;
   enforcer;
   contacts;
-  portfolio;
-  strategies;
-  autoInvest;
   constructor(keypairOrSigner, client, registry, configDir, isSignerMode) {
     super();
     if (isSignerMode) {
@@ -3231,21 +2097,12 @@ var T2000 = class _T2000 extends EventEmitter {
     this.enforcer = new SafeguardEnforcer(configDir);
     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();
     const naviAdapter = new NaviAdapter();
     naviAdapter.initSync(client);
     registry.registerLending(naviAdapter);
-    const cetusAdapter = new CetusAdapter();
-    cetusAdapter.initSync(client);
-    registry.registerSwap(cetusAdapter);
-    const suilendAdapter = new SuilendAdapter();
-    suilendAdapter.initSync(client);
-    registry.registerLending(suilendAdapter);
     return registry;
   }
   static async create(options = {}) {
@@ -3321,14 +2178,15 @@ var T2000 = class _T2000 extends EventEmitter {
     this.enforcer.assertNotLocked();
     this.enforcer.check({ operation: "pay", amount: options.maxPrice ?? 1 });
     const { Mppx } = await import('mppx/client');
-    const { sui } = await import('@mppsui/mpp/client');
+    const { sui } = await import('@suimpp/mpp/client');
     const client = this.client;
     const signer = this._signer;
+    const signerAddress = signer.getAddress();
     const mppx = Mppx.create({
       polyfill: false,
       methods: [sui({
         client,
-        signer,
+        signer: { toSuiAddress: () => signerAddress },
         execute: async (tx) => {
           const result = await executeWithGas(client, signer, () => tx);
           return { digest: result.digest, effects: result.effects };
@@ -3355,11 +2213,156 @@ var T2000 = class _T2000 extends EventEmitter {
       this.enforcer.recordUsage(options.maxPrice ?? 1);
     }
     return {
-      status: response.status,
-      body,
-      paid,
-      cost: paid ? options.maxPrice ?? void 0 : void 0,
-      receipt: receiptHeader ? { reference: receiptHeader, timestamp: (/* @__PURE__ */ new Date()).toISOString() } : void 0
+      status: response.status,
+      body,
+      paid,
+      cost: paid ? options.maxPrice ?? void 0 : void 0,
+      receipt: receiptHeader ? { reference: receiptHeader, timestamp: (/* @__PURE__ */ new Date()).toISOString() } : void 0
+    };
+  }
+  // -- VOLO vSUI Staking --
+  async stakeVSui(params) {
+    this.enforcer.assertNotLocked();
+    const { buildStakeVSuiTx: buildStakeVSuiTx2, getVoloStats: getVoloStats2 } = await Promise.resolve().then(() => (init_volo(), volo_exports));
+    const amountMist = BigInt(Math.floor(params.amount * Number(MIST_PER_SUI)));
+    const stats = await getVoloStats2();
+    const gasResult = await executeWithGas(this.client, this._signer, async () => {
+      return buildStakeVSuiTx2(this.client, this._address, amountMist);
+    });
+    const vSuiReceived = params.amount / stats.exchangeRate;
+    return {
+      success: true,
+      tx: gasResult.digest,
+      amountSui: params.amount,
+      vSuiReceived,
+      apy: stats.apy,
+      gasCost: gasResult.gasCostSui,
+      gasMethod: gasResult.gasMethod
+    };
+  }
+  async unstakeVSui(params) {
+    this.enforcer.assertNotLocked();
+    const { buildUnstakeVSuiTx: buildUnstakeVSuiTx2, getVoloStats: getVoloStats2, VSUI_TYPE: VSUI_TYPE2 } = await Promise.resolve().then(() => (init_volo(), volo_exports));
+    let amountMist;
+    let vSuiAmount;
+    if (params.amount === "all") {
+      amountMist = "all";
+      const coins = await this._fetchCoins(VSUI_TYPE2);
+      vSuiAmount = coins.reduce((sum, c) => sum + Number(c.balance), 0) / 1e9;
+    } else {
+      amountMist = BigInt(Math.floor(params.amount * 1e9));
+      vSuiAmount = params.amount;
+    }
+    const stats = await getVoloStats2();
+    const gasResult = await executeWithGas(this.client, this._signer, async () => {
+      return buildUnstakeVSuiTx2(this.client, this._address, amountMist);
+    });
+    const suiReceived = vSuiAmount * stats.exchangeRate;
+    return {
+      success: true,
+      tx: gasResult.digest,
+      vSuiAmount,
+      suiReceived,
+      gasCost: gasResult.gasCostSui,
+      gasMethod: gasResult.gasMethod
+    };
+  }
+  // -- Swap --
+  async swap(params) {
+    this.enforcer.assertNotLocked();
+    const { findSwapRoute: findSwapRoute2, buildSwapTx: buildSwapTx2, resolveTokenType: resolveTokenType2, TOKEN_MAP: TOKEN_MAP2 } = await Promise.resolve().then(() => (init_cetus_swap(), cetus_swap_exports));
+    const fromType = resolveTokenType2(params.from);
+    const toType = resolveTokenType2(params.to);
+    if (!fromType) throw new T2000Error("ASSET_NOT_SUPPORTED", `Unknown token: ${params.from}. Provide the full coin type.`);
+    if (!toType) throw new T2000Error("ASSET_NOT_SUPPORTED", `Unknown token: ${params.to}. Provide the full coin type.`);
+    const byAmountIn = params.byAmountIn ?? true;
+    const slippage = Math.min(params.slippage ?? 0.01, 0.05);
+    const fromEntry = Object.values(TOKEN_MAP2).includes(fromType) ? Object.entries(SUPPORTED_ASSETS).find(([, v]) => v.type === fromType) : null;
+    const fromDecimals = fromEntry ? fromEntry[1].decimals : fromType === "0x2::sui::SUI" ? 9 : 6;
+    const rawAmount = BigInt(Math.floor(params.amount * 10 ** fromDecimals));
+    const route = await findSwapRoute2({
+      walletAddress: this._address,
+      from: fromType,
+      to: toType,
+      amount: rawAmount,
+      byAmountIn
+    });
+    if (!route) throw new T2000Error("SWAP_NO_ROUTE", `No swap route found for ${params.from} -> ${params.to}.`);
+    if (route.insufficientLiquidity) throw new T2000Error("SWAP_NO_ROUTE", `Insufficient liquidity for ${params.from} -> ${params.to}.`);
+    if (route.priceImpact > 0.05) {
+      console.warn(`[swap] High price impact: ${(route.priceImpact * 100).toFixed(2)}%`);
+    }
+    const gasResult = await executeWithGas(this.client, this._signer, async () => {
+      const tx = new Transaction();
+      tx.setSender(this._address);
+      let inputCoin;
+      if (fromType === "0x2::sui::SUI") {
+        [inputCoin] = tx.splitCoins(tx.gas, [rawAmount]);
+      } else {
+        const coins = await this._fetchCoins(fromType);
+        if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${params.from} coins found.`);
+        const merged = this._mergeCoinsInTx(tx, coins);
+        [inputCoin] = tx.splitCoins(merged, [rawAmount]);
+      }
+      const outputCoin = await buildSwapTx2({
+        walletAddress: this._address,
+        route,
+        tx,
+        inputCoin,
+        slippage
+      });
+      tx.transferObjects([outputCoin], this._address);
+      return tx;
+    });
+    const toEntry = Object.entries(SUPPORTED_ASSETS).find(([, v]) => v.type === toType);
+    const toDecimals = toEntry ? toEntry[1].decimals : toType === "0x2::sui::SUI" ? 9 : 6;
+    const fromAmount = Number(route.amountIn) / 10 ** fromDecimals;
+    const toAmount = Number(route.amountOut) / 10 ** toDecimals;
+    const routeDesc = route.routerData.paths?.map((p) => p.provider).filter(Boolean).slice(0, 3).join(" + ") ?? "Cetus Aggregator";
+    return {
+      success: true,
+      tx: gasResult.digest,
+      fromToken: params.from,
+      toToken: params.to,
+      fromAmount,
+      toAmount,
+      priceImpact: route.priceImpact,
+      route: routeDesc,
+      gasCost: gasResult.gasCostSui,
+      gasMethod: gasResult.gasMethod
+    };
+  }
+  async swapQuote(params) {
+    const { findSwapRoute: findSwapRoute2, resolveTokenType: resolveTokenType2, TOKEN_MAP: TOKEN_MAP2 } = await Promise.resolve().then(() => (init_cetus_swap(), cetus_swap_exports));
+    const fromType = resolveTokenType2(params.from);
+    const toType = resolveTokenType2(params.to);
+    if (!fromType) throw new T2000Error("ASSET_NOT_SUPPORTED", `Unknown token: ${params.from}. Provide the full coin type.`);
+    if (!toType) throw new T2000Error("ASSET_NOT_SUPPORTED", `Unknown token: ${params.to}. Provide the full coin type.`);
+    const byAmountIn = params.byAmountIn ?? true;
+    const fromEntry = Object.values(TOKEN_MAP2).includes(fromType) ? Object.entries(SUPPORTED_ASSETS).find(([, v]) => v.type === fromType) : null;
+    const fromDecimals = fromEntry ? fromEntry[1].decimals : fromType === "0x2::sui::SUI" ? 9 : 6;
+    const rawAmount = BigInt(Math.floor(params.amount * 10 ** fromDecimals));
+    const route = await findSwapRoute2({
+      walletAddress: this._address,
+      from: fromType,
+      to: toType,
+      amount: rawAmount,
+      byAmountIn
+    });
+    if (!route) throw new T2000Error("SWAP_NO_ROUTE", `No swap route found for ${params.from} -> ${params.to}.`);
+    if (route.insufficientLiquidity) throw new T2000Error("SWAP_NO_ROUTE", `Insufficient liquidity for ${params.from} -> ${params.to}.`);
+    const toEntry = Object.entries(SUPPORTED_ASSETS).find(([, v]) => v.type === toType);
+    const toDecimals = toEntry ? toEntry[1].decimals : toType === "0x2::sui::SUI" ? 9 : 6;
+    const fromAmount = Number(route.amountIn) / 10 ** fromDecimals;
+    const toAmount = Number(route.amountOut) / 10 ** toDecimals;
+    const routeDesc = route.routerData.paths?.map((p) => p.provider).filter(Boolean).slice(0, 3).join(" + ") ?? "Cetus Aggregator";
+    return {
+      fromToken: params.from,
+      toToken: params.to,
+      fromAmount,
+      toAmount,
+      priceImpact: route.priceImpact,
+      route: routeDesc
     };
   }
   // -- Wallet --
@@ -3398,38 +2401,14 @@ var T2000 = class _T2000 extends EventEmitter {
   }
   async balance() {
     const bal = await queryBalance(this.client, this._address);
-    const portfolioPositions = this.portfolio.getPositions();
-    const earningAssets = new Set(
-      portfolioPositions.filter((p) => p.earning).map((p) => p.asset)
-    );
-    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 asset of Object.keys(INVESTMENT_ASSETS)) {
-      if (asset === "SUI") continue;
-      try {
-        if (swapAdapter) {
-          const quote = await swapAdapter.getQuote("USDC", asset, 1);
-          assetPrices[asset] = quote.expectedOutput > 0 ? 1 / quote.expectedOutput : 0;
-        }
-      } catch {
-        assetPrices[asset] = 0;
-      }
-    }
     let chainTotal = bal.available + bal.gasReserve.usdEquiv;
-    for (const asset of Object.keys(INVESTMENT_ASSETS)) {
-      if (asset === "SUI") continue;
-      chainTotal += (bal.assets[asset] ?? 0) * (assetPrices[asset] ?? 0);
-    }
     try {
       const positions = await this.positions();
       for (const pos of positions.positions) {
         const usdValue = pos.amountUsd ?? pos.amount;
         if (pos.type === "save") {
           chainTotal += usdValue;
-          if (!earningAssets.has(pos.asset)) {
-            bal.savings += usdValue;
-          }
+          bal.savings += usdValue;
         } else if (pos.type === "borrow") {
           chainTotal -= usdValue;
           bal.debt += usdValue;
@@ -3437,50 +2416,6 @@ var T2000 = class _T2000 extends EventEmitter {
       }
     } catch {
     }
-    try {
-      const trackedAmounts = {};
-      const trackedCostBasis = {};
-      const earningAssetSet = /* @__PURE__ */ new Set();
-      for (const pos of portfolioPositions) {
-        if (!(pos.asset in INVESTMENT_ASSETS)) continue;
-        trackedAmounts[pos.asset] = (trackedAmounts[pos.asset] ?? 0) + pos.totalAmount;
-        trackedCostBasis[pos.asset] = (trackedCostBasis[pos.asset] ?? 0) + pos.costBasis;
-        if (pos.earning) earningAssetSet.add(pos.asset);
-      }
-      let investmentValue = 0;
-      let investmentCostBasis = 0;
-      let trackedValue = 0;
-      for (const asset of Object.keys(INVESTMENT_ASSETS)) {
-        const price = assetPrices[asset] ?? 0;
-        const tracked = trackedAmounts[asset] ?? 0;
-        const costBasis = trackedCostBasis[asset] ?? 0;
-        if (asset === "SUI") {
-          const actualSui = earningAssetSet.has("SUI") ? tracked : Math.min(tracked, bal.gasReserve.sui);
-          investmentValue += actualSui * price;
-          trackedValue += actualSui * price;
-          if (actualSui < tracked && tracked > 0) {
-            investmentCostBasis += costBasis * (actualSui / tracked);
-          } else {
-            investmentCostBasis += costBasis;
-          }
-          if (!earningAssetSet.has("SUI")) {
-            const gasSui = Math.max(0, bal.gasReserve.sui - tracked);
-            bal.gasReserve = { sui: gasSui, usdEquiv: gasSui * price };
-          }
-        } else {
-          const onChainAmount = bal.assets[asset] ?? 0;
-          const effectiveAmount = Math.max(tracked, onChainAmount);
-          investmentValue += effectiveAmount * price;
-          trackedValue += tracked * price;
-          investmentCostBasis += costBasis;
-        }
-      }
-      bal.investment = investmentValue;
-      bal.investmentPnL = trackedValue - investmentCostBasis;
-    } catch {
-      bal.investment = 0;
-      bal.investmentPnL = 0;
-    }
     try {
       const pendingRewards = await this.getPendingRewards();
       bal.pendingRewards = pendingRewards.reduce((s, r) => s + r.estimatedValueUsd, 0);
@@ -3499,25 +2434,19 @@ var T2000 = class _T2000 extends EventEmitter {
   async deposit() {
     return {
       address: this._address,
-      network: "Sui (mainnet)",
-      supportedAssets: ["USDC"],
+      network: "mainnet",
+      supportedAssets: ["USDC", "USDT", "SUI"],
       instructions: [
-        `Send USDC on Sui to: ${this._address}`,
-        "",
-        "From a CEX (Coinbase, Binance):",
-        `  1. Withdraw USDC`,
-        `  2. Select "Sui" network`,
-        `  3. Paste address: ${truncateAddress(this._address)}`,
-        "",
-        "From another Sui wallet:",
-        `  Transfer USDC to ${truncateAddress(this._address)}`
+        `Send USDC to: ${this._address}`,
+        `Network: Sui Mainnet`,
+        `Or buy USDC on an exchange and withdraw to this address.`,
+        `USDC contract: ${SUPPORTED_ASSETS.USDC.type}`
       ].join("\n")
     };
   }
   exportKey() {
     return exportPrivateKey(this.keypair);
   }
-  /** Create a T2000 instance from zkLogin credentials (for web app). */
   static fromZkLogin(opts) {
     const signer = new ZkLoginSigner(opts.ephemeralKeypair, opts.zkProof, opts.userAddress, opts.maxEpoch);
     const client = getSuiClient(opts.rpcUrl);
@@ -3525,16 +2454,15 @@ var T2000 = class _T2000 extends EventEmitter {
   }
   async registerAdapter(adapter) {
     await adapter.init(this.client);
-    if ("buildSaveTx" in adapter) this.registry.registerLending(adapter);
-    if ("buildSwapTx" in adapter) this.registry.registerSwap(adapter);
+    this.registry.registerLending(adapter);
   }
   // -- Savings --
   async save(params) {
     this.enforcer.assertNotLocked();
-    const asset = "USDC";
+    const asset = params.asset ?? "USDC";
+    const assetInfo = SUPPORTED_ASSETS[asset];
+    if (!assetInfo) throw new T2000Error("ASSET_NOT_SUPPORTED", `Unsupported asset: ${asset}`);
     const bal = await queryBalance(this.client, this._address);
-    const usdcBalance = bal.stables.USDC ?? 0;
-    const needsAutoConvert = params.amount === "all" ? Object.entries(bal.stables).some(([k, v]) => k !== "USDC" && v > 0.01) : typeof params.amount === "number" && params.amount > usdcBalance;
     let amount;
     if (params.amount === "all") {
       amount = (bal.available ?? 0) - 1;
@@ -3553,54 +2481,25 @@ var T2000 = class _T2000 extends EventEmitter {
     const fee = calculateFee("save", amount);
     const saveAmount = amount;
     const adapter = await this.resolveLending(params.protocol, asset, "save");
-    const swapAdapter = this.registry.listSwap()[0];
-    const canPTB = adapter.addSaveToTx && (!needsAutoConvert || swapAdapter?.addSwapToTx);
+    const canPTB = !!adapter.addSaveToTx;
     const gasResult = await executeWithGas(this.client, this._signer, async () => {
-      if (canPTB && needsAutoConvert) {
+      if (canPTB) {
         const tx2 = new Transaction();
         tx2.setSender(this._address);
-        const usdcCoins = [];
-        for (const [stableAsset, stableAmount] of Object.entries(bal.stables)) {
-          if (stableAsset === "USDC" || stableAmount <= 0.01) continue;
-          const assetInfo = SUPPORTED_ASSETS[stableAsset];
-          if (!assetInfo) continue;
+        let inputCoin;
+        if (asset === "SUI") {
+          const rawAmount = BigInt(Math.floor(saveAmount * 10 ** assetInfo.decimals));
+          [inputCoin] = tx2.splitCoins(tx2.gas, [rawAmount]);
+        } else {
           const coins = await this._fetchCoins(assetInfo.type);
-          if (coins.length === 0) continue;
+          if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${asset} coins found`);
           const merged = this._mergeCoinsInTx(tx2, coins);
-          const { outputCoin } = await swapAdapter.addSwapToTx(
-            tx2,
-            this._address,
-            merged,
-            stableAsset,
-            "USDC",
-            stableAmount
-          );
-          usdcCoins.push(outputCoin);
-        }
-        const existingUsdc = await this._fetchCoins(SUPPORTED_ASSETS.USDC.type);
-        if (existingUsdc.length > 0) {
-          usdcCoins.push(this._mergeCoinsInTx(tx2, existingUsdc));
+          const rawAmount = BigInt(Math.floor(saveAmount * 10 ** assetInfo.decimals));
+          [inputCoin] = tx2.splitCoins(merged, [rawAmount]);
         }
-        if (usdcCoins.length > 1) {
-          tx2.mergeCoins(usdcCoins[0], usdcCoins.slice(1));
-        }
-        await adapter.addSaveToTx(tx2, this._address, usdcCoins[0], asset, { collectFee: true });
-        return tx2;
-      }
-      if (canPTB && !needsAutoConvert) {
-        const tx2 = new Transaction();
-        tx2.setSender(this._address);
-        const existingUsdc = await this._fetchCoins(SUPPORTED_ASSETS.USDC.type);
-        if (existingUsdc.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins found");
-        const merged = this._mergeCoinsInTx(tx2, existingUsdc);
-        const rawAmount = BigInt(Math.floor(saveAmount * 10 ** SUPPORTED_ASSETS.USDC.decimals));
-        const [depositCoin] = tx2.splitCoins(merged, [rawAmount]);
-        await adapter.addSaveToTx(tx2, this._address, depositCoin, asset, { collectFee: true });
+        await adapter.addSaveToTx(tx2, this._address, inputCoin, asset, { collectFee: true });
         return tx2;
       }
-      if (needsAutoConvert) {
-        await this._convertWalletStablesToUsdc(bal, params.amount === "all" ? void 0 : amount - usdcBalance);
-      }
       const { tx } = await adapter.buildSaveTx(this._address, saveAmount, asset, { collectFee: true });
       return tx;
     });
@@ -3633,24 +2532,22 @@ var T2000 = class _T2000 extends EventEmitter {
   }
   async withdraw(params) {
     this.enforcer.assertNotLocked();
-    if (params.amount === "all" && !params.protocol) {
+    if (params.amount === "all" && !params.protocol && !params.asset) {
       return this.withdrawAllProtocols();
     }
     const allPositions = await this.registry.allPositions(this._address);
-    const earningAssets = new Set(
-      this.portfolio.getPositions().filter((p) => p.earning).map((p) => p.asset)
-    );
     const supplies = [];
     for (const pos of allPositions) {
       if (params.protocol && pos.protocolId !== params.protocol) continue;
       for (const s of pos.positions.supplies) {
-        if (s.amount > 1e-3 && !earningAssets.has(s.asset)) {
+        if (s.amount > 1e-3) {
+          if (params.asset && s.asset !== params.asset) continue;
           supplies.push({ protocolId: pos.protocolId, asset: s.asset, amount: s.amount, apy: s.apy });
         }
       }
     }
     if (supplies.length === 0) {
-      throw new T2000Error("NO_COLLATERAL", "No savings to withdraw");
+      throw new T2000Error("NO_COLLATERAL", params.asset ? `No ${params.asset} savings to withdraw` : "No savings to withdraw");
     }
     supplies.sort((a, b) => {
       const aIsUsdc = a.asset === "USDC" ? 0 : 1;
@@ -3688,42 +2585,19 @@ var T2000 = class _T2000 extends EventEmitter {
     }
     const withdrawAmount = amount;
     let finalAmount = withdrawAmount;
-    const swapAdapter = target.asset !== "USDC" ? this.registry.listSwap()[0] : void 0;
-    const canPTB = adapter.addWithdrawToTx && (!swapAdapter || swapAdapter.addSwapToTx);
     const gasResult = await executeWithGas(this.client, this._signer, async () => {
-      if (canPTB) {
+      if (adapter.addWithdrawToTx) {
         const tx = new Transaction();
         tx.setSender(this._address);
         const { coin, effectiveAmount } = await adapter.addWithdrawToTx(tx, this._address, withdrawAmount, target.asset);
         finalAmount = effectiveAmount;
-        if (target.asset !== "USDC" && swapAdapter?.addSwapToTx) {
-          const { outputCoin, estimatedOut, toDecimals } = await swapAdapter.addSwapToTx(
-            tx,
-            this._address,
-            coin,
-            target.asset,
-            "USDC",
-            effectiveAmount,
-            500
-          );
-          finalAmount = estimatedOut / 10 ** toDecimals;
-          tx.transferObjects([outputCoin], this._address);
-        } else {
-          tx.transferObjects([coin], this._address);
-        }
+        tx.transferObjects([coin], this._address);
         return tx;
       }
       const built = await adapter.buildWithdrawTx(this._address, withdrawAmount, target.asset);
       finalAmount = built.effectiveAmount;
       return built.tx;
     });
-    if (target.asset !== "USDC") {
-      try {
-        const postBal = await queryBalance(this.client, this._address);
-        await this._convertWalletStablesToUsdc(postBal);
-      } catch {
-      }
-    }
     this.emitBalanceChange("USDC", finalAmount, "withdraw", gasResult.digest);
     return {
       success: true,
@@ -3735,13 +2609,10 @@ var T2000 = class _T2000 extends EventEmitter {
   }
   async withdrawAllProtocols() {
     const allPositions = await this.registry.allPositions(this._address);
-    const earningAssets = new Set(
-      this.portfolio.getPositions().filter((p) => p.earning).map((p) => p.asset)
-    );
     const withdrawable = [];
     for (const pos of allPositions) {
       for (const supply of pos.positions.supplies) {
-        if (supply.amount > 0.01 && !earningAssets.has(supply.asset)) {
+        if (supply.amount > 0.01) {
           withdrawable.push({ protocolId: pos.protocolId, asset: supply.asset, amount: supply.amount });
         }
       }
@@ -3768,87 +2639,39 @@ var T2000 = class _T2000 extends EventEmitter {
     if (entries.length === 0) {
       throw new T2000Error("NO_COLLATERAL", "No savings to withdraw across any protocol");
     }
-    const DUST_SWAP_THRESHOLD = 1;
-    const swappableEntries = entries.filter((e) => e.asset === "USDC" || e.maxAmount >= DUST_SWAP_THRESHOLD);
-    const dustEntries = entries.filter((e) => e.asset !== "USDC" && e.maxAmount < DUST_SWAP_THRESHOLD);
-    const hasNonUsdc = swappableEntries.some((e) => e.asset !== "USDC");
-    const swapAdapter = hasNonUsdc ? this.registry.listSwap()[0] : void 0;
-    const canPTB = swappableEntries.every((e) => e.adapter.addWithdrawToTx) && (!swapAdapter || swapAdapter.addSwapToTx);
-    let totalUsdcReceived = 0;
+    let totalReceived = 0;
+    const canPTB = entries.every((e) => e.adapter.addWithdrawToTx);
     const gasResult = await executeWithGas(this.client, this._signer, async () => {
       if (canPTB) {
         const tx = new Transaction();
         tx.setSender(this._address);
-        const usdcCoins = [];
-        for (const entry of swappableEntries) {
+        for (const entry of entries) {
           const { coin, effectiveAmount } = await entry.adapter.addWithdrawToTx(
             tx,
             this._address,
             entry.maxAmount,
             entry.asset
           );
-          if (entry.asset === "USDC") {
-            totalUsdcReceived += effectiveAmount;
-            usdcCoins.push(coin);
-          } else if (swapAdapter?.addSwapToTx) {
-            const { outputCoin, estimatedOut, toDecimals } = await swapAdapter.addSwapToTx(
-              tx,
-              this._address,
-              coin,
-              entry.asset,
-              "USDC",
-              effectiveAmount,
-              500
-            );
-            totalUsdcReceived += estimatedOut / 10 ** toDecimals;
-            usdcCoins.push(outputCoin);
-          } else {
-            totalUsdcReceived += effectiveAmount;
-            tx.transferObjects([coin], this._address);
-          }
-        }
-        for (const dust of dustEntries) {
-          if (dust.adapter.addWithdrawToTx) {
-            const { coin, effectiveAmount } = await dust.adapter.addWithdrawToTx(
-              tx,
-              this._address,
-              dust.maxAmount,
-              dust.asset
-            );
-            totalUsdcReceived += effectiveAmount;
-            tx.transferObjects([coin], this._address);
-          }
-        }
-        if (usdcCoins.length > 1) {
-          tx.mergeCoins(usdcCoins[0], usdcCoins.slice(1));
-        }
-        if (usdcCoins.length > 0) {
-          tx.transferObjects([usdcCoins[0]], this._address);
+          totalReceived += effectiveAmount;
+          tx.transferObjects([coin], this._address);
         }
         return tx;
       }
       let lastTx;
       for (const entry of entries) {
         const built = await entry.adapter.buildWithdrawTx(this._address, entry.maxAmount, entry.asset);
-        totalUsdcReceived += built.effectiveAmount;
+        totalReceived += built.effectiveAmount;
         lastTx = built.tx;
       }
       return lastTx;
     });
-    if (hasNonUsdc) {
-      try {
-        const postBal = await queryBalance(this.client, this._address);
-        await this._convertWalletStablesToUsdc(postBal);
-      } catch {
-      }
-    }
-    if (totalUsdcReceived <= 0) {
+    if (totalReceived <= 0) {
       throw new T2000Error("NO_COLLATERAL", "No savings to withdraw across any protocol");
     }
     return {
       success: true,
       tx: gasResult.digest,
-      amount: totalUsdcReceived,
+      amount: totalReceived,
       gasCost: gasResult.gasCostSui,
       gasMethod: gasResult.gasMethod
     };
@@ -3898,39 +2721,6 @@ var T2000 = class _T2000 extends EventEmitter {
     }
     return primary;
   }
-  async _swapToUsdc(asset, amount) {
-    const swapAdapter = this.registry.listSwap()[0];
-    if (!swapAdapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", "No swap adapter available");
-    let estimatedOut = 0;
-    let toDecimals = 6;
-    const gasResult = await executeWithGas(this.client, this._signer, async () => {
-      const built = await swapAdapter.buildSwapTx(this._address, asset, "USDC", amount);
-      estimatedOut = built.estimatedOut;
-      toDecimals = built.toDecimals;
-      return built.tx;
-    });
-    const usdcReceived = estimatedOut / 10 ** toDecimals;
-    return { usdcReceived, digest: gasResult.digest, gasCost: gasResult.gasCostSui };
-  }
-  async _swapFromUsdc(toAsset, amount) {
-    const swapAdapter = this.registry.listSwap()[0];
-    if (!swapAdapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", "No swap adapter available");
-    let estimatedOut = 0;
-    let toDecimals = 6;
-    const gasResult = await executeWithGas(this.client, this._signer, async () => {
-      const built = await swapAdapter.buildSwapTx(this._address, "USDC", toAsset, amount);
-      estimatedOut = built.estimatedOut;
-      toDecimals = built.toDecimals;
-      return built.tx;
-    });
-    const received = estimatedOut / 10 ** toDecimals;
-    return { received, digest: gasResult.digest, gasCost: gasResult.gasCostSui };
-  }
-  /**
-   * Auto-withdraw from savings when checking balance is insufficient for an
-   * operation. Handles non-USDC savings (e.g. USDe) via the standard withdraw
-   * path which swaps back to USDC. Throws if savings are also insufficient.
-   */
   _lastFundDigest;
   async _autoFundFromSavings(shortfall) {
     const positions = await this.positions();
@@ -3961,69 +2751,17 @@ var T2000 = class _T2000 extends EventEmitter {
     }
     this._lastFundDigest = result.tx;
   }
-  async _convertWalletStablesToUsdc(bal, amountNeeded) {
-    const nonUsdcStables = [];
-    for (const [asset, amount] of Object.entries(bal.stables)) {
-      if (asset !== "USDC" && amount > 0.01) {
-        nonUsdcStables.push({ asset, amount });
-      }
-    }
-    if (nonUsdcStables.length === 0) return;
-    nonUsdcStables.sort((a, b) => b.amount - a.amount);
-    let converted = 0;
-    for (const entry of nonUsdcStables) {
-      if (amountNeeded !== void 0 && converted >= amountNeeded) break;
-      try {
-        await this._swapToUsdc(entry.asset, entry.amount);
-        converted += entry.amount;
-      } catch {
-      }
-    }
-  }
   async maxWithdraw() {
     const adapter = await this.resolveLending(void 0, "USDC", "withdraw");
     return adapter.maxWithdraw(this._address, "USDC");
   }
   // -- Borrowing --
-  async adjustMaxBorrowForInvestments(adapter, maxResult) {
-    const earningPositions = this.portfolio.getPositions().filter((p) => p.earning);
-    if (earningPositions.length === 0) return maxResult;
-    let investmentCollateralUsd = 0;
-    const swapAdapter = this.registry.listSwap()[0];
-    for (const pos of earningPositions) {
-      if (pos.earningProtocol !== adapter.id) continue;
-      try {
-        let price = 0;
-        if (pos.asset === "SUI" && swapAdapter) {
-          price = await swapAdapter.getPoolPrice();
-        } else if (swapAdapter) {
-          const quote = await swapAdapter.getQuote("USDC", pos.asset, 1);
-          price = quote.expectedOutput > 0 ? 1 / quote.expectedOutput : 0;
-        }
-        investmentCollateralUsd += pos.totalAmount * price;
-      } catch {
-      }
-    }
-    if (investmentCollateralUsd <= 0) return maxResult;
-    const CONSERVATIVE_LTV = 0.6;
-    const investmentBorrowCapacity = investmentCollateralUsd * CONSERVATIVE_LTV;
-    const adjustedMax = Math.max(0, maxResult.maxAmount - investmentBorrowCapacity);
-    return { ...maxResult, maxAmount: adjustedMax };
-  }
   async borrow(params) {
     this.enforcer.assertNotLocked();
     const asset = "USDC";
     const adapter = await this.resolveLending(params.protocol, asset, "borrow");
-    const rawMax = await adapter.maxBorrow(this._address, asset);
-    const maxResult = await this.adjustMaxBorrowForInvestments(adapter, rawMax);
+    const maxResult = await adapter.maxBorrow(this._address, asset);
     if (maxResult.maxAmount <= 0) {
-      const hasInvestmentEarning = this.portfolio.getPositions().some((p) => p.earning && p.earningProtocol === adapter.id);
-      if (hasInvestmentEarning) {
-        throw new T2000Error(
-          "BORROW_GUARD_INVESTMENT",
-          "Max safe borrow: $0.00. Only savings deposits (stablecoins) count as borrowable collateral. Investment collateral (SUI, ETH, BTC) is excluded."
-        );
-      }
       throw new T2000Error("NO_COLLATERAL", "No collateral deposited. Save first with `t2000 save <amount>`.");
     }
     if (params.amount > maxResult.maxAmount) {
@@ -4072,30 +2810,8 @@ var T2000 = class _T2000 extends EventEmitter {
     const adapter = this.registry.getLending(target.protocolId);
     if (!adapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", `Protocol ${target.protocolId} not found`);
     const repayAmount = Math.min(params.amount, target.amount);
-    const swapAdapter = target.asset !== "USDC" ? this.registry.listSwap()[0] : void 0;
-    const canPTB = adapter.addRepayToTx && (!swapAdapter || swapAdapter.addSwapToTx);
     const gasResult = await executeWithGas(this.client, this._signer, async () => {
-      if (canPTB && target.asset !== "USDC" && swapAdapter?.addSwapToTx) {
-        const tx2 = new Transaction();
-        tx2.setSender(this._address);
-        const buffer = repayAmount * 1.005;
-        const usdcCoins = await this._fetchCoins(SUPPORTED_ASSETS.USDC.type);
-        if (usdcCoins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins for swap");
-        const merged = this._mergeCoinsInTx(tx2, usdcCoins);
-        const rawSwap = BigInt(Math.floor(buffer * 10 ** SUPPORTED_ASSETS.USDC.decimals));
-        const [splitCoin] = tx2.splitCoins(merged, [rawSwap]);
-        const { outputCoin } = await swapAdapter.addSwapToTx(
-          tx2,
-          this._address,
-          splitCoin,
-          "USDC",
-          target.asset,
-          buffer
-        );
-        await adapter.addRepayToTx(tx2, this._address, outputCoin, target.asset);
-        return tx2;
-      }
-      if (canPTB && target.asset === "USDC") {
+      if (adapter.addRepayToTx) {
         const tx2 = new Transaction();
         tx2.setSender(this._address);
         const usdcCoins = await this._fetchCoins(SUPPORTED_ASSETS.USDC.type);
@@ -4106,9 +2822,6 @@ var T2000 = class _T2000 extends EventEmitter {
         await adapter.addRepayToTx(tx2, this._address, repayCoin, target.asset);
         return tx2;
       }
-      if (target.asset !== "USDC") {
-        await this._swapFromUsdc(target.asset, repayAmount * 1.005);
-      }
       const { tx } = await adapter.buildRepayTx(this._address, repayAmount, target.asset);
       return tx;
     });
@@ -4130,8 +2843,7 @@ var T2000 = class _T2000 extends EventEmitter {
       const adapter = this.registry.getLending(borrow.protocolId);
       if (adapter) entries.push({ borrow, adapter });
     }
-    const swapAdapter = this.registry.listSwap()[0];
-    const canPTB = entries.every((e) => e.adapter.addRepayToTx) && (entries.every((e) => e.borrow.asset === "USDC") || swapAdapter?.addSwapToTx);
+    const canPTB = entries.every((e) => e.adapter.addRepayToTx);
     let totalRepaid = 0;
     const gasResult = await executeWithGas(this.client, this._signer, async () => {
       if (canPTB) {
@@ -4143,35 +2855,16 @@ var T2000 = class _T2000 extends EventEmitter {
           usdcMerged = this._mergeCoinsInTx(tx, usdcCoins);
         }
         for (const { borrow, adapter } of entries) {
-          if (borrow.asset !== "USDC" && swapAdapter?.addSwapToTx) {
-            const buffer = borrow.amount * 1.005;
-            const rawSwap = BigInt(Math.floor(buffer * 10 ** SUPPORTED_ASSETS.USDC.decimals));
-            if (!usdcMerged) throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC for swap");
-            const [splitCoin] = tx.splitCoins(usdcMerged, [rawSwap]);
-            const { outputCoin } = await swapAdapter.addSwapToTx(
-              tx,
-              this._address,
-              splitCoin,
-              "USDC",
-              borrow.asset,
-              buffer
-            );
-            await adapter.addRepayToTx(tx, this._address, outputCoin, borrow.asset);
-          } else {
-            const raw = BigInt(Math.floor(borrow.amount * 10 ** SUPPORTED_ASSETS.USDC.decimals));
-            if (!usdcMerged) throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC for repayment");
-            const [repayCoin] = tx.splitCoins(usdcMerged, [raw]);
-            await adapter.addRepayToTx(tx, this._address, repayCoin, borrow.asset);
-          }
+          const raw = BigInt(Math.floor(borrow.amount * 10 ** SUPPORTED_ASSETS.USDC.decimals));
+          if (!usdcMerged) throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC for repayment");
+          const [repayCoin] = tx.splitCoins(usdcMerged, [raw]);
+          await adapter.addRepayToTx(tx, this._address, repayCoin, borrow.asset);
           totalRepaid += borrow.amount;
         }
         return tx;
       }
       let lastTx;
       for (const { borrow, adapter } of entries) {
-        if (borrow.asset !== "USDC") {
-          await this._swapFromUsdc(borrow.asset, borrow.amount * 1.005);
-        }
         const { tx } = await adapter.buildRepayTx(this._address, borrow.amount, borrow.asset);
         lastTx = tx;
         totalRepaid += borrow.amount;
@@ -4182,536 +2875,27 @@ var T2000 = class _T2000 extends EventEmitter {
     const hf = firstAdapter ? await firstAdapter.getHealth(this._address) : { borrowed: 0 };
     this.emitBalanceChange("USDC", totalRepaid, "repay", gasResult.digest);
     return {
-      success: true,
-      tx: gasResult.digest,
-      amount: totalRepaid,
-      remainingDebt: hf.borrowed,
-      gasCost: gasResult.gasCostSui,
-      gasMethod: gasResult.gasMethod
-    };
-  }
-  async maxBorrow() {
-    const adapter = await this.resolveLending(void 0, "USDC", "borrow");
-    const rawMax = await adapter.maxBorrow(this._address, "USDC");
-    return this.adjustMaxBorrowForInvestments(adapter, rawMax);
-  }
-  async healthFactor() {
-    const adapter = await this.resolveLending(void 0, "USDC", "save");
-    const hf = await adapter.getHealth(this._address);
-    if (hf.healthFactor < 1.2) {
-      this.emit("healthCritical", { healthFactor: hf.healthFactor, threshold: 1.5, severity: "critical" });
-    } else if (hf.healthFactor < 2) {
-      this.emit("healthWarning", { healthFactor: hf.healthFactor, threshold: 2, severity: "warning" });
-    }
-    return hf;
-  }
-  // -- Swap (formerly Exchange) --
-  async swap(params) {
-    this.enforcer.assertNotLocked();
-    const fromAsset = params.from;
-    const toAsset = params.to;
-    if (!(fromAsset in SUPPORTED_ASSETS) || !(toAsset in SUPPORTED_ASSETS)) {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `Swap pair ${fromAsset}/${toAsset} is not supported`);
-    }
-    if (fromAsset === toAsset) {
-      throw new T2000Error("INVALID_AMOUNT", "Cannot swap same asset");
-    }
-    const best = await this.registry.bestSwapQuote(fromAsset, toAsset, params.amount);
-    const adapter = best.adapter;
-    const fee = calculateFee("swap", params.amount);
-    const swapAmount = params.amount;
-    const slippageBps = params.maxSlippage ? Math.round(params.maxSlippage * 1e4) : void 0;
-    let swapMeta = { estimatedOut: 0, toDecimals: 0 };
-    const gasResult = await executeWithGas(this.client, this._signer, async () => {
-      const built = await adapter.buildSwapTx(this._address, fromAsset, toAsset, swapAmount, slippageBps);
-      swapMeta = { estimatedOut: built.estimatedOut, toDecimals: built.toDecimals };
-      return built.tx;
-    });
-    const toInfo = SUPPORTED_ASSETS[toAsset];
-    await this.client.waitForTransaction({ digest: gasResult.digest });
-    const txDetail = await this.client.getTransactionBlock({
-      digest: gasResult.digest,
-      options: { showBalanceChanges: true }
-    });
-    let actualReceived = 0;
-    if (txDetail.balanceChanges) {
-      for (const change of txDetail.balanceChanges) {
-        if (change.coinType === toInfo.type && change.owner && typeof change.owner === "object" && "AddressOwner" in change.owner && change.owner.AddressOwner === this._address) {
-          const amt = Number(change.amount) / 10 ** toInfo.decimals;
-          if (amt > 0) actualReceived += amt;
-        }
-      }
-    }
-    const expectedOutput = swapMeta.estimatedOut / 10 ** swapMeta.toDecimals;
-    if (actualReceived === 0) actualReceived = expectedOutput;
-    const priceImpact = expectedOutput > 0 ? Math.abs(actualReceived - expectedOutput) / expectedOutput : 0;
-    reportFee(this._address, "swap", fee.amount, fee.rate, gasResult.digest);
-    this.emitBalanceChange(fromAsset, swapAmount, "swap", gasResult.digest);
-    const stableSet = new Set(STABLE_ASSETS);
-    if (!params._skipPortfolioRecord && stableSet.has(fromAsset) && toAsset in INVESTMENT_ASSETS && actualReceived > 0) {
-      const price = swapAmount / actualReceived;
-      this.portfolio.recordBuy({
-        id: `swap_${Date.now()}`,
-        type: "buy",
-        asset: toAsset,
-        amount: actualReceived,
-        price,
-        usdValue: swapAmount,
-        fee: fee.amount,
-        tx: gasResult.digest,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    } else if (!params._skipPortfolioRecord && fromAsset in INVESTMENT_ASSETS && stableSet.has(toAsset) && actualReceived > 0) {
-      const price = actualReceived / swapAmount;
-      this.portfolio.recordSell({
-        id: `swap_${Date.now()}`,
-        type: "sell",
-        asset: fromAsset,
-        amount: swapAmount,
-        price,
-        usdValue: actualReceived,
-        fee: fee.amount,
-        tx: gasResult.digest,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    }
-    return {
-      success: true,
-      tx: gasResult.digest,
-      fromAmount: swapAmount,
-      fromAsset,
-      toAmount: actualReceived,
-      toAsset,
-      priceImpact,
-      fee: fee.amount,
-      gasCost: gasResult.gasCostSui,
-      gasMethod: gasResult.gasMethod
-    };
-  }
-  async swapQuote(params) {
-    const fromAsset = params.from;
-    const toAsset = params.to;
-    const best = await this.registry.bestSwapQuote(fromAsset, toAsset, params.amount);
-    const fee = calculateFee("swap", params.amount);
-    return { ...best.quote, fee: { amount: fee.amount, rate: fee.rate } };
-  }
-  /** @deprecated Use swap() instead */
-  async exchange(params) {
-    return this.swap(params);
-  }
-  /** @deprecated Use swapQuote() instead */
-  async exchangeQuote(params) {
-    return this.swapQuote(params);
-  }
-  // -- Investment (strategies only — individual buy/sell deprecated, use swap()) --
-  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);
-    const totalFunds = bal.available + bal.savings;
-    if (params.usdAmount > totalFunds * 1.05) {
-      throw new T2000Error(
-        "INSUFFICIENT_BALANCE",
-        `Insufficient funds. You have $${totalFunds.toFixed(2)} total (checking: $${bal.available.toFixed(2)}, savings: $${bal.savings.toFixed(2)}) but need $${params.usdAmount.toFixed(2)}.`
-      );
-    }
-    if (bal.available < params.usdAmount) {
-      await this._autoFundFromSavings(params.usdAmount - bal.available);
-    }
-    let swapResult;
-    const maxRetries = 3;
-    for (let attempt = 0; ; attempt++) {
-      try {
-        swapResult = await this.swap({
-          from: "USDC",
-          to: params.asset,
-          amount: params.usdAmount,
-          maxSlippage: params.maxSlippage ?? defaultSlippage(params.asset),
-          _skipPortfolioRecord: true
-        });
-        break;
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        const isSlippage = msg.includes("slippage") || msg.includes("amount_out_slippage");
-        if (isSlippage && attempt < maxRetries) {
-          await new Promise((r) => setTimeout(r, 2e3 * (attempt + 1)));
-          continue;
-        }
-        throw err;
-      }
-    }
-    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`);
-    }
-    let pos = this.portfolio.getPosition(params.asset);
-    const didAutoWithdraw = !!(pos?.earning && pos.earningProtocol);
-    if (didAutoWithdraw) {
-      const unearnResult = await this.investUnearn({ asset: params.asset });
-      if (unearnResult.tx) {
-        await this.client.waitForTransaction({ digest: unearnResult.tx, options: { showEffects: true } });
-      }
-      pos = this.portfolio.getPosition(params.asset);
-    }
-    const assetInfo = SUPPORTED_ASSETS[params.asset];
-    const gasReserve = params.asset === "SUI" ? GAS_RESERVE_MIN : 0;
-    let walletAmount = 0;
-    for (let attempt = 0; ; attempt++) {
-      const assetBalance = await this.client.getBalance({
-        owner: this._address,
-        coinType: assetInfo.type
-      });
-      walletAmount = Number(assetBalance.totalBalance) / 10 ** assetInfo.decimals;
-      if (!didAutoWithdraw || walletAmount > gasReserve || attempt >= 5) break;
-      await new Promise((r) => setTimeout(r, 1500));
-    }
-    const maxSellable = Math.max(0, walletAmount - gasReserve);
-    const trackedAmount = pos ? pos.totalAmount : maxSellable;
-    if (trackedAmount <= 0) {
-      throw new T2000Error("INSUFFICIENT_INVESTMENT", `No ${params.asset} position to sell`);
-    }
-    let sellAmountAsset;
-    if (params.usdAmount === "all") {
-      sellAmountAsset = Math.min(trackedAmount, maxSellable);
-    } else {
-      const swapAdapter = this.registry.listSwap()[0];
-      if (!swapAdapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", "No swap adapter available");
-      const quote = await swapAdapter.getQuote("USDC", params.asset, 1);
-      const assetPrice = 1 / quote.expectedOutput;
-      sellAmountAsset = params.usdAmount / assetPrice;
-      const maxPosition = params._strategyOnly ? maxSellable : trackedAmount;
-      sellAmountAsset = Math.min(sellAmountAsset, maxPosition);
-      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");
-    }
-    let swapResult;
-    const maxRetries = 3;
-    for (let attempt = 0; ; attempt++) {
-      try {
-        swapResult = await this.swap({
-          from: params.asset,
-          to: "USDC",
-          amount: sellAmountAsset,
-          maxSlippage: params.maxSlippage ?? defaultSlippage(params.asset),
-          _skipPortfolioRecord: true
-        });
-        break;
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        const isSlippage = msg.includes("slippage") || msg.includes("amount_out_slippage");
-        if (isSlippage && attempt < maxRetries) {
-          await new Promise((r) => setTimeout(r, 2e3 * (attempt + 1)));
-          continue;
-        }
-        throw err;
-      }
-    }
-    const price = swapResult.toAmount / sellAmountAsset;
-    const directAmountBeforeSell = this.portfolio.getDirectAmount(params.asset);
-    let realizedPnL = 0;
-    try {
-      realizedPnL = this.portfolio.recordSell({
-        id: `inv_${Date.now()}`,
-        type: "sell",
-        asset: params.asset,
-        amount: sellAmountAsset,
-        price,
-        usdValue: swapResult.toAmount,
-        fee: swapResult.fee,
-        tx: swapResult.tx,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    } catch {
-    }
-    if (params.usdAmount === "all" && !params._strategyOnly) {
-      this.portfolio.closePosition(params.asset);
-      this.portfolio.deductFromStrategies(params.asset, sellAmountAsset);
-    } else if (!params._strategyOnly && sellAmountAsset > 0) {
-      const overflowIntoStrategy = sellAmountAsset - directAmountBeforeSell;
-      if (overflowIntoStrategy > 0) {
-        this.portfolio.deductFromStrategies(params.asset, overflowIntoStrategy);
-      }
-    }
-    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 investEarn(params) {
-    this.enforcer.assertNotLocked();
-    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 earn on`);
-    }
-    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 depositAmount = Math.min(pos.totalAmount, Math.max(0, walletAmount - gasReserve));
-    if (pos.earning) {
-      throw new T2000Error("INVEST_ALREADY_EARNING", `${params.asset} is already earning via ${pos.earningProtocol ?? "lending"}`);
-    }
-    if (depositAmount <= 0) {
-      throw new T2000Error("INSUFFICIENT_BALANCE", `No ${params.asset} available to deposit (wallet: ${walletAmount}, gas reserve: ${gasReserve})`);
-    }
-    let adapter;
-    let rate;
-    if (params.protocol) {
-      const specific = this.registry.getLending(params.protocol);
-      if (!specific) throw new T2000Error("PROTOCOL_UNAVAILABLE", `Protocol ${params.protocol} not found`);
-      adapter = specific;
-      rate = await specific.getRates(params.asset);
-    } else {
-      ({ adapter, rate } = await this.registry.bestSaveRate(params.asset));
-    }
-    const gasResult = await executeWithGas(this.client, this._signer, async () => {
-      const { tx } = await adapter.buildSaveTx(this._address, depositAmount, params.asset);
-      return tx;
-    });
-    this.portfolio.recordEarn(params.asset, adapter.id, rate.saveApy);
-    return {
-      success: true,
-      tx: gasResult.digest,
-      asset: params.asset,
-      amount: depositAmount,
-      protocol: adapter.name,
-      apy: rate.saveApy,
-      gasCost: gasResult.gasCostSui,
-      gasMethod: gasResult.gasMethod
-    };
-  }
-  async investUnearn(params) {
-    this.enforcer.assertNotLocked();
-    if (!(params.asset in INVESTMENT_ASSETS)) {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `${params.asset} is not available for investment`);
-    }
-    let pos = this.portfolio.getPosition(params.asset);
-    let adapter;
-    let withdrawAmount;
-    if (pos?.earning && pos.earningProtocol) {
-      adapter = this.registry.getLending(pos.earningProtocol);
-      withdrawAmount = pos.totalAmount;
-    } else {
-      const onChain = await this.registry.allPositions(this._address);
-      let found;
-      for (const entry of onChain) {
-        const supply = entry.positions.supplies.find((s) => s.asset === params.asset);
-        if (supply && supply.amount > 1e-10) {
-          found = { protocolId: entry.protocolId, amount: supply.amount };
-          break;
-        }
-      }
-      if (!found) {
-        throw new T2000Error("INVEST_NOT_EARNING", `${params.asset} is not currently earning (checked on-chain)`);
-      }
-      adapter = this.registry.getLending(found.protocolId);
-      withdrawAmount = found.amount;
-    }
-    if (!adapter) {
-      throw new T2000Error("PROTOCOL_UNAVAILABLE", `Lending protocol not found for ${params.asset}`);
-    }
-    const protocolName = adapter.name;
-    let effectiveAmount = withdrawAmount;
-    const gasResult = await executeWithGas(this.client, this._signer, async () => {
-      const result = await adapter.buildWithdrawTx(this._address, withdrawAmount, params.asset);
-      effectiveAmount = result.effectiveAmount;
-      return result.tx;
-    });
-    try {
-      this.portfolio.recordUnearn(params.asset);
-    } catch {
-    }
-    return {
-      success: true,
-      tx: gasResult.digest,
-      asset: params.asset,
-      amount: effectiveAmount,
-      protocol: protocolName,
-      apy: 0,
-      gasCost: gasResult.gasCostSui,
-      gasMethod: gasResult.gasMethod
-    };
-  }
-  // -- Invest Rebalance --
-  async investRebalance(opts = {}) {
-    this.enforcer.assertNotLocked();
-    const minDiff = opts.minYieldDiff ?? 0.1;
-    const positions = this.portfolio.getPositions().filter((p) => p.earning && p.earningProtocol);
-    if (positions.length === 0) {
-      return { executed: false, moves: [], totalGasCost: 0, skipped: [] };
-    }
-    const moves = [];
-    const skipped = [];
-    let totalGasCost = 0;
-    for (const pos of positions) {
-      const currentProtocol = pos.earningProtocol;
-      let best;
-      try {
-        best = await this.registry.bestSaveRate(pos.asset);
-      } catch {
-        const currentApy2 = pos.earningApy ?? 0;
-        skipped.push({ asset: pos.asset, protocol: currentProtocol, apy: currentApy2, bestApy: currentApy2, reason: "no_rates" });
-        continue;
-      }
-      let currentApy = pos.earningApy ?? 0;
-      try {
-        const currentAdapter = this.registry.getLending(currentProtocol);
-        if (currentAdapter) {
-          const liveRate = await currentAdapter.getRates(pos.asset);
-          currentApy = liveRate.saveApy;
-        }
-      } catch {
-      }
-      const apyGain = best.rate.saveApy - currentApy;
-      if (best.adapter.id === currentProtocol || apyGain <= 0) {
-        skipped.push({ asset: pos.asset, protocol: currentProtocol, apy: currentApy, bestApy: best.rate.saveApy, reason: "already_best" });
-        continue;
-      }
-      if (apyGain < minDiff) {
-        skipped.push({ asset: pos.asset, protocol: currentProtocol, apy: currentApy, bestApy: best.rate.saveApy, reason: "below_threshold" });
-        continue;
-      }
-      if (opts.dryRun) {
-        moves.push({
-          asset: pos.asset,
-          fromProtocol: this.registry.getLending(currentProtocol)?.name ?? currentProtocol,
-          toProtocol: best.adapter.name,
-          amount: pos.totalAmount,
-          oldApy: currentApy,
-          newApy: best.rate.saveApy,
-          txDigests: [],
-          gasCost: 0
-        });
-        continue;
-      }
-      const txDigests = [];
-      let moveGasCost = 0;
-      const fromAdapter = this.registry.getLending(currentProtocol);
-      if (!fromAdapter) {
-        skipped.push({ asset: pos.asset, protocol: currentProtocol, apy: currentApy, bestApy: best.rate.saveApy, reason: "protocol_unavailable" });
-        continue;
-      }
-      const withdrawResult = await executeWithGas(this.client, this._signer, async () => {
-        const result = await fromAdapter.buildWithdrawTx(this._address, pos.totalAmount, pos.asset);
-        return result.tx;
-      });
-      txDigests.push(withdrawResult.digest);
-      moveGasCost += withdrawResult.gasCostSui;
-      const depositResult = await executeWithGas(this.client, this._signer, async () => {
-        const assetInfo = SUPPORTED_ASSETS[pos.asset];
-        const balance = await this.client.getBalance({ owner: this._address, coinType: assetInfo.type });
-        const available = Number(balance.totalBalance) / 10 ** assetInfo.decimals;
-        const gasReserve = pos.asset === "SUI" ? GAS_RESERVE_MIN : 0;
-        const depositAmount = Math.max(0, available - gasReserve);
-        const { tx } = await best.adapter.buildSaveTx(this._address, depositAmount, pos.asset);
-        return tx;
-      });
-      txDigests.push(depositResult.digest);
-      moveGasCost += depositResult.gasCostSui;
-      this.portfolio.recordUnearn(pos.asset);
-      this.portfolio.recordEarn(pos.asset, best.adapter.id, best.rate.saveApy);
-      moves.push({
-        asset: pos.asset,
-        fromProtocol: fromAdapter.name,
-        toProtocol: best.adapter.name,
-        amount: pos.totalAmount,
-        oldApy: currentApy,
-        newApy: best.rate.saveApy,
-        txDigests,
-        gasCost: moveGasCost
-      });
-      totalGasCost += moveGasCost;
+      success: true,
+      tx: gasResult.digest,
+      amount: totalRepaid,
+      remainingDebt: hf.borrowed,
+      gasCost: gasResult.gasCostSui,
+      gasMethod: gasResult.gasMethod
+    };
+  }
+  async maxBorrow() {
+    const adapter = await this.resolveLending(void 0, "USDC", "borrow");
+    return adapter.maxBorrow(this._address, "USDC");
+  }
+  async healthFactor() {
+    const adapter = await this.resolveLending(void 0, "USDC", "save");
+    const hf = await adapter.getHealth(this._address);
+    if (hf.healthFactor < 1.2) {
+      this.emit("healthCritical", { healthFactor: hf.healthFactor, threshold: 1.5, severity: "critical" });
+    } else if (hf.healthFactor < 2) {
+      this.emit("healthWarning", { healthFactor: hf.healthFactor, threshold: 2, severity: "warning" });
     }
-    return { executed: !opts.dryRun && moves.length > 0, moves, totalGasCost, skipped };
+    return hf;
   }
   // -- Claim Rewards --
   async getPendingRewards() {
@@ -4729,7 +2913,7 @@ var T2000 = class _T2000 extends EventEmitter {
     this.enforcer.assertNotLocked();
     const adapters = this.registry.listLending().filter((a) => a.addClaimRewardsToTx);
     if (adapters.length === 0) {
-      return { success: true, tx: "", rewards: [], totalValueUsd: 0, usdcReceived: 0, gasCost: 0, gasMethod: "none" };
+      return { success: true, tx: "", rewards: [], totalValueUsd: 0, gasCost: 0, gasMethod: "none" };
     }
     const tx = new Transaction();
     tx.setSender(this._address);
@@ -4742,698 +2926,20 @@ var T2000 = class _T2000 extends EventEmitter {
       }
     }
     if (allRewards.length === 0) {
-      return { success: true, tx: "", rewards: [], totalValueUsd: 0, usdcReceived: 0, gasCost: 0, gasMethod: "none" };
+      return { success: true, tx: "", rewards: [], totalValueUsd: 0, gasCost: 0, gasMethod: "none" };
     }
     const claimResult = await executeWithGas(this.client, this._signer, async () => tx);
     await this.client.waitForTransaction({ digest: claimResult.digest });
-    const usdcReceived = await this.swapRewardTokensToUsdc(allRewards);
+    const totalValueUsd = allRewards.reduce((s, r) => s + r.estimatedValueUsd, 0);
     return {
       success: true,
       tx: claimResult.digest,
       rewards: allRewards,
-      totalValueUsd: usdcReceived,
-      usdcReceived,
+      totalValueUsd,
       gasCost: claimResult.gasCostSui,
       gasMethod: claimResult.gasMethod
     };
   }
-  async swapRewardTokensToUsdc(rewards) {
-    const uniqueTokens = [...new Set(rewards.map((r) => r.coinType))];
-    const usdcType = SUPPORTED_ASSETS.USDC.type;
-    const usdcDecimals = SUPPORTED_ASSETS.USDC.decimals;
-    let totalUsdc = 0;
-    for (const coinType of uniqueTokens) {
-      try {
-        const balResult = await this.client.getBalance({
-          owner: this._address,
-          coinType
-        });
-        const rawBalance = BigInt(balResult.totalBalance);
-        if (rawBalance <= 0n) continue;
-        const decimals = REWARD_TOKEN_DECIMALS[coinType] ?? 9;
-        const swapResult = await buildRawSwapTx({
-          client: this.client,
-          address: this._address,
-          fromCoinType: coinType,
-          fromDecimals: decimals,
-          toCoinType: usdcType,
-          toDecimals: usdcDecimals,
-          amount: rawBalance
-        });
-        const gasResult = await executeWithGas(this.client, this._signer, async () => swapResult.tx);
-        await this.client.waitForTransaction({ digest: gasResult.digest });
-        totalUsdc += swapResult.estimatedOut / 10 ** usdcDecimals;
-      } catch {
-      }
-    }
-    return totalUsdc;
-  }
-  // -- 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");
-    }
-    this.enforcer.check({ operation: "invest", amount: params.usdAmount });
-    const bal = await queryBalance(this.client, this._address);
-    const totalFunds = bal.available + bal.savings;
-    if (params.usdAmount > totalFunds * 1.05) {
-      throw new T2000Error(
-        "INSUFFICIENT_BALANCE",
-        `Insufficient funds. You have $${totalFunds.toFixed(2)} total (checking: $${bal.available.toFixed(2)}, savings: $${bal.savings.toFixed(2)}) but need $${params.usdAmount.toFixed(2)}.`
-      );
-    }
-    if (bal.available < params.usdAmount && !params.dryRun) {
-      await this._autoFundFromSavings(params.usdAmount - bal.available);
-    }
-    const buys = [];
-    const allocEntries = Object.entries(definition.allocations);
-    if (params.dryRun) {
-      const swapAdapter2 = this.registry.listSwap()[0];
-      for (const [asset, pct] of allocEntries) {
-        const assetUsd = params.usdAmount * (pct / 100);
-        let estAmount = 0;
-        let estPrice = 0;
-        try {
-          if (swapAdapter2) {
-            const quote = await swapAdapter2.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" };
-    }
-    const swapAdapter = this.registry.listSwap()[0];
-    if (!swapAdapter?.addSwapToTx) {
-      throw new T2000Error("PROTOCOL_UNAVAILABLE", "Swap adapter does not support composable PTB");
-    }
-    let swapMetas = [];
-    const gasResult = await executeWithGas(this.client, this._signer, async () => {
-      swapMetas = [];
-      const tx = new Transaction();
-      tx.setSender(this._address);
-      const usdcCoins = await this._fetchCoins(SUPPORTED_ASSETS.USDC.type);
-      if (usdcCoins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins found");
-      const mergedUsdc = this._mergeCoinsInTx(tx, usdcCoins);
-      const splitAmounts = allocEntries.map(
-        ([, pct]) => BigInt(Math.floor(params.usdAmount * (pct / 100) * 10 ** SUPPORTED_ASSETS.USDC.decimals))
-      );
-      const splitCoins = tx.splitCoins(mergedUsdc, splitAmounts);
-      const outputCoins = [];
-      for (let i = 0; i < allocEntries.length; i++) {
-        const [asset] = allocEntries[i];
-        const assetUsd = params.usdAmount * (allocEntries[i][1] / 100);
-        const { outputCoin, estimatedOut, toDecimals } = await swapAdapter.addSwapToTx(
-          tx,
-          this._address,
-          splitCoins[i],
-          "USDC",
-          asset,
-          assetUsd
-        );
-        outputCoins.push(outputCoin);
-        swapMetas.push({ asset, usdAmount: assetUsd, estimatedOut, toDecimals });
-      }
-      tx.transferObjects(outputCoins, this._address);
-      return tx;
-    });
-    const digest = gasResult.digest;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    for (const meta of swapMetas) {
-      const amount = meta.estimatedOut / 10 ** meta.toDecimals;
-      const price = meta.usdAmount / amount;
-      this.portfolio.recordBuy({
-        id: `inv_${Date.now()}_${meta.asset}`,
-        type: "buy",
-        asset: meta.asset,
-        amount,
-        price,
-        usdValue: meta.usdAmount,
-        fee: 0,
-        tx: digest,
-        timestamp: now
-      });
-      this.portfolio.recordStrategyBuy(params.strategy, {
-        id: `strat_${Date.now()}_${meta.asset}`,
-        type: "buy",
-        asset: meta.asset,
-        amount,
-        price,
-        usdValue: meta.usdAmount,
-        fee: 0,
-        tx: digest,
-        timestamp: now
-      });
-      buys.push({ asset: meta.asset, usdAmount: meta.usdAmount, amount, price, tx: digest });
-    }
-    return {
-      success: true,
-      strategy: params.strategy,
-      totalInvested: params.usdAmount,
-      buys,
-      gasCost: gasResult.gasCostSui,
-      gasMethod: gasResult.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 swapAdapter = this.registry.listSwap()[0];
-    if (!swapAdapter?.addSwapToTx) {
-      throw new T2000Error("PROTOCOL_UNAVAILABLE", "Swap adapter does not support composable PTB");
-    }
-    const unearnFailures = [];
-    for (const pos of stratPositions) {
-      try {
-        await this.investUnearn({ asset: pos.asset });
-        await new Promise((r) => setTimeout(r, 1500));
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        if (!msg.includes("not currently earning")) {
-          unearnFailures.push({ asset: pos.asset, error: msg });
-        }
-      }
-    }
-    let swapMetas = [];
-    const buildSellPtb = async () => {
-      swapMetas = [];
-      const tx = new Transaction();
-      tx.setSender(this._address);
-      const usdcOutputs = [];
-      for (const pos of stratPositions) {
-        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 sellAmount = Math.max(0, Math.min(pos.totalAmount, walletAmount) - gasReserve);
-        if (sellAmount <= 0) continue;
-        const rawAmount = BigInt(Math.floor(sellAmount * 10 ** assetInfo.decimals));
-        let splitCoin;
-        if (pos.asset === "SUI") {
-          [splitCoin] = tx.splitCoins(tx.gas, [rawAmount]);
-        } else {
-          const coins = await this._fetchCoins(assetInfo.type);
-          if (coins.length === 0) continue;
-          const merged = this._mergeCoinsInTx(tx, coins);
-          [splitCoin] = tx.splitCoins(merged, [rawAmount]);
-        }
-        const slippageBps = LOW_LIQUIDITY_ASSETS.has(pos.asset) ? 500 : 300;
-        const { outputCoin, estimatedOut, toDecimals } = await swapAdapter.addSwapToTx(
-          tx,
-          this._address,
-          splitCoin,
-          pos.asset,
-          "USDC",
-          sellAmount,
-          slippageBps
-        );
-        usdcOutputs.push(outputCoin);
-        swapMetas.push({ asset: pos.asset, amount: sellAmount, estimatedOut, toDecimals });
-      }
-      if (usdcOutputs.length === 0) {
-        throw new T2000Error("INSUFFICIENT_BALANCE", "No assets available to sell");
-      }
-      if (usdcOutputs.length > 1) {
-        tx.mergeCoins(usdcOutputs[0], usdcOutputs.slice(1));
-      }
-      tx.transferObjects([usdcOutputs[0]], this._address);
-      return tx;
-    };
-    let gasResult;
-    const MAX_RETRIES = 3;
-    for (let attempt = 0; ; attempt++) {
-      try {
-        gasResult = await executeWithGas(this.client, this._signer, buildSellPtb);
-        break;
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        const isSlippage = msg.includes("slippage") || msg.includes("amount_out_slippage");
-        if (isSlippage && attempt < MAX_RETRIES) {
-          await new Promise((r) => setTimeout(r, 2e3 * (attempt + 1)));
-          continue;
-        }
-        throw err;
-      }
-    }
-    const digest = gasResult.digest;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const sells = [];
-    let totalProceeds = 0;
-    let totalPnL = 0;
-    for (const meta of swapMetas) {
-      const usdValue = meta.estimatedOut / 10 ** meta.toDecimals;
-      const price = meta.amount > 0 ? usdValue / meta.amount : 0;
-      let pnl = 0;
-      try {
-        pnl = this.portfolio.recordStrategySell(params.strategy, {
-          id: `strat_sell_${Date.now()}_${meta.asset}`,
-          type: "sell",
-          asset: meta.asset,
-          amount: meta.amount,
-          price,
-          usdValue,
-          fee: 0,
-          tx: digest,
-          timestamp: now
-        });
-      } catch {
-      }
-      try {
-        this.portfolio.recordSell({
-          id: `inv_sell_${Date.now()}_${meta.asset}`,
-          type: "sell",
-          asset: meta.asset,
-          amount: meta.amount,
-          price,
-          usdValue,
-          fee: 0,
-          tx: digest,
-          timestamp: now
-        });
-      } catch {
-      }
-      sells.push({ asset: meta.asset, amount: meta.amount, usdValue, realizedPnL: pnl, tx: digest });
-      totalProceeds += usdValue;
-      totalPnL += pnl;
-    }
-    if (this.portfolio.hasStrategyPositions(params.strategy)) {
-      if (unearnFailures.length === 0) {
-        this.portfolio.clearStrategy(params.strategy);
-      } else {
-        for (const s of sells) {
-          this.portfolio.closeStrategyPosition(params.strategy, s.asset);
-        }
-      }
-    }
-    const failed = unearnFailures.map((f) => ({ asset: f.asset, reason: f.error }));
-    return {
-      success: true,
-      strategy: params.strategy,
-      totalProceeds,
-      realizedPnL: totalPnL,
-      sells,
-      failed: failed.length > 0 ? failed : void 0,
-      gasCost: gasResult.gasCostSui,
-      gasMethod: gasResult.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 threshold = 3;
-    const sellOps = [];
-    const buyOps = [];
-    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) {
-        buyOps.push({ asset, usdAmount: usdDiff });
-      } else {
-        const price = prices[asset] ?? 1;
-        const assetAmount = price > 0 ? usdDiff / price : 0;
-        sellOps.push({ asset, usdAmount: usdDiff, assetAmount });
-      }
-    }
-    if (sellOps.length === 0 && buyOps.length === 0) {
-      return { success: true, strategy: params.strategy, trades: [], beforeWeights, afterWeights: { ...beforeWeights }, targetWeights: { ...definition.allocations } };
-    }
-    if (!swapAdapter?.addSwapToTx) {
-      throw new T2000Error("PROTOCOL_UNAVAILABLE", "Swap adapter does not support composable PTB");
-    }
-    const tradeMetas = [];
-    const gasResult = await executeWithGas(this.client, this._signer, async () => {
-      tradeMetas.length = 0;
-      const tx = new Transaction();
-      tx.setSender(this._address);
-      const usdcCoins = [];
-      for (const sell of sellOps) {
-        const assetInfo = SUPPORTED_ASSETS[sell.asset];
-        const bal = await this.client.getBalance({ owner: this._address, coinType: assetInfo.type });
-        const walletAmount = Number(bal.totalBalance) / 10 ** assetInfo.decimals;
-        const gasReserve = sell.asset === "SUI" ? GAS_RESERVE_MIN : 0;
-        const sellAmount = Math.max(0, Math.min(sell.assetAmount, walletAmount) - gasReserve);
-        if (sellAmount <= 0) continue;
-        const rawAmount = BigInt(Math.floor(sellAmount * 10 ** assetInfo.decimals));
-        let splitCoin;
-        if (sell.asset === "SUI") {
-          [splitCoin] = tx.splitCoins(tx.gas, [rawAmount]);
-        } else {
-          const coins = await this._fetchCoins(assetInfo.type);
-          if (coins.length === 0) continue;
-          const merged = this._mergeCoinsInTx(tx, coins);
-          [splitCoin] = tx.splitCoins(merged, [rawAmount]);
-        }
-        const slippageBps = LOW_LIQUIDITY_ASSETS.has(sell.asset) ? 500 : 300;
-        const { outputCoin, estimatedOut, toDecimals } = await swapAdapter.addSwapToTx(
-          tx,
-          this._address,
-          splitCoin,
-          sell.asset,
-          "USDC",
-          sellAmount,
-          slippageBps
-        );
-        usdcCoins.push(outputCoin);
-        tradeMetas.push({ action: "sell", asset: sell.asset, usdAmount: sell.usdAmount, estimatedOut, toDecimals });
-      }
-      if (buyOps.length > 0) {
-        const walletUsdc = await this._fetchCoins(SUPPORTED_ASSETS.USDC.type);
-        if (walletUsdc.length > 0) {
-          usdcCoins.push(this._mergeCoinsInTx(tx, walletUsdc));
-        }
-        if (usdcCoins.length === 0) {
-          throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC available for rebalance buys");
-        }
-        if (usdcCoins.length > 1) {
-          tx.mergeCoins(usdcCoins[0], usdcCoins.slice(1));
-        }
-        const mergedUsdc = usdcCoins[0];
-        const splitAmounts = buyOps.map(
-          (b) => BigInt(Math.floor(b.usdAmount * 10 ** SUPPORTED_ASSETS.USDC.decimals))
-        );
-        const splitCoins = tx.splitCoins(mergedUsdc, splitAmounts);
-        const outputCoins = [];
-        for (let i = 0; i < buyOps.length; i++) {
-          const buy = buyOps[i];
-          const slippageBps = LOW_LIQUIDITY_ASSETS.has(buy.asset) ? 500 : 300;
-          const { outputCoin, estimatedOut, toDecimals } = await swapAdapter.addSwapToTx(
-            tx,
-            this._address,
-            splitCoins[i],
-            "USDC",
-            buy.asset,
-            buy.usdAmount,
-            slippageBps
-          );
-          outputCoins.push(outputCoin);
-          tradeMetas.push({ action: "buy", asset: buy.asset, usdAmount: buy.usdAmount, estimatedOut, toDecimals });
-        }
-        tx.transferObjects(outputCoins, this._address);
-      }
-      return tx;
-    });
-    const digest = gasResult.digest;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const trades = [];
-    for (const meta of tradeMetas) {
-      const rawAmount = meta.estimatedOut / 10 ** meta.toDecimals;
-      if (meta.action === "sell") {
-        const price = meta.usdAmount > 0 && rawAmount > 0 ? meta.usdAmount / rawAmount : prices[meta.asset] ?? 0;
-        const assetAmount = prices[meta.asset] > 0 ? meta.usdAmount / prices[meta.asset] : 0;
-        this.portfolio.recordStrategySell(params.strategy, {
-          id: `strat_rebal_${Date.now()}_${meta.asset}`,
-          type: "sell",
-          asset: meta.asset,
-          amount: assetAmount,
-          price,
-          usdValue: meta.usdAmount,
-          fee: 0,
-          tx: digest,
-          timestamp: now
-        });
-        this.portfolio.recordSell({
-          id: `inv_rebal_${Date.now()}_${meta.asset}`,
-          type: "sell",
-          asset: meta.asset,
-          amount: assetAmount,
-          price,
-          usdValue: meta.usdAmount,
-          fee: 0,
-          tx: digest,
-          timestamp: now
-        });
-        trades.push({ action: "sell", asset: meta.asset, usdAmount: meta.usdAmount, amount: assetAmount, tx: digest });
-      } else {
-        const amount = rawAmount;
-        const price = meta.usdAmount / amount;
-        this.portfolio.recordBuy({
-          id: `inv_rebal_${Date.now()}_${meta.asset}`,
-          type: "buy",
-          asset: meta.asset,
-          amount,
-          price,
-          usdValue: meta.usdAmount,
-          fee: 0,
-          tx: digest,
-          timestamp: now
-        });
-        this.portfolio.recordStrategyBuy(params.strategy, {
-          id: `strat_rebal_${Date.now()}_${meta.asset}`,
-          type: "buy",
-          asset: meta.asset,
-          amount,
-          price,
-          usdValue: meta.usdAmount,
-          fee: 0,
-          tx: digest,
-          timestamp: now
-        });
-        trades.push({ action: "buy", asset: meta.asset, usdAmount: meta.usdAmount, amount, tx: digest });
-      }
-    }
-    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();
-    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 enrichPosition = async (pos, adjustWallet) => {
-      const currentPrice = prices[pos.asset] ?? 0;
-      let totalAmount = pos.totalAmount;
-      let costBasis = pos.costBasis;
-      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 });
-          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;
-      return {
-        asset: pos.asset,
-        totalAmount,
-        costBasis,
-        avgPrice: pos.avgPrice,
-        currentPrice,
-        currentValue,
-        unrealizedPnL,
-        unrealizedPnLPct,
-        trades: pos.trades,
-        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 strategyAmountByAsset = {};
-    for (const strats of Object.values(strategyPositions)) {
-      for (const sp of strats) {
-        const prev = strategyAmountByAsset[sp.asset] ?? { amount: 0, costBasis: 0 };
-        strategyAmountByAsset[sp.asset] = {
-          amount: prev.amount + sp.totalAmount,
-          costBasis: prev.costBasis + sp.costBasis
-        };
-      }
-    }
-    const directOnly = enriched.map((pos) => {
-      const strat = strategyAmountByAsset[pos.asset];
-      if (!strat) return pos;
-      const directAmt = pos.totalAmount - strat.amount;
-      if (directAmt <= 1e-6) return null;
-      const directCost = pos.costBasis - strat.costBasis;
-      const currentValue = directAmt * (pos.currentPrice ?? 0);
-      return {
-        ...pos,
-        totalAmount: directAmt,
-        costBasis: directCost,
-        currentValue,
-        unrealizedPnL: currentValue - directCost,
-        unrealizedPnLPct: directCost > 0 ? (currentValue - directCost) / directCost * 100 : 0
-      };
-    }).filter((p) => p !== null);
-    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;
-    const result = {
-      positions: directOnly,
-      totalInvested,
-      totalValue,
-      unrealizedPnL: totalUnrealizedPnL,
-      unrealizedPnLPct: totalUnrealizedPnLPct,
-      realizedPnL
-    };
-    if (Object.keys(strategyPositions).length > 0) {
-      result.strategyPositions = strategyPositions;
-    }
-    return result;
-  }
   // -- Info --
   async positions() {
     const allPositions = await this.registry.allPositions(this._address);
@@ -5476,274 +2982,6 @@ var T2000 = class _T2000 extends EventEmitter {
   async allRatesAcrossAssets() {
     return this.registry.allRatesAcrossAssets();
   }
-  async rebalance(opts = {}) {
-    this.enforcer.assertNotLocked();
-    const dryRun = opts.dryRun ?? false;
-    const minYieldDiff = opts.minYieldDiff ?? 0.5;
-    const maxBreakEven = opts.maxBreakEven ?? 30;
-    const [allPositions, allRates] = await Promise.all([
-      this.registry.allPositions(this._address),
-      this.registry.allRatesAcrossAssets()
-    ]);
-    const earningAssets = new Set(
-      this.portfolio.getPositions().filter((p) => p.earning).map((p) => p.asset)
-    );
-    const savePositions = allPositions.flatMap(
-      (p) => p.positions.supplies.filter((s) => s.amount > 0.01).filter((s) => !earningAssets.has(s.asset)).filter((s) => !(s.asset in INVESTMENT_ASSETS)).map((s) => ({
-        protocolId: p.protocolId,
-        protocol: p.protocol,
-        asset: s.asset,
-        amount: s.amount,
-        apy: s.apy
-      }))
-    );
-    if (savePositions.length === 0) {
-      throw new T2000Error("NO_COLLATERAL", "No savings positions to rebalance. Use `t2000 save <amount>` first.");
-    }
-    const borrowPositions = allPositions.flatMap(
-      (p) => p.positions.borrows.filter((b) => b.amount > 0.01)
-    );
-    if (borrowPositions.length > 0) {
-      const healthResults = await Promise.all(
-        allPositions.filter((p) => p.positions.borrows.some((b) => b.amount > 0.01)).map(async (p) => {
-          const adapter = this.registry.getLending(p.protocolId);
-          if (!adapter) return null;
-          return adapter.getHealth(this._address);
-        })
-      );
-      for (const hf of healthResults) {
-        if (hf && hf.healthFactor < 1.5) {
-          throw new T2000Error(
-            "HEALTH_FACTOR_TOO_LOW",
-            `Cannot rebalance \u2014 health factor is ${hf.healthFactor.toFixed(2)} (minimum 1.5). Repay some debt first.`,
-            { healthFactor: hf.healthFactor }
-          );
-        }
-      }
-    }
-    const stableSet = new Set(STABLE_ASSETS);
-    const stableRates = allRates.filter((r) => stableSet.has(r.asset));
-    if (stableRates.length === 0) {
-      throw new T2000Error("PROTOCOL_UNAVAILABLE", "No stablecoin lending rates available for rebalance");
-    }
-    const bestRate = stableRates.reduce(
-      (best, r) => r.rates.saveApy > best.rates.saveApy ? r : best
-    );
-    const current = savePositions.reduce(
-      (worst, p) => p.apy < worst.apy ? p : worst
-    );
-    const withdrawAdapter = this.registry.getLending(current.protocolId);
-    if (withdrawAdapter) {
-      try {
-        const maxResult = await withdrawAdapter.maxWithdraw(this._address, current.asset);
-        if (maxResult.maxAmount < current.amount) {
-          current.amount = Math.max(0, maxResult.maxAmount - 0.01);
-        }
-      } catch {
-      }
-    }
-    if (current.amount <= 0.01) {
-      throw new T2000Error(
-        "HEALTH_FACTOR_TOO_LOW",
-        "Cannot rebalance \u2014 active borrows prevent safe withdrawal. Repay some debt first."
-      );
-    }
-    const apyDiff = bestRate.rates.saveApy - current.apy;
-    const isSameProtocol = current.protocolId === bestRate.protocolId;
-    const isSameAsset = current.asset === bestRate.asset;
-    if (apyDiff < minYieldDiff) {
-      return {
-        executed: false,
-        steps: [],
-        fromProtocol: current.protocol,
-        fromAsset: current.asset,
-        toProtocol: bestRate.protocol,
-        toAsset: bestRate.asset,
-        amount: current.amount,
-        currentApy: current.apy,
-        newApy: bestRate.rates.saveApy,
-        annualGain: current.amount * apyDiff / 100,
-        estimatedSwapCost: 0,
-        breakEvenDays: Infinity,
-        txDigests: [],
-        totalGasCost: 0
-      };
-    }
-    if (isSameProtocol && isSameAsset) {
-      return {
-        executed: false,
-        steps: [],
-        fromProtocol: current.protocol,
-        fromAsset: current.asset,
-        toProtocol: bestRate.protocol,
-        toAsset: bestRate.asset,
-        amount: current.amount,
-        currentApy: current.apy,
-        newApy: bestRate.rates.saveApy,
-        annualGain: 0,
-        estimatedSwapCost: 0,
-        breakEvenDays: Infinity,
-        txDigests: [],
-        totalGasCost: 0
-      };
-    }
-    const steps = [];
-    let estimatedSwapCost = 0;
-    steps.push({
-      action: "withdraw",
-      protocol: current.protocolId,
-      fromAsset: current.asset,
-      amount: current.amount
-    });
-    let amountToDeposit = current.amount;
-    if (!isSameAsset) {
-      try {
-        const quote = await this.registry.bestSwapQuote(current.asset, bestRate.asset, current.amount);
-        amountToDeposit = quote.quote.expectedOutput;
-        estimatedSwapCost = Math.abs(current.amount - amountToDeposit);
-      } catch {
-        estimatedSwapCost = current.amount * 3e-3;
-        amountToDeposit = current.amount - estimatedSwapCost;
-      }
-      steps.push({
-        action: "swap",
-        fromAsset: current.asset,
-        toAsset: bestRate.asset,
-        amount: current.amount,
-        estimatedOutput: amountToDeposit
-      });
-    }
-    steps.push({
-      action: "deposit",
-      protocol: bestRate.protocolId,
-      toAsset: bestRate.asset,
-      amount: amountToDeposit
-    });
-    const annualGain = amountToDeposit * apyDiff / 100;
-    const breakEvenDays = estimatedSwapCost > 0 ? Math.ceil(estimatedSwapCost / annualGain * 365) : 0;
-    if (breakEvenDays > maxBreakEven && estimatedSwapCost > 0) {
-      return {
-        executed: false,
-        steps,
-        fromProtocol: current.protocol,
-        fromAsset: current.asset,
-        toProtocol: bestRate.protocol,
-        toAsset: bestRate.asset,
-        amount: current.amount,
-        currentApy: current.apy,
-        newApy: bestRate.rates.saveApy,
-        annualGain,
-        estimatedSwapCost,
-        breakEvenDays,
-        txDigests: [],
-        totalGasCost: 0
-      };
-    }
-    if (dryRun) {
-      return {
-        executed: false,
-        steps,
-        fromProtocol: current.protocol,
-        fromAsset: current.asset,
-        toProtocol: bestRate.protocol,
-        toAsset: bestRate.asset,
-        amount: current.amount,
-        currentApy: current.apy,
-        newApy: bestRate.rates.saveApy,
-        annualGain,
-        estimatedSwapCost,
-        breakEvenDays,
-        txDigests: [],
-        totalGasCost: 0
-      };
-    }
-    if (!withdrawAdapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", `Protocol ${current.protocolId} not found`);
-    const depositAdapter = this.registry.getLending(bestRate.protocolId);
-    if (!depositAdapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", `Protocol ${bestRate.protocolId} not found`);
-    const canComposePTB = withdrawAdapter.addWithdrawToTx && depositAdapter.addSaveToTx && (isSameAsset || this.registry.listSwap()[0]?.addSwapToTx);
-    let txDigests;
-    let totalGasCost;
-    if (canComposePTB) {
-      const result = await executeWithGas(this.client, this._signer, async () => {
-        const tx = new Transaction();
-        tx.setSender(this._address);
-        const { coin: withdrawnCoin, effectiveAmount } = await withdrawAdapter.addWithdrawToTx(
-          tx,
-          this._address,
-          current.amount,
-          current.asset
-        );
-        amountToDeposit = effectiveAmount;
-        let depositCoin = withdrawnCoin;
-        if (!isSameAsset) {
-          const swapAdapter = this.registry.listSwap()[0];
-          const { outputCoin, estimatedOut, toDecimals } = await swapAdapter.addSwapToTx(
-            tx,
-            this._address,
-            withdrawnCoin,
-            current.asset,
-            bestRate.asset,
-            amountToDeposit
-          );
-          depositCoin = outputCoin;
-          amountToDeposit = estimatedOut / 10 ** toDecimals;
-        }
-        await depositAdapter.addSaveToTx(
-          tx,
-          this._address,
-          depositCoin,
-          bestRate.asset,
-          { collectFee: bestRate.asset === "USDC" }
-        );
-        return tx;
-      });
-      txDigests = [result.digest];
-      totalGasCost = result.gasCostSui;
-    } else {
-      txDigests = [];
-      totalGasCost = 0;
-      const withdrawResult = await executeWithGas(this.client, this._signer, async () => {
-        const built = await withdrawAdapter.buildWithdrawTx(this._address, current.amount, current.asset);
-        amountToDeposit = built.effectiveAmount;
-        return built.tx;
-      });
-      txDigests.push(withdrawResult.digest);
-      totalGasCost += withdrawResult.gasCostSui;
-      if (!isSameAsset) {
-        const swapAdapter = this.registry.listSwap()[0];
-        if (!swapAdapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", "No swap adapter available");
-        const swapResult = await executeWithGas(this.client, this._signer, async () => {
-          const built = await swapAdapter.buildSwapTx(this._address, current.asset, bestRate.asset, amountToDeposit);
-          amountToDeposit = built.estimatedOut / 10 ** built.toDecimals;
-          return built.tx;
-        });
-        txDigests.push(swapResult.digest);
-        totalGasCost += swapResult.gasCostSui;
-      }
-      const depositResult = await executeWithGas(this.client, this._signer, async () => {
-        const { tx } = await depositAdapter.buildSaveTx(this._address, amountToDeposit, bestRate.asset, { collectFee: bestRate.asset === "USDC" });
-        return tx;
-      });
-      txDigests.push(depositResult.digest);
-      totalGasCost += depositResult.gasCostSui;
-    }
-    return {
-      executed: true,
-      steps,
-      fromProtocol: current.protocol,
-      fromAsset: current.asset,
-      toProtocol: bestRate.protocol,
-      toAsset: bestRate.asset,
-      amount: current.amount,
-      currentApy: current.apy,
-      newApy: bestRate.rates.saveApy,
-      annualGain,
-      estimatedSwapCost,
-      breakEvenDays,
-      txDigests,
-      totalGasCost
-    };
-  }
   async earnings() {
     const result = await getEarnings(this.client, this._address);
     if (result.totalYieldEarned > 0) {
@@ -5760,17 +2998,6 @@ var T2000 = class _T2000 extends EventEmitter {
     return getFundStatus(this.client, this._address);
   }
   // -- Helpers --
-  async getFreeBalance(asset) {
-    if (!(asset in INVESTMENT_ASSETS)) return Infinity;
-    const pos = this.portfolio.getPosition(asset);
-    const walletInvested = pos && pos.totalAmount > 0 && !pos.earning ? pos.totalAmount : 0;
-    if (walletInvested <= 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 - walletInvested - gasReserve);
-  }
   async resolveLending(protocol, asset, capability) {
     if (protocol) {
       const adapter = this.registry.getLending(protocol);
@@ -5865,7 +3092,12 @@ async function callUsdcSponsorApi(address) {
   }
 }
 
+// src/index.ts
+init_errors();
+
 // src/utils/simulate.ts
+init_errors();
+init_errors();
 async function simulateTransaction(client, tx, sender) {
   tx.setSender(sender);
   try {
@@ -5935,6 +3167,6 @@ function parseMoveAbort(errorStr) {
   return { reason: errorStr };
 }
 
-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, KeypairSigner, MIST_PER_SUI, NaviAdapter, OUTBOUND_OPS, PERPS_MARKETS, PortfolioManager, ProtocolRegistry, STABLE_ASSETS, SUI_DECIMALS, SUPPORTED_ASSETS, SafeguardEnforcer, SafeguardError, StrategyManager, SuilendAdapter, T2000, T2000Error, USDC_DECIMALS, ZkLoginSigner, addCollectFeeToTx, allDescriptors, calculateFee, cetusDescriptor, executeAutoTopUp, executeWithGas, exportPrivateKey, formatAssetAmount, formatSui, formatUsd, generateKeypair, getAddress, getDecimals, getGasStatus, getPoolPrice, getRates, keypairFromPrivateKey, loadKey, mapMoveAbortCode, mapWalletError, mistToSui, naviDescriptor, rawToStable, rawToUsdc, saveKey, shouldAutoTopUp, simulateTransaction, solveHashcash, stableToRaw, suiToMist, suilendDescriptor, throwIfSimulationFailed, truncateAddress, usdcToRaw, validateAddress, walletExists };
+export { BPS_DENOMINATOR, CETUS_USDC_SUI_POOL, CLOCK_ID, ContactManager, DEFAULT_NETWORK, DEFAULT_SAFEGUARD_CONFIG, GAS_RESERVE_MIN, KeypairSigner, MIST_PER_SUI, NaviAdapter, OUTBOUND_OPS, ProtocolRegistry, STABLE_ASSETS, SUI_DECIMALS, SUPPORTED_ASSETS, SafeguardEnforcer, SafeguardError, T2000, T2000Error, USDC_DECIMALS, ZkLoginSigner, addCollectFeeToTx, allDescriptors, calculateFee, executeAutoTopUp, executeWithGas, exportPrivateKey, formatAssetAmount, formatSui, formatUsd, generateKeypair, getAddress, getDecimals, getGasStatus, getRates, keypairFromPrivateKey, loadKey, mapMoveAbortCode, mapWalletError, mistToSui, naviDescriptor, rawToStable, rawToUsdc, saveKey, shouldAutoTopUp, simulateTransaction, solveHashcash, stableToRaw, suiToMist, throwIfSimulationFailed, truncateAddress, usdcToRaw, validateAddress, walletExists };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map