@t2000/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1551 @@
+'use strict';
+
+var eventemitter3 = require('eventemitter3');
+var client = require('@mysten/sui/client');
+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 transactions = require('@mysten/sui/transactions');
+var lending = require('@naviprotocol/lending');
+var suiClmmSdk = require('@cetusprotocol/sui-clmm-sdk');
+
+// 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 = 5000000n;
+var SAVE_FEE_BPS = 10n;
+var SWAP_FEE_BPS = 10n;
+var BORROW_FEE_BPS = 5n;
+var CLOCK_ID = "0x6";
+var SUPPORTED_ASSETS = {
+  USDC: {
+    type: "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
+    decimals: 6,
+    symbol: "USDC"
+  },
+  SUI: {
+    type: "0x2::sui::SUI",
+    decimals: 9,
+    symbol: "SUI"
+  }
+};
+process.env.T2000_PACKAGE_ID ?? "0x51c44bb2ad3ba608cf9adbc6e37ee67268ef9313a4ff70957d4c6e7955dc7eef";
+process.env.T2000_CONFIG_ID ?? "0xd30408960ac38eced670acc102df9e178b5b46b3a8c0e96a53ec2fd3f39b5936";
+process.env.T2000_TREASURY_ID ?? "0x2398c2759cfce40f1b0f2b3e524eeba9e8f6428fcb1d1e39235dd042d48defc8";
+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 = "0xb8d7d9e66a60c239e7a60110efcf8b555571a820a5c015ae1ce01bd5e9c4ac51";
+var CETUS_GLOBAL_CONFIG = "0xdaa46292632c3c4d8f31f23ea0f9b36a28ff3677e9684980e4438403a67a3d8f";
+var CETUS_PACKAGE = "0x1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb";
+
+// 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"
+  };
+  return abortMessages[code] ?? `Move abort code: ${code}`;
+}
+
+// src/utils/sui.ts
+var cachedClient = null;
+function getSuiClient(rpcUrl) {
+  const url = rpcUrl ?? DEFAULT_RPC_URL;
+  if (cachedClient) return cachedClient;
+  cachedClient = new client.SuiClient({ url });
+  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 passphrase");
+  }
+}
+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 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`;
+}
+
+// src/wallet/send.ts
+async function buildAndExecuteSend({
+  client,
+  keypair,
+  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 senderAddress = keypair.getPublicKey().toSuiAddress();
+  const rawAmount = displayToRaw(amount, assetInfo.decimals);
+  const tx = new transactions.Transaction();
+  if (asset === "SUI") {
+    const [coin] = tx.splitCoins(tx.gas, [rawAmount]);
+    tx.transferObjects([coin], recipient);
+  } else {
+    const coins = await client.getCoins({
+      owner: senderAddress,
+      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);
+  }
+  const result = await client.signAndExecuteTransaction({
+    signer: keypair,
+    transaction: tx,
+    options: { showEffects: true }
+  });
+  await client.waitForTransaction({ digest: result.digest });
+  const gasUsed = result.effects?.gasUsed;
+  const gasCost = gasUsed ? Math.abs(
+    (Number(gasUsed.computationCost) + Number(gasUsed.storageCost) - Number(gasUsed.storageRebate)) / 1e9
+  ) : 0;
+  return {
+    digest: result.digest,
+    gasCost
+  };
+}
+
+// src/wallet/balance.ts
+var _cachedSuiPrice = 3.5;
+var _priceLastFetched = 0;
+var PRICE_CACHE_TTL_MS = 6e4;
+async function fetchSuiPrice(client) {
+  const now = Date.now();
+  if (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 = rawPrice * 1e3;
+        if (price > 0.01 && price < 1e3) {
+          _cachedSuiPrice = price;
+          _priceLastFetched = now;
+        }
+      }
+    }
+  } catch {
+  }
+  return _cachedSuiPrice;
+}
+async function queryBalance(client, address) {
+  const [usdcBalance, suiBalance, suiPriceUsd] = await Promise.all([
+    client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.USDC.type }),
+    client.getBalance({ owner: address, coinType: SUPPORTED_ASSETS.SUI.type }),
+    fetchSuiPrice(client)
+  ]);
+  const usdcAmount = Number(usdcBalance.totalBalance) / 10 ** SUPPORTED_ASSETS.USDC.decimals;
+  const suiAmount = Number(suiBalance.totalBalance) / Number(MIST_PER_SUI);
+  const savings = 0;
+  const usdEquiv = suiAmount * suiPriceUsd;
+  const total = usdcAmount + savings + usdEquiv;
+  return {
+    available: usdcAmount,
+    savings,
+    gasReserve: {
+      sui: suiAmount,
+      usdEquiv
+    },
+    total,
+    assets: {
+      USDC: usdcAmount,
+      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";
+}
+var ENV = { env: "prod" };
+var USDC_TYPE = 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 NAVI_BALANCE_DECIMALS = 9;
+function clientOpt(client, fresh = false) {
+  return { client, ...ENV, ...fresh ? { disableCache: true } : {} };
+}
+function extractGasCost(effects) {
+  if (!effects?.gasUsed) return 0;
+  return Math.abs(
+    (Number(effects.gasUsed.computationCost) + Number(effects.gasUsed.storageCost) - Number(effects.gasUsed.storageRebate)) / 1e9
+  );
+}
+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 findUsdcPosition(state) {
+  return state.find(
+    (p) => p.pool.token.symbol === "USDC" || p.pool.coinType.toLowerCase().includes("usdc")
+  );
+}
+async function updateOracle(tx, client, address) {
+  try {
+    const [feeds, state] = await Promise.all([
+      lending.getPriceFeeds(ENV),
+      lending.getLendingState(address, clientOpt(client))
+    ]);
+    const relevant = lending.filterPriceFeeds(feeds, { lendingState: state });
+    if (relevant.length > 0) {
+      await lending.updateOraclePricesPTB(tx, relevant, { ...ENV, updatePythPriceFeeds: true });
+    }
+  } catch {
+  }
+}
+async function save(client, keypair, amount) {
+  const address = keypair.getPublicKey().toSuiAddress();
+  const rawAmount = Number(usdcToRaw(amount));
+  const coins = await lending.getCoins(address, { coinType: USDC_TYPE, client });
+  if (!coins || coins.length === 0) {
+    throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins found");
+  }
+  const tx = new transactions.Transaction();
+  tx.setSender(address);
+  const coinObj = lending.mergeCoinsPTB(tx, coins, { balance: rawAmount });
+  await lending.depositCoinPTB(tx, USDC_TYPE, coinObj, ENV);
+  const result = await client.signAndExecuteTransaction({
+    signer: keypair,
+    transaction: tx,
+    options: { showEffects: true }
+  });
+  await client.waitForTransaction({ digest: result.digest });
+  const rates = await getRates();
+  return {
+    success: true,
+    tx: result.digest,
+    amount,
+    apy: rates.USDC.saveApy,
+    fee: 0,
+    gasCost: extractGasCost(result.effects),
+    gasMethod: "self-funded"
+  };
+}
+async function withdraw(client, keypair, amount) {
+  const address = keypair.getPublicKey().toSuiAddress();
+  const state = await lending.getLendingState(address, clientOpt(client, true));
+  const usdcPos = findUsdcPosition(state);
+  const deposited = usdcPos ? Number(usdcPos.supplyBalance) / 10 ** NAVI_BALANCE_DECIMALS : 0;
+  const effectiveAmount = Math.min(amount, Math.max(0, deposited - WITHDRAW_DUST_BUFFER));
+  if (effectiveAmount <= 0) throw new T2000Error("NO_COLLATERAL", "Nothing to withdraw");
+  const rawAmount = Number(usdcToRaw(effectiveAmount));
+  const tx = new transactions.Transaction();
+  tx.setSender(address);
+  await updateOracle(tx, client, address);
+  const withdrawnCoin = await lending.withdrawCoinPTB(tx, USDC_TYPE, rawAmount, ENV);
+  tx.transferObjects([withdrawnCoin], address);
+  const result = await client.signAndExecuteTransaction({
+    signer: keypair,
+    transaction: tx,
+    options: { showEffects: true }
+  });
+  await client.waitForTransaction({ digest: result.digest });
+  return {
+    success: true,
+    tx: result.digest,
+    amount: effectiveAmount,
+    gasCost: extractGasCost(result.effects),
+    gasMethod: "self-funded"
+  };
+}
+async function borrow(client, keypair, amount) {
+  const address = keypair.getPublicKey().toSuiAddress();
+  const rawAmount = Number(usdcToRaw(amount));
+  const tx = new transactions.Transaction();
+  tx.setSender(address);
+  await updateOracle(tx, client, address);
+  const borrowedCoin = await lending.borrowCoinPTB(tx, USDC_TYPE, rawAmount, ENV);
+  tx.transferObjects([borrowedCoin], address);
+  const result = await client.signAndExecuteTransaction({
+    signer: keypair,
+    transaction: tx,
+    options: { showEffects: true }
+  });
+  await client.waitForTransaction({ digest: result.digest });
+  const hf = await lending.getHealthFactor(address, clientOpt(client, true));
+  return {
+    success: true,
+    tx: result.digest,
+    amount,
+    fee: 0,
+    healthFactor: hf,
+    gasCost: extractGasCost(result.effects),
+    gasMethod: "self-funded"
+  };
+}
+async function repay(client, keypair, amount) {
+  const address = keypair.getPublicKey().toSuiAddress();
+  const rawAmount = Number(usdcToRaw(amount));
+  const coins = await lending.getCoins(address, { coinType: USDC_TYPE, client });
+  if (!coins || coins.length === 0) {
+    throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins to repay with");
+  }
+  const tx = new transactions.Transaction();
+  tx.setSender(address);
+  const coinObj = lending.mergeCoinsPTB(tx, coins, { balance: rawAmount });
+  await lending.repayCoinPTB(tx, USDC_TYPE, coinObj, { ...ENV, amount: rawAmount });
+  const result = await client.signAndExecuteTransaction({
+    signer: keypair,
+    transaction: tx,
+    options: { showEffects: true }
+  });
+  await client.waitForTransaction({ digest: result.digest });
+  const state = await lending.getLendingState(address, clientOpt(client, true));
+  const usdcPos = findUsdcPosition(state);
+  const remainingDebt = usdcPos ? Number(usdcPos.borrowBalance) / 10 ** NAVI_BALANCE_DECIMALS : 0;
+  return {
+    success: true,
+    tx: result.digest,
+    amount,
+    remainingDebt,
+    gasCost: extractGasCost(result.effects),
+    gasMethod: "self-funded"
+  };
+}
+async function getHealthFactor(client, keypair) {
+  const address = keypair.getPublicKey().toSuiAddress();
+  const [healthFactor, state, pool] = await Promise.all([
+    lending.getHealthFactor(address, clientOpt(client, true)),
+    lending.getLendingState(address, clientOpt(client, true)),
+    lending.getPool(USDC_TYPE, ENV)
+  ]);
+  const usdcPos = findUsdcPosition(state);
+  const supplied = usdcPos ? Number(usdcPos.supplyBalance) / 10 ** NAVI_BALANCE_DECIMALS : 0;
+  const borrowed = usdcPos ? Number(usdcPos.borrowBalance) / 10 ** NAVI_BALANCE_DECIMALS : 0;
+  const ltv = parseLtv(pool.ltv);
+  const liqThreshold = parseLiqThreshold(pool.liquidationFactor.threshold);
+  const maxBorrowVal = Math.max(0, supplied * ltv - borrowed);
+  return {
+    healthFactor: borrowed > 0 ? healthFactor : Infinity,
+    supplied,
+    borrowed,
+    maxBorrow: maxBorrowVal,
+    liquidationThreshold: liqThreshold
+  };
+}
+async function getRates(client) {
+  try {
+    const pool = await lending.getPool(USDC_TYPE, ENV);
+    let saveApy = rateToApy(pool.currentSupplyRate);
+    let borrowApy = rateToApy(pool.currentBorrowRate);
+    if (saveApy <= 0 || saveApy > 100) saveApy = 4;
+    if (borrowApy <= 0 || borrowApy > 100) borrowApy = 6;
+    return { USDC: { saveApy, borrowApy } };
+  } catch {
+    return { USDC: { saveApy: 4, borrowApy: 6 } };
+  }
+}
+async function getPositions(client, keypair) {
+  const address = keypair.getPublicKey().toSuiAddress();
+  const state = await lending.getLendingState(address, clientOpt(client, true));
+  const positions = [];
+  for (const pos of state) {
+    const symbol = pos.pool.token?.symbol ?? "UNKNOWN";
+    const supplyBal = Number(pos.supplyBalance) / 10 ** NAVI_BALANCE_DECIMALS;
+    const borrowBal = Number(pos.borrowBalance) / 10 ** NAVI_BALANCE_DECIMALS;
+    if (supplyBal > 1e-4) {
+      positions.push({
+        protocol: "navi",
+        asset: symbol,
+        type: "save",
+        amount: supplyBal,
+        apy: rateToApy(pos.pool.currentSupplyRate)
+      });
+    }
+    if (borrowBal > 1e-4) {
+      positions.push({
+        protocol: "navi",
+        asset: symbol,
+        type: "borrow",
+        amount: borrowBal,
+        apy: rateToApy(pos.pool.currentBorrowRate)
+      });
+    }
+  }
+  return { positions };
+}
+async function maxWithdrawAmount(client, keypair) {
+  const hf = await getHealthFactor(client, keypair);
+  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, keypair) {
+  const hf = await getHealthFactor(client, keypair);
+  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
+  };
+}
+var DEFAULT_SLIPPAGE_BPS = 300;
+function extractGasCost2(effects) {
+  if (!effects?.gasUsed) return 0;
+  return (Number(effects.gasUsed.computationCost) + Number(effects.gasUsed.storageCost) - Number(effects.gasUsed.storageRebate)) / 1e9;
+}
+function isA2B(from) {
+  return from === "USDC";
+}
+var _cetusSDK = null;
+function getCetusSDK() {
+  if (!_cetusSDK) {
+    _cetusSDK = suiClmmSdk.CetusClmmSDK.createSDK({ env: "mainnet" });
+  }
+  return _cetusSDK;
+}
+async function executeSwap(params) {
+  const { client, keypair, fromAsset, toAsset, amount, maxSlippageBps = DEFAULT_SLIPPAGE_BPS } = params;
+  const address = keypair.getPublicKey().toSuiAddress();
+  const a2b = isA2B(fromAsset);
+  const fromInfo = SUPPORTED_ASSETS[fromAsset];
+  const toInfo = SUPPORTED_ASSETS[toAsset];
+  const rawAmount = BigInt(Math.floor(amount * 10 ** fromInfo.decimals));
+  const sdk = getCetusSDK();
+  sdk.setSenderAddress(address);
+  const pool = await sdk.Pool.getPool(CETUS_USDC_SUI_POOL);
+  const preSwapResult = await sdk.Swap.preSwap({
+    pool,
+    current_sqrt_price: pool.current_sqrt_price,
+    coin_type_a: pool.coin_type_a,
+    coin_type_b: pool.coin_type_b,
+    decimals_a: 6,
+    decimals_b: 9,
+    a2b,
+    by_amount_in: true,
+    amount: rawAmount.toString()
+  });
+  const estimatedOut = Number(preSwapResult.estimated_amount_out);
+  const slippageFactor = (1e4 - maxSlippageBps) / 1e4;
+  const amountLimit = Math.floor(estimatedOut * slippageFactor);
+  const swapPayload = await sdk.Swap.createSwapPayload({
+    pool_id: pool.id,
+    coin_type_a: pool.coin_type_a,
+    coin_type_b: pool.coin_type_b,
+    a2b,
+    by_amount_in: true,
+    amount: preSwapResult.amount.toString(),
+    amount_limit: amountLimit.toString()
+  });
+  const result = await client.signAndExecuteTransaction({
+    signer: keypair,
+    transaction: swapPayload,
+    options: { showEffects: true, showBalanceChanges: true }
+  });
+  await client.waitForTransaction({ digest: result.digest });
+  let actualReceived = 0;
+  if (result.balanceChanges) {
+    for (const change of result.balanceChanges) {
+      if (change.coinType === toInfo.type && change.owner && typeof change.owner === "object" && "AddressOwner" in change.owner && change.owner.AddressOwner === address) {
+        const amt = Number(change.amount) / 10 ** toInfo.decimals;
+        if (amt > 0) actualReceived += amt;
+      }
+    }
+  }
+  const expectedOutput = estimatedOut / 10 ** toInfo.decimals;
+  if (actualReceived === 0) actualReceived = expectedOutput;
+  const priceImpact = expectedOutput > 0 ? Math.abs(actualReceived - expectedOutput) / expectedOutput : 0;
+  return {
+    digest: result.digest,
+    fromAmount: amount,
+    fromAsset,
+    toAmount: actualReceived,
+    toAsset,
+    priceImpact,
+    gasCost: extractGasCost2(result.effects)
+  };
+}
+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 a2b = isA2B(fromAsset);
+  const fromInfo = SUPPORTED_ASSETS[fromAsset];
+  const toInfo = SUPPORTED_ASSETS[toAsset];
+  const rawAmount = BigInt(Math.floor(amount * 10 ** fromInfo.decimals));
+  const poolPrice = await getPoolPrice(client);
+  try {
+    const sdk = getCetusSDK();
+    const pool = await sdk.Pool.getPool(CETUS_USDC_SUI_POOL);
+    const preSwapResult = await sdk.Swap.preSwap({
+      pool,
+      current_sqrt_price: pool.current_sqrt_price,
+      coin_type_a: pool.coin_type_a,
+      coin_type_b: pool.coin_type_b,
+      decimals_a: 6,
+      decimals_b: 9,
+      a2b,
+      by_amount_in: true,
+      amount: rawAmount.toString()
+    });
+    const expectedOutput = Number(preSwapResult.estimated_amount_out) / 10 ** toInfo.decimals;
+    return { expectedOutput, priceImpact: 0, poolPrice };
+  } catch {
+    let expectedOutput;
+    if (fromAsset === "USDC") {
+      expectedOutput = amount / poolPrice;
+    } else {
+      expectedOutput = amount * poolPrice;
+    }
+    return { expectedOutput, priceImpact: 0, poolPrice };
+  }
+}
+
+// src/protocols/protocolFee.ts
+var FEE_RATES = {
+  save: SAVE_FEE_BPS,
+  swap: SWAP_FEE_BPS,
+  borrow: BORROW_FEE_BPS
+};
+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
+  };
+}
+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 {
+  }
+}
+
+// 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
+  };
+}
+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(txBytesBase64, sender, type) {
+  const res = await fetch(`${API_BASE_URL}/api/gas`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ txBytes: txBytesBase64, 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 tx = new transactions.Transaction();
+  tx.setSender(address);
+  const usdcCoins = await client.getCoins({
+    owner: address,
+    coinType: SUPPORTED_ASSETS.USDC.type
+  });
+  if (usdcCoins.data.length === 0) {
+    throw new T2000Error("AUTO_TOPUP_FAILED", "No USDC coins available for auto-topup");
+  }
+  const coinIds = usdcCoins.data.map((c) => c.coinObjectId);
+  let usdcCoin;
+  if (coinIds.length === 1) {
+    usdcCoin = tx.splitCoins(tx.object(coinIds[0]), [AUTO_TOPUP_AMOUNT]);
+  } else {
+    const primary = tx.object(coinIds[0]);
+    if (coinIds.length > 1) {
+      tx.mergeCoins(primary, coinIds.slice(1).map((id) => tx.object(id)));
+    }
+    usdcCoin = tx.splitCoins(primary, [AUTO_TOPUP_AMOUNT]);
+  }
+  const MIN_SQRT_PRICE = "4295048016";
+  const [receivedCoin, returnedCoin] = tx.moveCall({
+    target: `${CETUS_PACKAGE}::pool_script::swap_a2b`,
+    arguments: [
+      tx.object(CETUS_GLOBAL_CONFIG),
+      tx.object(CETUS_USDC_SUI_POOL),
+      usdcCoin,
+      tx.pure.bool(true),
+      // by_amount_in
+      tx.pure.u64(AUTO_TOPUP_AMOUNT),
+      tx.pure.u128(MIN_SQRT_PRICE),
+      tx.object(CLOCK_ID)
+    ],
+    typeArguments: [SUPPORTED_ASSETS.USDC.type, SUPPORTED_ASSETS.SUI.type]
+  });
+  tx.transferObjects([receivedCoin], address);
+  tx.transferObjects([returnedCoin], address);
+  const txBytes = await tx.build({ client, onlyTransactionKind: true });
+  const txBytesBase64 = Buffer.from(txBytes).toString("base64");
+  let sponsoredResult;
+  try {
+    sponsoredResult = await requestGasSponsorship(txBytesBase64, address, "auto-topup");
+  } catch {
+    throw new T2000Error("AUTO_TOPUP_FAILED", "Gas station unavailable for auto-topup sponsorship");
+  }
+  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: Number(AUTO_TOPUP_AMOUNT) / 1e6,
+    suiReceived: Math.abs(suiReceived)
+  };
+}
+
+// src/t2000.ts
+var T2000 = class _T2000 extends eventemitter3.EventEmitter {
+  keypair;
+  client;
+  _address;
+  _lastGasMethod = "self-funded";
+  constructor(keypair, client) {
+    super();
+    this.keypair = keypair;
+    this.client = client;
+    this._address = getAddress(keypair);
+  }
+  static async create(options = {}) {
+    const { keyPath, passphrase, network = DEFAULT_NETWORK, rpcUrl, sponsored, name } = options;
+    const client = getSuiClient(rpcUrl);
+    if (sponsored) {
+      const keypair2 = generateKeypair();
+      if (passphrase) {
+        await saveKey(keypair2, passphrase, keyPath);
+      }
+      return new _T2000(keypair2, client);
+    }
+    const exists = await walletExists(keyPath);
+    if (!exists) {
+      throw new T2000Error(
+        "WALLET_NOT_FOUND",
+        "No wallet found. Run `t2000 init` to create one."
+      );
+    }
+    if (!passphrase) {
+      throw new T2000Error("WALLET_LOCKED", "Passphrase required to unlock wallet");
+    }
+    const keypair = await loadKey(passphrase, keyPath);
+    return new _T2000(keypair, client);
+  }
+  static fromPrivateKey(privateKey, options = {}) {
+    const keypair = keypairFromPrivateKey(privateKey);
+    const client = getSuiClient(options.rpcUrl);
+    return new _T2000(keypair, client);
+  }
+  static async init(options) {
+    const keypair = generateKeypair();
+    await saveKey(keypair, options.passphrase, options.keyPath);
+    const client = getSuiClient();
+    const agent = new _T2000(keypair, client);
+    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 --
+  /**
+   * Ensure the agent has enough SUI for gas.
+   * If SUI is low and USDC is available, auto-swaps $1 USDC → SUI.
+   */
+  async ensureGas() {
+    this._lastGasMethod = "self-funded";
+    const needsTopUp = await shouldAutoTopUp(this.client, this._address);
+    if (!needsTopUp) return;
+    try {
+      const result = await executeAutoTopUp(this.client, this.keypair);
+      this._lastGasMethod = "auto-topup";
+      this.emit("gasAutoTopUp", {
+        usdcSpent: result.usdcSpent,
+        suiReceived: result.suiReceived
+      });
+    } catch {
+      this.emit("gasStationFallback", {
+        reason: "auto-topup failed",
+        method: "self-funded",
+        suiUsed: 0
+      });
+    }
+  }
+  /** SuiClient 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) {
+    const asset = params.asset ?? "USDC";
+    if (!(asset in SUPPORTED_ASSETS)) {
+      throw new T2000Error("ASSET_NOT_SUPPORTED", `Asset ${asset} is not supported`);
+    }
+    await this.ensureGas();
+    const result = await buildAndExecuteSend({
+      client: this.client,
+      keypair: this.keypair,
+      to: params.to,
+      amount: params.amount,
+      asset
+    });
+    const balance = await this.balance();
+    this.emitBalanceChange(asset, params.amount, "send", result.digest);
+    return {
+      success: true,
+      tx: result.digest,
+      amount: params.amount,
+      to: params.to,
+      gasCost: result.gasCost,
+      gasCostUnit: "SUI",
+      gasMethod: this._lastGasMethod,
+      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);
+      bal.savings = savings;
+      bal.total = bal.available + savings + bal.gasReserve.usdEquiv;
+    } catch {
+    }
+    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);
+  }
+  // -- Savings --
+  async save(params) {
+    let amount;
+    if (params.amount === "all") {
+      const bal = await queryBalance(this.client, this._address);
+      const GAS_RESERVE_USDC = 1;
+      amount = bal.available - GAS_RESERVE_USDC;
+      if (amount <= 0) {
+        throw new T2000Error("INSUFFICIENT_BALANCE", "Balance too low to save after $1 gas reserve", {
+          reason: "gas_reserve_required",
+          available: bal.available
+        });
+      }
+    } else {
+      amount = params.amount;
+    }
+    const fee = calculateFee("save", amount);
+    await this.ensureGas();
+    const result = await save(this.client, this.keypair, amount);
+    reportFee(this._address, "save", fee.amount, fee.rate, result.tx);
+    this.emitBalanceChange("USDC", amount, "save", result.tx);
+    return { ...result, fee: fee.amount, gasMethod: this._lastGasMethod };
+  }
+  async withdraw(params) {
+    let amount;
+    if (params.amount === "all") {
+      const maxResult = await this.maxWithdraw();
+      amount = maxResult.maxAmount;
+      if (amount <= 0) {
+        throw new T2000Error("NO_COLLATERAL", "No savings to withdraw");
+      }
+    } else {
+      amount = params.amount;
+      const hf = await this.healthFactor();
+      if (hf.borrowed > 0) {
+        const maxResult = await this.maxWithdraw();
+        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
+            }
+          );
+        }
+      }
+    }
+    await this.ensureGas();
+    const result = await withdraw(this.client, this.keypair, amount);
+    this.emitBalanceChange("USDC", amount, "withdraw", result.tx);
+    return { ...result, gasMethod: this._lastGasMethod };
+  }
+  async maxWithdraw() {
+    return maxWithdrawAmount(this.client, this.keypair);
+  }
+  // -- Borrowing --
+  async borrow(params) {
+    const maxResult = await this.maxBorrow();
+    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);
+    await this.ensureGas();
+    const result = await borrow(this.client, this.keypair, params.amount);
+    reportFee(this._address, "borrow", fee.amount, fee.rate, result.tx);
+    this.emitBalanceChange("USDC", params.amount, "borrow", result.tx);
+    return { ...result, fee: fee.amount, gasMethod: this._lastGasMethod };
+  }
+  async repay(params) {
+    let amount;
+    if (params.amount === "all") {
+      const hf = await this.healthFactor();
+      amount = hf.borrowed;
+      if (amount <= 0) {
+        throw new T2000Error("NO_COLLATERAL", "No outstanding borrow to repay");
+      }
+    } else {
+      amount = params.amount;
+    }
+    await this.ensureGas();
+    const result = await repay(this.client, this.keypair, amount);
+    this.emitBalanceChange("USDC", amount, "repay", result.tx);
+    return { ...result, gasMethod: this._lastGasMethod };
+  }
+  async maxBorrow() {
+    return maxBorrowAmount(this.client, this.keypair);
+  }
+  async healthFactor() {
+    const hf = await getHealthFactor(this.client, this.keypair);
+    if (hf.healthFactor < 1.2) {
+      this.emit("healthCritical", { healthFactor: hf.healthFactor, threshold: 1.5, severity: "critical" });
+    } else if (hf.healthFactor < 2) {
+      this.emit("healthWarning", { healthFactor: hf.healthFactor, threshold: 2, severity: "warning" });
+    }
+    return hf;
+  }
+  // -- Swap --
+  async swap(params) {
+    const fromAsset = params.from.toUpperCase();
+    const toAsset = params.to.toUpperCase();
+    if (!(fromAsset in SUPPORTED_ASSETS) || !(toAsset in SUPPORTED_ASSETS)) {
+      throw new T2000Error("ASSET_NOT_SUPPORTED", `Swap pair ${fromAsset}/${toAsset} is not supported`);
+    }
+    if (fromAsset === toAsset) {
+      throw new T2000Error("INVALID_AMOUNT", "Cannot swap same asset");
+    }
+    const fee = calculateFee("swap", params.amount);
+    await this.ensureGas();
+    const result = await executeSwap({
+      client: this.client,
+      keypair: this.keypair,
+      fromAsset,
+      toAsset,
+      amount: params.amount,
+      maxSlippageBps: params.maxSlippage ? params.maxSlippage * 100 : void 0
+    });
+    reportFee(this._address, "swap", fee.amount, fee.rate, result.digest);
+    this.emitBalanceChange(result.fromAsset, result.fromAmount, "swap", result.digest);
+    return {
+      success: true,
+      tx: result.digest,
+      fromAmount: result.fromAmount,
+      fromAsset: result.fromAsset,
+      toAmount: result.toAmount,
+      toAsset: result.toAsset,
+      priceImpact: result.priceImpact,
+      fee: fee.amount,
+      gasCost: result.gasCost,
+      gasMethod: this._lastGasMethod
+    };
+  }
+  async swapQuote(params) {
+    const fromAsset = params.from.toUpperCase();
+    const toAsset = params.to.toUpperCase();
+    const quote = await getSwapQuote(this.client, fromAsset, toAsset, params.amount);
+    const fee = calculateFee("swap", params.amount);
+    return { ...quote, fee: { amount: fee.amount, rate: fee.rate } };
+  }
+  // -- Info --
+  async positions() {
+    return getPositions(this.client, this.keypair);
+  }
+  async rates() {
+    return getRates(this.client);
+  }
+  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);
+  }
+  // -- Helpers --
+  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/gas/manager.ts
+function extractGasCost3(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: extractGasCost3(result.effects)
+  };
+}
+async function tryAutoTopUpThenSelfFund(client, keypair, tx) {
+  const address = keypair.getPublicKey().toSuiAddress();
+  const canTopUp = await shouldAutoTopUp(client, address);
+  if (!canTopUp) return null;
+  try {
+    await executeAutoTopUp(client, keypair);
+  } catch {
+    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: "auto-topup",
+    gasCostSui: extractGasCost3(result.effects)
+  };
+}
+async function trySponsored(client, keypair, tx) {
+  const address = keypair.getPublicKey().toSuiAddress();
+  tx.setSender(address);
+  let txBytes;
+  try {
+    txBytes = await tx.build({ client, onlyTransactionKind: true });
+  } catch {
+    return null;
+  }
+  const txBytesBase64 = Buffer.from(txBytes).toString("base64");
+  let sponsoredResult;
+  try {
+    sponsoredResult = await requestGasSponsorship(txBytesBase64, address);
+  } catch {
+    return null;
+  }
+  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 = extractGasCost3(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) {
+  try {
+    const tx = await buildTx();
+    const result = await trySelfFunded(client, keypair, tx);
+    if (result) return result;
+  } catch {
+  }
+  try {
+    const tx = await buildTx();
+    const result = await tryAutoTopUpThenSelfFund(client, keypair, tx);
+    if (result) return result;
+  } catch {
+  }
+  try {
+    const tx = await buildTx();
+    const result = await trySponsored(client, keypair, tx);
+    if (result) return result;
+  } catch {
+  }
+  throw new T2000Error(
+    "INSUFFICIENT_GAS",
+    "No SUI for gas and Gas Station unavailable. Fund your wallet with SUI or USDC.",
+    { reason: "all_gas_methods_exhausted" }
+  );
+}
+
+exports.BPS_DENOMINATOR = BPS_DENOMINATOR;
+exports.CLOCK_ID = CLOCK_ID;
+exports.DEFAULT_NETWORK = DEFAULT_NETWORK;
+exports.MIST_PER_SUI = MIST_PER_SUI;
+exports.SUI_DECIMALS = SUI_DECIMALS;
+exports.SUPPORTED_ASSETS = SUPPORTED_ASSETS;
+exports.T2000 = T2000;
+exports.T2000Error = T2000Error;
+exports.USDC_DECIMALS = USDC_DECIMALS;
+exports.calculateFee = calculateFee;
+exports.executeAutoTopUp = executeAutoTopUp;
+exports.executeWithGas = executeWithGas;
+exports.exportPrivateKey = exportPrivateKey;
+exports.formatSui = formatSui;
+exports.formatUsd = formatUsd;
+exports.generateKeypair = generateKeypair;
+exports.getAddress = getAddress;
+exports.getGasStatus = getGasStatus;
+exports.getPoolPrice = getPoolPrice;
+exports.getRates = getRates;
+exports.getSwapQuote = getSwapQuote;
+exports.keypairFromPrivateKey = keypairFromPrivateKey;
+exports.loadKey = loadKey;
+exports.mapMoveAbortCode = mapMoveAbortCode;
+exports.mapWalletError = mapWalletError;
+exports.mistToSui = mistToSui;
+exports.rawToUsdc = rawToUsdc;
+exports.saveKey = saveKey;
+exports.shouldAutoTopUp = shouldAutoTopUp;
+exports.simulateTransaction = simulateTransaction;
+exports.solveHashcash = solveHashcash;
+exports.suiToMist = suiToMist;
+exports.throwIfSimulationFailed = throwIfSimulationFailed;
+exports.truncateAddress = truncateAddress;
+exports.usdcToRaw = usdcToRaw;
+exports.validateAddress = validateAddress;
+exports.walletExists = walletExists;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map