@t2000/sdk 0.14.1 → 0.15.0

package/dist/index.cjs

@@ -1,4463 +0,0 @@
-'use strict';
-
-var eventemitter3 = require('eventemitter3');
-var transactions = require('@mysten/sui/transactions');
-var jsonRpc = require('@mysten/sui/jsonRpc');
-var utils = require('@mysten/sui/utils');
-var ed25519 = require('@mysten/sui/keypairs/ed25519');
-var cryptography = require('@mysten/sui/cryptography');
-var crypto = require('crypto');
-var promises = require('fs/promises');
-var path = require('path');
-var os = require('os');
-var bcs = require('@mysten/sui/bcs');
-var aggregatorSdk = require('@cetusprotocol/aggregator-sdk');
-var fs = require('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 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: "0xaafb102dd0902f5055cadecd687fb5b71ca82ef0e0285d90afde828ec58ca96b::btc::BTC",
-    decimals: 8,
-    symbol: "BTC",
-    displayName: "Bitcoin"
-  },
-  ETH: {
-    type: "0xd0e89b2af5e4910726fbcd8b8dd37bb79b29e5f83f7491bca830e94f7f226d29::eth::ETH",
-    decimals: 8,
-    symbol: "ETH",
-    displayName: "Ethereum"
-  }
-};
-var STABLE_ASSETS = ["USDC", "USDT", "USDe", "USDsui"];
-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
-};
-var PERPS_MARKETS = ["SUI-PERP"];
-var DEFAULT_MAX_LEVERAGE = 5;
-var DEFAULT_MAX_POSITION_SIZE = 1e3;
-var GAS_RESERVE_MIN = 0.05;
-var SENTINEL = {
-  PACKAGE: "0x88b83f36dafcd5f6dcdcf1d2cb5889b03f61264ab3cee9cae35db7aa940a21b7",
-  AGENT_REGISTRY: "0xc47564f5f14c12b31e0dfa1a3dc99a6380a1edf8929c28cb0eaa3359c8db36ac",
-  ENCLAVE: "0xfb1261aeb9583514cb1341a548a5ec12d1231bd96af22215f1792617a93e1213",
-  PROTOCOL_CONFIG: "0x2fa4fa4a1dd0498612304635ff9334e1b922e78af325000e9d9c0e88adea459f",
-  TEE_API: "https://app.suisentinel.xyz/api/consume-prompt",
-  SENTINELS_API: "https://api.suisentinel.xyz/agents/mainnet",
-  RANDOM: "0x8",
-  MIN_FEE_MIST: 100000000n,
-  // 0.1 SUI
-  MAX_PROMPT_TOKENS: 600
-};
-
-// 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
-    };
-  }
-};
-function mapWalletError(error) {
-  const msg = error instanceof Error ? error.message : String(error);
-  if (msg.includes("rejected") || msg.includes("cancelled")) {
-    return new T2000Error("TRANSACTION_FAILED", "Transaction cancelled");
-  }
-  if (msg.includes("Insufficient") || msg.includes("insufficient")) {
-    return new T2000Error("INSUFFICIENT_BALANCE", "Insufficient balance");
-  }
-  return new T2000Error("UNKNOWN", msg, void 0, true);
-}
-function mapMoveAbortCode(code) {
-  const abortMessages = {
-    1: "Protocol is temporarily paused",
-    2: "Amount must be greater than zero",
-    3: "Invalid operation type",
-    4: "Fee rate exceeds maximum",
-    5: "Insufficient treasury balance",
-    6: "Not authorized",
-    7: "Package version mismatch \u2014 upgrade required",
-    8: "Timelock is active \u2014 wait for expiry",
-    9: "No pending change to execute",
-    10: "Already at current version",
-    // NAVI Protocol abort codes
-    1502: "Oracle price is stale \u2014 try again in a moment",
-    1503: 'Withdrawal amount is invalid (zero or dust) \u2014 try a specific amount instead of "all"',
-    1600: "Health factor too low \u2014 withdrawal would risk liquidation",
-    1605: "Asset borrowing is disabled or at capacity on this protocol",
-    // Cetus DEX abort codes
-    46001: "Swap failed \u2014 the DEX pool rejected the trade (liquidity or routing issue). Try again."
-  };
-  return abortMessages[code] ?? `Move abort code: ${code}`;
-}
-function isMoveAbort(msg) {
-  return msg.includes("MoveAbort") || msg.includes("MovePrimitiveRuntimeError");
-}
-function parseMoveAbortMessage(msg) {
-  const abortMatch = msg.match(/abort code:\s*(\d+)/i) ?? msg.match(/MoveAbort[^,]*,\s*(\d+)/);
-  if (abortMatch) {
-    const code = parseInt(abortMatch[1], 10);
-    const mapped = mapMoveAbortCode(code);
-    if (mapped.startsWith("Move abort code:")) {
-      const moduleMatch = msg.match(/in '([^']+)'/);
-      if (moduleMatch) return `${mapped} (in ${moduleMatch[1]})`;
-    }
-    return mapped;
-  }
-  return msg;
-}
-
-// src/utils/sui.ts
-var cachedClient = null;
-function getSuiClient(rpcUrl) {
-  const url = rpcUrl ?? DEFAULT_RPC_URL;
-  if (cachedClient) return cachedClient;
-  cachedClient = new jsonRpc.SuiJsonRpcClient({ url, network: "mainnet" });
-  return cachedClient;
-}
-function validateAddress(address) {
-  const normalized = utils.normalizeSuiAddress(address);
-  if (!utils.isValidSuiAddress(normalized)) {
-    throw new T2000Error("INVALID_ADDRESS", `Invalid Sui address: ${address}`);
-  }
-  return normalized;
-}
-function truncateAddress(address) {
-  if (address.length <= 10) return address;
-  return `${address.slice(0, 6)}...${address.slice(-4)}`;
-}
-var ALGORITHM = "aes-256-gcm";
-var SCRYPT_N = 2 ** 14;
-var SCRYPT_R = 8;
-var SCRYPT_P = 1;
-var SALT_LENGTH = 32;
-var IV_LENGTH = 16;
-function expandPath(p) {
-  if (p.startsWith("~")) return path.resolve(os.homedir(), p.slice(2));
-  return path.resolve(p);
-}
-function deriveKey(passphrase, salt) {
-  return crypto.scryptSync(passphrase, salt, 32, { N: SCRYPT_N, r: SCRYPT_R, p: SCRYPT_P });
-}
-function encrypt(data, passphrase) {
-  const salt = crypto.randomBytes(SALT_LENGTH);
-  const key = deriveKey(passphrase, salt);
-  const iv = crypto.randomBytes(IV_LENGTH);
-  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
-  const ciphertext = Buffer.concat([cipher.update(data), cipher.final()]);
-  const tag = cipher.getAuthTag();
-  return {
-    version: 1,
-    algorithm: ALGORITHM,
-    salt: salt.toString("hex"),
-    iv: iv.toString("hex"),
-    tag: tag.toString("hex"),
-    ciphertext: ciphertext.toString("hex")
-  };
-}
-function decrypt(encrypted, passphrase) {
-  const salt = Buffer.from(encrypted.salt, "hex");
-  const key = deriveKey(passphrase, salt);
-  const iv = Buffer.from(encrypted.iv, "hex");
-  const tag = Buffer.from(encrypted.tag, "hex");
-  const ciphertext = Buffer.from(encrypted.ciphertext, "hex");
-  const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
-  decipher.setAuthTag(tag);
-  try {
-    return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
-  } catch {
-    throw new T2000Error("WALLET_LOCKED", "Invalid PIN");
-  }
-}
-function generateKeypair() {
-  return ed25519.Ed25519Keypair.generate();
-}
-function keypairFromPrivateKey(privateKey) {
-  if (privateKey.startsWith("suiprivkey")) {
-    const decoded = cryptography.decodeSuiPrivateKey(privateKey);
-    return ed25519.Ed25519Keypair.fromSecretKey(decoded.secretKey);
-  }
-  const bytes = Buffer.from(privateKey.replace(/^0x/, ""), "hex");
-  return ed25519.Ed25519Keypair.fromSecretKey(bytes);
-}
-async function saveKey(keypair, passphrase, keyPath) {
-  const filePath = expandPath(keyPath ?? DEFAULT_KEY_PATH);
-  try {
-    await promises.access(filePath);
-    throw new T2000Error("WALLET_EXISTS", `Wallet already exists at ${filePath}`);
-  } catch (error) {
-    if (error instanceof T2000Error) throw error;
-  }
-  await promises.mkdir(path.dirname(filePath), { recursive: true });
-  const bech32Key = keypair.getSecretKey();
-  const encrypted = encrypt(Buffer.from(bech32Key, "utf-8"), passphrase);
-  await promises.writeFile(filePath, JSON.stringify(encrypted, null, 2), { mode: 384 });
-  return filePath;
-}
-async function loadKey(passphrase, keyPath) {
-  const filePath = expandPath(keyPath ?? DEFAULT_KEY_PATH);
-  let content;
-  try {
-    content = await promises.readFile(filePath, "utf-8");
-  } catch {
-    throw new T2000Error("WALLET_NOT_FOUND", `No wallet found at ${filePath}`);
-  }
-  const encrypted = JSON.parse(content);
-  const decrypted = decrypt(encrypted, passphrase);
-  const bech32Key = decrypted.toString("utf-8");
-  const decoded = cryptography.decodeSuiPrivateKey(bech32Key);
-  return ed25519.Ed25519Keypair.fromSecretKey(decoded.secretKey);
-}
-async function walletExists(keyPath) {
-  const filePath = expandPath(keyPath ?? DEFAULT_KEY_PATH);
-  try {
-    await promises.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function exportPrivateKey(keypair) {
-  return keypair.getSecretKey();
-}
-function getAddress(keypair) {
-  return keypair.getPublicKey().toSuiAddress();
-}
-
-// src/utils/format.ts
-function mistToSui(mist) {
-  return Number(mist) / Number(MIST_PER_SUI);
-}
-function suiToMist(sui) {
-  return BigInt(Math.round(sui * Number(MIST_PER_SUI)));
-}
-function usdcToRaw(amount) {
-  return BigInt(Math.round(amount * 10 ** USDC_DECIMALS));
-}
-function rawToUsdc(raw) {
-  return Number(raw) / 10 ** USDC_DECIMALS;
-}
-function stableToRaw(amount, decimals) {
-  return BigInt(Math.round(amount * 10 ** decimals));
-}
-function rawToStable(raw, decimals) {
-  return Number(raw) / 10 ** decimals;
-}
-function getDecimals(asset) {
-  return SUPPORTED_ASSETS[asset].decimals;
-}
-function displayToRaw(amount, decimals) {
-  return BigInt(Math.round(amount * 10 ** decimals));
-}
-function formatUsd(amount) {
-  return `$${amount.toFixed(2)}`;
-}
-function formatSui(amount) {
-  if (amount < 1e-3) return `${amount.toFixed(6)} SUI`;
-  return `${amount.toFixed(3)} SUI`;
-}
-function formatAssetAmount(amount, asset) {
-  if (asset === "BTC") return amount.toFixed(8);
-  if (asset === "ETH") return amount.toFixed(6);
-  return amount.toFixed(4);
-}
-var ASSET_LOOKUP = /* @__PURE__ */ new Map();
-for (const [key, info] of Object.entries(SUPPORTED_ASSETS)) {
-  ASSET_LOOKUP.set(key.toUpperCase(), key);
-  if (info.displayName && info.displayName.toUpperCase() !== key.toUpperCase()) {
-    ASSET_LOOKUP.set(info.displayName.toUpperCase(), key);
-  }
-}
-function normalizeAsset(input) {
-  return ASSET_LOOKUP.get(input.toUpperCase()) ?? input;
-}
-
-// src/wallet/send.ts
-async function buildSendTx({
-  client,
-  address,
-  to,
-  amount,
-  asset = "USDC"
-}) {
-  const recipient = validateAddress(to);
-  const assetInfo = SUPPORTED_ASSETS[asset];
-  if (!assetInfo) throw new T2000Error("ASSET_NOT_SUPPORTED", `Asset ${asset} is not supported`);
-  if (amount <= 0) throw new T2000Error("INVALID_AMOUNT", "Amount must be greater than zero");
-  const rawAmount = displayToRaw(amount, assetInfo.decimals);
-  const tx = new transactions.Transaction();
-  tx.setSender(address);
-  if (asset === "SUI") {
-    const [coin] = tx.splitCoins(tx.gas, [rawAmount]);
-    tx.transferObjects([coin], recipient);
-  } else {
-    const coins = await client.getCoins({ owner: address, coinType: assetInfo.type });
-    if (coins.data.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${asset} coins found`);
-    const totalBalance = coins.data.reduce((sum, c) => sum + BigInt(c.balance), 0n);
-    if (totalBalance < rawAmount) {
-      throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient ${asset} balance`, {
-        available: Number(totalBalance) / 10 ** assetInfo.decimals,
-        required: amount
-      });
-    }
-    const primaryCoin = tx.object(coins.data[0].coinObjectId);
-    if (coins.data.length > 1) {
-      tx.mergeCoins(primaryCoin, coins.data.slice(1).map((c) => tx.object(c.coinObjectId)));
-    }
-    const [sendCoin] = tx.splitCoins(primaryCoin, [rawAmount]);
-    tx.transferObjects([sendCoin], recipient);
-  }
-  return tx;
-}
-
-// src/wallet/balance.ts
-var _cachedSuiPrice = 0;
-var _priceLastFetched = 0;
-var PRICE_CACHE_TTL_MS = 6e4;
-async function fetchSuiPrice(client) {
-  const now = Date.now();
-  if (_cachedSuiPrice > 0 && now - _priceLastFetched < PRICE_CACHE_TTL_MS) {
-    return _cachedSuiPrice;
-  }
-  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 price = 1e3 / rawPrice;
-        if (price > 0.01 && price < 1e3) {
-          _cachedSuiPrice = price;
-          _priceLastFetched = now;
-        }
-      }
-    }
-  } catch {
-  }
-  return _cachedSuiPrice;
-}
-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 }))
-  );
-  const [suiBalance, suiPriceUsd, ...stableResults] = await Promise.all([
-    client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.SUI.type }),
-    fetchSuiPrice(client),
-    ...stableBalancePromises
-  ]);
-  const stables = {};
-  let totalStables = 0;
-  for (const { asset, amount } of stableResults) {
-    stables[asset] = amount;
-    totalStables += amount;
-  }
-  const suiAmount = Number(suiBalance.totalBalance) / Number(MIST_PER_SUI);
-  const savings = 0;
-  const usdEquiv = suiAmount * suiPriceUsd;
-  const total = totalStables + savings + usdEquiv;
-  return {
-    available: totalStables,
-    savings,
-    debt: 0,
-    investment: 0,
-    investmentPnL: 0,
-    gasReserve: {
-      sui: suiAmount,
-      usdEquiv
-    },
-    total,
-    stables,
-    assets: {
-      USDC: stables.USDC ?? 0,
-      SUI: suiAmount
-    }
-  };
-}
-
-// src/wallet/history.ts
-async function queryHistory(client, address, limit = 20) {
-  const txns = await client.queryTransactionBlocks({
-    filter: { FromAddress: address },
-    options: { showEffects: true, showInput: true },
-    limit,
-    order: "descending"
-  });
-  return txns.data.map((tx) => {
-    const gasUsed = tx.effects?.gasUsed;
-    const gasCost = gasUsed ? (Number(gasUsed.computationCost) + Number(gasUsed.storageCost) - Number(gasUsed.storageRebate)) / 1e9 : void 0;
-    return {
-      digest: tx.digest,
-      action: inferAction(tx.transaction),
-      timestamp: Number(tx.timestampMs ?? 0),
-      gasCost
-    };
-  });
-}
-function inferAction(txBlock) {
-  if (!txBlock || typeof txBlock !== "object") return "unknown";
-  const data = "data" in txBlock ? txBlock.data : void 0;
-  if (!data || typeof data !== "object") return "unknown";
-  const inner = "transaction" in data ? data.transaction : void 0;
-  if (!inner || typeof inner !== "object") return "unknown";
-  const kind = "kind" in inner ? inner.kind : void 0;
-  if (kind === "ProgrammableTransaction") return "transaction";
-  return kind ?? "unknown";
-}
-
-// 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) {
-  const bps = FEE_RATES[operation];
-  const feeAmount = amount * Number(bps) / Number(BPS_DENOMINATOR);
-  const rawAmount = usdcToRaw(feeAmount);
-  return {
-    amount: feeAmount,
-    asset: "USDC",
-    rate: Number(bps) / Number(BPS_DENOMINATOR),
-    rawAmount
-  };
-}
-function addCollectFeeToTx(tx, paymentCoin, operation) {
-  const bps = FEE_RATES[operation];
-  if (bps <= 0n) return;
-  tx.moveCall({
-    target: `${T2000_PACKAGE_ID}::treasury::collect_fee`,
-    typeArguments: [SUPPORTED_ASSETS.USDC.type],
-    arguments: [
-      tx.object(T2000_TREASURY_ID),
-      tx.object(T2000_CONFIG_ID),
-      paymentCoin,
-      tx.pure.u8(OP_CODES[operation])
-    ]
-  });
-}
-async function reportFee(agentAddress, operation, feeAmount, feeRate, txDigest) {
-  try {
-    await fetch(`${API_BASE_URL}/api/fees`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        agentAddress,
-        operation,
-        feeAmount: feeAmount.toString(),
-        feeRate: feeRate.toString(),
-        txDigest
-      })
-    });
-  } catch {
-  }
-}
-SUPPORTED_ASSETS.USDC.type;
-var RATE_DECIMALS = 27;
-var LTV_DECIMALS = 27;
-var MIN_HEALTH_FACTOR = 1.5;
-var WITHDRAW_DUST_BUFFER = 1e-3;
-var CLOCK = "0x06";
-var SUI_SYSTEM_STATE = "0x05";
-var NAVI_BALANCE_DECIMALS = 9;
-var CONFIG_API = "https://open-api.naviprotocol.io/api/navi/config?env=prod";
-var POOLS_API = "https://open-api.naviprotocol.io/api/navi/pools?env=prod";
-var PACKAGE_API = "https://open-api.naviprotocol.io/api/package";
-var packageCache = null;
-function toBigInt(v) {
-  if (typeof v === "bigint") return v;
-  return BigInt(String(v));
-}
-var UserStateInfo = bcs.bcs.struct("UserStateInfo", {
-  asset_id: bcs.bcs.u8(),
-  borrow_balance: bcs.bcs.u256(),
-  supply_balance: bcs.bcs.u256()
-});
-function decodeDevInspect(result, schema) {
-  const rv = result.results?.[0]?.returnValues?.[0];
-  if (result.error || !rv) return void 0;
-  const bytes = Uint8Array.from(rv[0]);
-  return schema.parse(bytes);
-}
-var configCache = null;
-var poolsCache = null;
-var CACHE_TTL = 5 * 6e4;
-async function fetchJson(url) {
-  const res = await fetch(url);
-  if (!res.ok) throw new T2000Error("PROTOCOL_UNAVAILABLE", `NAVI API error: ${res.status}`);
-  const json = await res.json();
-  return json.data ?? json;
-}
-async function getLatestPackageId() {
-  if (packageCache && Date.now() - packageCache.ts < CACHE_TTL) return packageCache.id;
-  const res = await fetch(PACKAGE_API);
-  if (!res.ok) throw new T2000Error("PROTOCOL_UNAVAILABLE", `NAVI package API error: ${res.status}`);
-  const json = await res.json();
-  if (!json.packageId) throw new T2000Error("PROTOCOL_UNAVAILABLE", "NAVI package API returned no packageId");
-  packageCache = { id: json.packageId, ts: Date.now() };
-  return json.packageId;
-}
-async function getConfig(fresh = false) {
-  if (configCache && !fresh && Date.now() - configCache.ts < CACHE_TTL) return configCache.data;
-  const [data, latestPkg] = await Promise.all([
-    fetchJson(CONFIG_API),
-    getLatestPackageId()
-  ]);
-  data.package = latestPkg;
-  configCache = { data, ts: Date.now() };
-  return data;
-}
-async function getPools(fresh = false) {
-  if (poolsCache && !fresh && Date.now() - poolsCache.ts < CACHE_TTL) return poolsCache.data;
-  const data = await fetchJson(POOLS_API);
-  poolsCache = { data, ts: Date.now() };
-  return data;
-}
-function matchesCoinType(poolType, targetType) {
-  const poolSuffix = poolType.split("::").slice(1).join("::").toLowerCase();
-  const targetSuffix = targetType.split("::").slice(1).join("::").toLowerCase();
-  return poolSuffix === targetSuffix;
-}
-function resolvePoolSymbol(pool) {
-  const coinType = pool.suiCoinType || pool.coinType || "";
-  for (const [key, info] of Object.entries(SUPPORTED_ASSETS)) {
-    if (matchesCoinType(coinType, info.type)) return key;
-  }
-  return pool.token?.symbol ?? "UNKNOWN";
-}
-async function getPool(asset = "USDC") {
-  const pools = await getPools();
-  const targetType = SUPPORTED_ASSETS[asset].type;
-  const pool = pools.find(
-    (p) => matchesCoinType(p.suiCoinType || p.coinType || "", targetType)
-  );
-  if (!pool) {
-    throw new T2000Error(
-      "ASSET_NOT_SUPPORTED",
-      `${SUPPORTED_ASSETS[asset].displayName} pool not found on NAVI. Try: ${STABLE_ASSETS.filter((a) => a !== asset).join(", ")}`
-    );
-  }
-  return pool;
-}
-function addOracleUpdate(tx, config, pool) {
-  const feed = config.oracle.feeds?.find((f2) => f2.assetId === pool.id);
-  if (!feed) {
-    throw new T2000Error("PROTOCOL_UNAVAILABLE", `Oracle feed not found for asset ${pool.token?.symbol ?? pool.id}`);
-  }
-  tx.moveCall({
-    target: `${config.oracle.packageId}::oracle_pro::update_single_price_v2`,
-    arguments: [
-      tx.object(CLOCK),
-      tx.object(config.oracle.oracleConfig),
-      tx.object(config.oracle.priceOracle),
-      tx.object(config.oracle.supraOracleHolder),
-      tx.object(feed.pythPriceInfoObject),
-      tx.object(config.oracle.switchboardAggregator),
-      tx.pure.address(feed.feedId)
-    ]
-  });
-}
-function refreshStableOracles(tx, config, pools) {
-  const stableTypes = STABLE_ASSETS.map((a) => SUPPORTED_ASSETS[a].type);
-  const stablePools = pools.filter((p) => {
-    const ct = p.suiCoinType || p.coinType || "";
-    return stableTypes.some((t) => matchesCoinType(ct, t));
-  });
-  for (const pool of stablePools) {
-    addOracleUpdate(tx, config, pool);
-  }
-}
-function rateToApy(rawRate) {
-  if (!rawRate || rawRate === "0") return 0;
-  return Number(BigInt(rawRate)) / 10 ** RATE_DECIMALS * 100;
-}
-function parseLtv(rawLtv) {
-  if (!rawLtv || rawLtv === "0") return 0.75;
-  return Number(BigInt(rawLtv)) / 10 ** LTV_DECIMALS;
-}
-function parseLiqThreshold(val) {
-  if (typeof val === "number") return val;
-  const n = Number(val);
-  if (n > 1) return Number(BigInt(val)) / 10 ** LTV_DECIMALS;
-  return n;
-}
-function normalizeHealthFactor(raw) {
-  const v = raw / 10 ** RATE_DECIMALS;
-  return v > 1e5 ? Infinity : v;
-}
-function compoundBalance(rawBalance, currentIndex) {
-  if (!rawBalance || !currentIndex || currentIndex === "0") return 0;
-  const scale = BigInt("1" + "0".repeat(RATE_DECIMALS));
-  const half = scale / 2n;
-  const result = (rawBalance * BigInt(currentIndex) + half) / scale;
-  return Number(result) / 10 ** NAVI_BALANCE_DECIMALS;
-}
-async function getUserState(client, address) {
-  const config = await getConfig();
-  const tx = new transactions.Transaction();
-  tx.moveCall({
-    target: `${config.uiGetter}::getter_unchecked::get_user_state`,
-    arguments: [tx.object(config.storage), tx.pure.address(address)]
-  });
-  const result = await client.devInspectTransactionBlock({
-    transactionBlock: tx,
-    sender: address
-  });
-  const decoded = decodeDevInspect(result, bcs.bcs.vector(UserStateInfo));
-  if (!decoded) return [];
-  const mapped = decoded.map((s) => ({
-    assetId: s.asset_id,
-    supplyBalance: toBigInt(s.supply_balance),
-    borrowBalance: toBigInt(s.borrow_balance)
-  }));
-  return mapped.filter((s) => s.supplyBalance !== 0n || s.borrowBalance !== 0n);
-}
-async function fetchCoins(client, owner, coinType) {
-  const all = [];
-  let cursor;
-  let hasNext = true;
-  while (hasNext) {
-    const page = await 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;
-}
-function mergeCoins(tx, coins) {
-  if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No coins to merge");
-  const primary = tx.object(coins[0].coinObjectId);
-  if (coins.length > 1) {
-    tx.mergeCoins(primary, coins.slice(1).map((c) => tx.object(c.coinObjectId)));
-  }
-  return primary;
-}
-async function buildSaveTx(client, address, amount, options = {}) {
-  if (!amount || amount <= 0 || !Number.isFinite(amount)) {
-    throw new T2000Error("INVALID_AMOUNT", "Save amount must be a positive number");
-  }
-  const asset = options.asset ?? "USDC";
-  const assetInfo = SUPPORTED_ASSETS[asset];
-  const rawAmount = Number(stableToRaw(amount, assetInfo.decimals));
-  const [config, pool] = await Promise.all([getConfig(), getPool(asset)]);
-  const coins = await fetchCoins(client, address, assetInfo.type);
-  if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} coins found`);
-  const tx = new transactions.Transaction();
-  tx.setSender(address);
-  const coinObj = mergeCoins(tx, coins);
-  if (options.collectFee) {
-    addCollectFeeToTx(tx, coinObj, "save");
-  }
-  tx.moveCall({
-    target: `${config.package}::incentive_v3::entry_deposit`,
-    arguments: [
-      tx.object(CLOCK),
-      tx.object(config.storage),
-      tx.object(pool.contract.pool),
-      tx.pure.u8(pool.id),
-      coinObj,
-      tx.pure.u64(rawAmount),
-      tx.object(config.incentiveV2),
-      tx.object(config.incentiveV3)
-    ],
-    typeArguments: [pool.suiCoinType]
-  });
-  return tx;
-}
-async function buildWithdrawTx(client, address, amount, options = {}) {
-  const asset = options.asset ?? "USDC";
-  const assetInfo = SUPPORTED_ASSETS[asset];
-  const [config, pool, pools, states] = await Promise.all([
-    getConfig(),
-    getPool(asset),
-    getPools(),
-    getUserState(client, address)
-  ]);
-  const assetState = states.find((s) => s.assetId === pool.id);
-  const deposited = assetState ? compoundBalance(assetState.supplyBalance, pool.currentSupplyIndex) : 0;
-  const effectiveAmount = Math.min(amount, Math.max(0, deposited - WITHDRAW_DUST_BUFFER));
-  if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", `Nothing to withdraw for ${assetInfo.displayName} on NAVI`);
-  const rawAmount = Number(stableToRaw(effectiveAmount, assetInfo.decimals));
-  if (rawAmount <= 0) {
-    throw new T2000Error("INVALID_AMOUNT", `Withdrawal amount rounds to zero \u2014 balance is dust`);
-  }
-  const tx = new transactions.Transaction();
-  tx.setSender(address);
-  refreshStableOracles(tx, config, pools);
-  const [balance] = tx.moveCall({
-    target: `${config.package}::incentive_v3::withdraw_v2`,
-    arguments: [
-      tx.object(CLOCK),
-      tx.object(config.oracle.priceOracle),
-      tx.object(config.storage),
-      tx.object(pool.contract.pool),
-      tx.pure.u8(pool.id),
-      tx.pure.u64(rawAmount),
-      tx.object(config.incentiveV2),
-      tx.object(config.incentiveV3),
-      tx.object(SUI_SYSTEM_STATE)
-    ],
-    typeArguments: [pool.suiCoinType]
-  });
-  const [coin] = tx.moveCall({
-    target: "0x2::coin::from_balance",
-    arguments: [balance],
-    typeArguments: [pool.suiCoinType]
-  });
-  tx.transferObjects([coin], address);
-  return { tx, effectiveAmount };
-}
-async function addWithdrawToTx(tx, client, address, amount, options = {}) {
-  const asset = options.asset ?? "USDC";
-  const assetInfo = SUPPORTED_ASSETS[asset];
-  const [config, pool, pools, states] = await Promise.all([
-    getConfig(),
-    getPool(asset),
-    getPools(),
-    getUserState(client, address)
-  ]);
-  const assetState = states.find((s) => s.assetId === pool.id);
-  const deposited = assetState ? compoundBalance(assetState.supplyBalance, pool.currentSupplyIndex) : 0;
-  const effectiveAmount = Math.min(amount, Math.max(0, deposited - WITHDRAW_DUST_BUFFER));
-  if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", `Nothing to withdraw for ${assetInfo.displayName} on NAVI`);
-  const rawAmount = Number(stableToRaw(effectiveAmount, assetInfo.decimals));
-  if (rawAmount <= 0) {
-    const [coin2] = tx.moveCall({
-      target: "0x2::coin::zero",
-      typeArguments: [pool.suiCoinType]
-    });
-    return { coin: coin2, effectiveAmount: 0 };
-  }
-  refreshStableOracles(tx, config, pools);
-  const [balance] = tx.moveCall({
-    target: `${config.package}::incentive_v3::withdraw_v2`,
-    arguments: [
-      tx.object(CLOCK),
-      tx.object(config.oracle.priceOracle),
-      tx.object(config.storage),
-      tx.object(pool.contract.pool),
-      tx.pure.u8(pool.id),
-      tx.pure.u64(rawAmount),
-      tx.object(config.incentiveV2),
-      tx.object(config.incentiveV3),
-      tx.object(SUI_SYSTEM_STATE)
-    ],
-    typeArguments: [pool.suiCoinType]
-  });
-  const [coin] = tx.moveCall({
-    target: "0x2::coin::from_balance",
-    arguments: [balance],
-    typeArguments: [pool.suiCoinType]
-  });
-  return { coin, effectiveAmount };
-}
-async function addSaveToTx(tx, _client, _address, coin, options = {}) {
-  const asset = options.asset ?? "USDC";
-  const [config, pool] = await Promise.all([getConfig(), getPool(asset)]);
-  if (options.collectFee) {
-    addCollectFeeToTx(tx, coin, "save");
-  }
-  const [coinValue] = tx.moveCall({
-    target: "0x2::coin::value",
-    typeArguments: [pool.suiCoinType],
-    arguments: [coin]
-  });
-  tx.moveCall({
-    target: `${config.package}::incentive_v3::entry_deposit`,
-    arguments: [
-      tx.object(CLOCK),
-      tx.object(config.storage),
-      tx.object(pool.contract.pool),
-      tx.pure.u8(pool.id),
-      coin,
-      coinValue,
-      tx.object(config.incentiveV2),
-      tx.object(config.incentiveV3)
-    ],
-    typeArguments: [pool.suiCoinType]
-  });
-}
-async function addRepayToTx(tx, client, _address, coin, options = {}) {
-  const asset = options.asset ?? "USDC";
-  const [config, pool] = await Promise.all([getConfig(), getPool(asset)]);
-  addOracleUpdate(tx, config, pool);
-  const [coinValue] = tx.moveCall({
-    target: "0x2::coin::value",
-    typeArguments: [pool.suiCoinType],
-    arguments: [coin]
-  });
-  tx.moveCall({
-    target: `${config.package}::incentive_v3::entry_repay`,
-    arguments: [
-      tx.object(CLOCK),
-      tx.object(config.oracle.priceOracle),
-      tx.object(config.storage),
-      tx.object(pool.contract.pool),
-      tx.pure.u8(pool.id),
-      coin,
-      coinValue,
-      tx.object(config.incentiveV2),
-      tx.object(config.incentiveV3)
-    ],
-    typeArguments: [pool.suiCoinType]
-  });
-}
-async function buildBorrowTx(client, address, amount, options = {}) {
-  if (!amount || amount <= 0 || !Number.isFinite(amount)) {
-    throw new T2000Error("INVALID_AMOUNT", "Borrow amount must be a positive number");
-  }
-  const asset = options.asset ?? "USDC";
-  const assetInfo = SUPPORTED_ASSETS[asset];
-  const rawAmount = Number(stableToRaw(amount, assetInfo.decimals));
-  const [config, pool, pools] = await Promise.all([
-    getConfig(),
-    getPool(asset),
-    getPools()
-  ]);
-  const tx = new transactions.Transaction();
-  tx.setSender(address);
-  refreshStableOracles(tx, config, pools);
-  const [balance] = tx.moveCall({
-    target: `${config.package}::incentive_v3::borrow_v2`,
-    arguments: [
-      tx.object(CLOCK),
-      tx.object(config.oracle.priceOracle),
-      tx.object(config.storage),
-      tx.object(pool.contract.pool),
-      tx.pure.u8(pool.id),
-      tx.pure.u64(rawAmount),
-      tx.object(config.incentiveV2),
-      tx.object(config.incentiveV3),
-      tx.object(SUI_SYSTEM_STATE)
-    ],
-    typeArguments: [pool.suiCoinType]
-  });
-  const [borrowedCoin] = tx.moveCall({
-    target: "0x2::coin::from_balance",
-    arguments: [balance],
-    typeArguments: [pool.suiCoinType]
-  });
-  if (options.collectFee) {
-    addCollectFeeToTx(tx, borrowedCoin, "borrow");
-  }
-  tx.transferObjects([borrowedCoin], address);
-  return tx;
-}
-async function buildRepayTx(client, address, amount, options = {}) {
-  if (!amount || amount <= 0 || !Number.isFinite(amount)) {
-    throw new T2000Error("INVALID_AMOUNT", "Repay amount must be a positive number");
-  }
-  const asset = options.asset ?? "USDC";
-  const assetInfo = SUPPORTED_ASSETS[asset];
-  const rawAmount = Number(stableToRaw(amount, assetInfo.decimals));
-  const [config, pool] = await Promise.all([getConfig(), getPool(asset)]);
-  const coins = await fetchCoins(client, address, assetInfo.type);
-  if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} coins to repay with`);
-  const tx = new transactions.Transaction();
-  tx.setSender(address);
-  addOracleUpdate(tx, config, pool);
-  const coinObj = mergeCoins(tx, coins);
-  tx.moveCall({
-    target: `${config.package}::incentive_v3::entry_repay`,
-    arguments: [
-      tx.object(CLOCK),
-      tx.object(config.oracle.priceOracle),
-      tx.object(config.storage),
-      tx.object(pool.contract.pool),
-      tx.pure.u8(pool.id),
-      coinObj,
-      tx.pure.u64(rawAmount),
-      tx.object(config.incentiveV2),
-      tx.object(config.incentiveV3)
-    ],
-    typeArguments: [pool.suiCoinType]
-  });
-  return tx;
-}
-async function getHealthFactor(client, addressOrKeypair) {
-  const address = typeof addressOrKeypair === "string" ? addressOrKeypair : addressOrKeypair.getPublicKey().toSuiAddress();
-  const [config, pools, states] = await Promise.all([
-    getConfig(),
-    getPools(),
-    getUserState(client, address)
-  ]);
-  let supplied = 0;
-  let borrowed = 0;
-  let weightedLtv = 0;
-  let weightedLiqThreshold = 0;
-  for (const state of states) {
-    const pool = pools.find((p) => p.id === state.assetId);
-    if (!pool) continue;
-    const supplyBal = compoundBalance(state.supplyBalance, pool.currentSupplyIndex);
-    const borrowBal = compoundBalance(state.borrowBalance, pool.currentBorrowIndex);
-    const price = pool.token?.price ?? 1;
-    supplied += supplyBal * price;
-    borrowed += borrowBal * price;
-    if (supplyBal > 0) {
-      weightedLtv += supplyBal * price * parseLtv(pool.ltv);
-      weightedLiqThreshold += supplyBal * price * parseLiqThreshold(pool.liquidationFactor.threshold);
-    }
-  }
-  const ltv = supplied > 0 ? weightedLtv / supplied : 0.75;
-  const liqThreshold = supplied > 0 ? weightedLiqThreshold / supplied : 0.75;
-  const maxBorrowVal = Math.max(0, supplied * ltv - borrowed);
-  const usdcPool = pools.find((p) => matchesCoinType(p.suiCoinType || p.coinType || "", SUPPORTED_ASSETS.USDC.type));
-  let healthFactor;
-  if (borrowed <= 0) {
-    healthFactor = Infinity;
-  } else if (usdcPool) {
-    try {
-      const tx = new transactions.Transaction();
-      tx.moveCall({
-        target: `${config.uiGetter}::calculator_unchecked::dynamic_health_factor`,
-        arguments: [
-          tx.object(CLOCK),
-          tx.object(config.storage),
-          tx.object(config.oracle.priceOracle),
-          tx.pure.u8(usdcPool.id),
-          tx.pure.address(address),
-          tx.pure.u8(usdcPool.id),
-          tx.pure.u64(0),
-          tx.pure.u64(0),
-          tx.pure.bool(false)
-        ],
-        typeArguments: [usdcPool.suiCoinType]
-      });
-      const result = await client.devInspectTransactionBlock({
-        transactionBlock: tx,
-        sender: address
-      });
-      const decoded = decodeDevInspect(result, bcs.bcs.u256());
-      if (decoded !== void 0) {
-        healthFactor = normalizeHealthFactor(Number(decoded));
-      } else {
-        healthFactor = supplied * liqThreshold / borrowed;
-      }
-    } catch {
-      healthFactor = supplied * liqThreshold / borrowed;
-    }
-  } else {
-    healthFactor = supplied * liqThreshold / borrowed;
-  }
-  return {
-    healthFactor,
-    supplied,
-    borrowed,
-    maxBorrow: maxBorrowVal,
-    liquidationThreshold: liqThreshold
-  };
-}
-async function getRates(client) {
-  try {
-    const pools = await getPools();
-    const result = {};
-    for (const asset of STABLE_ASSETS) {
-      const targetType = SUPPORTED_ASSETS[asset].type;
-      const pool = pools.find((p) => matchesCoinType(p.suiCoinType || p.coinType || "", targetType));
-      if (!pool) continue;
-      let saveApy = rateToApy(pool.currentSupplyRate);
-      let borrowApy = rateToApy(pool.currentBorrowRate);
-      if (saveApy <= 0 || saveApy > 100) saveApy = 0;
-      if (borrowApy <= 0 || borrowApy > 100) borrowApy = 0;
-      result[asset] = { saveApy, borrowApy };
-    }
-    if (!result.USDC) result.USDC = { saveApy: 4, borrowApy: 6 };
-    return result;
-  } catch {
-    return { USDC: { saveApy: 4, borrowApy: 6 } };
-  }
-}
-async function getPositions(client, addressOrKeypair) {
-  const address = typeof addressOrKeypair === "string" ? addressOrKeypair : addressOrKeypair.getPublicKey().toSuiAddress();
-  const [states, pools] = await Promise.all([getUserState(client, address), getPools()]);
-  const positions = [];
-  for (const state of states) {
-    const pool = pools.find((p) => p.id === state.assetId);
-    if (!pool) continue;
-    const symbol = resolvePoolSymbol(pool);
-    const supplyBal = compoundBalance(state.supplyBalance, pool.currentSupplyIndex);
-    const borrowBal = compoundBalance(state.borrowBalance, pool.currentBorrowIndex);
-    if (supplyBal > 1e-4) {
-      positions.push({
-        protocol: "navi",
-        asset: symbol,
-        type: "save",
-        amount: supplyBal,
-        apy: rateToApy(pool.currentSupplyRate)
-      });
-    }
-    if (borrowBal > 1e-4) {
-      positions.push({
-        protocol: "navi",
-        asset: symbol,
-        type: "borrow",
-        amount: borrowBal,
-        apy: rateToApy(pool.currentBorrowRate)
-      });
-    }
-  }
-  return { positions };
-}
-async function maxWithdrawAmount(client, addressOrKeypair) {
-  const hf = await getHealthFactor(client, addressOrKeypair);
-  const ltv = hf.liquidationThreshold > 0 ? hf.liquidationThreshold : 0.75;
-  let maxAmount;
-  if (hf.borrowed === 0) {
-    maxAmount = hf.supplied;
-  } else {
-    maxAmount = Math.max(0, hf.supplied - hf.borrowed * MIN_HEALTH_FACTOR / ltv);
-  }
-  const remainingSupply = hf.supplied - maxAmount;
-  const hfAfter = hf.borrowed > 0 ? remainingSupply / hf.borrowed : Infinity;
-  return { maxAmount, healthFactorAfter: hfAfter, currentHF: hf.healthFactor };
-}
-async function maxBorrowAmount(client, addressOrKeypair) {
-  const hf = await getHealthFactor(client, addressOrKeypair);
-  const ltv = hf.liquidationThreshold > 0 ? hf.liquidationThreshold : 0.75;
-  const maxAmount = Math.max(0, hf.supplied * ltv / MIN_HEALTH_FACTOR - hf.borrowed);
-  return { maxAmount, healthFactorAfter: MIN_HEALTH_FACTOR, currentHF: hf.healthFactor };
-}
-
-// src/protocols/yieldTracker.ts
-async function getEarnings(client, keypair) {
-  const hf = await getHealthFactor(client, keypair);
-  const rates = await getRates();
-  const supplied = hf.supplied;
-  const apy = rates.USDC.saveApy / 100;
-  const dailyRate = apy / 365;
-  const dailyEarning = supplied * dailyRate;
-  const totalYieldEarned = dailyEarning * 30;
-  return {
-    totalYieldEarned,
-    currentApy: rates.USDC.saveApy,
-    dailyEarning,
-    supplied
-  };
-}
-async function getFundStatus(client, keypair) {
-  const earnings = await getEarnings(client, keypair);
-  return {
-    supplied: earnings.supplied,
-    apy: earnings.currentApy,
-    earnedToday: earnings.dailyEarning,
-    earnedAllTime: earnings.totalYieldEarned,
-    projectedMonthly: earnings.dailyEarning * 30
-  };
-}
-var descriptor = {
-  id: "sentinel",
-  name: "Sui Sentinel",
-  packages: [SENTINEL.PACKAGE],
-  actionMap: {
-    "sentinel::request_attack": "sentinel_attack",
-    "sentinel::consume_prompt": "sentinel_settle"
-  }
-};
-function mapAgent(raw) {
-  return {
-    id: raw.agent_id,
-    objectId: raw.agent_object_id,
-    name: raw.agent_name,
-    model: raw.model ?? "unknown",
-    systemPrompt: raw.prompt,
-    attackFee: BigInt(raw.cost_per_message),
-    prizePool: BigInt(raw.total_balance),
-    totalAttacks: raw.total_attacks,
-    successfulBreaches: raw.successful_breaches ?? 0,
-    state: raw.state
-  };
-}
-async function listSentinels() {
-  const res = await fetch(SENTINEL.SENTINELS_API);
-  if (!res.ok) {
-    throw new T2000Error("SENTINEL_API_ERROR", `Sentinel API returned ${res.status}`);
-  }
-  const data = await res.json();
-  if (!Array.isArray(data.agents)) {
-    throw new T2000Error("SENTINEL_API_ERROR", "Unexpected API response shape");
-  }
-  return data.agents.filter((a) => a.state === "active").map(mapAgent);
-}
-async function getSentinelInfo(client, sentinelObjectId) {
-  const agents = await listSentinels();
-  const match = agents.find((a) => a.objectId === sentinelObjectId || a.id === sentinelObjectId);
-  if (match) return match;
-  const obj = await client.getObject({
-    id: sentinelObjectId,
-    options: { showContent: true, showType: true }
-  });
-  if (!obj.data) {
-    throw new T2000Error("SENTINEL_NOT_FOUND", `Sentinel ${sentinelObjectId} not found on-chain`);
-  }
-  const content = obj.data.content;
-  if (!content || content.dataType !== "moveObject") {
-    throw new T2000Error("SENTINEL_NOT_FOUND", `Object ${sentinelObjectId} is not a Move object`);
-  }
-  const fields = content.fields;
-  return {
-    id: fields.id?.id ?? sentinelObjectId,
-    objectId: sentinelObjectId,
-    name: fields.name ?? "Unknown",
-    model: fields.model ?? "unknown",
-    systemPrompt: fields.system_prompt ?? "",
-    attackFee: BigInt(fields.cost_per_message ?? "0"),
-    prizePool: BigInt(fields.balance ?? "0"),
-    totalAttacks: Number(fields.total_attacks ?? "0"),
-    successfulBreaches: Number(fields.successful_breaches ?? "0"),
-    state: fields.state ?? "unknown"
-  };
-}
-async function requestAttack(client, signer, sentinelObjectId, feeMist) {
-  if (feeMist < SENTINEL.MIN_FEE_MIST) {
-    throw new T2000Error("INVALID_AMOUNT", `Attack fee must be at least 0.1 SUI (${SENTINEL.MIN_FEE_MIST} MIST)`);
-  }
-  const tx = new transactions.Transaction();
-  const [coin] = tx.splitCoins(tx.gas, [Number(feeMist)]);
-  const [attack2] = tx.moveCall({
-    target: `${SENTINEL.PACKAGE}::sentinel::request_attack`,
-    arguments: [
-      tx.object(SENTINEL.AGENT_REGISTRY),
-      tx.object(sentinelObjectId),
-      tx.object(SENTINEL.PROTOCOL_CONFIG),
-      coin,
-      tx.object(SENTINEL.RANDOM),
-      tx.object(CLOCK_ID)
-    ]
-  });
-  const address = signer.toSuiAddress();
-  tx.transferObjects([attack2], address);
-  const result = await client.signAndExecuteTransaction({
-    signer,
-    transaction: tx,
-    options: { showObjectChanges: true, showEffects: true }
-  });
-  await client.waitForTransaction({ digest: result.digest });
-  const attackObj = result.objectChanges?.find(
-    (c) => c.type === "created" && c.objectType?.includes("::sentinel::Attack")
-  );
-  const attackObjectId = attackObj && "objectId" in attackObj ? attackObj.objectId : void 0;
-  if (!attackObjectId) {
-    throw new T2000Error("SENTINEL_TX_FAILED", "Attack object was not created \u2014 transaction may have failed");
-  }
-  return { attackObjectId, digest: result.digest };
-}
-async function submitPrompt(agentId, attackObjectId, prompt) {
-  const res = await fetch(SENTINEL.TEE_API, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      agent_id: agentId,
-      attack_object_id: attackObjectId,
-      message: prompt
-    })
-  });
-  if (!res.ok) {
-    const body = await res.text().catch(() => "");
-    throw new T2000Error("SENTINEL_TEE_ERROR", `TEE returned ${res.status}: ${body.slice(0, 200)}`);
-  }
-  const raw = await res.json();
-  const envelope = raw.response ?? raw;
-  const data = envelope.data ?? envelope;
-  const signature = raw.signature ?? data.signature;
-  const timestampMs = envelope.timestamp_ms ?? data.timestamp_ms;
-  if (typeof signature !== "string") {
-    throw new T2000Error("SENTINEL_TEE_ERROR", "TEE response missing signature");
-  }
-  return {
-    success: data.success ?? data.is_success,
-    score: data.score,
-    agentResponse: data.agent_response,
-    juryResponse: data.jury_response,
-    funResponse: data.fun_response ?? "",
-    signature,
-    timestampMs
-  };
-}
-async function settleAttack(client, signer, sentinelObjectId, attackObjectId, prompt, verdict) {
-  const sigBytes = Array.from(Buffer.from(verdict.signature.replace(/^0x/, ""), "hex"));
-  const tx = new transactions.Transaction();
-  tx.moveCall({
-    target: `${SENTINEL.PACKAGE}::sentinel::consume_prompt`,
-    arguments: [
-      tx.object(SENTINEL.AGENT_REGISTRY),
-      tx.object(SENTINEL.PROTOCOL_CONFIG),
-      tx.object(sentinelObjectId),
-      tx.pure.bool(verdict.success),
-      tx.pure.string(verdict.agentResponse),
-      tx.pure.string(verdict.juryResponse),
-      tx.pure.string(verdict.funResponse),
-      tx.pure.string(prompt),
-      tx.pure.u8(verdict.score),
-      tx.pure.u64(verdict.timestampMs),
-      tx.pure(bcs.bcs.vector(bcs.bcs.u8()).serialize(sigBytes)),
-      tx.object(SENTINEL.ENCLAVE),
-      tx.object(attackObjectId),
-      tx.object(CLOCK_ID)
-    ]
-  });
-  const result = await client.signAndExecuteTransaction({
-    signer,
-    transaction: tx,
-    options: { showEffects: true }
-  });
-  await client.waitForTransaction({ digest: result.digest });
-  const txSuccess = result.effects?.status?.status === "success";
-  return { digest: result.digest, success: txSuccess };
-}
-async function attack(client, signer, sentinelId, prompt, feeMist) {
-  const sentinel = await getSentinelInfo(client, sentinelId);
-  const fee = feeMist ?? sentinel.attackFee;
-  if (fee < SENTINEL.MIN_FEE_MIST) {
-    throw new T2000Error("INVALID_AMOUNT", `Attack fee must be at least 0.1 SUI`);
-  }
-  const { attackObjectId, digest: requestTx } = await requestAttack(
-    client,
-    signer,
-    sentinel.objectId,
-    fee
-  );
-  const verdict = await submitPrompt(sentinel.id, attackObjectId, prompt);
-  const { digest: settleTx } = await settleAttack(
-    client,
-    signer,
-    sentinel.objectId,
-    attackObjectId,
-    prompt,
-    verdict
-  );
-  const won = verdict.success && verdict.score >= 70;
-  return {
-    attackObjectId,
-    sentinelId: sentinel.id,
-    prompt,
-    verdict,
-    requestTx,
-    settleTx,
-    won,
-    feePaid: Number(fee) / Number(MIST_PER_SUI)
-  };
-}
-
-// src/adapters/registry.ts
-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()) {
-      if (!adapter.supportedAssets.includes(asset)) continue;
-      if (!adapter.capabilities.includes("save")) continue;
-      try {
-        const rate = await adapter.getRates(asset);
-        candidates.push({ adapter, rate });
-      } catch {
-      }
-    }
-    if (candidates.length === 0) {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `No lending adapter supports saving ${asset}`);
-    }
-    candidates.sort((a, b) => b.rate.saveApy - a.rate.saveApy);
-    return candidates[0];
-  }
-  async bestBorrowRate(asset, opts) {
-    const candidates = [];
-    for (const adapter of this.lending.values()) {
-      if (!adapter.supportedAssets.includes(asset)) continue;
-      if (!adapter.capabilities.includes("borrow")) continue;
-      if (opts?.requireSameAssetBorrow && !adapter.supportsSameAssetBorrow) continue;
-      try {
-        const rate = await adapter.getRates(asset);
-        candidates.push({ adapter, rate });
-      } catch {
-      }
-    }
-    if (candidates.length === 0) {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `No lending adapter supports borrowing ${asset}`);
-    }
-    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) {
-      for (const adapter of this.lending.values()) {
-        if (!adapter.supportedAssets.includes(asset)) continue;
-        if (!adapter.capabilities.includes("save")) continue;
-        try {
-          const rate = await adapter.getRates(asset);
-          candidates.push({ adapter, rate, asset });
-        } catch {
-        }
-      }
-    }
-    if (candidates.length === 0) {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", "No lending adapter found for any stablecoin");
-    }
-    candidates.sort((a, b) => b.rate.saveApy - a.rate.saveApy);
-    return candidates[0];
-  }
-  async allRatesAcrossAssets() {
-    const results = [];
-    for (const asset of STABLE_ASSETS) {
-      for (const adapter of this.lending.values()) {
-        if (!adapter.supportedAssets.includes(asset)) continue;
-        try {
-          const rates = await adapter.getRates(asset);
-          if (rates.saveApy > 0 || rates.borrowApy > 0) {
-            results.push({ protocol: adapter.name, protocolId: adapter.id, asset, rates });
-          }
-        } catch {
-        }
-      }
-    }
-    return results;
-  }
-  async allRates(asset) {
-    const results = [];
-    for (const adapter of this.lending.values()) {
-      if (!adapter.supportedAssets.includes(asset)) continue;
-      try {
-        const rates = await adapter.getRates(asset);
-        results.push({ protocol: adapter.name, protocolId: adapter.id, rates });
-      } catch {
-      }
-    }
-    return results;
-  }
-  async allPositions(address) {
-    const results = [];
-    for (const adapter of this.lending.values()) {
-      try {
-        const positions = await adapter.getPositions(address);
-        if (positions.supplies.length > 0 || positions.borrows.length > 0) {
-          results.push({ protocol: adapter.name, protocolId: adapter.id, positions });
-        }
-      } catch {
-      }
-    }
-    return results;
-  }
-  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
-var descriptor2 = {
-  id: "navi",
-  name: "NAVI Protocol",
-  packages: [],
-  dynamicPackageId: true,
-  actionMap: {
-    "incentive_v3::entry_deposit": "save",
-    "incentive_v3::deposit": "save",
-    "incentive_v3::withdraw_v2": "withdraw",
-    "incentive_v3::entry_withdraw": "withdraw",
-    "incentive_v3::borrow_v2": "borrow",
-    "incentive_v3::entry_borrow": "borrow",
-    "incentive_v3::entry_repay": "repay",
-    "incentive_v3::repay": "repay"
-  }
-};
-var NaviAdapter = class {
-  id = "navi";
-  name = "NAVI Protocol";
-  version = "1.0.0";
-  capabilities = ["save", "withdraw", "borrow", "repay"];
-  supportedAssets = [...STABLE_ASSETS];
-  supportsSameAssetBorrow = true;
-  client;
-  async init(client) {
-    this.client = client;
-  }
-  initSync(client) {
-    this.client = client;
-  }
-  async getRates(asset) {
-    const rates = await getRates(this.client);
-    const normalized = normalizeAsset(asset);
-    const r = rates[normalized];
-    if (!r) throw new T2000Error("ASSET_NOT_SUPPORTED", `NAVI does not support ${asset}`);
-    return { asset: normalized, saveApy: r.saveApy, borrowApy: r.borrowApy };
-  }
-  async getPositions(address) {
-    const result = await getPositions(this.client, address);
-    return {
-      supplies: result.positions.filter((p) => p.type === "save").map((p) => ({ asset: p.asset, amount: p.amount, apy: p.apy })),
-      borrows: result.positions.filter((p) => p.type === "borrow").map((p) => ({ asset: p.asset, amount: p.amount, apy: p.apy }))
-    };
-  }
-  async getHealth(address) {
-    return getHealthFactor(this.client, address);
-  }
-  async buildSaveTx(address, amount, asset, options) {
-    const stableAsset = normalizeAsset(asset);
-    const tx = await buildSaveTx(this.client, address, amount, { ...options, asset: stableAsset });
-    return { tx };
-  }
-  async buildWithdrawTx(address, amount, asset) {
-    const stableAsset = normalizeAsset(asset);
-    const result = await buildWithdrawTx(this.client, address, amount, { asset: stableAsset });
-    return { tx: result.tx, effectiveAmount: result.effectiveAmount };
-  }
-  async buildBorrowTx(address, amount, asset, options) {
-    const stableAsset = normalizeAsset(asset);
-    const tx = await buildBorrowTx(this.client, address, amount, { ...options, asset: stableAsset });
-    return { tx };
-  }
-  async buildRepayTx(address, amount, asset) {
-    const stableAsset = normalizeAsset(asset);
-    const tx = await buildRepayTx(this.client, address, amount, { asset: stableAsset });
-    return { tx };
-  }
-  async maxWithdraw(address, _asset) {
-    return maxWithdrawAmount(this.client, address);
-  }
-  async maxBorrow(address, _asset) {
-    return maxBorrowAmount(this.client, address);
-  }
-  async addWithdrawToTx(tx, address, amount, asset) {
-    const stableAsset = normalizeAsset(asset);
-    return addWithdrawToTx(tx, this.client, address, amount, { asset: stableAsset });
-  }
-  async addSaveToTx(tx, address, coin, asset, options) {
-    const stableAsset = normalizeAsset(asset);
-    return addSaveToTx(tx, this.client, address, coin, { ...options, asset: stableAsset });
-  }
-  async addRepayToTx(tx, address, coin, asset) {
-    const stableAsset = normalizeAsset(asset);
-    return addRepayToTx(tx, this.client, address, coin, { asset: stableAsset });
-  }
-};
-var DEFAULT_SLIPPAGE_BPS = 300;
-function createAggregatorClient(client, signer) {
-  return new aggregatorSdk.AggregatorClient({
-    client,
-    signer,
-    env: aggregatorSdk.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 result = await aggClient.findRouters({
-    from: fromInfo.type,
-    target: toInfo.type,
-    amount: rawAmount,
-    byAmountIn: true
-  });
-  if (!result || result.insufficientLiquidity) {
-    throw new T2000Error(
-      "ASSET_NOT_SUPPORTED",
-      `No swap route found for ${fromAsset} \u2192 ${toAsset}`
-    );
-  }
-  const tx = new transactions.Transaction();
-  const slippage = maxSlippageBps / 1e4;
-  await aggClient.fastRouterSwap({
-    router: result,
-    txb: tx,
-    slippage
-  });
-  const estimatedOut = Number(result.amountOut.toString());
-  return {
-    tx,
-    estimatedOut,
-    toDecimals: toInfo.decimals
-  };
-}
-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 result = await aggClient.findRouters({
-    from: fromInfo.type,
-    target: toInfo.type,
-    amount: rawAmount,
-    byAmountIn: true
-  });
-  if (!result || result.insufficientLiquidity) {
-    throw new T2000Error(
-      "ASSET_NOT_SUPPORTED",
-      `No swap route found for ${fromAsset} \u2192 ${toAsset}`
-    );
-  }
-  const slippage = maxSlippageBps / 1e4;
-  const outputCoin = await aggClient.routerSwap({
-    router: result,
-    txb: tx,
-    inputCoin,
-    slippage
-  });
-  const estimatedOut = Number(result.amountOut.toString());
-  return {
-    outputCoin,
-    estimatedOut,
-    toDecimals: toInfo.decimals
-  };
-}
-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 descriptor3 = {
-  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 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
-    });
-  }
-};
-SUPPORTED_ASSETS.USDC.type;
-var WAD = 1e18;
-var MIN_HEALTH_FACTOR2 = 1.5;
-var CLOCK2 = "0x6";
-var LENDING_MARKET_ID = "0x84030d26d85eaa7035084a057f2f11f701b7e2e4eda87551becbc7c97505ece1";
-var LENDING_MARKET_TYPE = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::suilend::MAIN_POOL";
-var SUILEND_PACKAGE = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf";
-var UPGRADE_CAP_ID = "0x3d4ef1859c3ee9fc72858f588b56a09da5466e64f8cc4e90a7b3b909fba8a7ae";
-var FALLBACK_PUBLISHED_AT = "0x3d4353f3bd3565329655e6b77bc2abfd31e558b86662ebd078ae453d416bc10f";
-var descriptor4 = {
-  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::borrow": "borrow",
-    "lending_market::repay": "repay"
-  }
-};
-function interpolateRate(utilBreakpoints, aprBreakpoints, utilizationPct) {
-  if (utilBreakpoints.length === 0) return 0;
-  if (utilizationPct <= utilBreakpoints[0]) return aprBreakpoints[0];
-  if (utilizationPct >= utilBreakpoints[utilBreakpoints.length - 1]) {
-    return aprBreakpoints[aprBreakpoints.length - 1];
-  }
-  for (let i = 1; i < utilBreakpoints.length; i++) {
-    if (utilizationPct <= utilBreakpoints[i]) {
-      const t = (utilizationPct - utilBreakpoints[i - 1]) / (utilBreakpoints[i] - utilBreakpoints[i - 1]);
-      return aprBreakpoints[i - 1] + t * (aprBreakpoints[i] - aprBreakpoints[i - 1]);
-    }
-  }
-  return aprBreakpoints[aprBreakpoints.length - 1];
-}
-function computeRates(reserve) {
-  const available = reserve.availableAmount / 10 ** reserve.mintDecimals;
-  const borrowed = reserve.borrowedAmountWad / WAD / 10 ** reserve.mintDecimals;
-  const totalDeposited = available + borrowed;
-  const utilizationPct = totalDeposited > 0 ? borrowed / totalDeposited * 100 : 0;
-  if (reserve.interestRateUtils.length === 0) return { borrowAprPct: 0, depositAprPct: 0 };
-  const aprs = reserve.interestRateAprs.map((a) => a / 100);
-  const borrowAprPct = interpolateRate(reserve.interestRateUtils, aprs, utilizationPct);
-  const depositAprPct = utilizationPct / 100 * (borrowAprPct / 100) * (1 - reserve.spreadFeeBps / 1e4) * 100;
-  return { borrowAprPct, depositAprPct };
-}
-function cTokenRatio(reserve) {
-  if (reserve.ctokenSupply === 0) return 1;
-  const totalSupply = reserve.availableAmount + reserve.borrowedAmountWad / WAD - reserve.unclaimedSpreadFeesWad / WAD;
-  return totalSupply / reserve.ctokenSupply;
-}
-function f(obj) {
-  if (obj && typeof obj === "object" && "fields" in obj) return obj.fields;
-  return obj;
-}
-function str(v) {
-  return String(v ?? "0");
-}
-function num(v) {
-  return Number(str(v));
-}
-function parseReserve(raw, index) {
-  const r = f(raw);
-  const coinTypeField = f(r.coin_type);
-  const config = f(f(r.config)?.element);
-  return {
-    coinType: str(coinTypeField?.name),
-    mintDecimals: num(r.mint_decimals),
-    availableAmount: num(r.available_amount),
-    borrowedAmountWad: num(f(r.borrowed_amount)?.value),
-    ctokenSupply: num(r.ctoken_supply),
-    unclaimedSpreadFeesWad: num(f(r.unclaimed_spread_fees)?.value),
-    cumulativeBorrowRateWad: num(f(r.cumulative_borrow_rate)?.value),
-    openLtvPct: num(config?.open_ltv_pct),
-    closeLtvPct: num(config?.close_ltv_pct),
-    spreadFeeBps: num(config?.spread_fee_bps),
-    interestRateUtils: Array.isArray(config?.interest_rate_utils) ? config.interest_rate_utils.map(num) : [],
-    interestRateAprs: Array.isArray(config?.interest_rate_aprs) ? config.interest_rate_aprs.map(num) : [],
-    arrayIndex: index
-  };
-}
-function parseObligation(raw) {
-  const deposits = Array.isArray(raw.deposits) ? raw.deposits.map((d) => {
-    const df = f(d);
-    return {
-      coinType: str(f(df.coin_type)?.name),
-      ctokenAmount: num(df.deposited_ctoken_amount),
-      reserveIdx: num(df.reserve_array_index)
-    };
-  }) : [];
-  const borrows = Array.isArray(raw.borrows) ? raw.borrows.map((b) => {
-    const bf = f(b);
-    return {
-      coinType: str(f(bf.coin_type)?.name),
-      borrowedWad: num(f(bf.borrowed_amount)?.value),
-      cumBorrowRateWad: num(f(bf.cumulative_borrow_rate)?.value),
-      reserveIdx: num(bf.reserve_array_index)
-    };
-  }) : [];
-  return { deposits, borrows };
-}
-var SuilendAdapter = class {
-  id = "suilend";
-  name = "Suilend";
-  version = "2.0.0";
-  capabilities = ["save", "withdraw", "borrow", "repay"];
-  supportedAssets = [...STABLE_ASSETS];
-  supportsSameAssetBorrow = false;
-  client;
-  publishedAt = null;
-  reserveCache = null;
-  async init(client) {
-    this.client = client;
-  }
-  initSync(client) {
-    this.client = client;
-  }
-  // -- On-chain reads -------------------------------------------------------
-  async resolvePackage() {
-    if (this.publishedAt) return this.publishedAt;
-    try {
-      const cap = await this.client.getObject({ id: UPGRADE_CAP_ID, options: { showContent: true } });
-      if (cap.data?.content?.dataType === "moveObject") {
-        const fields = cap.data.content.fields;
-        this.publishedAt = str(fields.package);
-        return this.publishedAt;
-      }
-    } catch {
-    }
-    this.publishedAt = FALLBACK_PUBLISHED_AT;
-    return this.publishedAt;
-  }
-  async loadReserves(fresh = false) {
-    if (this.reserveCache && !fresh) return this.reserveCache;
-    const market = await this.client.getObject({
-      id: LENDING_MARKET_ID,
-      options: { showContent: true }
-    });
-    if (market.data?.content?.dataType !== "moveObject") {
-      throw new T2000Error("PROTOCOL_UNAVAILABLE", "Failed to read Suilend lending market");
-    }
-    const fields = market.data.content.fields;
-    const reservesRaw = fields.reserves;
-    if (!Array.isArray(reservesRaw)) {
-      throw new T2000Error("PROTOCOL_UNAVAILABLE", "Failed to parse Suilend reserves");
-    }
-    this.reserveCache = reservesRaw.map((r, i) => parseReserve(r, i));
-    return this.reserveCache;
-  }
-  findReserve(reserves, asset) {
-    let coinType;
-    if (asset in SUPPORTED_ASSETS) {
-      coinType = SUPPORTED_ASSETS[asset].type;
-    } else if (asset.includes("::")) {
-      coinType = asset;
-    } else {
-      return void 0;
-    }
-    try {
-      const normalized = utils.normalizeStructTag(coinType);
-      return reserves.find((r) => {
-        try {
-          return utils.normalizeStructTag(r.coinType) === normalized;
-        } catch {
-          return false;
-        }
-      });
-    } catch {
-      return void 0;
-    }
-  }
-  async fetchObligationCaps(address) {
-    const capType = `${SUILEND_PACKAGE}::lending_market::ObligationOwnerCap<${LENDING_MARKET_TYPE}>`;
-    const caps = [];
-    let cursor;
-    let hasNext = true;
-    while (hasNext) {
-      const page = await this.client.getOwnedObjects({
-        owner: address,
-        filter: { StructType: capType },
-        options: { showContent: true },
-        cursor: cursor ?? void 0
-      });
-      for (const item of page.data) {
-        if (item.data?.content?.dataType !== "moveObject") continue;
-        const fields = item.data.content.fields;
-        caps.push({
-          id: item.data.objectId,
-          obligationId: str(fields.obligation_id)
-        });
-      }
-      cursor = page.nextCursor;
-      hasNext = page.hasNextPage;
-    }
-    return caps;
-  }
-  async fetchObligation(obligationId) {
-    const obj = await this.client.getObject({ id: obligationId, options: { showContent: true } });
-    if (obj.data?.content?.dataType !== "moveObject") {
-      throw new T2000Error("PROTOCOL_UNAVAILABLE", "Failed to read Suilend obligation");
-    }
-    return parseObligation(obj.data.content.fields);
-  }
-  resolveSymbol(coinType) {
-    try {
-      const normalized = utils.normalizeStructTag(coinType);
-      for (const [key, info] of Object.entries(SUPPORTED_ASSETS)) {
-        try {
-          if (utils.normalizeStructTag(info.type) === normalized) return key;
-        } catch {
-        }
-      }
-    } catch {
-    }
-    const parts = coinType.split("::");
-    return parts[parts.length - 1] || "UNKNOWN";
-  }
-  // -- Adapter interface ----------------------------------------------------
-  async getRates(asset) {
-    const reserves = await this.loadReserves();
-    const reserve = this.findReserve(reserves, asset);
-    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `Suilend does not support ${asset}`);
-    const { borrowAprPct, depositAprPct } = computeRates(reserve);
-    return { asset, saveApy: depositAprPct, borrowApy: borrowAprPct };
-  }
-  async getPositions(address) {
-    const supplies = [];
-    const borrows = [];
-    const caps = await this.fetchObligationCaps(address);
-    if (caps.length === 0) return { supplies, borrows };
-    const [reserves, obligation] = await Promise.all([
-      this.loadReserves(),
-      this.fetchObligation(caps[0].obligationId)
-    ]);
-    for (const dep of obligation.deposits) {
-      const reserve = reserves[dep.reserveIdx];
-      if (!reserve) continue;
-      const ratio = cTokenRatio(reserve);
-      const amount = dep.ctokenAmount * ratio / 10 ** reserve.mintDecimals;
-      const { depositAprPct } = computeRates(reserve);
-      supplies.push({ asset: this.resolveSymbol(dep.coinType), amount, apy: depositAprPct });
-    }
-    for (const bor of obligation.borrows) {
-      const reserve = reserves[bor.reserveIdx];
-      if (!reserve) continue;
-      const rawAmount = bor.borrowedWad / WAD / 10 ** reserve.mintDecimals;
-      const reserveRate = reserve.cumulativeBorrowRateWad / WAD;
-      const posRate = bor.cumBorrowRateWad / WAD;
-      const compounded = posRate > 0 ? rawAmount * (reserveRate / posRate) : rawAmount;
-      const { borrowAprPct } = computeRates(reserve);
-      borrows.push({ asset: this.resolveSymbol(bor.coinType), amount: compounded, apy: borrowAprPct });
-    }
-    return { supplies, borrows };
-  }
-  async getHealth(address) {
-    const caps = await this.fetchObligationCaps(address);
-    if (caps.length === 0) {
-      return { healthFactor: Infinity, supplied: 0, borrowed: 0, maxBorrow: 0, liquidationThreshold: 0 };
-    }
-    const [reserves, obligation] = await Promise.all([
-      this.loadReserves(),
-      this.fetchObligation(caps[0].obligationId)
-    ]);
-    let supplied = 0;
-    let borrowed = 0;
-    let weightedCloseLtv = 0;
-    let weightedOpenLtv = 0;
-    for (const dep of obligation.deposits) {
-      const reserve = reserves[dep.reserveIdx];
-      if (!reserve) continue;
-      const ratio = cTokenRatio(reserve);
-      const amount = dep.ctokenAmount * ratio / 10 ** reserve.mintDecimals;
-      supplied += amount;
-      weightedCloseLtv += amount * (reserve.closeLtvPct / 100);
-      weightedOpenLtv += amount * (reserve.openLtvPct / 100);
-    }
-    for (const bor of obligation.borrows) {
-      const reserve = reserves[bor.reserveIdx];
-      if (!reserve) continue;
-      const rawAmount = bor.borrowedWad / WAD / 10 ** reserve.mintDecimals;
-      const reserveRate = reserve.cumulativeBorrowRateWad / WAD;
-      const posRate = bor.cumBorrowRateWad / WAD;
-      borrowed += posRate > 0 ? rawAmount * (reserveRate / posRate) : rawAmount;
-    }
-    const liqThreshold = supplied > 0 ? weightedCloseLtv / supplied : 0.75;
-    const openLtv = supplied > 0 ? weightedOpenLtv / supplied : 0.7;
-    const healthFactor = borrowed > 0 ? supplied * liqThreshold / borrowed : Infinity;
-    const maxBorrow = Math.max(0, supplied * openLtv - borrowed);
-    return { healthFactor, supplied, borrowed, maxBorrow, liquidationThreshold: liqThreshold };
-  }
-  async buildSaveTx(address, amount, asset, options) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves()]);
-    const reserve = this.findReserve(reserves, assetKey);
-    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend. Try: NAVI or a different asset.`);
-    const caps = await this.fetchObligationCaps(address);
-    const tx = new transactions.Transaction();
-    tx.setSender(address);
-    let capRef;
-    if (caps.length === 0) {
-      const [newCap] = tx.moveCall({
-        target: `${pkg}::lending_market::create_obligation`,
-        typeArguments: [LENDING_MARKET_TYPE],
-        arguments: [tx.object(LENDING_MARKET_ID)]
-      });
-      capRef = newCap;
-    } else {
-      capRef = caps[0].id;
-    }
-    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 rawAmount = stableToRaw(amount, assetInfo.decimals).toString();
-    const [depositCoin] = tx.splitCoins(tx.object(primaryCoinId), [rawAmount]);
-    if (options?.collectFee) {
-      addCollectFeeToTx(tx, depositCoin, "save");
-    }
-    const [ctokens] = tx.moveCall({
-      target: `${pkg}::lending_market::deposit_liquidity_and_mint_ctokens`,
-      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        tx.object(CLOCK2),
-        depositCoin
-      ]
-    });
-    tx.moveCall({
-      target: `${pkg}::lending_market::deposit_ctokens_into_obligation`,
-      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        typeof capRef === "string" ? tx.object(capRef) : capRef,
-        tx.object(CLOCK2),
-        ctokens
-      ]
-    });
-    if (typeof capRef !== "string") {
-      tx.transferObjects([capRef], address);
-    }
-    return { tx };
-  }
-  async buildWithdrawTx(address, amount, asset) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves(true)]);
-    const reserve = this.findReserve(reserves, assetKey);
-    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend`);
-    const caps = await this.fetchObligationCaps(address);
-    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend position found");
-    const positions = await this.getPositions(address);
-    const deposited = positions.supplies.find((s) => s.asset === assetKey)?.amount ?? 0;
-    const effectiveAmount = Math.min(amount, deposited);
-    if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", `Nothing to withdraw for ${assetInfo.displayName} on Suilend`);
-    const ratio = cTokenRatio(reserve);
-    const ctokenAmount = Math.ceil(effectiveAmount * 10 ** reserve.mintDecimals / ratio);
-    const tx = new transactions.Transaction();
-    tx.setSender(address);
-    const [ctokens] = tx.moveCall({
-      target: `${pkg}::lending_market::withdraw_ctokens`,
-      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        tx.object(caps[0].id),
-        tx.object(CLOCK2),
-        tx.pure.u64(ctokenAmount)
-      ]
-    });
-    const exemptionType = `${SUILEND_PACKAGE}::lending_market::RateLimiterExemption<${LENDING_MARKET_TYPE}, ${assetInfo.type}>`;
-    const [none] = tx.moveCall({
-      target: "0x1::option::none",
-      typeArguments: [exemptionType]
-    });
-    const [coin] = tx.moveCall({
-      target: `${pkg}::lending_market::redeem_ctokens_and_withdraw_liquidity`,
-      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        tx.object(CLOCK2),
-        ctokens,
-        none
-      ]
-    });
-    tx.transferObjects([coin], address);
-    return { tx, effectiveAmount };
-  }
-  async addWithdrawToTx(tx, address, amount, asset) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves(true)]);
-    const reserve = this.findReserve(reserves, assetKey);
-    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend`);
-    const caps = await this.fetchObligationCaps(address);
-    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend position found");
-    const positions = await this.getPositions(address);
-    const deposited = positions.supplies.find((s) => s.asset === assetKey)?.amount ?? 0;
-    const effectiveAmount = Math.min(amount, deposited);
-    if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", `Nothing to withdraw for ${assetInfo.displayName} on Suilend`);
-    const ratio = cTokenRatio(reserve);
-    const ctokenAmount = Math.ceil(effectiveAmount * 10 ** reserve.mintDecimals / ratio);
-    const [ctokens] = tx.moveCall({
-      target: `${pkg}::lending_market::withdraw_ctokens`,
-      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        tx.object(caps[0].id),
-        tx.object(CLOCK2),
-        tx.pure.u64(ctokenAmount)
-      ]
-    });
-    const exemptionType = `${SUILEND_PACKAGE}::lending_market::RateLimiterExemption<${LENDING_MARKET_TYPE}, ${assetInfo.type}>`;
-    const [none] = tx.moveCall({
-      target: "0x1::option::none",
-      typeArguments: [exemptionType]
-    });
-    const [coin] = tx.moveCall({
-      target: `${pkg}::lending_market::redeem_ctokens_and_withdraw_liquidity`,
-      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        tx.object(CLOCK2),
-        ctokens,
-        none
-      ]
-    });
-    return { coin, effectiveAmount };
-  }
-  async addSaveToTx(tx, address, coin, asset, options) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves()]);
-    const reserve = this.findReserve(reserves, assetKey);
-    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend`);
-    const caps = await this.fetchObligationCaps(address);
-    let capRef;
-    if (caps.length === 0) {
-      const [newCap] = tx.moveCall({
-        target: `${pkg}::lending_market::create_obligation`,
-        typeArguments: [LENDING_MARKET_TYPE],
-        arguments: [tx.object(LENDING_MARKET_ID)]
-      });
-      capRef = newCap;
-    } else {
-      capRef = caps[0].id;
-    }
-    if (options?.collectFee) {
-      addCollectFeeToTx(tx, coin, "save");
-    }
-    const [ctokens] = tx.moveCall({
-      target: `${pkg}::lending_market::deposit_liquidity_and_mint_ctokens`,
-      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        tx.object(CLOCK2),
-        coin
-      ]
-    });
-    tx.moveCall({
-      target: `${pkg}::lending_market::deposit_ctokens_into_obligation`,
-      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        typeof capRef === "string" ? tx.object(capRef) : capRef,
-        tx.object(CLOCK2),
-        ctokens
-      ]
-    });
-    if (typeof capRef !== "string") {
-      tx.transferObjects([capRef], address);
-    }
-  }
-  async buildBorrowTx(address, amount, asset, options) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves()]);
-    const reserve = this.findReserve(reserves, assetKey);
-    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend. Try: NAVI or a different asset.`);
-    const caps = await this.fetchObligationCaps(address);
-    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend position found. Deposit collateral first with: t2000 save <amount>");
-    const rawAmount = stableToRaw(amount, assetInfo.decimals);
-    const tx = new transactions.Transaction();
-    tx.setSender(address);
-    const [coin] = tx.moveCall({
-      target: `${pkg}::lending_market::borrow`,
-      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        tx.object(caps[0].id),
-        tx.object(CLOCK2),
-        tx.pure.u64(rawAmount)
-      ]
-    });
-    if (options?.collectFee) {
-      addCollectFeeToTx(tx, coin, "borrow");
-    }
-    tx.transferObjects([coin], address);
-    return { tx };
-  }
-  async buildRepayTx(address, amount, asset) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves()]);
-    const reserve = this.findReserve(reserves, assetKey);
-    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend`);
-    const caps = await this.fetchObligationCaps(address);
-    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend obligation found");
-    const allCoins = await this.fetchAllCoins(address, assetInfo.type);
-    if (allCoins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", `No ${assetInfo.displayName} coins to repay with`);
-    const rawAmount = stableToRaw(amount, assetInfo.decimals);
-    const tx = new transactions.Transaction();
-    tx.setSender(address);
-    const primaryCoinId = allCoins[0].coinObjectId;
-    if (allCoins.length > 1) {
-      tx.mergeCoins(tx.object(primaryCoinId), allCoins.slice(1).map((c) => tx.object(c.coinObjectId)));
-    }
-    const [repayCoin] = tx.splitCoins(tx.object(primaryCoinId), [rawAmount.toString()]);
-    tx.moveCall({
-      target: `${pkg}::lending_market::repay`,
-      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        tx.object(caps[0].id),
-        tx.object(CLOCK2),
-        repayCoin
-      ]
-    });
-    return { tx };
-  }
-  async addRepayToTx(tx, address, coin, asset) {
-    const assetKey = asset in SUPPORTED_ASSETS ? asset : "USDC";
-    const assetInfo = SUPPORTED_ASSETS[assetKey];
-    const [pkg, reserves] = await Promise.all([this.resolvePackage(), this.loadReserves()]);
-    const reserve = this.findReserve(reserves, assetKey);
-    if (!reserve) throw new T2000Error("ASSET_NOT_SUPPORTED", `${assetInfo.displayName} reserve not found on Suilend`);
-    const caps = await this.fetchObligationCaps(address);
-    if (caps.length === 0) throw new T2000Error("NO_COLLATERAL", "No Suilend obligation found");
-    tx.moveCall({
-      target: `${pkg}::lending_market::repay`,
-      typeArguments: [LENDING_MARKET_TYPE, assetInfo.type],
-      arguments: [
-        tx.object(LENDING_MARKET_ID),
-        tx.pure.u64(reserve.arrayIndex),
-        tx.object(caps[0].id),
-        tx.object(CLOCK2),
-        coin
-      ]
-    });
-  }
-  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);
-    const maxAmount = health.maxBorrow;
-    return { maxAmount, 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;
-  }
-};
-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;
-  }
-  return true;
-}
-function solveHashcash(challenge) {
-  const bits = parseInt(challenge.split(":")[1], 10);
-  let counter = 0;
-  while (true) {
-    const stamp = `${challenge}${counter.toString(16)}`;
-    const hash = crypto.createHash("sha256").update(stamp).digest();
-    if (hasLeadingZeroBits(hash, bits)) return stamp;
-    counter++;
-  }
-}
-
-// src/gas/gasStation.ts
-async function requestGasSponsorship(txJson, sender, type) {
-  const txBytes = Buffer.from(txJson).toString("base64");
-  const res = await fetch(`${API_BASE_URL}/api/gas`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ txJson, txBytes, sender, type })
-  });
-  const data = await res.json();
-  if (!res.ok) {
-    const errorCode = data.error;
-    if (errorCode === "CIRCUIT_BREAKER" || errorCode === "POOL_DEPLETED") {
-      throw new T2000Error(
-        "GAS_STATION_UNAVAILABLE",
-        data.message ?? "Gas station temporarily unavailable",
-        { retryAfter: data.retryAfter },
-        true
-      );
-    }
-    if (errorCode === "GAS_FEE_EXCEEDED") {
-      throw new T2000Error(
-        "GAS_FEE_EXCEEDED",
-        data.message ?? "Gas fee exceeds ceiling",
-        { retryAfter: data.retryAfter },
-        true
-      );
-    }
-    throw new T2000Error(
-      "GAS_STATION_UNAVAILABLE",
-      data.message ?? "Gas sponsorship request failed",
-      void 0,
-      true
-    );
-  }
-  return data;
-}
-async function reportGasUsage(sender, txDigest, gasCostSui, usdcCharged, type) {
-  try {
-    await fetch(`${API_BASE_URL}/api/gas/report`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ sender, txDigest, gasCostSui, usdcCharged, type })
-    });
-  } catch {
-  }
-}
-async function getGasStatus(address) {
-  const url = new URL(`${API_BASE_URL}/api/gas/status`);
-  if (address) url.searchParams.set("address", address);
-  const res = await fetch(url.toString());
-  if (!res.ok) {
-    throw new T2000Error("GAS_STATION_UNAVAILABLE", "Failed to fetch gas status", void 0, true);
-  }
-  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 < AUTO_TOPUP_THRESHOLD && usdcRaw >= AUTO_TOPUP_MIN_USDC;
-}
-async function executeAutoTopUp(client, keypair) {
-  const address = keypair.getPublicKey().toSuiAddress();
-  const topupAmountHuman = Number(AUTO_TOPUP_AMOUNT) / 1e6;
-  const { tx } = await buildSwapTx({
-    client,
-    address,
-    fromAsset: "USDC",
-    toAsset: "SUI",
-    amount: topupAmountHuman
-  });
-  const txJson = tx.serialize();
-  const sponsoredResult = await requestGasSponsorship(txJson, address, "auto-topup");
-  const sponsoredTxBytes = Buffer.from(sponsoredResult.txBytes, "base64");
-  const { signature: agentSig } = await keypair.signTransaction(sponsoredTxBytes);
-  const result = await client.executeTransactionBlock({
-    transactionBlock: sponsoredResult.txBytes,
-    signature: [agentSig, sponsoredResult.sponsorSignature],
-    options: { showEffects: true, showBalanceChanges: true }
-  });
-  await client.waitForTransaction({ digest: result.digest });
-  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);
-      }
-    }
-  }
-  reportGasUsage(address, result.digest, 0, 0, "auto-topup");
-  return {
-    success: true,
-    tx: result.digest,
-    usdcSpent: topupAmountHuman,
-    suiReceived: Math.abs(suiReceived)
-  };
-}
-
-// src/gas/manager.ts
-function extractGasCost(effects) {
-  if (!effects?.gasUsed) return 0;
-  return (Number(effects.gasUsed.computationCost) + Number(effects.gasUsed.storageCost) - Number(effects.gasUsed.storageRebate)) / 1e9;
-}
-async function getSuiBalance(client, address) {
-  const bal = await client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.SUI.type });
-  return BigInt(bal.totalBalance);
-}
-async function trySelfFunded(client, keypair, tx) {
-  const address = keypair.getPublicKey().toSuiAddress();
-  const suiBalance = await getSuiBalance(client, address);
-  if (suiBalance < AUTO_TOPUP_THRESHOLD) return null;
-  tx.setSender(address);
-  const result = await client.signAndExecuteTransaction({
-    signer: keypair,
-    transaction: tx,
-    options: { showEffects: true }
-  });
-  await client.waitForTransaction({ digest: result.digest });
-  return {
-    digest: result.digest,
-    effects: result.effects,
-    gasMethod: "self-funded",
-    gasCostSui: extractGasCost(result.effects)
-  };
-}
-async function tryAutoTopUpThenSelfFund(client, keypair, tx) {
-  const address = keypair.getPublicKey().toSuiAddress();
-  const canTopUp = await shouldAutoTopUp(client, address);
-  if (!canTopUp) return null;
-  await executeAutoTopUp(client, keypair);
-  tx.setSender(address);
-  const result = await client.signAndExecuteTransaction({
-    signer: keypair,
-    transaction: tx,
-    options: { showEffects: true }
-  });
-  await client.waitForTransaction({ digest: result.digest });
-  return {
-    digest: result.digest,
-    effects: result.effects,
-    gasMethod: "auto-topup",
-    gasCostSui: extractGasCost(result.effects)
-  };
-}
-async function trySponsored(client, keypair, tx) {
-  const address = keypair.getPublicKey().toSuiAddress();
-  tx.setSender(address);
-  const txJson = tx.serialize();
-  const sponsoredResult = await requestGasSponsorship(txJson, address);
-  const sponsoredTxBytes = Buffer.from(sponsoredResult.txBytes, "base64");
-  const { signature: agentSig } = await keypair.signTransaction(sponsoredTxBytes);
-  const result = await client.executeTransactionBlock({
-    transactionBlock: sponsoredResult.txBytes,
-    signature: [agentSig, sponsoredResult.sponsorSignature],
-    options: { showEffects: true }
-  });
-  await client.waitForTransaction({ digest: result.digest });
-  const gasCost = extractGasCost(result.effects);
-  reportGasUsage(address, result.digest, gasCost, 0, sponsoredResult.type);
-  return {
-    digest: result.digest,
-    effects: result.effects,
-    gasMethod: "sponsored",
-    gasCostSui: gasCost
-  };
-}
-async function executeWithGas(client, keypair, buildTx, options) {
-  if (options?.enforcer && options?.metadata) {
-    options.enforcer.check(options.metadata);
-  }
-  const errors = [];
-  try {
-    const tx = await buildTx();
-    const result = await trySelfFunded(client, keypair, tx);
-    if (result) return result;
-    errors.push("self-funded: SUI below threshold");
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (isMoveAbort(msg)) {
-      throw new T2000Error("TRANSACTION_FAILED", parseMoveAbortMessage(msg));
-    }
-    errors.push(`self-funded: ${msg}`);
-  }
-  try {
-    const tx = await buildTx();
-    const result = await tryAutoTopUpThenSelfFund(client, keypair, tx);
-    if (result) return result;
-    errors.push("auto-topup: not eligible (low USDC or sufficient SUI)");
-  } catch (err) {
-    errors.push(`auto-topup: ${err instanceof Error ? err.message : String(err)}`);
-  }
-  try {
-    const tx = await buildTx();
-    const result = await trySponsored(client, keypair, tx);
-    if (result) return result;
-    errors.push("sponsored: returned null");
-  } catch (err) {
-    errors.push(`sponsored: ${err instanceof Error ? err.message : String(err)}`);
-  }
-  throw new T2000Error(
-    "INSUFFICIENT_GAS",
-    `No SUI for gas and Gas Station unavailable. Fund your wallet with SUI or USDC. [${errors.join(" | ")}]`,
-    { reason: "all_gas_methods_exhausted", errors }
-  );
-}
-
-// src/safeguards/types.ts
-var OUTBOUND_OPS = /* @__PURE__ */ new Set([
-  "send",
-  "pay",
-  "sentinel"
-]);
-var DEFAULT_SAFEGUARD_CONFIG = {
-  locked: false,
-  maxPerTx: 0,
-  maxDailySend: 0,
-  dailyUsed: 0,
-  dailyResetDate: ""
-};
-
-// src/safeguards/errors.ts
-var SafeguardError = class extends T2000Error {
-  rule;
-  details;
-  constructor(rule, details, message) {
-    const msg = message ?? buildMessage(rule, details);
-    super("SAFEGUARD_BLOCKED", msg, { rule, ...details });
-    this.name = "SafeguardError";
-    this.rule = rule;
-    this.details = details;
-  }
-  toJSON() {
-    return {
-      error: "SAFEGUARD_BLOCKED",
-      message: this.message,
-      retryable: this.retryable,
-      data: { rule: this.rule, ...this.details }
-    };
-  }
-};
-function buildMessage(rule, details) {
-  switch (rule) {
-    case "locked":
-      return "Agent is locked. All operations are frozen.";
-    case "maxPerTx":
-      return `Amount $${(details.attempted ?? 0).toFixed(2)} exceeds per-transaction limit ($${(details.limit ?? 0).toFixed(2)})`;
-    case "maxDailySend":
-      return `Daily send limit reached ($${(details.current ?? 0).toFixed(2)}/$${(details.limit ?? 0).toFixed(2)} used today)`;
-  }
-}
-
-// src/safeguards/enforcer.ts
-var SafeguardEnforcer = class {
-  config;
-  configPath;
-  constructor(configDir) {
-    this.config = { ...DEFAULT_SAFEGUARD_CONFIG };
-    this.configPath = configDir ? path.join(configDir, "config.json") : null;
-  }
-  load() {
-    if (!this.configPath) return;
-    try {
-      const raw = JSON.parse(fs.readFileSync(this.configPath, "utf-8"));
-      this.config = {
-        ...DEFAULT_SAFEGUARD_CONFIG,
-        locked: raw.locked ?? false,
-        maxPerTx: raw.maxPerTx ?? 0,
-        maxDailySend: raw.maxDailySend ?? 0,
-        dailyUsed: raw.dailyUsed ?? 0,
-        dailyResetDate: raw.dailyResetDate ?? ""
-      };
-    } catch {
-      this.config = { ...DEFAULT_SAFEGUARD_CONFIG };
-    }
-  }
-  assertNotLocked() {
-    this.load();
-    if (this.config.locked) {
-      throw new SafeguardError("locked", {});
-    }
-  }
-  check(metadata) {
-    this.load();
-    if (this.config.locked) {
-      throw new SafeguardError("locked", {});
-    }
-    if (!OUTBOUND_OPS.has(metadata.operation)) return;
-    const amount = metadata.amount ?? 0;
-    if (this.config.maxPerTx > 0 && amount > this.config.maxPerTx) {
-      throw new SafeguardError("maxPerTx", {
-        attempted: amount,
-        limit: this.config.maxPerTx
-      });
-    }
-    this.resetDailyIfNewDay();
-    if (this.config.maxDailySend > 0 && this.config.dailyUsed + amount > this.config.maxDailySend) {
-      throw new SafeguardError("maxDailySend", {
-        attempted: amount,
-        limit: this.config.maxDailySend,
-        current: this.config.dailyUsed
-      });
-    }
-  }
-  recordUsage(amount) {
-    this.resetDailyIfNewDay();
-    this.config.dailyUsed += amount;
-    this.save();
-  }
-  lock() {
-    this.config.locked = true;
-    this.save();
-  }
-  unlock() {
-    this.config.locked = false;
-    this.save();
-  }
-  set(key, value) {
-    if (key === "locked" && typeof value === "boolean") {
-      this.config.locked = value;
-    } else if (key === "maxPerTx" && typeof value === "number") {
-      this.config.maxPerTx = value;
-    } else if (key === "maxDailySend" && typeof value === "number") {
-      this.config.maxDailySend = value;
-    }
-    this.save();
-  }
-  getConfig() {
-    this.load();
-    this.resetDailyIfNewDay();
-    return { ...this.config };
-  }
-  isConfigured() {
-    return this.config.maxPerTx > 0 || this.config.maxDailySend > 0;
-  }
-  resetDailyIfNewDay() {
-    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    if (this.config.dailyResetDate !== today) {
-      this.config.dailyUsed = 0;
-      this.config.dailyResetDate = today;
-      this.save();
-    }
-  }
-  save() {
-    if (!this.configPath) return;
-    try {
-      let existing = {};
-      try {
-        existing = JSON.parse(fs.readFileSync(this.configPath, "utf-8"));
-      } catch {
-      }
-      const merged = {
-        ...existing,
-        locked: this.config.locked,
-        maxPerTx: this.config.maxPerTx,
-        maxDailySend: this.config.maxDailySend,
-        dailyUsed: this.config.dailyUsed,
-        dailyResetDate: this.config.dailyResetDate
-      };
-      const dir = this.configPath.replace(/[/\\][^/\\]+$/, "");
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-      fs.writeFileSync(this.configPath, JSON.stringify(merged, null, 2) + "\n");
-    } catch {
-    }
-  }
-};
-var RESERVED_NAMES = /* @__PURE__ */ new Set(["to", "all", "address"]);
-var ContactManager = class {
-  contacts = {};
-  filePath;
-  dir;
-  constructor(configDir) {
-    this.dir = configDir ?? path.join(os.homedir(), ".t2000");
-    this.filePath = path.join(this.dir, "contacts.json");
-    this.load();
-  }
-  load() {
-    try {
-      if (fs.existsSync(this.filePath)) {
-        this.contacts = JSON.parse(fs.readFileSync(this.filePath, "utf-8"));
-      }
-    } catch {
-      this.contacts = {};
-    }
-  }
-  save() {
-    if (!fs.existsSync(this.dir)) fs.mkdirSync(this.dir, { recursive: true });
-    fs.writeFileSync(this.filePath, JSON.stringify(this.contacts, null, 2));
-  }
-  add(name, address) {
-    this.validateName(name);
-    const normalized = validateAddress(address);
-    const key = name.toLowerCase();
-    const existed = key in this.contacts;
-    this.contacts[key] = { name, address: normalized };
-    this.save();
-    return { action: existed ? "updated" : "added" };
-  }
-  remove(name) {
-    const key = name.toLowerCase();
-    if (!(key in this.contacts)) return false;
-    delete this.contacts[key];
-    this.save();
-    return true;
-  }
-  get(name) {
-    this.load();
-    return this.contacts[name.toLowerCase()];
-  }
-  list() {
-    this.load();
-    return Object.values(this.contacts);
-  }
-  resolve(nameOrAddress) {
-    this.load();
-    if (nameOrAddress.startsWith("0x") && nameOrAddress.length >= 42) {
-      return { address: validateAddress(nameOrAddress) };
-    }
-    const contact = this.contacts[nameOrAddress.toLowerCase()];
-    if (contact) {
-      return { address: contact.address, contactName: contact.name };
-    }
-    throw new T2000Error(
-      "CONTACT_NOT_FOUND",
-      `"${nameOrAddress}" is not a valid Sui address or saved contact.
-  Add it: t2000 contacts add ${nameOrAddress} 0x...`
-    );
-  }
-  validateName(name) {
-    if (name.startsWith("0x")) {
-      throw new T2000Error("INVALID_CONTACT_NAME", "Contact names cannot start with 0x");
-    }
-    if (!/^[a-zA-Z0-9_]+$/.test(name)) {
-      throw new T2000Error("INVALID_CONTACT_NAME", "Contact names can only contain letters, numbers, and underscores");
-    }
-    if (name.length > 32) {
-      throw new T2000Error("INVALID_CONTACT_NAME", "Contact names must be 32 characters or fewer");
-    }
-    if (RESERVED_NAMES.has(name.toLowerCase())) {
-      throw new T2000Error("INVALID_CONTACT_NAME", `"${name}" is a reserved name and cannot be used as a contact`);
-    }
-  }
-};
-function emptyData() {
-  return { positions: {}, realizedPnL: 0 };
-}
-var PortfolioManager = class {
-  data = emptyData();
-  filePath;
-  dir;
-  constructor(configDir) {
-    this.dir = configDir ?? path.join(os.homedir(), ".t2000");
-    this.filePath = path.join(this.dir, "portfolio.json");
-    this.load();
-  }
-  load() {
-    try {
-      if (fs.existsSync(this.filePath)) {
-        this.data = JSON.parse(fs.readFileSync(this.filePath, "utf-8"));
-      }
-    } catch {
-      this.data = emptyData();
-    }
-  }
-  save() {
-    if (!fs.existsSync(this.dir)) fs.mkdirSync(this.dir, { recursive: true });
-    fs.writeFileSync(this.filePath, JSON.stringify(this.data, null, 2));
-  }
-  recordBuy(trade) {
-    this.load();
-    const pos = this.data.positions[trade.asset] ?? { totalAmount: 0, costBasis: 0, avgPrice: 0, trades: [] };
-    pos.totalAmount += trade.amount;
-    pos.costBasis += trade.usdValue;
-    pos.avgPrice = pos.costBasis / pos.totalAmount;
-    pos.trades.push(trade);
-    this.data.positions[trade.asset] = pos;
-    this.save();
-  }
-  recordSell(trade) {
-    this.load();
-    const pos = this.data.positions[trade.asset];
-    if (!pos || pos.totalAmount <= 0) {
-      throw new T2000Error("INSUFFICIENT_INVESTMENT", `No ${trade.asset} position to sell`);
-    }
-    const sellAmount = Math.min(trade.amount, pos.totalAmount);
-    const costOfSold = pos.avgPrice * sellAmount;
-    const realizedPnL = trade.usdValue - costOfSold;
-    pos.totalAmount -= sellAmount;
-    pos.costBasis -= costOfSold;
-    if (pos.totalAmount < 1e-6) {
-      pos.totalAmount = 0;
-      pos.costBasis = 0;
-      pos.avgPrice = 0;
-    }
-    pos.trades.push(trade);
-    this.data.realizedPnL += realizedPnL;
-    this.data.positions[trade.asset] = pos;
-    this.save();
-    return realizedPnL;
-  }
-  getPosition(asset) {
-    this.load();
-    return this.data.positions[asset];
-  }
-  getPositions() {
-    this.load();
-    return Object.entries(this.data.positions).filter(([, pos]) => pos.totalAmount > 0).map(([asset, pos]) => ({ asset, ...pos }));
-  }
-  getRealizedPnL() {
-    this.load();
-    return this.data.realizedPnL;
-  }
-};
-var DEFAULT_CONFIG_DIR = path.join(os.homedir(), ".t2000");
-var T2000 = class _T2000 extends eventemitter3.EventEmitter {
-  keypair;
-  client;
-  _address;
-  registry;
-  enforcer;
-  contacts;
-  portfolio;
-  constructor(keypair, client, registry, configDir) {
-    super();
-    this.keypair = keypair;
-    this.client = client;
-    this._address = getAddress(keypair);
-    this.registry = registry ?? _T2000.createDefaultRegistry(client);
-    this.enforcer = new SafeguardEnforcer(configDir);
-    this.enforcer.load();
-    this.contacts = new ContactManager(configDir);
-    this.portfolio = new PortfolioManager(configDir);
-  }
-  static createDefaultRegistry(client) {
-    const registry = new ProtocolRegistry();
-    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 = {}) {
-    const { keyPath, pin, passphrase, network = DEFAULT_NETWORK, rpcUrl, sponsored, name } = options;
-    const secret = pin ?? passphrase;
-    const client = getSuiClient(rpcUrl);
-    if (sponsored) {
-      const keypair2 = generateKeypair();
-      if (secret) {
-        await saveKey(keypair2, secret, keyPath);
-      }
-      return new _T2000(keypair2, client, void 0, DEFAULT_CONFIG_DIR);
-    }
-    const exists = await walletExists(keyPath);
-    if (!exists) {
-      throw new T2000Error(
-        "WALLET_NOT_FOUND",
-        "No wallet found. Run `t2000 init` to create one."
-      );
-    }
-    if (!secret) {
-      throw new T2000Error("WALLET_LOCKED", "PIN required to unlock wallet");
-    }
-    const keypair = await loadKey(secret, keyPath);
-    return new _T2000(keypair, client, void 0, DEFAULT_CONFIG_DIR);
-  }
-  static fromPrivateKey(privateKey, options = {}) {
-    const keypair = keypairFromPrivateKey(privateKey);
-    const client = getSuiClient(options.rpcUrl);
-    return new _T2000(keypair, client);
-  }
-  static async init(options) {
-    const secret = options.pin ?? options.passphrase ?? "";
-    const keypair = generateKeypair();
-    await saveKey(keypair, secret, options.keyPath);
-    const client = getSuiClient();
-    const agent = new _T2000(keypair, client, void 0, DEFAULT_CONFIG_DIR);
-    const address = agent.address();
-    let sponsored = false;
-    if (options.sponsored !== false) {
-      try {
-        await callSponsorApi(address, options.name);
-        sponsored = true;
-      } catch {
-      }
-    }
-    return { agent, address, sponsored };
-  }
-  // -- Gas --
-  /** SuiJsonRpcClient used by this agent — exposed for x402 and other integrations. */
-  get suiClient() {
-    return this.client;
-  }
-  /** Ed25519Keypair used by this agent — exposed for x402 and other integrations. */
-  get signer() {
-    return this.keypair;
-  }
-  // -- Wallet --
-  address() {
-    return this._address;
-  }
-  async send(params) {
-    this.enforcer.assertNotLocked();
-    const asset = params.asset ?? "USDC";
-    if (!(asset in SUPPORTED_ASSETS)) {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `Asset ${asset} is not supported`);
-    }
-    if (asset in INVESTMENT_ASSETS) {
-      const free = await this.getFreeBalance(asset);
-      if (params.amount > free) {
-        const pos = this.portfolio.getPosition(asset);
-        const invested = pos?.totalAmount ?? 0;
-        throw new T2000Error(
-          "INVESTMENT_LOCKED",
-          `Cannot send ${params.amount} ${asset} \u2014 ${invested.toFixed(4)} ${asset} is invested. Free ${asset}: ${free.toFixed(4)}
-To access invested funds: t2000 invest sell ${params.amount} ${asset}`,
-          { free, invested, requested: params.amount }
-        );
-      }
-    }
-    const resolved = this.contacts.resolve(params.to);
-    const sendAmount = params.amount;
-    const sendTo = resolved.address;
-    const gasResult = await executeWithGas(
-      this.client,
-      this.keypair,
-      () => buildSendTx({ client: this.client, address: this._address, to: sendTo, amount: sendAmount, asset }),
-      { metadata: { operation: "send", amount: sendAmount }, enforcer: this.enforcer }
-    );
-    this.enforcer.recordUsage(sendAmount);
-    const balance = await this.balance();
-    this.emitBalanceChange(asset, sendAmount, "send", gasResult.digest);
-    return {
-      success: true,
-      tx: gasResult.digest,
-      amount: sendAmount,
-      to: resolved.address,
-      contactName: resolved.contactName,
-      gasCost: gasResult.gasCostSui,
-      gasCostUnit: "SUI",
-      gasMethod: gasResult.gasMethod,
-      balance
-    };
-  }
-  async balance() {
-    const bal = await queryBalance(this.client, this._address);
-    try {
-      const positions = await this.positions();
-      const savings = positions.positions.filter((p) => p.type === "save").reduce((sum, p) => sum + p.amount, 0);
-      const debt = positions.positions.filter((p) => p.type === "borrow").reduce((sum, p) => sum + p.amount, 0);
-      bal.savings = savings;
-      bal.debt = debt;
-    } catch {
-    }
-    try {
-      const portfolioPositions = this.portfolio.getPositions();
-      const suiPrice = bal.gasReserve.sui > 0 ? bal.gasReserve.usdEquiv / bal.gasReserve.sui : 0;
-      const assetPrices = { SUI: suiPrice };
-      const swapAdapter = this.registry.listSwap()[0];
-      for (const pos of portfolioPositions) {
-        if (pos.asset !== "SUI" && pos.asset in INVESTMENT_ASSETS && !(pos.asset in assetPrices)) {
-          try {
-            if (swapAdapter) {
-              const quote = await swapAdapter.getQuote("USDC", pos.asset, 1);
-              assetPrices[pos.asset] = quote.expectedOutput > 0 ? 1 / quote.expectedOutput : 0;
-            }
-          } catch {
-            assetPrices[pos.asset] = 0;
-          }
-        }
-      }
-      let investmentValue = 0;
-      let investmentCostBasis = 0;
-      for (const pos of portfolioPositions) {
-        if (!(pos.asset in INVESTMENT_ASSETS)) continue;
-        const price = assetPrices[pos.asset] ?? 0;
-        if (pos.asset === "SUI") {
-          const actualHeld = Math.min(pos.totalAmount, bal.gasReserve.sui);
-          investmentValue += actualHeld * price;
-          if (actualHeld < pos.totalAmount && pos.totalAmount > 0) {
-            investmentCostBasis += pos.costBasis * (actualHeld / pos.totalAmount);
-          } else {
-            investmentCostBasis += pos.costBasis;
-          }
-          const gasSui = Math.max(0, bal.gasReserve.sui - pos.totalAmount);
-          bal.gasReserve = { sui: gasSui, usdEquiv: gasSui * price };
-        } else {
-          investmentValue += pos.totalAmount * price;
-          investmentCostBasis += pos.costBasis;
-        }
-      }
-      bal.investment = investmentValue;
-      bal.investmentPnL = investmentValue - investmentCostBasis;
-    } catch {
-      bal.investment = 0;
-      bal.investmentPnL = 0;
-    }
-    bal.total = bal.available + bal.savings - bal.debt + bal.investment + bal.gasReserve.usdEquiv;
-    return bal;
-  }
-  async history(params) {
-    return queryHistory(this.client, this._address, params?.limit);
-  }
-  async deposit() {
-    return {
-      address: this._address,
-      network: "Sui (mainnet)",
-      supportedAssets: ["USDC"],
-      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)}`
-      ].join("\n")
-    };
-  }
-  exportKey() {
-    return exportPrivateKey(this.keypair);
-  }
-  async registerAdapter(adapter) {
-    await adapter.init(this.client);
-    if ("buildSaveTx" in adapter) this.registry.registerLending(adapter);
-    if ("buildSwapTx" in adapter) this.registry.registerSwap(adapter);
-  }
-  // -- Savings --
-  async save(params) {
-    this.enforcer.assertNotLocked();
-    const asset = "USDC";
-    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;
-      if (amount <= 0) {
-        throw new T2000Error("INSUFFICIENT_BALANCE", "Balance too low to save after $1 gas reserve", {
-          reason: "gas_reserve_required",
-          available: bal.available ?? 0
-        });
-      }
-    } else {
-      amount = params.amount;
-      if (amount > (bal.available ?? 0)) {
-        throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient balance. Available: $${(bal.available ?? 0).toFixed(2)}, requested: $${amount.toFixed(2)}`);
-      }
-    }
-    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 gasResult = await executeWithGas(this.client, this.keypair, async () => {
-      if (canPTB && needsAutoConvert) {
-        const tx2 = new transactions.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;
-          const coins = await this._fetchCoins(assetInfo.type);
-          if (coins.length === 0) continue;
-          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));
-        }
-        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 transactions.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 });
-        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;
-    });
-    const rates = await adapter.getRates(asset);
-    reportFee(this._address, "save", fee.amount, fee.rate, gasResult.digest);
-    this.emitBalanceChange(asset, saveAmount, "save", gasResult.digest);
-    let savingsBalance = saveAmount;
-    try {
-      const positions = await this.positions();
-      savingsBalance = positions.positions.filter((p) => p.type === "save" && p.asset === asset).reduce((sum, p) => sum + p.amount, 0);
-    } catch {
-    }
-    return {
-      success: true,
-      tx: gasResult.digest,
-      amount: saveAmount,
-      apy: rates.saveApy,
-      fee: fee.amount,
-      gasCost: gasResult.gasCostSui,
-      gasMethod: gasResult.gasMethod,
-      savingsBalance
-    };
-  }
-  async withdraw(params) {
-    this.enforcer.assertNotLocked();
-    if (params.amount === "all" && !params.protocol) {
-      return this.withdrawAllProtocols();
-    }
-    const allPositions = await this.registry.allPositions(this._address);
-    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) 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");
-    }
-    supplies.sort((a, b) => a.apy - b.apy);
-    const target = supplies[0];
-    const adapter = this.registry.getLending(target.protocolId);
-    if (!adapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", `Protocol ${target.protocolId} not found`);
-    let amount;
-    if (params.amount === "all") {
-      const maxResult = await adapter.maxWithdraw(this._address, target.asset);
-      amount = maxResult.maxAmount;
-      if (amount <= 0) {
-        throw new T2000Error("NO_COLLATERAL", "No savings to withdraw");
-      }
-    } else {
-      amount = params.amount;
-      const hf = await adapter.getHealth(this._address);
-      if (hf.borrowed > 0) {
-        const maxResult = await adapter.maxWithdraw(this._address, target.asset);
-        if (amount > maxResult.maxAmount) {
-          throw new T2000Error(
-            "WITHDRAW_WOULD_LIQUIDATE",
-            `Withdrawing $${amount.toFixed(2)} would drop health factor below 1.5`,
-            {
-              safeWithdrawAmount: maxResult.maxAmount,
-              currentHF: maxResult.currentHF,
-              projectedHF: maxResult.healthFactorAfter
-            }
-          );
-        }
-      }
-    }
-    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.keypair, async () => {
-      if (canPTB) {
-        const tx = new transactions.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
-          );
-          finalAmount = estimatedOut / 10 ** toDecimals;
-          tx.transferObjects([outputCoin], this._address);
-        } else {
-          tx.transferObjects([coin], this._address);
-        }
-        return tx;
-      }
-      const built = await adapter.buildWithdrawTx(this._address, withdrawAmount, target.asset);
-      finalAmount = built.effectiveAmount;
-      return built.tx;
-    });
-    this.emitBalanceChange("USDC", finalAmount, "withdraw", gasResult.digest);
-    return {
-      success: true,
-      tx: gasResult.digest,
-      amount: finalAmount,
-      gasCost: gasResult.gasCostSui,
-      gasMethod: gasResult.gasMethod
-    };
-  }
-  async withdrawAllProtocols() {
-    const allPositions = await this.registry.allPositions(this._address);
-    const withdrawable = [];
-    for (const pos of allPositions) {
-      for (const supply of pos.positions.supplies) {
-        if (supply.amount > 0.01) {
-          withdrawable.push({ protocolId: pos.protocolId, asset: supply.asset, amount: supply.amount });
-        }
-      }
-    }
-    if (withdrawable.length === 0) {
-      throw new T2000Error("NO_COLLATERAL", "No savings to withdraw across any protocol");
-    }
-    const entries = [];
-    for (const entry of withdrawable) {
-      const adapter = this.registry.getLending(entry.protocolId);
-      if (!adapter) continue;
-      const maxResult = await adapter.maxWithdraw(this._address, entry.asset);
-      const perAssetMax = Math.min(entry.amount, maxResult.maxAmount);
-      if (perAssetMax > 0.01) {
-        entries.push({ ...entry, maxAmount: perAssetMax, adapter });
-      }
-    }
-    if (entries.length === 0) {
-      throw new T2000Error("NO_COLLATERAL", "No savings to withdraw across any protocol");
-    }
-    const swapAdapter = this.registry.listSwap()[0];
-    const canPTB = entries.every((e) => e.adapter.addWithdrawToTx) && (!swapAdapter || swapAdapter.addSwapToTx);
-    let totalUsdcReceived = 0;
-    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
-      if (canPTB) {
-        const tx = new transactions.Transaction();
-        tx.setSender(this._address);
-        const usdcCoins = [];
-        for (const entry of entries) {
-          const { coin, effectiveAmount } = await entry.adapter.addWithdrawToTx(
-            tx,
-            this._address,
-            entry.maxAmount,
-            entry.asset
-          );
-          if (entry.asset !== "USDC" && swapAdapter?.addSwapToTx) {
-            const { outputCoin, estimatedOut, toDecimals } = await swapAdapter.addSwapToTx(
-              tx,
-              this._address,
-              coin,
-              entry.asset,
-              "USDC",
-              effectiveAmount
-            );
-            totalUsdcReceived += estimatedOut / 10 ** toDecimals;
-            usdcCoins.push(outputCoin);
-          } else {
-            totalUsdcReceived += effectiveAmount;
-            usdcCoins.push(coin);
-          }
-        }
-        if (usdcCoins.length > 1) {
-          tx.mergeCoins(usdcCoins[0], usdcCoins.slice(1));
-        }
-        tx.transferObjects([usdcCoins[0]], 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;
-        lastTx = built.tx;
-      }
-      return lastTx;
-    });
-    if (totalUsdcReceived <= 0) {
-      throw new T2000Error("NO_COLLATERAL", "No savings to withdraw across any protocol");
-    }
-    return {
-      success: true,
-      tx: gasResult.digest,
-      amount: totalUsdcReceived,
-      gasCost: gasResult.gasCostSui,
-      gasMethod: gasResult.gasMethod
-    };
-  }
-  async _fetchCoins(coinType) {
-    const all = [];
-    let cursor;
-    let hasNext = true;
-    while (hasNext) {
-      const page = await this.client.getCoins({ owner: this._address, 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;
-  }
-  _mergeCoinsInTx(tx, coins) {
-    if (coins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No coins to merge");
-    const primary = tx.object(coins[0].coinObjectId);
-    if (coins.length > 1) {
-      tx.mergeCoins(primary, coins.slice(1).map((c) => tx.object(c.coinObjectId)));
-    }
-    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.keypair, 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.keypair, 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 };
-  }
-  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 borrow(params) {
-    this.enforcer.assertNotLocked();
-    const asset = "USDC";
-    const adapter = await this.resolveLending(params.protocol, asset, "borrow");
-    const maxResult = await adapter.maxBorrow(this._address, asset);
-    if (maxResult.maxAmount <= 0) {
-      throw new T2000Error("NO_COLLATERAL", "No collateral deposited. Save first with `t2000 save <amount>`.");
-    }
-    if (params.amount > maxResult.maxAmount) {
-      throw new T2000Error("HEALTH_FACTOR_TOO_LOW", `Max safe borrow: $${maxResult.maxAmount.toFixed(2)}`, {
-        maxBorrow: maxResult.maxAmount,
-        currentHF: maxResult.currentHF
-      });
-    }
-    const fee = calculateFee("borrow", params.amount);
-    const borrowAmount = params.amount;
-    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
-      const { tx } = await adapter.buildBorrowTx(this._address, borrowAmount, asset, { collectFee: true });
-      return tx;
-    });
-    const hf = await adapter.getHealth(this._address);
-    reportFee(this._address, "borrow", fee.amount, fee.rate, gasResult.digest);
-    this.emitBalanceChange(asset, borrowAmount, "borrow", gasResult.digest);
-    return {
-      success: true,
-      tx: gasResult.digest,
-      amount: borrowAmount,
-      fee: fee.amount,
-      healthFactor: hf.healthFactor,
-      gasCost: gasResult.gasCostSui,
-      gasMethod: gasResult.gasMethod
-    };
-  }
-  async repay(params) {
-    this.enforcer.assertNotLocked();
-    const allPositions = await this.registry.allPositions(this._address);
-    const borrows = [];
-    for (const pos of allPositions) {
-      if (params.protocol && pos.protocolId !== params.protocol) continue;
-      for (const b of pos.positions.borrows) {
-        if (b.amount > 1e-3) borrows.push({ protocolId: pos.protocolId, asset: b.asset, amount: b.amount, apy: b.apy });
-      }
-    }
-    if (borrows.length === 0) {
-      throw new T2000Error("NO_COLLATERAL", "No outstanding borrow to repay");
-    }
-    if (params.amount === "all") {
-      return this._repayAllBorrows(borrows);
-    }
-    borrows.sort((a, b) => b.apy - a.apy);
-    const target = borrows[0];
-    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.keypair, async () => {
-      if (canPTB && target.asset !== "USDC" && swapAdapter?.addSwapToTx) {
-        const tx2 = new transactions.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") {
-        const tx2 = new transactions.Transaction();
-        tx2.setSender(this._address);
-        const usdcCoins = await this._fetchCoins(SUPPORTED_ASSETS.USDC.type);
-        if (usdcCoins.length === 0) throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins");
-        const merged = this._mergeCoinsInTx(tx2, usdcCoins);
-        const raw = BigInt(Math.floor(repayAmount * 10 ** SUPPORTED_ASSETS.USDC.decimals));
-        const [repayCoin] = tx2.splitCoins(merged, [raw]);
-        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;
-    });
-    const hf = await adapter.getHealth(this._address);
-    this.emitBalanceChange("USDC", repayAmount, "repay", gasResult.digest);
-    return {
-      success: true,
-      tx: gasResult.digest,
-      amount: repayAmount,
-      remainingDebt: hf.borrowed,
-      gasCost: gasResult.gasCostSui,
-      gasMethod: gasResult.gasMethod
-    };
-  }
-  async _repayAllBorrows(borrows) {
-    borrows.sort((a, b) => b.apy - a.apy);
-    const entries = [];
-    for (const borrow of borrows) {
-      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);
-    let totalRepaid = 0;
-    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
-      if (canPTB) {
-        const tx = new transactions.Transaction();
-        tx.setSender(this._address);
-        const usdcCoins = await this._fetchCoins(SUPPORTED_ASSETS.USDC.type);
-        let usdcMerged;
-        if (usdcCoins.length > 0) {
-          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);
-          }
-          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;
-      }
-      return lastTx;
-    });
-    const firstAdapter = entries[0]?.adapter;
-    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");
-    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 hf;
-  }
-  // -- Exchange --
-  async exchange(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");
-    }
-    if (!params._bypassInvestmentGuard && fromAsset in INVESTMENT_ASSETS) {
-      const free = await this.getFreeBalance(fromAsset);
-      if (params.amount > free) {
-        const pos = this.portfolio.getPosition(fromAsset);
-        const invested = pos?.totalAmount ?? 0;
-        throw new T2000Error(
-          "INVESTMENT_LOCKED",
-          `Cannot exchange ${params.amount} ${fromAsset} \u2014 ${invested.toFixed(4)} ${fromAsset} is invested. Free ${fromAsset}: ${free.toFixed(4)}
-To sell investment: t2000 invest sell ${params.amount} ${fromAsset}`,
-          { free, invested, requested: params.amount }
-        );
-      }
-    }
-    const best = await this.registry.bestSwapQuote(fromAsset, toAsset, params.amount);
-    const adapter = best.adapter;
-    const fee = calculateFee("swap", params.amount);
-    const swapAmount = params.amount;
-    const slippageBps = params.maxSlippage ? params.maxSlippage * 100 : void 0;
-    let swapMeta = { estimatedOut: 0, toDecimals: 0 };
-    const gasResult = await executeWithGas(this.client, this.keypair, 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);
-    return {
-      success: true,
-      tx: gasResult.digest,
-      fromAmount: swapAmount,
-      fromAsset,
-      toAmount: actualReceived,
-      toAsset,
-      priceImpact,
-      fee: fee.amount,
-      gasCost: gasResult.gasCostSui,
-      gasMethod: gasResult.gasMethod
-    };
-  }
-  async exchangeQuote(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 } };
-  }
-  // -- Investment --
-  async investBuy(params) {
-    this.enforcer.assertNotLocked();
-    if (!params.usdAmount || params.usdAmount <= 0 || !isFinite(params.usdAmount)) {
-      throw new T2000Error("INVALID_AMOUNT", "Investment amount must be greater than $0");
-    }
-    this.enforcer.check({ operation: "invest", amount: params.usdAmount });
-    if (!(params.asset in INVESTMENT_ASSETS)) {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `${params.asset} is not available for investment`);
-    }
-    const bal = await queryBalance(this.client, this._address);
-    if (bal.available < params.usdAmount) {
-      throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient checking balance. Available: $${bal.available.toFixed(2)}, requested: $${params.usdAmount.toFixed(2)}`);
-    }
-    const swapResult = await this.exchange({
-      from: "USDC",
-      to: params.asset,
-      amount: params.usdAmount,
-      maxSlippage: params.maxSlippage ?? 0.03,
-      _bypassInvestmentGuard: true
-    });
-    if (swapResult.toAmount === 0) {
-      throw new T2000Error("SWAP_FAILED", "Swap returned zero tokens \u2014 try a different amount or check liquidity");
-    }
-    const price = params.usdAmount / swapResult.toAmount;
-    this.portfolio.recordBuy({
-      id: `inv_${Date.now()}`,
-      type: "buy",
-      asset: params.asset,
-      amount: swapResult.toAmount,
-      price,
-      usdValue: params.usdAmount,
-      fee: swapResult.fee,
-      tx: swapResult.tx,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    const pos = this.portfolio.getPosition(params.asset);
-    const currentPrice = price;
-    const position = {
-      asset: params.asset,
-      totalAmount: pos?.totalAmount ?? swapResult.toAmount,
-      costBasis: pos?.costBasis ?? params.usdAmount,
-      avgPrice: pos?.avgPrice ?? price,
-      currentPrice,
-      currentValue: (pos?.totalAmount ?? swapResult.toAmount) * currentPrice,
-      unrealizedPnL: 0,
-      unrealizedPnLPct: 0,
-      trades: pos?.trades ?? []
-    };
-    return {
-      success: true,
-      tx: swapResult.tx,
-      type: "buy",
-      asset: params.asset,
-      amount: swapResult.toAmount,
-      price,
-      usdValue: params.usdAmount,
-      fee: swapResult.fee,
-      gasCost: swapResult.gasCost,
-      gasMethod: swapResult.gasMethod,
-      position
-    };
-  }
-  async investSell(params) {
-    this.enforcer.assertNotLocked();
-    if (params.usdAmount !== "all") {
-      if (!params.usdAmount || params.usdAmount <= 0 || !isFinite(params.usdAmount)) {
-        throw new T2000Error("INVALID_AMOUNT", "Sell amount must be greater than $0");
-      }
-    }
-    if (!(params.asset in INVESTMENT_ASSETS)) {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `${params.asset} is not available for investment`);
-    }
-    const pos = this.portfolio.getPosition(params.asset);
-    if (!pos || pos.totalAmount <= 0) {
-      throw new T2000Error("INSUFFICIENT_INVESTMENT", `No ${params.asset} position to sell`);
-    }
-    const assetInfo = SUPPORTED_ASSETS[params.asset];
-    const assetBalance = await this.client.getBalance({
-      owner: this._address,
-      coinType: assetInfo.type
-    });
-    const walletAmount = Number(assetBalance.totalBalance) / 10 ** assetInfo.decimals;
-    const gasReserve = params.asset === "SUI" ? GAS_RESERVE_MIN : 0;
-    const maxSellable = Math.max(0, walletAmount - gasReserve);
-    let sellAmountAsset;
-    if (params.usdAmount === "all") {
-      sellAmountAsset = Math.min(pos.totalAmount, maxSellable);
-    } else {
-      const swapAdapter = this.registry.listSwap()[0];
-      if (!swapAdapter) throw new T2000Error("PROTOCOL_UNAVAILABLE", "No swap adapter available");
-      const quote = await swapAdapter.getQuote("USDC", params.asset, 1);
-      const assetPrice = 1 / quote.expectedOutput;
-      sellAmountAsset = params.usdAmount / assetPrice;
-      sellAmountAsset = Math.min(sellAmountAsset, pos.totalAmount);
-      if (sellAmountAsset > maxSellable) {
-        throw new T2000Error(
-          "INSUFFICIENT_INVESTMENT",
-          `Cannot sell $${params.usdAmount.toFixed(2)} \u2014 max sellable: $${(maxSellable * assetPrice).toFixed(2)} (gas reserve: ${gasReserve} ${params.asset})`
-        );
-      }
-    }
-    if (sellAmountAsset <= 0) {
-      throw new T2000Error("INSUFFICIENT_INVESTMENT", "Nothing to sell after gas reserve");
-    }
-    const swapResult = await this.exchange({
-      from: params.asset,
-      to: "USDC",
-      amount: sellAmountAsset,
-      maxSlippage: params.maxSlippage ?? 0.03,
-      _bypassInvestmentGuard: true
-    });
-    const price = swapResult.toAmount / sellAmountAsset;
-    const realizedPnL = this.portfolio.recordSell({
-      id: `inv_${Date.now()}`,
-      type: "sell",
-      asset: params.asset,
-      amount: sellAmountAsset,
-      price,
-      usdValue: swapResult.toAmount,
-      fee: swapResult.fee,
-      tx: swapResult.tx,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    const updatedPos = this.portfolio.getPosition(params.asset);
-    const position = {
-      asset: params.asset,
-      totalAmount: updatedPos?.totalAmount ?? 0,
-      costBasis: updatedPos?.costBasis ?? 0,
-      avgPrice: updatedPos?.avgPrice ?? 0,
-      currentPrice: price,
-      currentValue: (updatedPos?.totalAmount ?? 0) * price,
-      unrealizedPnL: 0,
-      unrealizedPnLPct: 0,
-      trades: updatedPos?.trades ?? []
-    };
-    return {
-      success: true,
-      tx: swapResult.tx,
-      type: "sell",
-      asset: params.asset,
-      amount: sellAmountAsset,
-      price,
-      usdValue: swapResult.toAmount,
-      fee: swapResult.fee,
-      gasCost: swapResult.gasCost,
-      gasMethod: swapResult.gasMethod,
-      realizedPnL,
-      position
-    };
-  }
-  async getPortfolio() {
-    const positions = this.portfolio.getPositions();
-    const realizedPnL = this.portfolio.getRealizedPnL();
-    const prices = {};
-    const swapAdapter = this.registry.listSwap()[0];
-    for (const asset of Object.keys(INVESTMENT_ASSETS)) {
-      try {
-        if (asset === "SUI" && swapAdapter) {
-          prices[asset] = await swapAdapter.getPoolPrice();
-        } else if (swapAdapter) {
-          const quote = await swapAdapter.getQuote("USDC", asset, 1);
-          prices[asset] = quote.expectedOutput > 0 ? 1 / quote.expectedOutput : 0;
-        }
-      } catch {
-        prices[asset] = 0;
-      }
-    }
-    const enriched = [];
-    for (const pos of positions) {
-      const currentPrice = prices[pos.asset] ?? 0;
-      let totalAmount = pos.totalAmount;
-      let costBasis = pos.costBasis;
-      if (pos.asset in INVESTMENT_ASSETS) {
-        try {
-          const assetInfo = SUPPORTED_ASSETS[pos.asset];
-          const bal = await this.client.getBalance({ owner: this._address, coinType: assetInfo.type });
-          const walletAmount = Number(bal.totalBalance) / 10 ** assetInfo.decimals;
-          const gasReserve = pos.asset === "SUI" ? GAS_RESERVE_MIN : 0;
-          const actualHeld = Math.max(0, walletAmount - gasReserve);
-          if (actualHeld < totalAmount) {
-            const ratio = totalAmount > 0 ? actualHeld / totalAmount : 0;
-            costBasis *= ratio;
-            totalAmount = actualHeld;
-          }
-        } catch {
-        }
-      }
-      const currentValue = totalAmount * currentPrice;
-      const unrealizedPnL = currentPrice > 0 ? currentValue - costBasis : 0;
-      const unrealizedPnLPct = currentPrice > 0 && costBasis > 0 ? unrealizedPnL / costBasis * 100 : 0;
-      enriched.push({
-        asset: pos.asset,
-        totalAmount,
-        costBasis,
-        avgPrice: pos.avgPrice,
-        currentPrice,
-        currentValue,
-        unrealizedPnL,
-        unrealizedPnLPct,
-        trades: pos.trades
-      });
-    }
-    const totalInvested = enriched.reduce((sum, p) => sum + p.costBasis, 0);
-    const totalValue = enriched.reduce((sum, p) => sum + p.currentValue, 0);
-    const totalUnrealizedPnL = totalValue - totalInvested;
-    const totalUnrealizedPnLPct = totalInvested > 0 ? totalUnrealizedPnL / totalInvested * 100 : 0;
-    return {
-      positions: enriched,
-      totalInvested,
-      totalValue,
-      unrealizedPnL: totalUnrealizedPnL,
-      unrealizedPnLPct: totalUnrealizedPnLPct,
-      realizedPnL
-    };
-  }
-  // -- Info --
-  async positions() {
-    const allPositions = await this.registry.allPositions(this._address);
-    const positions = allPositions.flatMap(
-      (p) => [
-        ...p.positions.supplies.filter((s) => s.amount > 5e-3).map((s) => ({
-          protocol: p.protocolId,
-          asset: s.asset,
-          type: "save",
-          amount: s.amount,
-          apy: s.apy
-        })),
-        ...p.positions.borrows.filter((b) => b.amount > 5e-3).map((b) => ({
-          protocol: p.protocolId,
-          asset: b.asset,
-          type: "borrow",
-          amount: b.amount,
-          apy: b.apy
-        }))
-      ]
-    );
-    return { positions };
-  }
-  async rates() {
-    const allRatesResult = await this.registry.allRatesAcrossAssets();
-    const result = {};
-    for (const entry of allRatesResult) {
-      if (!result[entry.asset] || entry.rates.saveApy > result[entry.asset].saveApy) {
-        result[entry.asset] = { saveApy: entry.rates.saveApy, borrowApy: entry.rates.borrowApy };
-      }
-    }
-    if (!result.USDC) result.USDC = { saveApy: 0, borrowApy: 0 };
-    return result;
-  }
-  async allRates(asset = "USDC") {
-    return this.registry.allRates(asset);
-  }
-  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 savePositions = allPositions.flatMap(
-      (p) => p.positions.supplies.filter((s) => s.amount > 0.01).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 bestRate = allRates.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.keypair, async () => {
-        const tx = new transactions.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.keypair, 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.keypair, 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.keypair, 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.keypair);
-    if (result.totalYieldEarned > 0) {
-      this.emit("yield", {
-        earned: result.dailyEarning,
-        total: result.totalYieldEarned,
-        apy: result.currentApy / 100,
-        timestamp: Date.now()
-      });
-    }
-    return result;
-  }
-  async fundStatus() {
-    return getFundStatus(this.client, this.keypair);
-  }
-  // -- Sentinel --
-  async sentinelList() {
-    return listSentinels();
-  }
-  async sentinelInfo(id) {
-    return getSentinelInfo(this.client, id);
-  }
-  async sentinelAttack(id, prompt, fee) {
-    this.enforcer.check({ operation: "sentinel", amount: fee ? Number(fee) / 1e9 : 0.1 });
-    return attack(this.client, this.keypair, id, prompt, fee);
-  }
-  // -- Helpers --
-  async getFreeBalance(asset) {
-    if (!(asset in INVESTMENT_ASSETS)) return Infinity;
-    const pos = this.portfolio.getPosition(asset);
-    const invested = pos?.totalAmount ?? 0;
-    if (invested <= 0) return Infinity;
-    const assetInfo = SUPPORTED_ASSETS[asset];
-    const balance = await this.client.getBalance({ owner: this._address, coinType: assetInfo.type });
-    const walletAmount = Number(balance.totalBalance) / 10 ** assetInfo.decimals;
-    const gasReserve = asset === "SUI" ? GAS_RESERVE_MIN : 0;
-    return Math.max(0, walletAmount - invested - gasReserve);
-  }
-  async resolveLending(protocol, asset, capability) {
-    if (protocol) {
-      const adapter = this.registry.getLending(protocol);
-      if (!adapter) throw new T2000Error("ASSET_NOT_SUPPORTED", `Lending adapter '${protocol}' not found`);
-      return adapter;
-    }
-    if (capability === "save") {
-      const { adapter } = await this.registry.bestSaveRate(asset);
-      return adapter;
-    }
-    if (capability === "borrow" || capability === "repay") {
-      const adapters2 = this.registry.listLending().filter(
-        (a) => a.supportedAssets.includes(asset) && a.capabilities.includes(capability) && (capability !== "borrow" || a.supportsSameAssetBorrow)
-      );
-      if (adapters2.length === 0) {
-        const alternatives = this.registry.listLending().filter(
-          (a) => a.capabilities.includes(capability) && (capability !== "borrow" || a.supportsSameAssetBorrow)
-        );
-        if (alternatives.length > 0) {
-          const altList = alternatives.map((a) => a.name).join(", ");
-          const altAssets = [...new Set(alternatives.flatMap((a) => [...a.supportedAssets]))].join(", ");
-          throw new T2000Error("ASSET_NOT_SUPPORTED", `No protocol supports ${capability} for ${asset}. Available for ${capability}: ${altList} (assets: ${altAssets})`);
-        }
-        throw new T2000Error("ASSET_NOT_SUPPORTED", `No adapter supports ${capability} ${asset}`);
-      }
-      return adapters2[0];
-    }
-    const adapters = this.registry.listLending().filter(
-      (a) => a.supportedAssets.includes(asset) && a.capabilities.includes(capability)
-    );
-    if (adapters.length === 0) {
-      const alternatives = this.registry.listLending().filter(
-        (a) => a.capabilities.includes(capability)
-      );
-      if (alternatives.length > 0) {
-        const altList = alternatives.map((a) => `${a.name} (${[...a.supportedAssets].join(", ")})`).join("; ");
-        throw new T2000Error("ASSET_NOT_SUPPORTED", `No protocol supports ${capability} for ${asset}. Try: ${altList}`);
-      }
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `No adapter supports ${capability} ${asset}`);
-    }
-    return adapters[0];
-  }
-  emitBalanceChange(asset, amount, cause, tx) {
-    this.emit("balanceChange", { asset, previous: 0, current: 0, cause, tx });
-  }
-};
-async function callSponsorApi(address, name) {
-  const res = await fetch(`${API_BASE_URL}/api/sponsor`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ address, name })
-  });
-  if (res.status === 429) {
-    const data = await res.json();
-    if (data.challenge) {
-      const proof = solveHashcash(data.challenge);
-      const retry = await fetch(`${API_BASE_URL}/api/sponsor`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ address, name, proof })
-      });
-      if (!retry.ok) throw new T2000Error("SPONSOR_RATE_LIMITED", "Sponsor rate limited");
-      return;
-    }
-  }
-  if (!res.ok) {
-    throw new T2000Error("SPONSOR_FAILED", "Sponsor API unavailable");
-  }
-}
-
-// src/utils/simulate.ts
-async function simulateTransaction(client, tx, sender) {
-  tx.setSender(sender);
-  try {
-    const txBytes = await tx.build({ client });
-    const dryRun = await client.dryRunTransactionBlock({
-      transactionBlock: Buffer.from(txBytes).toString("base64")
-    });
-    const status = dryRun.effects?.status;
-    const gasUsed = dryRun.effects?.gasUsed;
-    const gasEstimateSui = gasUsed ? (Number(gasUsed.computationCost) + Number(gasUsed.storageCost) - Number(gasUsed.storageRebate)) / 1e9 : 0;
-    if (status?.status === "failure") {
-      const rawError = status.error ?? "Unknown simulation error";
-      const parsed = parseMoveAbort(rawError);
-      return {
-        success: false,
-        gasEstimateSui,
-        error: {
-          moveAbortCode: parsed.abortCode,
-          moveModule: parsed.module,
-          reason: parsed.reason,
-          rawError
-        }
-      };
-    }
-    return { success: true, gasEstimateSui };
-  } catch (err) {
-    const rawError = err instanceof Error ? err.message : String(err);
-    return {
-      success: false,
-      gasEstimateSui: 0,
-      error: {
-        reason: "Simulation failed: " + rawError,
-        rawError
-      }
-    };
-  }
-}
-function throwIfSimulationFailed(sim) {
-  if (sim.success) return;
-  throw new T2000Error(
-    "SIMULATION_FAILED",
-    sim.error?.reason ?? "Transaction simulation failed",
-    {
-      moveAbortCode: sim.error?.moveAbortCode,
-      moveModule: sim.error?.moveModule,
-      reason: sim.error?.reason,
-      rawError: sim.error?.rawError
-    }
-  );
-}
-function parseMoveAbort(errorStr) {
-  const abortMatch = errorStr.match(/MoveAbort\([^,]*,\s*(\d+)\)/);
-  const moduleMatch = errorStr.match(/name:\s*Identifier\("([^"]+)"\)/);
-  if (abortMatch) {
-    const code = parseInt(abortMatch[1], 10);
-    const module = moduleMatch?.[1];
-    const reason = mapMoveAbortCode(code);
-    return { abortCode: code, module, reason };
-  }
-  if (errorStr.includes("MovePrimitiveRuntimeError")) {
-    const module = moduleMatch?.[1];
-    return {
-      module,
-      reason: `Move runtime error in ${module ?? "unknown"} module`
-    };
-  }
-  return { reason: errorStr };
-}
-
-// src/adapters/index.ts
-var allDescriptors = [
-  descriptor2,
-  descriptor4,
-  descriptor3,
-  descriptor
-];
-
-exports.BPS_DENOMINATOR = BPS_DENOMINATOR;
-exports.CLOCK_ID = CLOCK_ID;
-exports.CetusAdapter = CetusAdapter;
-exports.ContactManager = ContactManager;
-exports.DEFAULT_MAX_LEVERAGE = DEFAULT_MAX_LEVERAGE;
-exports.DEFAULT_MAX_POSITION_SIZE = DEFAULT_MAX_POSITION_SIZE;
-exports.DEFAULT_NETWORK = DEFAULT_NETWORK;
-exports.DEFAULT_SAFEGUARD_CONFIG = DEFAULT_SAFEGUARD_CONFIG;
-exports.GAS_RESERVE_MIN = GAS_RESERVE_MIN;
-exports.INVESTMENT_ASSETS = INVESTMENT_ASSETS;
-exports.MIST_PER_SUI = MIST_PER_SUI;
-exports.NaviAdapter = NaviAdapter;
-exports.OUTBOUND_OPS = OUTBOUND_OPS;
-exports.PERPS_MARKETS = PERPS_MARKETS;
-exports.PortfolioManager = PortfolioManager;
-exports.ProtocolRegistry = ProtocolRegistry;
-exports.SENTINEL = SENTINEL;
-exports.SUI_DECIMALS = SUI_DECIMALS;
-exports.SUPPORTED_ASSETS = SUPPORTED_ASSETS;
-exports.SafeguardEnforcer = SafeguardEnforcer;
-exports.SafeguardError = SafeguardError;
-exports.SuilendAdapter = SuilendAdapter;
-exports.T2000 = T2000;
-exports.T2000Error = T2000Error;
-exports.USDC_DECIMALS = USDC_DECIMALS;
-exports.addCollectFeeToTx = addCollectFeeToTx;
-exports.allDescriptors = allDescriptors;
-exports.calculateFee = calculateFee;
-exports.cetusDescriptor = descriptor3;
-exports.executeAutoTopUp = executeAutoTopUp;
-exports.executeWithGas = executeWithGas;
-exports.exportPrivateKey = exportPrivateKey;
-exports.formatAssetAmount = formatAssetAmount;
-exports.formatSui = formatSui;
-exports.formatUsd = formatUsd;
-exports.generateKeypair = generateKeypair;
-exports.getAddress = getAddress;
-exports.getDecimals = getDecimals;
-exports.getGasStatus = getGasStatus;
-exports.getPoolPrice = getPoolPrice;
-exports.getRates = getRates;
-exports.getSentinelInfo = getSentinelInfo;
-exports.keypairFromPrivateKey = keypairFromPrivateKey;
-exports.listSentinels = listSentinels;
-exports.loadKey = loadKey;
-exports.mapMoveAbortCode = mapMoveAbortCode;
-exports.mapWalletError = mapWalletError;
-exports.mistToSui = mistToSui;
-exports.naviDescriptor = descriptor2;
-exports.rawToStable = rawToStable;
-exports.rawToUsdc = rawToUsdc;
-exports.requestAttack = requestAttack;
-exports.saveKey = saveKey;
-exports.sentinelAttack = attack;
-exports.sentinelDescriptor = descriptor;
-exports.settleAttack = settleAttack;
-exports.shouldAutoTopUp = shouldAutoTopUp;
-exports.simulateTransaction = simulateTransaction;
-exports.solveHashcash = solveHashcash;
-exports.stableToRaw = stableToRaw;
-exports.submitPrompt = submitPrompt;
-exports.suiToMist = suiToMist;
-exports.suilendDescriptor = descriptor4;
-exports.throwIfSimulationFailed = throwIfSimulationFailed;
-exports.truncateAddress = truncateAddress;
-exports.usdcToRaw = usdcToRaw;
-exports.validateAddress = validateAddress;
-exports.walletExists = walletExists;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map