logiqical 0.1.2 → 0.3.0

package/dist/index.mjs

@@ -1,780 +1,2485 @@
-// src/errors.ts
-var LogiqicalError = class extends Error {
-  constructor(message, statusCode, endpoint) {
-    super(message);
-    this.statusCode = statusCode;
-    this.endpoint = endpoint;
-    this.name = "LogiqicalError";
+// src/client.ts
+import { ethers as ethers8, JsonRpcProvider as JsonRpcProvider2, Contract } from "ethers";
+
+// src/wallet.ts
+import {
+  Wallet,
+  JsonRpcProvider
+} from "ethers";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CHAINS = {
+  avalanche: {
+    chainId: 43114,
+    name: "Avalanche C-Chain",
+    rpcUrl: "https://api.avax.network/ext/bc/C/rpc",
+    nativeCurrency: { name: "Avalanche", symbol: "AVAX", decimals: 18 },
+    blockExplorer: "https://snowtrace.io"
+  },
+  fuji: {
+    chainId: 43113,
+    name: "Avalanche Fuji Testnet",
+    rpcUrl: "https://api.avax-test.network/ext/bc/C/rpc",
+    nativeCurrency: { name: "Avalanche", symbol: "AVAX", decimals: 18 },
+    blockExplorer: "https://testnet.snowtrace.io"
+  },
+  ethereum: {
+    chainId: 1,
+    name: "Ethereum",
+    rpcUrl: "https://eth.llamarpc.com",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    blockExplorer: "https://etherscan.io"
+  },
+  base: {
+    chainId: 8453,
+    name: "Base",
+    rpcUrl: "https://mainnet.base.org",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    blockExplorer: "https://basescan.org"
+  },
+  arbitrum: {
+    chainId: 42161,
+    name: "Arbitrum One",
+    rpcUrl: "https://arb1.arbitrum.io/rpc",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    blockExplorer: "https://arbiscan.io"
+  },
+  optimism: {
+    chainId: 10,
+    name: "Optimism",
+    rpcUrl: "https://mainnet.optimism.io",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    blockExplorer: "https://optimistic.etherscan.io"
+  },
+  polygon: {
+    chainId: 137,
+    name: "Polygon",
+    rpcUrl: "https://polygon-rpc.com",
+    nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 },
+    blockExplorer: "https://polygonscan.com"
+  },
+  bsc: {
+    chainId: 56,
+    name: "BNB Smart Chain",
+    rpcUrl: "https://bsc-dataseed.binance.org",
+    nativeCurrency: { name: "BNB", symbol: "BNB", decimals: 18 },
+    blockExplorer: "https://bscscan.com"
+  },
+  fantom: {
+    chainId: 250,
+    name: "Fantom Opera",
+    rpcUrl: "https://rpc.ftm.tools",
+    nativeCurrency: { name: "Fantom", symbol: "FTM", decimals: 18 },
+    blockExplorer: "https://ftmscan.com"
+  },
+  gnosis: {
+    chainId: 100,
+    name: "Gnosis Chain",
+    rpcUrl: "https://rpc.gnosischain.com",
+    nativeCurrency: { name: "xDAI", symbol: "xDAI", decimals: 18 },
+    blockExplorer: "https://gnosisscan.io"
+  },
+  zksync: {
+    chainId: 324,
+    name: "zkSync Era",
+    rpcUrl: "https://mainnet.era.zksync.io",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    blockExplorer: "https://explorer.zksync.io"
+  },
+  linea: {
+    chainId: 59144,
+    name: "Linea",
+    rpcUrl: "https://rpc.linea.build",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    blockExplorer: "https://lineascan.build"
+  },
+  scroll: {
+    chainId: 534352,
+    name: "Scroll",
+    rpcUrl: "https://rpc.scroll.io",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    blockExplorer: "https://scrollscan.com"
+  },
+  blast: {
+    chainId: 81457,
+    name: "Blast",
+    rpcUrl: "https://rpc.blast.io",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    blockExplorer: "https://blastscan.io"
+  },
+  mantle: {
+    chainId: 5e3,
+    name: "Mantle",
+    rpcUrl: "https://rpc.mantle.xyz",
+    nativeCurrency: { name: "MNT", symbol: "MNT", decimals: 18 },
+    blockExplorer: "https://mantlescan.xyz"
+  },
+  celo: {
+    chainId: 42220,
+    name: "Celo",
+    rpcUrl: "https://forno.celo.org",
+    nativeCurrency: { name: "CELO", symbol: "CELO", decimals: 18 },
+    blockExplorer: "https://celoscan.io"
+  },
+  moonbeam: {
+    chainId: 1284,
+    name: "Moonbeam",
+    rpcUrl: "https://rpc.api.moonbeam.network",
+    nativeCurrency: { name: "GLMR", symbol: "GLMR", decimals: 18 },
+    blockExplorer: "https://moonscan.io"
+  },
+  sei: {
+    chainId: 1329,
+    name: "Sei",
+    rpcUrl: "https://evm-rpc.sei-apis.com",
+    nativeCurrency: { name: "SEI", symbol: "SEI", decimals: 18 },
+    blockExplorer: "https://seitrace.com"
+  },
+  mode: {
+    chainId: 34443,
+    name: "Mode",
+    rpcUrl: "https://mainnet.mode.network",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    blockExplorer: "https://explorer.mode.network"
+  },
+  aurora: {
+    chainId: 1313161554,
+    name: "Aurora",
+    rpcUrl: "https://mainnet.aurora.dev",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    blockExplorer: "https://explorer.aurora.dev"
   }
 };
-var LogiqicalAuthError = class extends LogiqicalError {
-  constructor(endpoint) {
-    super("Invalid or missing API key. Call client.register() or provide an apiKey in config.", 401, endpoint);
-    this.name = "LogiqicalAuthError";
+var KEYSTORE_DIR = join(homedir(), ".logiqical", "keys");
+function ensureKeystoreDir() {
+  if (!existsSync(KEYSTORE_DIR)) {
+    mkdirSync(KEYSTORE_DIR, { recursive: true });
+  }
+}
+var AgentWallet = class _AgentWallet {
+  wallet;
+  provider;
+  chain;
+  address;
+  constructor(wallet, provider, chain) {
+    this.wallet = wallet;
+    this.provider = provider;
+    this.chain = chain;
+    this.address = wallet.address;
+  }
+  /** The private key (use carefully) */
+  get privateKey() {
+    return this.wallet.privateKey;
+  }
+  // ── Factory Methods ──
+  /** Generate a brand new wallet with a random private key */
+  static generate(config = {}) {
+    const { provider, chain } = _AgentWallet.resolveProvider(config);
+    const hdWallet = Wallet.createRandom();
+    const wallet = new Wallet(hdWallet.privateKey, provider);
+    return new _AgentWallet(wallet, provider, chain);
+  }
+  /** Import an existing wallet from a private key */
+  static fromPrivateKey(privateKey, config = {}) {
+    const { provider, chain } = _AgentWallet.resolveProvider(config);
+    const wallet = new Wallet(privateKey, provider);
+    return new _AgentWallet(wallet, provider, chain);
+  }
+  /** Boot from encrypted keystore, or generate + save if none exists */
+  static async boot(config = {}) {
+    const password = config.password ?? "logiqical-agent";
+    const name = config.keystoreName ?? "agent";
+    const keystorePath = join(KEYSTORE_DIR, `${name}.json`);
+    const { provider, chain } = _AgentWallet.resolveProvider(config);
+    if (existsSync(keystorePath)) {
+      const data = JSON.parse(readFileSync(keystorePath, "utf-8"));
+      const decrypted = await Wallet.fromEncryptedJson(data.encryptedJson, password);
+      const connected = new Wallet(decrypted.privateKey, provider);
+      return new _AgentWallet(connected, provider, chain);
+    }
+    const hdWallet = Wallet.createRandom();
+    const wallet = new Wallet(hdWallet.privateKey, provider);
+    const agentWallet = new _AgentWallet(wallet, provider, chain);
+    await agentWallet.saveKeystore(password, name);
+    return agentWallet;
+  }
+  // ── Keystore Operations ──
+  /** Encrypt and save the wallet to the keystore directory */
+  async saveKeystore(password, name) {
+    const pw = password ?? "logiqical-agent";
+    const n = name ?? "agent";
+    ensureKeystoreDir();
+    const encryptedJson = await this.wallet.encrypt(pw);
+    const data = {
+      address: this.address,
+      encryptedJson,
+      network: this.chain.name,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const keystorePath = join(KEYSTORE_DIR, `${n}.json`);
+    writeFileSync(keystorePath, JSON.stringify(data, null, 2));
+    return keystorePath;
+  }
+  // ── Core Operations ──
+  /** Get native token balance (formatted) */
+  async getBalance() {
+    const balance = await this.provider.getBalance(this.address);
+    const { formatEther } = await import("ethers");
+    return formatEther(balance);
+  }
+  /** Get balance of any address */
+  async getBalanceOf(address) {
+    const balance = await this.provider.getBalance(address);
+    const { formatEther } = await import("ethers");
+    return formatEther(balance);
+  }
+  /** Sign a message */
+  async signMessage(message) {
+    return this.wallet.signMessage(message);
+  }
+  /** Sign typed data (EIP-712) */
+  async signTypedData(domain, types, value) {
+    return this.wallet.signTypedData(domain, types, value);
+  }
+  /** Sign a transaction without broadcasting */
+  async signTransaction(tx) {
+    return this.wallet.signTransaction(tx);
+  }
+  /** Sign and broadcast a transaction */
+  async sendTransaction(tx) {
+    return this.wallet.sendTransaction(tx);
+  }
+  /** Send native token to an address */
+  async send(to, amount) {
+    const { parseEther } = await import("ethers");
+    return this.wallet.sendTransaction({
+      to,
+      value: parseEther(amount)
+    });
+  }
+  /**
+   * Sign and broadcast an unsigned tx object returned by the Logiqical API.
+   * Handles the { to, data, value, chainId, gas/gasLimit } format.
+   */
+  async signAndBroadcast(unsignedTx) {
+    const tx = {
+      to: unsignedTx.to,
+      data: unsignedTx.data,
+      value: unsignedTx.value
+    };
+    if (unsignedTx.gasLimit || unsignedTx.gas) {
+      tx.gasLimit = unsignedTx.gasLimit || unsignedTx.gas;
+    }
+    return this.wallet.sendTransaction(tx);
+  }
+  /**
+   * Sign and broadcast multiple unsigned txs in sequence.
+   * Waits for each to confirm before sending the next.
+   */
+  async signAndBroadcastAll(unsignedTxs, confirmations = 1) {
+    const results = [];
+    for (const utx of unsignedTxs) {
+      const txResponse = await this.signAndBroadcast(utx);
+      await txResponse.wait(confirmations);
+      results.push(txResponse);
+    }
+    return results;
+  }
+  /** Call a read-only contract method (no gas, no signing) */
+  async call(tx) {
+    return this.provider.call(tx);
+  }
+  /** Switch to a different network (returns new AgentWallet instance) */
+  switchNetwork(network) {
+    const { provider, chain } = _AgentWallet.resolveProvider({ network });
+    const wallet = new Wallet(this.privateKey, provider);
+    return new _AgentWallet(wallet, provider, chain);
+  }
+  // ── Internal ──
+  static resolveProvider(config) {
+    const networkKey = config.network ?? "avalanche";
+    const chain = CHAINS[networkKey];
+    if (!chain && !config.rpcUrl) {
+      throw new Error(`Unknown network "${networkKey}". Use a known chain (${Object.keys(CHAINS).join(", ")}) or provide rpcUrl.`);
+    }
+    const rpcUrl = config.rpcUrl ?? chain.rpcUrl;
+    const resolvedChain = chain ?? {
+      chainId: 0,
+      name: networkKey,
+      rpcUrl,
+      nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 }
+    };
+    const provider = new JsonRpcProvider(rpcUrl, resolvedChain.chainId || void 0);
+    return { provider, chain: resolvedChain };
   }
 };
 
-// src/http.ts
-var HttpClient = class {
-  constructor(baseUrl, apiKey) {
-    this.baseUrl = baseUrl;
-    this.apiKey = apiKey ?? null;
-  }
-  apiKey;
-  setApiKey(key) {
-    this.apiKey = key;
-  }
-  getApiKey() {
-    return this.apiKey;
-  }
-  async get(path, params, skipAuth = false) {
-    const url = new URL(path, this.baseUrl);
-    if (params) {
-      for (const [k, v] of Object.entries(params)) {
-        if (v !== void 0) url.searchParams.set(k, String(v));
+// src/policy.ts
+import { ethers } from "ethers";
+var PolicyEngine = class {
+  policy;
+  spendLog = [];
+  constructor(policy = {}) {
+    this.policy = policy;
+  }
+  getPolicy() {
+    return { ...this.policy };
+  }
+  setPolicy(policy) {
+    this.policy = policy;
+  }
+  updatePolicy(updates) {
+    this.policy = { ...this.policy, ...updates };
+  }
+  /** Check a transaction against the policy. Throws if rejected. */
+  check(tx) {
+    const value = tx.value ? BigInt(tx.value) : 0n;
+    if (this.policy.maxPerTx) {
+      const max = ethers.parseEther(this.policy.maxPerTx);
+      if (value > max) {
+        throw new PolicyError(
+          `Transaction value ${ethers.formatEther(value)} exceeds per-tx limit of ${this.policy.maxPerTx}`,
+          "MAX_PER_TX_EXCEEDED"
+        );
       }
     }
-    const headers = {};
-    if (!skipAuth && this.apiKey) headers["X-API-Key"] = this.apiKey;
-    const res = await fetch(url.toString(), { headers });
-    return this.handleResponse(res, path);
-  }
-  async post(path, body) {
-    const url = new URL(path, this.baseUrl);
-    const headers = { "Content-Type": "application/json" };
-    if (this.apiKey) headers["X-API-Key"] = this.apiKey;
-    const res = await fetch(url.toString(), { method: "POST", headers, body: JSON.stringify(body) });
-    return this.handleResponse(res, path);
-  }
-  async handleResponse(res, endpoint) {
-    if (res.status === 401) throw new LogiqicalAuthError(endpoint);
-    const data = await res.json().catch(() => null);
-    if (!res.ok) {
-      const msg = data?.error ?? `HTTP ${res.status}`;
-      throw new LogiqicalError(msg, res.status, endpoint);
+    if (this.policy.allowedContracts && this.policy.allowedContracts.length > 0) {
+      const to = tx.to.toLowerCase();
+      const allowed = this.policy.allowedContracts.map((a) => a.toLowerCase());
+      if (!allowed.includes(to)) {
+        throw new PolicyError(
+          `Contract ${tx.to} not in allowlist`,
+          "CONTRACT_NOT_ALLOWED"
+        );
+      }
+    }
+    if (this.policy.blockedContracts && this.policy.blockedContracts.length > 0) {
+      const to = tx.to.toLowerCase();
+      const blocked = this.policy.blockedContracts.map((b) => b.toLowerCase());
+      if (blocked.includes(to)) {
+        throw new PolicyError(
+          `Contract ${tx.to} is blocked`,
+          "CONTRACT_BLOCKED"
+        );
+      }
+    }
+    if (this.policy.maxPerHour) {
+      const max = ethers.parseEther(this.policy.maxPerHour);
+      const hourSpend = this.getSpendSince(Date.now() - 36e5);
+      if (hourSpend + value > max) {
+        throw new PolicyError(
+          `Would exceed hourly budget of ${this.policy.maxPerHour} AVAX (spent ${ethers.formatEther(hourSpend)} this hour)`,
+          "HOURLY_BUDGET_EXCEEDED"
+        );
+      }
+    }
+    if (this.policy.maxPerDay) {
+      const max = ethers.parseEther(this.policy.maxPerDay);
+      const daySpend = this.getSpendSince(Date.now() - 864e5);
+      if (daySpend + value > max) {
+        throw new PolicyError(
+          `Would exceed daily budget of ${this.policy.maxPerDay} AVAX (spent ${ethers.formatEther(daySpend)} today)`,
+          "DAILY_BUDGET_EXCEEDED"
+        );
+      }
     }
-    return data;
   }
-};
-
-// src/modules/swap.ts
-var SwapModule = class {
-  constructor(http, auth) {
-    this.http = http;
-    this.auth = auth;
+  /** Record a spend after successful broadcast */
+  recordSpend(value) {
+    this.spendLog.push({ amount: value, timestamp: Date.now() });
+    const cutoff = Date.now() - 864e5;
+    this.spendLog = this.spendLog.filter((r) => r.timestamp > cutoff);
   }
-  /**
-   * Get AVAX and ARENA token balances for a wallet.
-   * @param wallet - Wallet address to check
-   */
-  async getBalances(wallet) {
-    await this.auth();
-    return this.http.get("/balances", { wallet });
+  /** Get budget status */
+  getBudgetStatus() {
+    const hourSpend = this.getSpendSince(Date.now() - 36e5);
+    const daySpend = this.getSpendSince(Date.now() - 864e5);
+    return {
+      spentLastHour: ethers.formatEther(hourSpend),
+      spentLast24h: ethers.formatEther(daySpend),
+      remainingHour: this.policy.maxPerHour ? ethers.formatEther(ethers.parseEther(this.policy.maxPerHour) - hourSpend) : null,
+      remainingDay: this.policy.maxPerDay ? ethers.formatEther(ethers.parseEther(this.policy.maxPerDay) - daySpend) : null
+    };
   }
-  /**
-   * Quote how much ARENA you get for a given amount of AVAX.
-   * @param avax - Amount of AVAX to spend
-   */
-  async quote(avax) {
-    await this.auth();
-    return this.http.get("/quote", { avax });
+  get shouldSimulate() {
+    return this.policy.simulateBeforeSend ?? false;
   }
-  /**
-   * Quote how much AVAX you get for selling a given amount of ARENA.
-   * @param arena - Amount of ARENA to sell
-   */
-  async sellQuote(arena) {
-    await this.auth();
-    return this.http.get("/quote/sell", { arena });
+  get isDryRun() {
+    return this.policy.dryRun ?? false;
   }
-  /**
-   * Build unsigned transaction to buy ARENA with AVAX.
-   *
-   * Sign the transaction, then broadcast via `client.broadcast()`.
-   *
-   * @param wallet - Your wallet address
-   * @param avax - Amount of AVAX to spend
-   * @param slippage - Slippage tolerance in basis points (default: 500 = 5%)
-   */
-  async buildBuy(wallet, avax, slippage) {
-    await this.auth();
-    return this.http.get("/build/buy", { wallet, avax, slippage });
+  getSpendSince(since) {
+    return this.spendLog.filter((r) => r.timestamp > since).reduce((sum, r) => sum + r.amount, 0n);
   }
-  /**
-   * Build unsigned transactions to sell ARENA for AVAX.
-   *
-   * Returns 2 transactions — execute in order:
-   * 1. Approve — allows the DEX router to spend your ARENA
-   * 2. Swap — executes the ARENA → AVAX swap
-   *
-   * Sign each, broadcast via `client.broadcast()`, wait for confirmation before the next.
-   *
-   * @param wallet - Your wallet address
-   * @param amount - Amount of ARENA to sell, or "max" for entire balance
-   * @param slippage - Slippage tolerance in basis points (default: 500 = 5%)
-   */
-  async buildSell(wallet, amount, slippage) {
-    await this.auth();
-    return this.http.get("/build/sell-arena", { wallet, amount, slippage });
+};
+var PolicyError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "PolicyError";
+  }
+};
+
+// src/modules/swap.ts
+import { ethers as ethers2 } from "ethers";
+
+// src/constants.ts
+var CHAIN_ID = 43114;
+var ARENA_TOKEN = "0xB8d7710f7d8349A506b75dD184F05777c82dAd0C";
+var WAVAX = "0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7";
+var ARENA_STAKING = "0xeffb809d99142ce3b51c1796c096f5b01b4aaec4";
+var LB_ROUTER = "0x18556DA13313f3532c54711497A8FedAC273220E";
+var LB_QUOTER = "0x9A550a522BBaDFB69019b0432800Ed17855A51C3";
+var LAUNCH_CONTRACT = "0x8315f1eb449Dd4B779495C3A0b05e5d194446c6e";
+var TOKEN_MANAGER = "0x2196e106af476f57618373ec028924767c758464";
+var AVAX_HELPER = "0x03f1a18519abedbef210fa44e13b71fec01b8dfa";
+var ARENA_PAIRED_THRESHOLD = 100000000000n;
+var GRANULARITY_SCALER = 10n ** 18n;
+var ARENA_SHARES_CONTRACT = "0xc605c2cf66ee98ea925b1bb4fea584b71c00cc4c";
+var FRACTION_SCALER = 100;
+var ARENA_SOCIAL_API = "https://api.starsarena.com";
+var LIFI_API = "https://li.quest/v1";
+var HL_INFO = "https://api.hyperliquid.xyz/info";
+var DEFAULT_SLIPPAGE_BPS = 500;
+var ERC20_ABI = [
+  "function balanceOf(address owner) view returns (uint256)",
+  "function approve(address spender, uint256 amount) returns (bool)",
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function decimals() view returns (uint8)",
+  "function symbol() view returns (string)",
+  "function name() view returns (string)",
+  "function totalSupply() view returns (uint256)"
+];
+var ARENA_STAKING_ABI = [
+  "function deposit(uint256 _amount)",
+  "function withdraw(uint256 _amount)",
+  "function emergencyWithdraw()",
+  "function pendingReward(address _user, address _token) view returns (uint256)",
+  "function getUserInfo(address _user, address _rewardToken) view returns (uint256, uint256)",
+  "function rewardTokensLength() view returns (uint256)"
+];
+var LB_ROUTER_ABI = [
+  "function swapExactNATIVEForTokens(uint256 amountOutMin, tuple(uint256[] pairBinSteps, uint8[] versions, address[] tokenPath) path, address to, uint256 deadline) payable returns (uint256 amountOut)",
+  "function swapExactTokensForNATIVE(uint256 amountIn, uint256 amountOutMin, tuple(uint256[] pairBinSteps, uint8[] versions, address[] tokenPath) path, address payable to, uint256 deadline) returns (uint256 amountOut)"
+];
+var LB_QUOTER_ABI = [
+  "function findBestPathFromAmountIn(address[] calldata route, uint128 amountIn) view returns (tuple(address[] route, address[] pairs, uint256[] binSteps, uint256[] versions, uint128[] amounts, uint128[] virtualAmountsWithoutSlippage, uint128[] fees) quote)"
+];
+var LAUNCH_CONTRACT_ABI = [
+  "function createToken(uint16 a, uint8 b, uint128 curveScaler, uint8 creatorFeeBasisPoints, address tokenCreatorAddress, uint256 tokenSplit, string name, string symbol, uint256 amount) payable",
+  "function buyAndCreateLpIfPossible(uint256 amount, uint256 tokenId) payable",
+  "function sell(uint256 amount, uint256 tokenId)",
+  "function calculateCostWithFees(uint256 amountInToken, uint256 tokenId) view returns (uint256)",
+  "function calculateRewardWithFees(uint256 amount, uint256 tokenId) view returns (uint256)",
+  "function getMaxTokensForSale(uint256 tokenId) view returns (uint256)",
+  "function tokenSupply(uint256 tokenId) view returns (uint256)",
+  "function getTokenParameters(uint256 tokenId) view returns (uint128 curveScaler, uint16 a, uint8 b, bool lpDeployed, uint8 lpPercentage, uint8 salePercentage, uint8 creatorFeeBasisPoints, address creatorAddress, address pairAddress, address tokenContractAddress)",
+  "function tokenIdentifier() view returns (uint256)",
+  "function protocolFeeBasisPoint() view returns (uint256)",
+  "event Buy(address indexed user, uint256 indexed tokenId, uint256 tokenAmount, uint256 cost, uint256 tokenSupply, address referrerAddress, uint256 referralFee, uint256 creatorFee, uint256 protocolFee)",
+  "event Sell(address indexed user, uint256 indexed tokenId, uint256 tokenAmount, uint256 reward, uint256 tokenSupply, address referrerAddress, uint256 referralFee, uint256 creatorFee, uint256 protocolFee)"
+];
+var TOKEN_MANAGER_ABI = [
+  "function createToken(uint32 a, uint8 b, uint128 curveScaler, uint8 creatorFeeBasisPoints, address tokenCreatorAddress, uint256 tokenSplit, string name, string symbol, uint256 amount)",
+  "function calculateCostWithFees(uint256 amountInToken, uint256 tokenId) view returns (uint256)",
+  "function calculateRewardWithFees(uint256 amount, uint256 tokenId) view returns (uint256)",
+  "function getMaxTokensForSale(uint256 tokenId) view returns (uint256)",
+  "function tokenSupply(uint256 tokenId) view returns (uint256)",
+  "function getTokenParameters(uint256 tokenId) view returns (uint128 curveScaler, uint32 a, uint8 b, bool lpDeployed, uint8 lpPercentage, uint8 salePercentage, uint8 creatorFeeBasisPoints, address creatorAddress, address pairAddress, address tokenContractAddress)",
+  "function tokenIdentifier() view returns (uint256)",
+  "function protocolFeeBasisPoint() view returns (uint256)",
+  "event Buy(address indexed user, uint256 indexed tokenId, uint256 tokenAmount, uint256 cost, uint256 tokenSupply, address referrerAddress, uint256 referralFee, uint256 creatorFee, uint256 protocolFee)",
+  "event Sell(address indexed user, uint256 indexed tokenId, uint256 tokenAmount, uint256 reward, uint256 tokenSupply, address referrerAddress, uint256 referralFee, uint256 creatorFee, uint256 protocolFee)"
+];
+var AVAX_HELPER_ABI = [
+  "function buyAndCreateLpIfPossibleWithAvax(uint256 tokenId, uint256 amountOutMin) payable returns (uint256)",
+  "function sellToAvax(uint256 tokenId, uint256 amount, uint256 amountOutAvaxMin) returns (uint256)"
+];
+var SHARES_ABI = [
+  "function buyFractionalShares(address sharesSubject, address user, uint256 amount) payable",
+  "function sellFractionalShares(address sharesSubject, address user, uint256 amount) payable",
+  "function getBuyPriceForFractionalSharesAfterFee(address sharesSubject, uint256 amount) view returns (uint256)",
+  "function getSellPriceForFractionalSharesAfterFee(address sharesSubject, uint256 amount) view returns (uint256)",
+  "function getBuyPriceForFractionalShares(address sharesSubject, uint256 amount) view returns (uint256)",
+  "function getSellPriceForFractionalShares(address sharesSubject, uint256 amount) view returns (uint256)",
+  "function getMyFractionalShares(address sharesSubject, address user) view returns (uint256)",
+  "function getSharesSupply(address sharesSubject) view returns (uint256)",
+  "function getTotalFractionalSupply(address sharesSubject) view returns (uint256)",
+  "function fractionalSharesBalance(address, address) view returns (uint256)",
+  "function protocolFeePercent() view returns (uint256)",
+  "function subjectFeePercent() view returns (uint256)",
+  "function referralFeePercent() view returns (uint256)"
+];
+
+// src/modules/swap.ts
+var SwapModule = class {
+  constructor(provider) {
+    this.provider = provider;
+    this.arenaToken = new ethers2.Contract(ethers2.getAddress(ARENA_TOKEN), ERC20_ABI, provider);
+    this.lbQuoter = new ethers2.Contract(ethers2.getAddress(LB_QUOTER), LB_QUOTER_ABI, provider);
+  }
+  arenaToken;
+  lbQuoter;
+  /** Get AVAX and ARENA balances for a wallet */
+  async getBalances(wallet) {
+    const [avax, arena] = await Promise.all([
+      this.provider.getBalance(wallet),
+      this.arenaToken.balanceOf(wallet)
+    ]);
+    const decimals = await this.arenaToken.decimals();
+    return {
+      avax: avax.toString(),
+      arena: arena.toString(),
+      avaxFormatted: ethers2.formatEther(avax),
+      arenaFormatted: ethers2.formatUnits(arena, decimals)
+    };
+  }
+  /** Quote how much ARENA for a given AVAX amount (includes 0.3% fee) */
+  async quote(avaxAmount) {
+    const amountIn = ethers2.parseEther(avaxAmount);
+    const fee = amountIn * 30n / 10000n;
+    const netAmount = amountIn - fee;
+    const route = [WAVAX, ARENA_TOKEN];
+    const quote = await this.lbQuoter.findBestPathFromAmountIn(route, netAmount);
+    const arenaOut = quote.amounts[quote.amounts.length - 1];
+    const decimals = await this.arenaToken.decimals();
+    const arenaFormatted = ethers2.formatUnits(arenaOut, decimals);
+    return {
+      arenaOut: arenaFormatted,
+      fee: ethers2.formatEther(fee),
+      netAvax: ethers2.formatEther(netAmount),
+      rate: (parseFloat(arenaFormatted) / parseFloat(ethers2.formatEther(netAmount))).toFixed(2)
+    };
+  }
+  /** Quote how much AVAX for selling ARENA */
+  async sellQuote(arenaAmount) {
+    const decimals = await this.arenaToken.decimals();
+    const amountIn = ethers2.parseUnits(arenaAmount, decimals);
+    const route = [ARENA_TOKEN, WAVAX];
+    const quote = await this.lbQuoter.findBestPathFromAmountIn(route, amountIn);
+    const avaxOut = quote.amounts[quote.amounts.length - 1];
+    const avaxFormatted = ethers2.formatEther(avaxOut);
+    return {
+      avaxOut: avaxFormatted,
+      arenaIn: arenaAmount,
+      rate: (parseFloat(arenaAmount) / parseFloat(avaxFormatted)).toFixed(2)
+    };
+  }
+  /** Build unsigned tx to buy ARENA with AVAX via LFJ DEX */
+  async buildBuy(wallet, avaxAmount, slippageBps = DEFAULT_SLIPPAGE_BPS) {
+    const amountIn = ethers2.parseEther(avaxAmount);
+    const route = [WAVAX, ARENA_TOKEN];
+    const quote = await this.lbQuoter.findBestPathFromAmountIn(route, amountIn);
+    const expectedOut = quote.amounts[quote.amounts.length - 1];
+    if (expectedOut === 0n) throw new Error("Quote returned zero \u2014 pool may have no liquidity");
+    const clampedSlippage = BigInt(Math.max(0, Math.min(1e4, Number(slippageBps))));
+    const amountOutMin = expectedOut - expectedOut * clampedSlippage / 10000n;
+    const deadline = Math.floor(Date.now() / 1e3) + 3600;
+    const path = {
+      pairBinSteps: [...quote.binSteps].map((b) => b.toString()),
+      versions: [...quote.versions].map((v) => Number(v)),
+      tokenPath: [...route]
+    };
+    const iface = new ethers2.Interface(LB_ROUTER_ABI);
+    const data = iface.encodeFunctionData("swapExactNATIVEForTokens", [amountOutMin, path, wallet, deadline]);
+    const decimals = await this.arenaToken.decimals();
+    return {
+      transactions: [{
+        to: ethers2.getAddress(LB_ROUTER),
+        data,
+        value: ethers2.toBeHex(amountIn, 32),
+        chainId: CHAIN_ID,
+        gasLimit: "500000",
+        description: `Buy ARENA with ${avaxAmount} AVAX (~${ethers2.formatUnits(expectedOut, decimals)} ARENA)`
+      }],
+      summary: `Swap ${avaxAmount} AVAX \u2192 ~${ethers2.formatUnits(expectedOut, decimals)} ARENA`
+    };
+  }
+  /** Build unsigned txs to sell ARENA for AVAX: [approve, swap] */
+  async buildSell(wallet, arenaAmount, slippageBps = DEFAULT_SLIPPAGE_BPS) {
+    const decimals = await this.arenaToken.decimals();
+    let sellAmount;
+    if (arenaAmount === "max") {
+      sellAmount = await this.arenaToken.balanceOf(wallet);
+      if (sellAmount === 0n) throw new Error("No ARENA balance to sell");
+    } else {
+      sellAmount = ethers2.parseUnits(arenaAmount, decimals);
+    }
+    const route = [ARENA_TOKEN, WAVAX];
+    const quote = await this.lbQuoter.findBestPathFromAmountIn(route, sellAmount);
+    const expectedOut = quote.amounts[quote.amounts.length - 1];
+    if (expectedOut === 0n) throw new Error("Quote returned zero \u2014 pool may have no liquidity");
+    const clampedSlippage = BigInt(Math.max(0, Math.min(1e4, Number(slippageBps))));
+    const amountOutMin = expectedOut - expectedOut * clampedSlippage / 10000n;
+    const deadline = Math.floor(Date.now() / 1e3) + 3600;
+    const path = {
+      pairBinSteps: [...quote.binSteps].map((b) => b.toString()),
+      versions: [...quote.versions].map((v) => Number(v)),
+      tokenPath: [...route]
+    };
+    const approveIface = new ethers2.Interface(ERC20_ABI);
+    const approveData = approveIface.encodeFunctionData("approve", [ethers2.getAddress(LB_ROUTER), sellAmount]);
+    const swapIface = new ethers2.Interface(LB_ROUTER_ABI);
+    const swapData = swapIface.encodeFunctionData("swapExactTokensForNATIVE", [sellAmount, amountOutMin, path, wallet, deadline]);
+    return {
+      transactions: [
+        {
+          to: ethers2.getAddress(ARENA_TOKEN),
+          data: approveData,
+          value: "0",
+          chainId: CHAIN_ID,
+          gasLimit: "60000",
+          description: `Approve ${ethers2.formatUnits(sellAmount, decimals)} ARENA for swap`
+        },
+        {
+          to: ethers2.getAddress(LB_ROUTER),
+          data: swapData,
+          value: "0",
+          chainId: CHAIN_ID,
+          gasLimit: "500000",
+          description: `Sell ${ethers2.formatUnits(sellAmount, decimals)} ARENA for ~${ethers2.formatEther(expectedOut)} AVAX`
+        }
+      ]
+    };
   }
 };
 
 // src/modules/staking.ts
+import { ethers as ethers3 } from "ethers";
 var StakingModule = class {
-  constructor(http, auth) {
-    this.http = http;
-    this.auth = auth;
+  constructor(provider) {
+    this.provider = provider;
+    this.arenaToken = new ethers3.Contract(ethers3.getAddress(ARENA_TOKEN), ERC20_ABI, provider);
+    this.staking = new ethers3.Contract(ethers3.getAddress(ARENA_STAKING), ARENA_STAKING_ABI, provider);
   }
-  /**
-   * Get staking info for a wallet — staked amount, pending rewards, APY.
-   * @param wallet - Wallet address to check
-   */
+  arenaToken;
+  staking;
+  /** Get staking info — staked amount, pending rewards */
   async getInfo(wallet) {
-    await this.auth();
-    return this.http.get("/stake/info", { wallet });
-  }
-  /**
-   * Build unsigned transactions to stake ARENA tokens.
-   *
-   * Returns 2 transactions — execute in order:
-   * 1. Approve — allows the staking contract to spend your ARENA
-   * 2. Stake — deposits ARENA into staking
-   *
-   * @param wallet - Your wallet address
-   * @param amount - Amount of ARENA to stake
-   */
+    const decimals = await this.arenaToken.decimals();
+    const [stakedRaw] = await this.staking.getUserInfo(wallet, ethers3.getAddress(ARENA_TOKEN));
+    const pendingRaw = await this.staking.pendingReward(wallet, ethers3.getAddress(ARENA_TOKEN));
+    return {
+      staked: stakedRaw.toString(),
+      stakedFormatted: ethers3.formatUnits(stakedRaw, decimals),
+      rewards: pendingRaw.toString(),
+      rewardsFormatted: ethers3.formatUnits(pendingRaw, decimals)
+    };
+  }
+  /** Build txs to stake ARENA: [approve, deposit] */
   async buildStake(wallet, amount) {
-    await this.auth();
-    return this.http.get("/build/stake", { wallet, amount });
-  }
-  /**
-   * Build unsigned transactions to buy ARENA with AVAX and stake in one flow.
-   *
-   * Combines swap + approve + stake. Returns multiple transactions — execute in order.
-   *
-   * @param wallet - Your wallet address
-   * @param avax - Amount of AVAX to spend
-   * @param slippage - Slippage tolerance in basis points (default: 500 = 5%)
-   */
-  async buildBuyAndStake(wallet, avax, slippage) {
-    await this.auth();
-    return this.http.get("/build/buy-and-stake", { wallet, avax, slippage });
-  }
-  /**
-   * Build unsigned transaction to unstake ARENA tokens and claim rewards.
-   * @param wallet - Your wallet address
-   * @param amount - Amount of ARENA to unstake
-   */
+    const decimals = await this.arenaToken.decimals();
+    let stakeAmount;
+    if (amount === "max") {
+      stakeAmount = await this.arenaToken.balanceOf(wallet);
+    } else {
+      stakeAmount = ethers3.parseUnits(amount, decimals);
+    }
+    const approveIface = new ethers3.Interface(ERC20_ABI);
+    const approveData = approveIface.encodeFunctionData("approve", [ethers3.getAddress(ARENA_STAKING), stakeAmount]);
+    const stakingIface = new ethers3.Interface(ARENA_STAKING_ABI);
+    const stakeData = stakingIface.encodeFunctionData("deposit", [stakeAmount]);
+    return {
+      transactions: [
+        {
+          to: ethers3.getAddress(ARENA_TOKEN),
+          data: approveData,
+          value: "0",
+          chainId: CHAIN_ID,
+          gasLimit: "60000",
+          description: `Approve ${ethers3.formatUnits(stakeAmount, decimals)} ARENA for staking`
+        },
+        {
+          to: ethers3.getAddress(ARENA_STAKING),
+          data: stakeData,
+          value: "0",
+          chainId: CHAIN_ID,
+          gasLimit: "300000",
+          description: `Stake ${ethers3.formatUnits(stakeAmount, decimals)} ARENA`
+        }
+      ]
+    };
+  }
+  /** Build tx to unstake ARENA + claim rewards */
   async buildUnstake(wallet, amount) {
-    await this.auth();
-    return this.http.get("/build/unstake", { wallet, amount });
+    const decimals = await this.arenaToken.decimals();
+    let withdrawAmount;
+    if (amount === "max") {
+      const [stakedRaw] = await this.staking.getUserInfo(wallet, ethers3.getAddress(ARENA_TOKEN));
+      withdrawAmount = stakedRaw;
+    } else {
+      withdrawAmount = ethers3.parseUnits(amount, decimals);
+    }
+    const iface = new ethers3.Interface(ARENA_STAKING_ABI);
+    const data = iface.encodeFunctionData("withdraw", [withdrawAmount]);
+    return {
+      transactions: [{
+        to: ethers3.getAddress(ARENA_STAKING),
+        data,
+        value: "0",
+        chainId: CHAIN_ID,
+        gasLimit: "300000",
+        description: `Unstake ${ethers3.formatUnits(withdrawAmount, decimals)} ARENA + claim rewards`
+      }]
+    };
+  }
+  /** Build buy-and-stake flow (3 txs): buy ARENA via LFJ, approve, stake */
+  async buildBuyAndStake(wallet, avaxAmount, slippageBps = DEFAULT_SLIPPAGE_BPS) {
+    const lbQuoter = new ethers3.Contract(ethers3.getAddress(LB_QUOTER), LB_QUOTER_ABI, this.provider);
+    const amountIn = ethers3.parseEther(avaxAmount);
+    const route = [WAVAX, ARENA_TOKEN];
+    const quote = await lbQuoter.findBestPathFromAmountIn(route, amountIn);
+    const expectedOut = quote.amounts[quote.amounts.length - 1];
+    const clampedSlippage = BigInt(Math.max(0, Math.min(1e4, Number(slippageBps))));
+    const amountOutMin = expectedOut - expectedOut * clampedSlippage / 10000n;
+    const deadline = Math.floor(Date.now() / 1e3) + 3600;
+    const decimals = await this.arenaToken.decimals();
+    const path = {
+      pairBinSteps: [...quote.binSteps].map((b) => b.toString()),
+      versions: [...quote.versions].map((v) => Number(v)),
+      tokenPath: [...route]
+    };
+    const routerIface = new ethers3.Interface(LB_ROUTER_ABI);
+    const buyData = routerIface.encodeFunctionData("swapExactNATIVEForTokens", [amountOutMin, path, wallet, deadline]);
+    const erc20Iface = new ethers3.Interface(ERC20_ABI);
+    const approveData = erc20Iface.encodeFunctionData("approve", [ethers3.getAddress(ARENA_STAKING), ethers3.MaxUint256]);
+    const stakingIface = new ethers3.Interface(ARENA_STAKING_ABI);
+    const stakeData = stakingIface.encodeFunctionData("deposit", [expectedOut]);
+    return {
+      transactions: [
+        {
+          to: ethers3.getAddress(LB_ROUTER),
+          data: buyData,
+          value: ethers3.toBeHex(amountIn, 32),
+          chainId: CHAIN_ID,
+          gasLimit: "500000",
+          description: `Step 1/3: Buy ~${ethers3.formatUnits(expectedOut, decimals)} ARENA with ${avaxAmount} AVAX`
+        },
+        {
+          to: ethers3.getAddress(ARENA_TOKEN),
+          data: approveData,
+          value: "0",
+          chainId: CHAIN_ID,
+          gasLimit: "60000",
+          description: `Step 2/3: Approve ARENA for staking`
+        },
+        {
+          to: ethers3.getAddress(ARENA_STAKING),
+          data: stakeData,
+          value: "0",
+          chainId: CHAIN_ID,
+          gasLimit: "300000",
+          description: `Step 3/3: Stake ~${ethers3.formatUnits(expectedOut, decimals)} ARENA`
+        }
+      ]
+    };
   }
 };
 
 // src/modules/launchpad.ts
+import { ethers as ethers4 } from "ethers";
 var LaunchpadModule = class {
-  constructor(http, auth) {
-    this.http = http;
-    this.auth = auth;
-  }
-  // ── Discovery ──
-  /**
-   * Get recently launched tokens on Arena.
-   * @param count - Number of tokens (max 50, default 10)
-   * @param type - Filter: "all", "avax" (AVAX-paired), or "arena" (ARENA-paired)
-   */
-  async getRecent(count, type) {
-    await this.auth();
-    return this.http.get("/launchpad/recent", { count, type });
-  }
-  /**
-   * Search for a token by name, symbol, or contract address.
-   * @param q - Search query — name, symbol, or 0x contract address
-   */
-  async search(q) {
-    await this.auth();
-    return this.http.get("/launchpad/search", { q });
-  }
-  /**
-   * Get tokens that are closest to graduating from the bonding curve to DEX.
-   * @param count - Number of tokens (max 20, default 5)
-   */
-  async getGraduating(count) {
-    await this.auth();
-    return this.http.get("/launchpad/graduating", { count });
-  }
-  /**
-   * Get tokens that have already graduated from the bonding curve to DEX.
-   * @param count - Number of tokens (max 50, default 10)
-   */
-  async getGraduated(count) {
-    await this.auth();
-    return this.http.get("/launchpad/graduated", { count });
-  }
-  /**
-   * Get top tokens by trading volume.
-   * @param timeframe - "5m", "1h", "4h", "24h", or "all_time"
-   * @param count - Number of tokens (max 50, default 10)
-   */
-  async getTopVolume(timeframe, count) {
-    await this.auth();
-    return this.http.get("/launchpad/top-volume", { timeframe, count });
-  }
-  // ── Intelligence ──
-  /**
-   * Get full token profile with stats — price, market cap, graduation progress, buy/sell activity.
-   * @param tokenId - Arena token ID
-   * @param address - Or token contract address (0x...)
-   */
-  async getToken(tokenId, address) {
-    await this.auth();
-    return this.http.get("/launchpad/token", { tokenId, address });
-  }
-  /**
-   * Get a buy or sell quote for a bonding curve token.
-   * @param tokenId - Arena token ID
-   * @param side - "buy" or "sell"
-   * @param amount - For buy: AVAX amount. For sell: token amount.
-   */
-  async quote(tokenId, side, amount) {
-    await this.auth();
-    const params = { tokenId, side };
-    if (side === "buy") params.avax = amount;
-    else params.tokenAmount = amount;
-    return this.http.get("/launchpad/quote", params);
-  }
-  /**
-   * Get agent's tracked portfolio — all launchpad tokens the agent has bought.
-   * @param wallet - Agent wallet address
-   */
-  async getPortfolio(wallet) {
-    await this.auth();
-    return this.http.get("/launchpad/portfolio", { wallet });
-  }
-  /**
-   * Get market cap data for a token.
-   * @param tokenId - Arena token ID
-   */
-  async getMarketCap(tokenId) {
-    await this.auth();
-    return this.http.get("/launchpad/market-cap", { tokenId });
-  }
-  /**
-   * Get recent trade activity for a token.
-   * @param tokenId - Arena token ID
-   * @param address - Or token contract address
-   * @param count - Number of trades (max 50, default 20)
-   */
-  async getActivity(tokenId, address, count) {
-    await this.auth();
-    return this.http.get("/launchpad/activity", { tokenId, address, count });
-  }
-  /**
-   * Get top holders for a token with PnL data.
-   * @param address - Token contract address
-   * @param tokenId - Or Arena token ID
-   * @param count - Number of holders (max 50, default 20)
-   */
-  async getHolders(address, tokenId, count) {
-    await this.auth();
-    return this.http.get("/launchpad/holders", { address, tokenId, count });
-  }
-  /**
-   * Get platform overview — total tokens launched, contract addresses, stats.
-   */
+  constructor(provider) {
+    this.provider = provider;
+    this.launchContract = new ethers4.Contract(ethers4.getAddress(LAUNCH_CONTRACT), LAUNCH_CONTRACT_ABI, provider);
+    this.tokenManager = new ethers4.Contract(ethers4.getAddress(TOKEN_MANAGER), TOKEN_MANAGER_ABI, provider);
+    this.avaxHelper = new ethers4.Contract(ethers4.getAddress(AVAX_HELPER), AVAX_HELPER_ABI, provider);
+  }
+  launchContract;
+  tokenManager;
+  avaxHelper;
+  isArenaPaired(tokenId) {
+    return BigInt(tokenId) >= ARENA_PAIRED_THRESHOLD;
+  }
+  getContract(tokenId) {
+    return this.isArenaPaired(tokenId) ? this.tokenManager : this.launchContract;
+  }
+  /** Get platform overview — total tokens, fees, contract addresses */
   async getOverview() {
-    await this.auth();
-    return this.http.get("/launchpad/overview");
-  }
-  /**
-   * Get the global trade feed across all launchpad tokens.
-   * @param count - Number of trades (max 100, default 50)
-   * @param offset - Pagination offset
-   */
-  async getTrades(count, offset) {
-    await this.auth();
-    return this.http.get("/launchpad/trades", { count, offset });
-  }
-  // ── Token Launch ──
-  /**
-   * Launch a new token on Arena — uploads image, creates community, and returns the unsigned createToken transaction.
-   *
-   * @param wallet - Creator wallet address
-   * @param name - Token name (also used as community name)
-   * @param symbol - Token ticker symbol
-   * @param imageBase64 - Token image as base64 string (optional)
-   * @param paymentToken - "avax" or "arena" (default: "arena")
-   * @param initialBuyAvax - AVAX amount for initial buy at creation (default: "0")
-   */
-  async launch(wallet, name, symbol, imageBase64, paymentToken = "arena", initialBuyAvax = "0") {
-    await this.auth();
-    return this.http.post("/launchpad/launch", {
-      wallet,
+    const [avaxLatest, arenaLatest, protocolFeeAvax, protocolFeeArena] = await Promise.all([
+      this.launchContract.tokenIdentifier(),
+      this.tokenManager.tokenIdentifier(),
+      this.launchContract.protocolFeeBasisPoint(),
+      this.tokenManager.protocolFeeBasisPoint()
+    ]);
+    return {
+      totalAvaxPairedTokens: (avaxLatest - 1n).toString(),
+      totalArenaPairedTokens: (arenaLatest - ARENA_PAIRED_THRESHOLD).toString(),
+      totalTokens: (avaxLatest - 1n + (arenaLatest - ARENA_PAIRED_THRESHOLD)).toString(),
+      protocolFeeBps: { avaxPaired: protocolFeeAvax.toString(), arenaPaired: protocolFeeArena.toString() },
+      contracts: { launchContract: LAUNCH_CONTRACT, tokenManager: TOKEN_MANAGER, avaxHelper: AVAX_HELPER }
+    };
+  }
+  /** Get full token info by ID */
+  async getToken(tokenId) {
+    const contract = this.getContract(tokenId);
+    const id = BigInt(tokenId);
+    const [params, supply, maxForSale] = await Promise.all([
+      contract.getTokenParameters(id),
+      contract.tokenSupply(id),
+      contract.getMaxTokensForSale(id)
+    ]);
+    const tokenAddress = params.tokenContractAddress;
+    if (tokenAddress === ethers4.ZeroAddress) throw new Error(`Token ID ${tokenId} not found`);
+    const token = new ethers4.Contract(tokenAddress, ERC20_ABI, this.provider);
+    let name = "Unknown", symbol = "UNKNOWN";
+    try {
+      [name, symbol] = await Promise.all([token.name(), token.symbol()]);
+    } catch {
+    }
+    let priceAvax = "0";
+    if (!params.lpDeployed) {
+      try {
+        const cost = await contract.calculateCostWithFees(1n, id);
+        priceAvax = ethers4.formatEther(cost);
+      } catch {
+      }
+    }
+    const salePerc = BigInt(params.salePercentage);
+    const saleAllocation = supply * salePerc / 100n;
+    const amountSold = saleAllocation > maxForSale ? saleAllocation - maxForSale : 0n;
+    const graduationProgress = saleAllocation > 0n ? Number(amountSold * 10000n / saleAllocation) / 100 : 0;
+    return {
+      tokenId,
+      type: this.isArenaPaired(tokenId) ? "ARENA-paired" : "AVAX-paired",
       name,
       symbol,
-      imageBase64,
-      paymentToken,
-      initialBuyAvax
-    });
-  }
-  /**
-   * Upload a token image to Arena's CDN and get the hosted URL.
-   * Use this before launch() if you want to preview the image URL first.
-   *
-   * @param imageBase64 - Image as base64 string
-   * @param fileType - MIME type (default: "image/jpeg")
-   */
-  async uploadImage(imageBase64, fileType = "image/jpeg") {
-    await this.auth();
-    return this.http.post("/launchpad/upload-image", { imageBase64, fileType });
-  }
-  /**
-   * Build only the createToken transaction (no image or community creation).
-   * Useful if you want to handle image upload and community creation separately.
-   *
-   * @param wallet - Creator wallet address
-   * @param name - Token name
-   * @param symbol - Token ticker symbol
-   * @param paymentToken - "avax" or "arena" (default: "arena")
-   * @param initialBuyAvax - AVAX for initial buy (default: "0")
-   */
-  async buildCreate(wallet, name, symbol, paymentToken = "arena", initialBuyAvax = "0") {
-    await this.auth();
-    return this.http.get("/launchpad/build/create", { wallet, name, symbol, paymentToken, initialBuyAvax });
-  }
-  // ── Trading ──
-  /**
-   * Build unsigned transaction to buy a launchpad token with AVAX.
-   *
-   * Auto-detects if the token is AVAX-paired or ARENA-paired and routes accordingly.
-   * If the token has graduated to DEX, returns transactions for DEX swap instead.
-   *
-   * @param wallet - Your wallet address
-   * @param tokenId - Arena token ID
-   * @param avax - Amount of AVAX to spend
-   * @param slippage - Slippage in basis points (default: 500 = 5%)
-   */
-  async buildBuy(wallet, tokenId, avax, slippage) {
-    await this.auth();
-    return this.http.get("/launchpad/build/buy", { wallet, tokenId, avax, slippage });
-  }
-  /**
-   * Build unsigned transaction(s) to sell a launchpad token.
-   *
-   * Returns approve + sell transactions. Execute in order.
-   * Use amount="max" to sell entire balance.
-   *
-   * If the token has graduated to DEX, returns transactions for DEX swap instead.
-   *
-   * @param wallet - Your wallet address
-   * @param tokenId - Arena token ID
-   * @param amount - Token amount to sell, or "max" for entire balance
-   * @param slippage - Slippage in basis points (default: 500 = 5%)
-   */
-  async buildSell(wallet, tokenId, amount, slippage) {
-    await this.auth();
-    return this.http.get("/launchpad/build/sell", { wallet, tokenId, amount, slippage });
+      tokenAddress,
+      creator: params.creatorAddress,
+      priceAvax,
+      graduationProgress: `${graduationProgress.toFixed(2)}%`,
+      graduated: params.lpDeployed,
+      amountSold: ethers4.formatUnits(amountSold, 18),
+      totalSupply: ethers4.formatUnits(supply, 18),
+      remainingForSale: ethers4.formatUnits(maxForSale, 18)
+    };
+  }
+  /** Get a buy or sell quote */
+  async quote(tokenId, side, amount) {
+    const contract = this.getContract(tokenId);
+    const id = BigInt(tokenId);
+    if (side === "buy") {
+      const avaxWei = ethers4.parseEther(amount);
+      if (!this.isArenaPaired(tokenId)) {
+        const tokenAmountWei2 = await this.binarySearchTokenAmount(avaxWei, id);
+        if (tokenAmountWei2 === 0n) return { tokenId, side, avaxIn: amount, tokensOut: "0", note: "Insufficient liquidity" };
+        const exactCost = await this.launchContract.calculateCostWithFees(tokenAmountWei2 / GRANULARITY_SCALER, id);
+        return { tokenId, side, avaxIn: ethers4.formatEther(exactCost), tokensOut: ethers4.formatUnits(tokenAmountWei2, 18) };
+      }
+      return { tokenId, side, avaxIn: amount, tokensOut: "determined at execution (ARENA-paired)" };
+    }
+    const tokenAmountWei = ethers4.parseUnits(amount, 18);
+    const reward = await contract.calculateRewardWithFees(tokenAmountWei, id);
+    return {
+      tokenId,
+      side,
+      tokenAmount: amount,
+      rewardAvax: this.isArenaPaired(tokenId) ? void 0 : ethers4.formatEther(reward),
+      rewardArena: this.isArenaPaired(tokenId) ? ethers4.formatUnits(reward, 18) : void 0
+    };
+  }
+  /** Get recent token launches */
+  async getRecent(count = 10) {
+    const results = [];
+    const fetchToken = async (id, contract, pairType) => {
+      try {
+        const params = await contract.getTokenParameters(id);
+        if (params.tokenContractAddress === ethers4.ZeroAddress) return null;
+        const token = new ethers4.Contract(params.tokenContractAddress, ERC20_ABI, this.provider);
+        let name = "Unknown", symbol = "UNKNOWN";
+        try {
+          [name, symbol] = await Promise.all([token.name(), token.symbol()]);
+        } catch {
+        }
+        return { tokenId: id.toString(), type: pairType, name, symbol, tokenAddress: params.tokenContractAddress, graduated: params.lpDeployed };
+      } catch {
+        return null;
+      }
+    };
+    const latestAvax = await this.launchContract.tokenIdentifier();
+    const avaxPromises = [];
+    for (let i = 0; i < Math.ceil(count / 2) && latestAvax - BigInt(i) > 0n; i++) {
+      avaxPromises.push(fetchToken(latestAvax - BigInt(i) - 1n, this.launchContract, "AVAX-paired"));
+    }
+    const latestArena = await this.tokenManager.tokenIdentifier();
+    const arenaPromises = [];
+    for (let i = 0; i < Math.ceil(count / 2) && latestArena - BigInt(i) >= ARENA_PAIRED_THRESHOLD; i++) {
+      arenaPromises.push(fetchToken(latestArena - BigInt(i) - 1n, this.tokenManager, "ARENA-paired"));
+    }
+    results.push(...(await Promise.all([...avaxPromises, ...arenaPromises])).filter(Boolean));
+    return { count: results.length, tokens: results.slice(0, count) };
+  }
+  /** Build unsigned tx to buy a launchpad token */
+  async buildBuy(wallet, tokenId, avax, slippageBps = DEFAULT_SLIPPAGE_BPS) {
+    const id = BigInt(tokenId);
+    const avaxWei = ethers4.parseEther(avax);
+    const contract = this.getContract(tokenId);
+    const params = await contract.getTokenParameters(id);
+    if (params.lpDeployed) throw new Error("Token graduated to DEX \u2014 use dex.buildSwap() instead");
+    if (!this.isArenaPaired(tokenId)) {
+      const tokenAmountWei = await this.binarySearchTokenAmount(avaxWei, id);
+      if (tokenAmountWei === 0n) throw new Error("Cannot calculate buy amount \u2014 token may be sold out");
+      const iface2 = new ethers4.Interface(LAUNCH_CONTRACT_ABI);
+      const data2 = iface2.encodeFunctionData("buyAndCreateLpIfPossible", [tokenAmountWei, id]);
+      return { transactions: [{ to: ethers4.getAddress(LAUNCH_CONTRACT), data: data2, value: ethers4.toBeHex(avaxWei, 32), chainId: CHAIN_ID, gasLimit: "500000", description: `Buy ~${ethers4.formatUnits(tokenAmountWei, 18)} tokens (ID ${tokenId})` }] };
+    }
+    const iface = new ethers4.Interface(AVAX_HELPER_ABI);
+    const data = iface.encodeFunctionData("buyAndCreateLpIfPossibleWithAvax", [id, 0n]);
+    return { transactions: [{ to: ethers4.getAddress(AVAX_HELPER), data, value: ethers4.toBeHex(avaxWei, 32), chainId: CHAIN_ID, gasLimit: "500000", description: `Buy tokens (ID ${tokenId}) with ${avax} AVAX` }] };
+  }
+  /** Build unsigned txs to sell a launchpad token: [approve, sell] */
+  async buildSell(wallet, tokenId, amount, slippageBps = DEFAULT_SLIPPAGE_BPS) {
+    const id = BigInt(tokenId);
+    const contract = this.getContract(tokenId);
+    const params = await contract.getTokenParameters(id);
+    if (params.lpDeployed) throw new Error("Token graduated to DEX \u2014 use dex.buildSwap() instead");
+    const tokenAddress = params.tokenContractAddress;
+    if (tokenAddress === ethers4.ZeroAddress) throw new Error(`Token ID ${tokenId} not found`);
+    const token = new ethers4.Contract(tokenAddress, ERC20_ABI, this.provider);
+    let sellAmount;
+    if (amount === "max") {
+      sellAmount = await token.balanceOf(wallet);
+    } else {
+      sellAmount = ethers4.parseUnits(amount, 18);
+    }
+    if (sellAmount === 0n) throw new Error("Zero balance");
+    if (!this.isArenaPaired(tokenId)) {
+      sellAmount = sellAmount / GRANULARITY_SCALER * GRANULARITY_SCALER;
+      if (sellAmount === 0n) throw new Error("Balance too small");
+    }
+    const spender = this.isArenaPaired(tokenId) ? ethers4.getAddress(AVAX_HELPER) : ethers4.getAddress(LAUNCH_CONTRACT);
+    const erc20Iface = new ethers4.Interface(ERC20_ABI);
+    const approveTx = { to: tokenAddress, data: erc20Iface.encodeFunctionData("approve", [spender, ethers4.MaxUint256]), value: "0", chainId: CHAIN_ID, gasLimit: "60000", description: "Approve token for selling" };
+    let sellData;
+    let sellTo;
+    if (!this.isArenaPaired(tokenId)) {
+      sellData = new ethers4.Interface(LAUNCH_CONTRACT_ABI).encodeFunctionData("sell", [sellAmount, id]);
+      sellTo = ethers4.getAddress(LAUNCH_CONTRACT);
+    } else {
+      let minOut = 0n;
+      try {
+        const reward = await contract.calculateRewardWithFees(sellAmount, id);
+        minOut = reward - reward * BigInt(slippageBps) / 10000n;
+      } catch {
+      }
+      sellData = new ethers4.Interface(AVAX_HELPER_ABI).encodeFunctionData("sellToAvax", [id, sellAmount, minOut]);
+      sellTo = ethers4.getAddress(AVAX_HELPER);
+    }
+    return { transactions: [approveTx, { to: sellTo, data: sellData, value: "0", chainId: CHAIN_ID, gasLimit: "500000", description: `Sell ${ethers4.formatUnits(sellAmount, 18)} tokens (ID ${tokenId})` }] };
+  }
+  /** Binary search for max tokens purchasable with given AVAX */
+  async binarySearchTokenAmount(avaxBudgetWei, tokenId) {
+    let maxForSale;
+    try {
+      maxForSale = await this.launchContract.getMaxTokensForSale(tokenId);
+    } catch {
+      maxForSale = 100000000n * GRANULARITY_SCALER;
+    }
+    const maxWhole = maxForSale / GRANULARITY_SCALER;
+    if (maxWhole <= 0n) return 0n;
+    let lo = 1n;
+    let hi = maxWhole;
+    let best = 0n;
+    for (let i = 0; i < 30 && lo <= hi; i++) {
+      const mid = (lo + hi) / 2n;
+      try {
+        const cost = await this.launchContract.calculateCostWithFees(mid, tokenId);
+        if (cost <= avaxBudgetWei) {
+          best = mid;
+          lo = mid + 1n;
+        } else {
+          hi = mid - 1n;
+        }
+      } catch {
+        hi = mid - 1n;
+      }
+    }
+    return best > 0n ? best * GRANULARITY_SCALER : 0n;
   }
 };
 
 // src/modules/dex.ts
+import { ethers as ethers5 } from "ethers";
+var KNOWN_TOKENS = {
+  AVAX: WAVAX,
+  WAVAX,
+  USDC: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+  "USDC.e": "0xA7D7079b0FEaD91F3e65f86E8915Cb59c1a4C664",
+  USDT: "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7",
+  "USDT.e": "0xc7198437980c041c805A1EDcbA50c1Ce5db95118",
+  JOE: "0x6e84a6216eA6dACC71eE8E6b0a5B7322EEbC0fDd",
+  ARENA: "0xB8d7710f7d8349A506b75dD184F05777c82dAd0C",
+  "BTC.b": "0x152b9d0FdC40C096DE20232Db5A0dF62B48dEeEB",
+  "WETH.e": "0x49D5c2BdFfac6CE2BFdB6640F4F80f226bc10bAB",
+  GMX: "0x62edc0692BD897D2295872a9FFCac5425011c661",
+  sAVAX: "0x2b2C81e08f1Af8835a78Bb2A90AE924ACE0eA4bE"
+};
 var DexModule = class {
-  constructor(http, auth) {
-    this.http = http;
-    this.auth = auth;
-  }
-  /**
-   * List all known tokens with addresses and decimals.
-   * You can also pass any contract address directly to other methods — not limited to this list.
-   */
-  async getTokens() {
-    await this.auth();
-    return this.http.get("/dex/tokens");
-  }
-  /**
-   * Get on-chain info for any token by contract address — name, symbol, decimals.
-   * @param address - Token contract address (0x...)
-   */
+  constructor(provider) {
+    this.provider = provider;
+    this.lbQuoter = new ethers5.Contract(ethers5.getAddress(LB_QUOTER), LB_QUOTER_ABI, provider);
+  }
+  lbQuoter;
+  /** Resolve token symbol or address to a checksummed address */
+  resolveToken(tokenOrAddress) {
+    const upper = tokenOrAddress.toUpperCase();
+    if (KNOWN_TOKENS[upper]) return ethers5.getAddress(KNOWN_TOKENS[upper]);
+    if (KNOWN_TOKENS[tokenOrAddress]) return ethers5.getAddress(KNOWN_TOKENS[tokenOrAddress]);
+    if (tokenOrAddress.startsWith("0x")) return ethers5.getAddress(tokenOrAddress);
+    throw new Error(`Unknown token: ${tokenOrAddress}. Use a symbol (AVAX, USDC, JOE, ARENA) or a 0x contract address.`);
+  }
+  /** List known tokens */
+  getTokens() {
+    const tokens = Object.entries(KNOWN_TOKENS).map(([symbol, address]) => ({ symbol, address }));
+    return { tokens, note: "You can also pass any ERC-20 contract address directly." };
+  }
+  /** Look up any ERC-20 token by address */
   async getTokenInfo(address) {
-    await this.auth();
-    return this.http.get("/dex/token-info", { address });
+    const addr = ethers5.getAddress(address);
+    const token = new ethers5.Contract(addr, ERC20_ABI, this.provider);
+    const [name, symbol, decimals] = await Promise.all([token.name(), token.symbol(), token.decimals()]);
+    return { address: addr, symbol, name, decimals: Number(decimals) };
+  }
+  /** Get balance of any token */
+  async getBalance(wallet, tokenOrAddress) {
+    const address = this.resolveToken(tokenOrAddress);
+    if (address.toLowerCase() === WAVAX.toLowerCase() && tokenOrAddress.toUpperCase() === "AVAX") {
+      const balance2 = await this.provider.getBalance(wallet);
+      return { wallet, token: "AVAX", balance: balance2.toString(), formatted: ethers5.formatEther(balance2), symbol: "AVAX" };
+    }
+    const token = new ethers5.Contract(address, ERC20_ABI, this.provider);
+    const [balance, symbol, decimals] = await Promise.all([token.balanceOf(wallet), token.symbol(), token.decimals()]);
+    return { wallet, token: address, balance: balance.toString(), formatted: ethers5.formatUnits(balance, decimals), symbol };
   }
-  /**
-   * Quote a swap between any two tokens on Avalanche.
-   * @param from - Source token symbol or contract address
-   * @param to - Destination token symbol or contract address
-   * @param amount - Amount of source token to swap
-   */
+  /** Quote a swap between any two tokens */
   async quote(from, to, amount) {
-    await this.auth();
-    return this.http.get("/dex/quote", { from, to, amount });
-  }
-  /**
-   * Get the balance of any token for a wallet.
-   * @param wallet - Wallet address
-   * @param token - Token symbol or contract address
-   */
-  async getBalance(wallet, token) {
-    await this.auth();
-    return this.http.get("/dex/balance", { wallet, token });
-  }
-  /**
-   * Build unsigned transaction(s) to swap any token pair on Avalanche via LFJ/Pharaoh DEX.
-   *
-   * May return multiple transactions (approve + swap). Execute in order.
-   *
-   * @param wallet - Your wallet address
-   * @param from - Source token symbol or contract address
-   * @param to - Destination token symbol or contract address
-   * @param amount - Amount to swap, or "max" for entire balance
-   * @param slippage - Slippage tolerance in basis points (default: 500 = 5%)
-   */
-  async buildSwap(wallet, from, to, amount, slippage) {
-    await this.auth();
-    return this.http.get("/dex/build/swap", { wallet, from, to, amount, slippage });
+    const fromAddr = this.resolveToken(from);
+    const toAddr = this.resolveToken(to);
+    const fromToken = new ethers5.Contract(fromAddr, ERC20_ABI, this.provider);
+    const decimals = fromAddr.toLowerCase() === WAVAX.toLowerCase() ? 18 : Number(await fromToken.decimals());
+    const amountIn = ethers5.parseUnits(amount, decimals);
+    const route = [fromAddr, toAddr];
+    const quoteResult = await this.lbQuoter.findBestPathFromAmountIn(route, amountIn);
+    const amountOut = quoteResult.amounts[quoteResult.amounts.length - 1];
+    const toToken = new ethers5.Contract(toAddr, ERC20_ABI, this.provider);
+    const toDecimals = toAddr.toLowerCase() === WAVAX.toLowerCase() ? 18 : Number(await toToken.decimals());
+    const outFormatted = ethers5.formatUnits(amountOut, toDecimals);
+    return {
+      from,
+      to,
+      amountIn: amount,
+      amountOut: outFormatted,
+      rate: (parseFloat(outFormatted) / parseFloat(amount)).toFixed(6),
+      path: route
+    };
+  }
+  /** Build swap transactions (1 tx for AVAX→token, 2 txs for token→token with approve) */
+  async buildSwap(wallet, from, to, amount, slippageBps = DEFAULT_SLIPPAGE_BPS) {
+    const fromAddr = this.resolveToken(from);
+    const toAddr = this.resolveToken(to);
+    const isFromNative = from.toUpperCase() === "AVAX";
+    const isToNative = to.toUpperCase() === "AVAX";
+    const fromToken = new ethers5.Contract(fromAddr, ERC20_ABI, this.provider);
+    const fromDecimals = isFromNative ? 18 : Number(await fromToken.decimals());
+    let amountIn;
+    if (amount === "max" && !isFromNative) {
+      amountIn = await fromToken.balanceOf(wallet);
+      if (amountIn === 0n) throw new Error("No balance to swap");
+    } else {
+      amountIn = ethers5.parseUnits(amount, fromDecimals);
+    }
+    const route = [fromAddr, toAddr];
+    const quoteResult = await this.lbQuoter.findBestPathFromAmountIn(route, amountIn);
+    const expectedOut = quoteResult.amounts[quoteResult.amounts.length - 1];
+    if (expectedOut === 0n) throw new Error("Quote returned zero \u2014 no liquidity for this pair");
+    const clampedSlippage = BigInt(Math.max(0, Math.min(1e4, Number(slippageBps))));
+    const amountOutMin = expectedOut - expectedOut * clampedSlippage / 10000n;
+    const deadline = Math.floor(Date.now() / 1e3) + 3600;
+    const path = {
+      pairBinSteps: [...quoteResult.binSteps].map((b) => b.toString()),
+      versions: [...quoteResult.versions].map((v) => Number(v)),
+      tokenPath: [...route]
+    };
+    const txs = [];
+    const routerIface = new ethers5.Interface(LB_ROUTER_ABI);
+    if (isFromNative) {
+      const data = routerIface.encodeFunctionData("swapExactNATIVEForTokens", [amountOutMin, path, wallet, deadline]);
+      txs.push({ to: ethers5.getAddress(LB_ROUTER), data, value: ethers5.toBeHex(amountIn, 32), chainId: CHAIN_ID, gasLimit: "500000", description: `Swap ${amount} AVAX \u2192 ${to}` });
+    } else if (isToNative) {
+      const erc20Iface = new ethers5.Interface(ERC20_ABI);
+      txs.push({
+        to: fromAddr,
+        data: erc20Iface.encodeFunctionData("approve", [ethers5.getAddress(LB_ROUTER), amountIn]),
+        value: "0",
+        chainId: CHAIN_ID,
+        gasLimit: "60000",
+        description: `Approve ${from} for swap`
+      });
+      const data = routerIface.encodeFunctionData("swapExactTokensForNATIVE", [amountIn, amountOutMin, path, wallet, deadline]);
+      txs.push({ to: ethers5.getAddress(LB_ROUTER), data, value: "0", chainId: CHAIN_ID, gasLimit: "500000", description: `Swap ${from} \u2192 AVAX` });
+    } else {
+      const erc20Iface = new ethers5.Interface(ERC20_ABI);
+      txs.push({
+        to: fromAddr,
+        data: erc20Iface.encodeFunctionData("approve", [ethers5.getAddress(LB_ROUTER), amountIn]),
+        value: "0",
+        chainId: CHAIN_ID,
+        gasLimit: "60000",
+        description: `Approve ${from} for swap`
+      });
+      throw new Error("Direct token\u2192token swaps not yet supported. Route through AVAX: swap TOKEN\u2192AVAX, then AVAX\u2192TOKEN.");
+    }
+    const toToken = new ethers5.Contract(toAddr, ERC20_ABI, this.provider);
+    const toDecimals = isToNative ? 18 : Number(await toToken.decimals());
+    return { transactions: txs, summary: `Swap ${amount} ${from} \u2192 ~${ethers5.formatUnits(expectedOut, toDecimals)} ${to}` };
   }
 };
 
 // src/modules/perps.ts
 var PerpsModule = class {
-  constructor(http, auth) {
-    this.http = http;
-    this.auth = auth;
+  constructor(arenaApiKey) {
+    this.arenaApiKey = arenaApiKey;
+  }
+  setArenaApiKey(key) {
+    this.arenaApiKey = key;
+  }
+  async arenaRequest(method, path, body, query) {
+    if (!this.arenaApiKey) throw new Error("Arena API key required for perps. Pass arenaApiKey in config.");
+    let url = `${ARENA_SOCIAL_API}${path}`;
+    if (query) {
+      const params = new URLSearchParams(query);
+      url += `?${params.toString()}`;
+    }
+    const headers = { "x-api-key": this.arenaApiKey, "Content-Type": "application/json" };
+    const res = await fetch(url, { method, headers, body: body ? JSON.stringify(body) : void 0 });
+    const data = await res.json();
+    if (!res.ok) {
+      throw new Error(data.message || data.error || `Arena perps error ${res.status}`);
+    }
+    return data;
   }
-  // ── Setup ──
-  /**
-   * Link your Arena API key to enable perps trading.
-   * One-time setup — after this, all /perp endpoints work automatically.
-   * @param arenaApiKey - Your Arena API key (from arena.social)
-   */
-  async setup(arenaApiKey) {
-    await this.auth();
-    return this.http.post("/perp/setup", { arenaApiKey });
+  async hlPost(body) {
+    const res = await fetch(HL_INFO, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
+    if (!res.ok) throw new Error(`Hyperliquid API error ${res.status}`);
+    return res.json();
   }
-  // ── Registration ──
-  /** Register for perps trading on Hyperliquid */
+  // ── Setup (via Arena API) ──
   async register() {
-    await this.auth();
-    return this.http.post("/perp/register", {});
+    return this.arenaRequest("POST", "/agents/perp/register", { provider: "HYPERLIQUID" });
   }
-  /** Check perps registration status */
   async getRegistrationStatus() {
-    await this.auth();
-    return this.http.get("/perp/registration-status");
+    return this.arenaRequest("GET", "/agents/perp/registration-status", void 0, { provider: "HYPERLIQUID" });
   }
-  /** Get your Hyperliquid API wallet address */
   async getWalletAddress() {
-    await this.auth();
-    return this.http.get("/perp/wallet-address");
+    return this.arenaRequest("GET", "/agents/perp/wallet-address", void 0, { provider: "HYPERLIQUID" });
   }
-  // ── Auth Flow ──
-  /** Check which auth steps are completed */
+  // ── Auth Flow (via Arena API — EIP-712 signing) ──
   async getAuthStatus() {
-    await this.auth();
-    return this.http.post("/perp/auth/status", {});
+    return this.arenaRequest("POST", "/agents/perp/auth/status", { provider: "HYPERLIQUID" });
   }
-  /**
-   * Get EIP-712 payload for an auth step.
-   * @param step - Auth step: "accept-terms", "approve-agent", "set-referrer", "approve-builder-fee"
-   * @param body - Optional body (accept-terms requires mainWalletAddress)
-   */
-  async getAuthPayload(step, body) {
-    await this.auth();
-    return this.http.post(`/perp/auth/${step}/payload`, body || {});
+  async getAuthPayload(step, mainWalletAddress) {
+    const body = { provider: "HYPERLIQUID" };
+    if (mainWalletAddress) body.mainWalletAddress = mainWalletAddress;
+    return this.arenaRequest("POST", `/agents/perp/auth/${step}/payload`, body);
   }
-  /**
-   * Submit signed EIP-712 payload for an auth step.
-   * @param step - Auth step
-   * @param body - Signed payload with signature and metadata
-   */
-  async submitAuthSignature(step, body) {
-    await this.auth();
-    return this.http.post(`/perp/auth/${step}/submit`, body);
+  async submitAuthSignature(step, signature, mainWalletAddress, metadata) {
+    return this.arenaRequest("POST", `/agents/perp/auth/${step}/submit`, { provider: "HYPERLIQUID", mainWalletAddress, signature, metadata });
   }
-  /** Enable HIP-3 abstraction (automated, no signature needed) */
   async enableHip3() {
-    await this.auth();
-    return this.http.post("/perp/auth/enable-hip3", {});
+    return this.arenaRequest("POST", "/agents/perp/auth/enable-hip3", { provider: "HYPERLIQUID" });
   }
-  // ── Market Data ──
-  /** Get all available perpetual trading pairs (250+ markets) */
+  // ── Market Data (direct Hyperliquid) ──
   async getTradingPairs() {
-    await this.auth();
-    return this.http.get("/perp/trading-pairs");
-  }
-  // ── Leverage ──
-  /**
-   * Update leverage for a market. Must be called before first order.
-   * @param symbol - Market symbol (e.g. "BTC", "ETH")
-   * @param leverage - Leverage multiplier (1-50 depending on market)
-   * @param leverageType - "cross" or "isolated"
-   */
+    const raw = await this.hlPost({ type: "metaAndAssetCtxs" });
+    const universe = raw[0].universe;
+    const pairs = universe.map((m, i) => ({
+      name: m.name,
+      symbol: m.name,
+      baseAssetId: i,
+      sizePrecision: m.szDecimals,
+      maxLeverage: m.maxLeverage,
+      isDelisted: false,
+      marginMode: m.onlyIsolated ? "isolated" : "cross"
+    }));
+    return { pairs, count: pairs.length };
+  }
+  // ── Trading (via Arena API — they hold the signing keys) ──
   async updateLeverage(symbol, leverage, leverageType = "cross") {
-    await this.auth();
-    return this.http.post("/perp/leverage/update", { symbol, leverage, leverageType });
+    return this.arenaRequest("POST", "/agents/perp/leverage/update", { provider: "HYPERLIQUID", symbol, leverage, leverageType });
   }
-  // ── Trading ──
-  /**
-   * Place one or more perpetual orders.
-   * @param orders - Array of order objects (see docs for BaseOrderParams)
-   */
   async placeOrder(orders) {
-    await this.auth();
-    return this.http.post("/perp/orders/place", { orders });
+    return this.arenaRequest("POST", "/agents/perp/orders/place", { provider: "HYPERLIQUID", orders });
   }
-  /**
-   * Cancel one or more open orders.
-   * @param cancels - Array of { assetIndex, oid }
-   */
   async cancelOrders(cancels) {
-    await this.auth();
-    return this.http.post("/perp/orders/cancel", { cancels });
+    return this.arenaRequest("POST", "/agents/perp/orders/cancel", { provider: "HYPERLIQUID", cancels });
   }
-  /**
-   * Modify an existing order.
-   * @param oid - Order ID to modify
-   * @param order - New order parameters
-   */
-  async modifyOrder(oid, order) {
-    await this.auth();
-    return this.http.post("/perp/orders/modify", { oid, order });
-  }
-  /**
-   * Close a position (convenience — creates reduce-only IOC with 10% slippage).
-   * @param symbol - Market symbol
-   * @param positionSide - "long" or "short"
-   * @param size - Position size to close
-   * @param currentPrice - Current market price
-   * @param closePercent - Percentage to close (default: 100)
-   */
   async closePosition(symbol, positionSide, size, currentPrice, closePercent = 100) {
-    await this.auth();
-    return this.http.post("/perp/orders/close-position", {
-      symbol,
-      positionSide,
-      size,
-      currentPrice,
-      closePercent
-    });
+    return this.arenaRequest("POST", "/agents/perp/orders/close-position", { provider: "HYPERLIQUID", symbol, positionSide, size, currentPrice, closePercent });
   }
-  // ── Account Data ──
-  /** Get open orders */
   async getOrders() {
-    await this.auth();
-    return this.http.get("/perp/orders");
+    return this.arenaRequest("GET", "/agents/perp/orders", void 0, { provider: "HYPERLIQUID" });
   }
-  /** Get trade execution history */
   async getTradeExecutions() {
-    await this.auth();
-    return this.http.get("/perp/trade-executions");
+    return this.arenaRequest("GET", "/agents/perp/trade-executions", void 0, { provider: "HYPERLIQUID" });
   }
-  /**
-   * Get positions and margin summary (queries Hyperliquid directly).
-   * @param wallet - Your Hyperliquid wallet address (from getWalletAddress)
-   */
+  // ── Positions (direct Hyperliquid — read-only, no auth needed) ──
   async getPositions(wallet) {
-    await this.auth();
-    return this.http.get("/perp/positions", { wallet });
+    return this.hlPost({ type: "clearinghouseState", user: wallet });
   }
-  /**
-   * Get open orders from Hyperliquid directly.
-   * @param wallet - Your Hyperliquid wallet address
-   */
   async getOpenOrders(wallet) {
-    await this.auth();
-    return this.http.get("/perp/open-orders", { wallet });
+    return this.hlPost({ type: "openOrders", user: wallet });
   }
 };
 
 // src/modules/bridge.ts
+var BRIDGE_CHAINS = {
+  ethereum: 1,
+  base: 8453,
+  arbitrum: 42161,
+  optimism: 10,
+  polygon: 137,
+  bsc: 56,
+  avalanche: 43114,
+  fantom: 250,
+  gnosis: 100,
+  zksync: 324,
+  linea: 59144,
+  scroll: 534352,
+  blast: 81457,
+  mantle: 5e3
+};
+var USDC = {
+  "1": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+  "42161": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+  "43114": "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+  "8453": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  "10": "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+  "137": "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"
+};
+var NATIVE_TOKEN = "0x0000000000000000000000000000000000000000";
 var BridgeModule = class {
-  constructor(http, auth) {
-    this.http = http;
-    this.auth = auth;
-  }
-  /**
-   * Get all supported chains for cross-chain bridging.
-   */
   async getChains() {
-    await this.auth();
-    return this.http.get("/bridge/chains");
+    const res = await fetch(`${LIFI_API}/chains`);
+    if (!res.ok) throw new Error(`Li.Fi chains failed (${res.status})`);
+    const data = await res.json();
+    return { chains: data.chains, count: data.chains.length };
   }
-  /**
-   * Get tokens available on specified chains.
-   * @param chains - Comma-separated chain IDs (e.g. "43114,42161")
-   */
   async getTokens(chains) {
-    await this.auth();
-    return this.http.get("/bridge/tokens", { chains });
+    const res = await fetch(`${LIFI_API}/tokens?chains=${chains}`);
+    if (!res.ok) throw new Error(`Li.Fi tokens failed (${res.status})`);
+    const data = await res.json();
+    return { tokens: data.tokens };
   }
-  /**
-   * Get info for a specific token on a chain.
-   * @param chainId - Chain ID
-   * @param address - Token contract address
-   */
   async getToken(chainId, address) {
-    await this.auth();
-    return this.http.get("/bridge/token", { chainId, address });
+    const res = await fetch(`${LIFI_API}/token?chain=${chainId}&token=${address}`);
+    if (!res.ok) throw new Error(`Li.Fi token failed (${res.status})`);
+    return await res.json();
   }
-  /**
-   * Get available bridge connections between two chains.
-   * @param fromChainId - Source chain ID
-   * @param toChainId - Destination chain ID
-   * @param fromToken - Optional source token address
-   * @param toToken - Optional destination token address
-   */
   async getConnections(fromChainId, toChainId, fromToken, toToken) {
-    await this.auth();
-    const params = { fromChainId, toChainId };
-    if (fromToken) params.fromToken = fromToken;
-    if (toToken) params.toToken = toToken;
-    return this.http.get("/bridge/connections", params);
+    const params = new URLSearchParams({ fromChain: fromChainId.toString(), toChain: toChainId.toString() });
+    if (fromToken) params.set("fromToken", fromToken);
+    if (toToken) params.set("toToken", toToken);
+    const res = await fetch(`${LIFI_API}/connections?${params}`);
+    if (!res.ok) throw new Error(`Li.Fi connections failed (${res.status})`);
+    const data = await res.json();
+    return { connections: data.connections };
   }
-  /**
-   * Get a bridge quote with unsigned transaction data.
-   * The agent signs the returned tx on the source chain.
-   *
-   * @param fromChainId - Source chain ID
-   * @param toChainId - Destination chain ID
-   * @param fromToken - Source token address (use 0x0000...0000 for native tokens)
-   * @param toToken - Destination token address
-   * @param fromAmount - Human-readable amount (e.g. "0.1")
-   * @param fromAddress - Sender wallet address
-   * @param toAddress - Optional receiver address (defaults to fromAddress)
-   * @param slippage - Slippage tolerance as decimal (default 0.03 = 3%)
-   * @param fromDecimals - Token decimals (default 18)
-   */
   async getQuote(fromChainId, toChainId, fromToken, toToken, fromAmount, fromAddress, toAddress, slippage, fromDecimals) {
-    await this.auth();
-    const params = { fromChainId, toChainId, fromToken, toToken, fromAmount, fromAddress };
-    if (toAddress) params.toAddress = toAddress;
-    if (slippage !== void 0) params.slippage = slippage;
-    if (fromDecimals !== void 0) params.fromDecimals = fromDecimals;
-    return this.http.get("/bridge/quote", params);
+    const decimals = fromDecimals ?? 18;
+    const amountWei = this.parseUnits(fromAmount, decimals);
+    const params = new URLSearchParams({
+      fromChain: fromChainId.toString(),
+      toChain: toChainId.toString(),
+      fromToken,
+      toToken,
+      fromAmount: amountWei,
+      fromAddress,
+      toAddress: toAddress ?? fromAddress,
+      slippage: (slippage ?? 0.03).toString(),
+      integrator: "logiqical"
+    });
+    const res = await fetch(`${LIFI_API}/quote?${params}`);
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Li.Fi quote failed (${res.status}): ${body}`);
+    }
+    return this.parseQuote(await res.json());
   }
-  /**
-   * Get multiple bridge route options.
-   */
   async getRoutes(fromChainId, toChainId, fromToken, toToken, fromAmount, fromAddress, toAddress, slippage, fromDecimals) {
-    await this.auth();
-    const params = { fromChainId, toChainId, fromToken, toToken, fromAmount, fromAddress };
-    if (toAddress) params.toAddress = toAddress;
-    if (slippage !== void 0) params.slippage = slippage;
-    if (fromDecimals !== void 0) params.fromDecimals = fromDecimals;
-    return this.http.get("/bridge/routes", params);
+    const decimals = fromDecimals ?? 18;
+    const amountWei = this.parseUnits(fromAmount, decimals);
+    const body = {
+      fromChainId,
+      toChainId,
+      fromTokenAddress: fromToken,
+      toTokenAddress: toToken,
+      fromAmount: amountWei,
+      fromAddress,
+      toAddress: toAddress ?? fromAddress,
+      options: { slippage: slippage ?? 0.03, integrator: "logiqical", order: "RECOMMENDED" }
+    };
+    const res = await fetch(`${LIFI_API}/advanced/routes`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
+    if (!res.ok) {
+      const b = await res.text().catch(() => "");
+      throw new Error(`Li.Fi routes failed (${res.status}): ${b}`);
+    }
+    const data = await res.json();
+    const routes = (data.routes ?? []).map((r) => this.parseRoute(r));
+    return { routes, count: routes.length };
   }
-  /**
-   * Check bridge transfer status.
-   * @param txHash - Source chain transaction hash
-   * @param fromChainId - Source chain ID
-   * @param toChainId - Destination chain ID
-   * @param bridge - Optional bridge tool name
-   */
   async getStatus(txHash, fromChainId, toChainId, bridge) {
-    await this.auth();
-    const params = { txHash, fromChainId, toChainId };
-    if (bridge) params.bridge = bridge;
-    return this.http.get("/bridge/status", params);
+    const params = new URLSearchParams({ txHash, fromChain: fromChainId.toString(), toChain: toChainId.toString() });
+    if (bridge) params.set("bridge", bridge);
+    const res = await fetch(`${LIFI_API}/status?${params}`);
+    if (!res.ok) throw new Error(`Li.Fi status failed (${res.status})`);
+    return await res.json();
+  }
+  getInfo() {
+    return { chains: BRIDGE_CHAINS, usdc: USDC, nativeToken: NATIVE_TOKEN, tip: "Use 0x0000...0000 for native tokens" };
+  }
+  parseUnits(amount, decimals) {
+    const parts = amount.split(".");
+    const whole = parts[0] || "0";
+    const frac = (parts[1] || "").slice(0, decimals).padEnd(decimals, "0");
+    return (BigInt(whole) * BigInt(10) ** BigInt(decimals) + BigInt(frac)).toString();
+  }
+  parseQuote(data) {
+    const action = data.action ?? {};
+    const estimate = data.estimate ?? {};
+    const txReq = data.transactionRequest;
+    const quote = {
+      id: data.id ?? data.tool ?? "unknown",
+      fromChainId: action.fromChainId ?? 0,
+      toChainId: action.toChainId ?? 0,
+      fromToken: action.fromToken?.address ?? "",
+      toToken: action.toToken?.address ?? "",
+      fromAmount: action.fromAmount ?? "0",
+      toAmount: estimate.toAmount ?? "0",
+      estimatedGas: estimate.gasCosts?.[0]?.amountUSD ?? "0",
+      estimatedTime: estimate.executionDuration ?? 0,
+      tool: data.tool ?? "unknown"
+    };
+    if (txReq) {
+      quote.transaction = { to: txReq.to, data: txReq.data, value: txReq.value ?? "0x0", gasLimit: txReq.gasLimit, chainId: txReq.chainId ?? action.fromChainId };
+    }
+    return quote;
+  }
+  parseRoute(route) {
+    const steps = route.steps ?? [];
+    const firstStep = steps[0] ?? {};
+    const action = firstStep.action ?? {};
+    const estimate = firstStep.estimate ?? {};
+    return {
+      id: route.id ?? "unknown",
+      fromChainId: route.fromChainId ?? 0,
+      toChainId: route.toChainId ?? 0,
+      fromToken: route.fromToken?.address ?? "",
+      toToken: route.toToken?.address ?? "",
+      fromAmount: route.fromAmount ?? "0",
+      toAmount: route.toAmount ?? "0",
+      estimatedGas: route.gasCostUSD ?? "0",
+      estimatedTime: steps.reduce((t, s) => t + (s.estimate?.executionDuration ?? 0), 0),
+      tool: firstStep.tool ?? "unknown"
+    };
   }
-  /**
-   * Get reference info — common chain IDs, USDC addresses, native token constant.
-   */
-  async getInfo() {
-    await this.auth();
-    return this.http.get("/bridge/info");
+};
+
+// src/modules/tickets.ts
+import { ethers as ethers6 } from "ethers";
+var TicketsModule = class {
+  constructor(provider) {
+    this.provider = provider;
+    this.contract = new ethers6.Contract(ethers6.getAddress(ARENA_SHARES_CONTRACT), SHARES_ABI, provider);
+  }
+  contract;
+  async getBuyPrice(subject, amount = "1") {
+    const fractionalAmount = this.ticketsToFractional(amount);
+    const subjectAddr = ethers6.getAddress(subject);
+    const [price, priceWithFee] = await Promise.all([
+      this.contract.getBuyPriceForFractionalShares(subjectAddr, fractionalAmount),
+      this.contract.getBuyPriceForFractionalSharesAfterFee(subjectAddr, fractionalAmount)
+    ]);
+    return { price: ethers6.formatEther(price), priceWithFee: ethers6.formatEther(priceWithFee), tickets: amount, fractionalAmount };
+  }
+  async getSellPrice(subject, amount = "1") {
+    const fractionalAmount = this.ticketsToFractional(amount);
+    const subjectAddr = ethers6.getAddress(subject);
+    const [price, priceAfterFee] = await Promise.all([
+      this.contract.getSellPriceForFractionalShares(subjectAddr, fractionalAmount),
+      this.contract.getSellPriceForFractionalSharesAfterFee(subjectAddr, fractionalAmount)
+    ]);
+    return { price: ethers6.formatEther(price), priceAfterFee: ethers6.formatEther(priceAfterFee), tickets: amount, fractionalAmount };
+  }
+  async getBalance(subject, user) {
+    const frac = await this.contract.getMyFractionalShares(ethers6.getAddress(subject), ethers6.getAddress(user));
+    return { tickets: (Number(frac) / FRACTION_SCALER).toString(), fractionalAmount: frac.toString() };
+  }
+  async getSupply(subject) {
+    const subjectAddr = ethers6.getAddress(subject);
+    const [wholeSupply, fracSupply] = await Promise.all([
+      this.contract.getSharesSupply(subjectAddr),
+      this.contract.getTotalFractionalSupply(subjectAddr)
+    ]);
+    return { wholeSupply: wholeSupply.toString(), fractionalSupply: fracSupply.toString(), tickets: (Number(fracSupply) / FRACTION_SCALER).toString() };
+  }
+  async getFees() {
+    const [protocol, subject, referral] = await Promise.all([
+      this.contract.protocolFeePercent(),
+      this.contract.subjectFeePercent(),
+      this.contract.referralFeePercent()
+    ]);
+    const toPercent = (v) => (Number(v) / 1e16).toFixed(1) + "%";
+    return { protocolFee: toPercent(protocol), subjectFee: toPercent(subject), referralFee: toPercent(referral), totalFeePercent: toPercent(protocol + subject + referral) };
+  }
+  async buildBuyTx(wallet, subject, amount = "1") {
+    const fractionalAmount = this.ticketsToFractional(amount);
+    const subjectAddr = ethers6.getAddress(subject);
+    const userAddr = ethers6.getAddress(wallet);
+    const cost = await this.contract.getBuyPriceForFractionalSharesAfterFee(subjectAddr, fractionalAmount);
+    if (cost === 0n) throw new Error("Could not get buy price \u2014 subject may not exist");
+    const iface = new ethers6.Interface(SHARES_ABI);
+    const data = iface.encodeFunctionData("buyFractionalShares", [subjectAddr, userAddr, fractionalAmount]);
+    return {
+      transaction: {
+        to: ethers6.getAddress(ARENA_SHARES_CONTRACT),
+        data,
+        value: ethers6.toBeHex(cost, 32),
+        chainId: CHAIN_ID,
+        gasLimit: "200000",
+        description: `Buy ${amount} ticket(s) for ~${ethers6.formatEther(cost)} AVAX`
+      }
+    };
+  }
+  async buildSellTx(wallet, subject, amount = "1") {
+    const fractionalAmount = this.ticketsToFractional(amount);
+    const subjectAddr = ethers6.getAddress(subject);
+    const userAddr = ethers6.getAddress(wallet);
+    const balance = await this.contract.getMyFractionalShares(subjectAddr, userAddr);
+    if (balance < BigInt(fractionalAmount)) {
+      throw new Error(`Insufficient tickets: have ${Number(balance) / FRACTION_SCALER}, trying to sell ${amount}`);
+    }
+    const proceeds = await this.contract.getSellPriceForFractionalSharesAfterFee(subjectAddr, fractionalAmount);
+    const iface = new ethers6.Interface(SHARES_ABI);
+    const data = iface.encodeFunctionData("sellFractionalShares", [subjectAddr, userAddr, fractionalAmount]);
+    return {
+      transaction: {
+        to: ethers6.getAddress(ARENA_SHARES_CONTRACT),
+        data,
+        value: "0x0",
+        chainId: CHAIN_ID,
+        gasLimit: "200000",
+        description: `Sell ${amount} ticket(s) for ~${ethers6.formatEther(proceeds)} AVAX`
+      }
+    };
+  }
+  ticketsToFractional(tickets) {
+    const num = parseFloat(tickets);
+    if (isNaN(num) || num <= 0) throw new Error(`Invalid ticket amount: ${tickets}`);
+    return Math.round(num * FRACTION_SCALER);
+  }
+};
+
+// src/modules/social.ts
+var SocialModule = class {
+  constructor(arenaApiKey) {
+    this.arenaApiKey = arenaApiKey;
+  }
+  setArenaApiKey(key) {
+    this.arenaApiKey = key;
+  }
+  async request(method, path, body, query) {
+    if (!this.arenaApiKey) throw new Error("Arena API key required for social endpoints. Pass arenaApiKey in config.");
+    let url = `${ARENA_SOCIAL_API}${path}`;
+    if (query) {
+      const params = new URLSearchParams(query);
+      url += `?${params.toString()}`;
+    }
+    const headers = { "x-api-key": this.arenaApiKey, "Content-Type": "application/json" };
+    const res = await fetch(url, { method, headers, body: body ? JSON.stringify(body) : void 0 });
+    const data = await res.json();
+    if (!res.ok) {
+      const msg = data.message || data.error || `Arena API error ${res.status}`;
+      throw new Error(msg);
+    }
+    return data;
+  }
+  // ── User Discovery ──
+  async searchUsers(q, page = 1, pageSize = 20) {
+    return this.request("GET", "/agents/user/search", void 0, { searchString: q, page: String(page), pageSize: String(pageSize) });
+  }
+  async getUserByHandle(handle) {
+    return this.request("GET", "/agents/user/handle", void 0, { handle });
+  }
+  async getUserById(userId) {
+    return this.request("GET", "/agents/user/id", void 0, { userId });
+  }
+  async getTopUsers(page = 1, pageSize = 20) {
+    return this.request("GET", "/agents/user/top", void 0, { page: String(page), pageSize: String(pageSize) });
+  }
+  async getMe() {
+    return this.request("GET", "/agents/user/me");
+  }
+  // ── Profile ──
+  async updateProfile(updates) {
+    return this.request("PATCH", "/agents/user/profile", updates);
+  }
+  async updateBanner(bannerUrl) {
+    return this.request("POST", "/agents/profile/banner", { bannerUrl });
+  }
+  // ── Follow ──
+  async follow(userId) {
+    return this.request("POST", "/agents/follow/follow", { userId });
+  }
+  async unfollow(userId) {
+    return this.request("POST", "/agents/follow/unfollow", { userId });
+  }
+  async getFollowers(userId, page = 1, pageSize = 20) {
+    return this.request("GET", "/agents/follow/followers/list", void 0, { followersOfUserId: userId, pageNumber: String(page), pageSize: String(pageSize) });
+  }
+  async getFollowing(userId, page = 1, pageSize = 20) {
+    return this.request("GET", "/agents/follow/following/list", void 0, { followingUserId: userId, pageNumber: String(page), pageSize: String(pageSize) });
+  }
+  // ── Shares ──
+  async getSharesStats(userId) {
+    return this.request("GET", "/agents/shares/stats", void 0, { userId });
+  }
+  async getShareHolders(userId, page = 1, pageSize = 20) {
+    const q = { page: String(page), pageSize: String(pageSize) };
+    if (userId) q.userId = userId;
+    return this.request("GET", "/agents/shares/holders", void 0, q);
+  }
+  async getHoldings(page = 1, pageSize = 20) {
+    return this.request("GET", "/agents/shares/holdings", void 0, { page: String(page), pageSize: String(pageSize) });
+  }
+  // ── Chat: Conversations ──
+  async getConversations(page = 1) {
+    return this.request("GET", "/agents/chat/conversations", void 0, { page: String(page), pageSize: "20" });
+  }
+  async getDirectMessages() {
+    return this.request("GET", "/agents/chat/direct-messages", void 0, { page: "1", pageSize: "20" });
+  }
+  async getGroupChats() {
+    return this.request("GET", "/agents/chat/project-chats", void 0, { page: "1", pageSize: "20" });
+  }
+  async getGroup(groupId) {
+    return this.request("GET", "/agents/chat/group", void 0, { groupId });
+  }
+  async getMembers(groupId) {
+    return this.request("GET", "/agents/chat/members", void 0, { groupId, page: "1", pageSize: "20" });
+  }
+  async getOrCreateDM(userId) {
+    return this.request("GET", "/agents/chat/group/by/user", void 0, { userId });
+  }
+  async acceptChat(groupId) {
+    return this.request("GET", "/agents/chat/accept-chat", void 0, { groupId });
+  }
+  // ── Chat: Messages ──
+  async sendMessage(groupId, text, replyId) {
+    const body = { groupId, text, files: [] };
+    if (replyId) body.replyId = replyId;
+    return this.request("POST", "/agents/chat/message", body);
+  }
+  async getMessages(groupId, after) {
+    const q = { groupId };
+    if (after) q.timeFrom = after;
+    return this.request("GET", "/agents/chat/messages/a", void 0, q);
+  }
+  async searchMessages(q, groupId) {
+    const query = { searchQuery: q, limit: "20" };
+    if (groupId) query.groupId = groupId;
+    return this.request("GET", "/agents/chat/messages/search", void 0, query);
+  }
+  async getMentions(groupId) {
+    const q = { limit: "50" };
+    if (groupId) q.groupId = groupId;
+    return this.request("GET", "/agents/chat/messages/mentions", void 0, q);
+  }
+  // ── Chat: Reactions & Pins ──
+  async react(messageId, groupId, reaction) {
+    return this.request("POST", "/agents/chat/react", { messageId, groupId, reaction });
+  }
+  async pinMessage(messageId, groupId, isPinned = true) {
+    return this.request("POST", "/agents/chat/message/pin", { messageId, groupId, isPinned });
+  }
+  async getPinnedMessages(groupId) {
+    return this.request("GET", `/agents/chat/messages/pinned/${groupId}`);
+  }
+  // ── Threads ──
+  async createThread(content, replyToId) {
+    const body = { content };
+    if (replyToId) body.replyToId = replyToId;
+    return this.request("POST", "/agents/threads", body);
+  }
+  async likeThread(threadId) {
+    return this.request("POST", "/agents/threads/like", { threadId });
+  }
+  async repost(threadId) {
+    return this.request("POST", "/agents/threads/repost", { threadId });
+  }
+};
+
+// src/modules/signals.ts
+var SignalsModule = class {
+  assetCache = null;
+  candleCache = /* @__PURE__ */ new Map();
+  async hlPost(body) {
+    const res = await fetch(HL_INFO, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
+    if (!res.ok) throw new Error(`Hyperliquid API error ${res.status}`);
+    return res.json();
+  }
+  /** Get all asset contexts (cached 10s) */
+  async getAssetContexts() {
+    if (this.assetCache && Date.now() - this.assetCache.ts < 1e4) return this.assetCache.data;
+    const raw = await this.hlPost({ type: "metaAndAssetCtxs" });
+    const result = { meta: raw[0].universe, contexts: raw[1] };
+    this.assetCache = { data: result, ts: Date.now() };
+    return result;
+  }
+  /** Get market signal for a specific asset */
+  async getMarketSignal(coin) {
+    const { meta, contexts } = await this.getAssetContexts();
+    const idx = meta.findIndex((m2) => m2.name.toUpperCase() === coin.toUpperCase());
+    if (idx === -1) throw new Error(`Asset ${coin} not found on Hyperliquid`);
+    const m = meta[idx];
+    const ctx = contexts[idx];
+    const price = parseFloat(ctx.markPx);
+    const prevPrice = parseFloat(ctx.prevDayPx);
+    const funding = parseFloat(ctx.funding);
+    const change24h = price - prevPrice;
+    const change24hPct = prevPrice > 0 ? change24h / prevPrice * 100 : 0;
+    let fundingBias = "neutral";
+    if (funding > 1e-4) fundingBias = "long-heavy";
+    else if (funding < -1e-4) fundingBias = "short-heavy";
+    return {
+      coin: m.name,
+      price,
+      oraclePrice: parseFloat(ctx.oraclePx),
+      change24h,
+      change24hPct: Math.round(change24hPct * 100) / 100,
+      volume24h: Math.round(parseFloat(ctx.dayNtlVlm)),
+      openInterest: Math.round(parseFloat(ctx.openInterest)),
+      fundingRate: funding,
+      fundingAnnualized: Math.round(funding * 8760 * 1e4) / 100,
+      fundingBias,
+      maxLeverage: m.maxLeverage
+    };
+  }
+  /** Get funding rate extremes across all markets */
+  async getFundingExtremes(count = 10) {
+    const { meta, contexts } = await this.getAssetContexts();
+    const signals = meta.map((m, i) => this.buildSignal(m, contexts[i]));
+    const sorted = [...signals].sort((a, b) => b.fundingRate - a.fundingRate);
+    return { mostPositive: sorted.slice(0, count), mostNegative: sorted.slice(-count).reverse() };
+  }
+  /** Get candle data for technical analysis (cached 60s) */
+  async getCandles(coin, interval = "1h", count = 100) {
+    const cacheKey = `${coin}-${interval}`;
+    const cached = this.candleCache.get(cacheKey);
+    if (cached && Date.now() - cached.ts < 6e4) return cached.data.slice(-count);
+    const startTime = Date.now() - count * this.intervalToMs(interval);
+    const data = await this.hlPost({ type: "candleSnapshot", req: { coin: coin.toUpperCase(), interval, startTime, endTime: Date.now() } });
+    const candles = data.map((c) => [c.t, parseFloat(c.o), parseFloat(c.h), parseFloat(c.l), parseFloat(c.c), parseFloat(c.v)]);
+    this.candleCache.set(cacheKey, { data: candles, ts: Date.now() });
+    return candles.slice(-count);
+  }
+  /** Compute technical signals from candle data */
+  async getTechnicalSignal(coin, interval = "1h") {
+    const candles = await this.getCandles(coin, interval, 100);
+    const closes = candles.map((c) => c[4]);
+    const highs = candles.map((c) => c[2]);
+    const lows = candles.map((c) => c[3]);
+    const price = closes[closes.length - 1];
+    const sma20 = this.sma(closes, 20);
+    const sma50 = this.sma(closes, 50);
+    const rsi14 = this.rsi(closes, 14);
+    let trend = "neutral";
+    if (price > sma20 && price > sma50) trend = "bullish";
+    else if (price < sma20 && price < sma50) trend = "bearish";
+    let momentum = "moderate";
+    if (rsi14 > 70 || rsi14 < 30) momentum = "strong";
+    else if (rsi14 > 60 || rsi14 < 40) momentum = "moderate";
+    else momentum = "weak";
+    const returns = closes.slice(-21).map((c, i, arr) => i === 0 ? 0 : (c - arr[i - 1]) / arr[i - 1]);
+    returns.shift();
+    const volatility = Math.sqrt(returns.reduce((sum, r) => sum + r * r, 0) / returns.length) * 100;
+    const resistance = Math.max(...highs.slice(-20));
+    const support = Math.min(...lows.slice(-20));
+    return {
+      coin: coin.toUpperCase(),
+      price,
+      sma20: Math.round(sma20 * 100) / 100,
+      sma50: Math.round(sma50 * 100) / 100,
+      rsi14: Math.round(rsi14 * 100) / 100,
+      trend,
+      momentum,
+      priceVsSma20: Math.round((price - sma20) / sma20 * 1e4) / 100,
+      priceVsSma50: Math.round((price - sma50) / sma50 * 1e4) / 100,
+      volatility: Math.round(volatility * 100) / 100,
+      support: Math.round(support * 100) / 100,
+      resistance: Math.round(resistance * 100) / 100
+    };
+  }
+  /** Get whale positions from orderbook depth */
+  async getWhalePositions(coin, minPositionUsd = 1e5) {
+    const book = await this.hlPost({ type: "l2Book", coin: coin.toUpperCase() });
+    const whales = [];
+    for (const level of book.levels[0] ?? []) {
+      const px = parseFloat(level.px);
+      const sz = parseFloat(level.sz);
+      const value = px * sz;
+      if (value >= minPositionUsd) whales.push({ coin: coin.toUpperCase(), size: sz, entryPrice: px, side: "long", positionValue: Math.round(value) });
+    }
+    for (const level of book.levels[1] ?? []) {
+      const px = parseFloat(level.px);
+      const sz = parseFloat(level.sz);
+      const value = px * sz;
+      if (value >= minPositionUsd) whales.push({ coin: coin.toUpperCase(), size: sz, entryPrice: px, side: "short", positionValue: Math.round(value) });
+    }
+    return whales.sort((a, b) => b.positionValue - a.positionValue);
+  }
+  /** Full signal summary — everything an agent needs to decide */
+  async summary(coin) {
+    const [market, technical, whalePositions] = await Promise.all([
+      this.getMarketSignal(coin),
+      this.getTechnicalSignal(coin),
+      this.getWhalePositions(coin)
+    ]);
+    const topLongs = whalePositions.filter((w) => w.side === "long").slice(0, 5);
+    const topShorts = whalePositions.filter((w) => w.side === "short").slice(0, 5);
+    const longValue = topLongs.reduce((s, w) => s + w.positionValue, 0);
+    const shortValue = topShorts.reduce((s, w) => s + w.positionValue, 0);
+    let netBias = "neutral";
+    if (longValue > shortValue * 1.3) netBias = "long";
+    else if (shortValue > longValue * 1.3) netBias = "short";
+    const reasons = [];
+    let longScore = 0;
+    let shortScore = 0;
+    if (technical.trend === "bullish") {
+      longScore += 2;
+      reasons.push("Price above SMA20 & SMA50 (bullish trend)");
+    } else if (technical.trend === "bearish") {
+      shortScore += 2;
+      reasons.push("Price below SMA20 & SMA50 (bearish trend)");
+    }
+    if (technical.rsi14 < 30) {
+      longScore += 2;
+      reasons.push(`RSI ${technical.rsi14} \u2014 oversold`);
+    } else if (technical.rsi14 > 70) {
+      shortScore += 2;
+      reasons.push(`RSI ${technical.rsi14} \u2014 overbought`);
+    }
+    if (market.fundingBias === "long-heavy") {
+      shortScore += 1;
+      reasons.push("Crowded long \u2014 contrarian short signal");
+    } else if (market.fundingBias === "short-heavy") {
+      longScore += 1;
+      reasons.push("Crowded short \u2014 contrarian long signal");
+    }
+    if (netBias === "long") {
+      longScore += 1;
+      reasons.push("Whale bias: more large bids");
+    } else if (netBias === "short") {
+      shortScore += 1;
+      reasons.push("Whale bias: more large asks");
+    }
+    if (market.change24hPct > 3) {
+      longScore += 1;
+      reasons.push(`+${market.change24hPct}% momentum`);
+    } else if (market.change24hPct < -3) {
+      shortScore += 1;
+      reasons.push(`${market.change24hPct}% selling`);
+    }
+    const diff = Math.abs(longScore - shortScore);
+    let direction = "wait";
+    let confidence = "low";
+    if (diff >= 4) {
+      direction = longScore > shortScore ? "long" : "short";
+      confidence = "high";
+    } else if (diff >= 2) {
+      direction = longScore > shortScore ? "long" : "short";
+      confidence = "medium";
+    } else {
+      reasons.push("Mixed signals \u2014 wait for better setup.");
+    }
+    return {
+      coin: coin.toUpperCase(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      market,
+      technical,
+      whaleActivity: { topLongs, topShorts, netBias, largestPosition: whalePositions[0] ?? null },
+      verdict: { direction, confidence, reasons }
+    };
+  }
+  /** Scan for top trading opportunities */
+  async scan(count = 5) {
+    const [movers, funding] = await Promise.all([this.getTopMovers(10), this.getFundingExtremes(10)]);
+    const candidates = /* @__PURE__ */ new Set(["BTC", "ETH", "SOL"]);
+    movers.gainers.slice(0, 3).forEach((s) => candidates.add(s.coin));
+    movers.losers.slice(0, 3).forEach((s) => candidates.add(s.coin));
+    funding.mostPositive.slice(0, 2).forEach((s) => candidates.add(s.coin));
+    funding.mostNegative.slice(0, 2).forEach((s) => candidates.add(s.coin));
+    const summaries = await Promise.all(Array.from(candidates).slice(0, 15).map((c) => this.summary(c).catch(() => null)));
+    const valid = summaries.filter((s) => s !== null && s.verdict.direction !== "wait");
+    const order = { high: 3, medium: 2, low: 1 };
+    valid.sort((a, b) => order[b.verdict.confidence] - order[a.verdict.confidence]);
+    return valid.slice(0, count);
+  }
+  async getTopMovers(count) {
+    const { meta, contexts } = await this.getAssetContexts();
+    const signals = meta.map((m, i) => this.buildSignal(m, contexts[i]));
+    const sorted = [...signals].sort((a, b) => b.change24hPct - a.change24hPct);
+    return { gainers: sorted.slice(0, count), losers: sorted.slice(-count).reverse() };
+  }
+  buildSignal(m, ctx) {
+    const price = parseFloat(ctx.markPx);
+    const prevPrice = parseFloat(ctx.prevDayPx);
+    const funding = parseFloat(ctx.funding);
+    const change24hPct = prevPrice > 0 ? (price - prevPrice) / prevPrice * 100 : 0;
+    let fundingBias = "neutral";
+    if (funding > 1e-4) fundingBias = "long-heavy";
+    else if (funding < -1e-4) fundingBias = "short-heavy";
+    return {
+      coin: m.name,
+      price,
+      oraclePrice: parseFloat(ctx.oraclePx),
+      change24h: price - prevPrice,
+      change24hPct: Math.round(change24hPct * 100) / 100,
+      volume24h: Math.round(parseFloat(ctx.dayNtlVlm)),
+      openInterest: Math.round(parseFloat(ctx.openInterest)),
+      fundingRate: funding,
+      fundingAnnualized: Math.round(funding * 8760 * 1e4) / 100,
+      fundingBias,
+      maxLeverage: m.maxLeverage
+    };
+  }
+  sma(data, period) {
+    const s = data.slice(-period);
+    return s.reduce((sum, v) => sum + v, 0) / s.length;
+  }
+  rsi(closes, period) {
+    const changes = closes.slice(-period - 1).map((c, i, arr) => i === 0 ? 0 : c - arr[i - 1]);
+    changes.shift();
+    let avgGain = 0;
+    let avgLoss = 0;
+    for (const ch of changes) {
+      if (ch > 0) avgGain += ch;
+      else avgLoss += Math.abs(ch);
+    }
+    avgGain /= period;
+    avgLoss /= period;
+    if (avgLoss === 0) return 100;
+    return 100 - 100 / (1 + avgGain / avgLoss);
+  }
+  intervalToMs(interval) {
+    const map = { "1m": 6e4, "5m": 3e5, "15m": 9e5, "1h": 36e5, "4h": 144e5, "1d": 864e5 };
+    return map[interval] ?? 36e5;
+  }
+};
+
+// src/modules/market.ts
+var COINGECKO_API = "https://api.coingecko.com/api/v3";
+var MarketModule = class {
+  /** Get prices for one or more coins (by CoinGecko ID) */
+  async price(ids) {
+    const idStr = Array.isArray(ids) ? ids.join(",") : ids;
+    const res = await fetch(`${COINGECKO_API}/simple/price?ids=${idStr}&vs_currencies=usd&include_24hr_change=true&include_market_cap=true&include_24hr_vol=true`);
+    if (!res.ok) throw new Error(`CoinGecko price error ${res.status}`);
+    return res.json();
+  }
+  /** Get trending coins */
+  async trending() {
+    const res = await fetch(`${COINGECKO_API}/search/trending`);
+    if (!res.ok) throw new Error(`CoinGecko trending error ${res.status}`);
+    const data = await res.json();
+    const coins = (data.coins ?? []).map((c) => ({
+      id: c.item.id,
+      name: c.item.name,
+      symbol: c.item.symbol,
+      market_cap_rank: c.item.market_cap_rank,
+      thumb: c.item.thumb,
+      price_btc: c.item.price_btc
+    }));
+    return { coins };
+  }
+  /** Get top coins by market cap */
+  async markets(count = 20, page = 1) {
+    const res = await fetch(`${COINGECKO_API}/coins/markets?vs_currency=usd&order=market_cap_desc&per_page=${count}&page=${page}&sparkline=false`);
+    if (!res.ok) throw new Error(`CoinGecko markets error ${res.status}`);
+    const data = await res.json();
+    const coins = data.map((c) => ({
+      id: c.id,
+      symbol: c.symbol,
+      name: c.name,
+      current_price: c.current_price,
+      market_cap: c.market_cap,
+      price_change_percentage_24h: c.price_change_percentage_24h,
+      total_volume: c.total_volume,
+      market_cap_rank: c.market_cap_rank
+    }));
+    return { coins };
+  }
+  /** Search for coins by query */
+  async search(query) {
+    const res = await fetch(`${COINGECKO_API}/search?query=${encodeURIComponent(query)}`);
+    if (!res.ok) throw new Error(`CoinGecko search error ${res.status}`);
+    const data = await res.json();
+    return { coins: (data.coins ?? []).map((c) => ({ id: c.id, name: c.name, symbol: c.symbol, market_cap_rank: c.market_cap_rank })) };
+  }
+  /** Get AVAX price specifically */
+  async avaxPrice() {
+    const data = await this.price("avalanche-2");
+    const avax = data["avalanche-2"];
+    return { usd: avax?.usd ?? 0, change24h: avax?.usd_24h_change ?? 0 };
+  }
+  /** Get ARENA price specifically */
+  async arenaPrice() {
+    const data = await this.price("arena-social");
+    const arena = data["arena-social"];
+    return { usd: arena?.usd ?? 0, change24h: arena?.usd_24h_change ?? 0 };
+  }
+};
+
+// src/modules/defi.ts
+import { ethers as ethers7 } from "ethers";
+var SAVAX_ADDRESS = "0x2b2C81e08f1Af8835a78Bb2A90AE924ACE0eA4bE";
+var SAVAX_ABI = [
+  "function submit() payable returns (uint256)",
+  "function requestUnlock(uint256 shareAmount) returns (uint256)",
+  "function getPooledAvaxByShares(uint256 shareAmount) view returns (uint256)",
+  "function getSharesByPooledAvax(uint256 avaxAmount) view returns (uint256)",
+  "function totalPooledAvax() view returns (uint256)",
+  "function totalShares() view returns (uint256)",
+  "function balanceOf(address) view returns (uint256)",
+  "function cooldownPeriod() view returns (uint256)",
+  "function exchangeRate() view returns (uint256)",
+  "function approve(address,uint256) returns (bool)"
+];
+var VAULT_ABI = [
+  "function asset() view returns (address)",
+  "function totalAssets() view returns (uint256)",
+  "function totalSupply() view returns (uint256)",
+  "function balanceOf(address) view returns (uint256)",
+  "function convertToShares(uint256 assets) view returns (uint256)",
+  "function convertToAssets(uint256 shares) view returns (uint256)",
+  "function maxDeposit(address) view returns (uint256)",
+  "function maxWithdraw(address) view returns (uint256)",
+  "function previewDeposit(uint256 assets) view returns (uint256)",
+  "function previewWithdraw(uint256 assets) view returns (uint256)",
+  "function deposit(uint256 assets, address receiver) returns (uint256)",
+  "function withdraw(uint256 assets, address receiver, address owner) returns (uint256)",
+  "function decimals() view returns (uint8)",
+  "function symbol() view returns (string)",
+  "function name() view returns (string)"
+];
+var ERC20_ABI2 = [
+  "function balanceOf(address) view returns (uint256)",
+  "function approve(address,uint256) returns (bool)",
+  "function allowance(address,address) view returns (uint256)",
+  "function decimals() view returns (uint8)",
+  "function symbol() view returns (string)"
+];
+var DefiModule = class {
+  constructor(provider) {
+    this.provider = provider;
+    this.savax = new ethers7.Contract(ethers7.getAddress(SAVAX_ADDRESS), SAVAX_ABI, provider);
+  }
+  savax;
+  // ── sAVAX Liquid Staking ──
+  /** Get sAVAX staking info: exchange rate, total staked, your balance */
+  async sAvaxInfo(wallet) {
+    const [totalPooled, totalShares] = await Promise.all([
+      this.savax.totalPooledAvax(),
+      this.savax.totalShares()
+    ]);
+    const exchangeRate = totalShares > 0n ? ethers7.formatEther(totalPooled * ethers7.parseEther("1") / totalShares) : "1.0";
+    const result = {
+      exchangeRate,
+      totalPooledAvax: ethers7.formatEther(totalPooled),
+      totalShares: ethers7.formatEther(totalShares)
+    };
+    if (wallet) {
+      const balance = await this.savax.balanceOf(wallet);
+      const avaxValue = await this.savax.getPooledAvaxByShares(balance);
+      result.balance = ethers7.formatEther(balance);
+      result.balanceInAvax = ethers7.formatEther(avaxValue);
+    }
+    return result;
+  }
+  /** Quote: how much sAVAX for staking AVAX */
+  async sAvaxStakeQuote(avaxAmount) {
+    const avaxWei = ethers7.parseEther(avaxAmount);
+    const shares = await this.savax.getSharesByPooledAvax(avaxWei);
+    return { avaxIn: avaxAmount, savaxOut: ethers7.formatEther(shares) };
+  }
+  /** Build tx to stake AVAX → sAVAX */
+  async buildSAvaxStake(avaxAmount) {
+    const avaxWei = ethers7.parseEther(avaxAmount);
+    const iface = new ethers7.Interface(SAVAX_ABI);
+    const data = iface.encodeFunctionData("submit", []);
+    return {
+      transactions: [{
+        to: ethers7.getAddress(SAVAX_ADDRESS),
+        data,
+        value: ethers7.toBeHex(avaxWei, 32),
+        chainId: CHAIN_ID,
+        gasLimit: "300000",
+        description: `Stake ${avaxAmount} AVAX \u2192 sAVAX`
+      }]
+    };
+  }
+  /** Build tx to request unstake sAVAX → AVAX (delayed) */
+  async buildSAvaxUnstake(wallet, amount) {
+    let shareAmount;
+    if (amount === "max") {
+      shareAmount = await this.savax.balanceOf(wallet);
+    } else {
+      shareAmount = ethers7.parseEther(amount);
+    }
+    if (shareAmount === 0n) throw new Error("Zero sAVAX balance");
+    const iface = new ethers7.Interface(SAVAX_ABI);
+    const data = iface.encodeFunctionData("requestUnlock", [shareAmount]);
+    return {
+      transactions: [{
+        to: ethers7.getAddress(SAVAX_ADDRESS),
+        data,
+        value: "0",
+        chainId: CHAIN_ID,
+        gasLimit: "300000",
+        description: `Request unstake ${ethers7.formatEther(shareAmount)} sAVAX`
+      }]
+    };
+  }
+  // ── ERC-4626 Vaults ──
+  /** Get info about any ERC-4626 vault */
+  async vaultInfo(vaultAddress, wallet) {
+    const vault = new ethers7.Contract(ethers7.getAddress(vaultAddress), VAULT_ABI, this.provider);
+    const [name, symbol, asset, totalAssets, totalSupply, decimals] = await Promise.all([
+      vault.name(),
+      vault.symbol(),
+      vault.asset(),
+      vault.totalAssets(),
+      vault.totalSupply(),
+      vault.decimals()
+    ]);
+    const sharePrice = totalSupply > 0n ? ethers7.formatUnits(totalAssets * 10n ** BigInt(decimals) / totalSupply, decimals) : "1.0";
+    const result = {
+      name,
+      symbol,
+      asset,
+      totalAssets: ethers7.formatUnits(totalAssets, decimals),
+      totalSupply: ethers7.formatUnits(totalSupply, decimals),
+      sharePrice
+    };
+    if (wallet) {
+      const shares = await vault.balanceOf(wallet);
+      const assets = shares > 0n ? await vault.convertToAssets(shares) : 0n;
+      result.userShares = ethers7.formatUnits(shares, decimals);
+      result.userAssets = ethers7.formatUnits(assets, decimals);
+    }
+    return result;
+  }
+  /** Quote vault deposit — how many shares for given assets */
+  async vaultDepositQuote(vaultAddress, amount) {
+    const vault = new ethers7.Contract(ethers7.getAddress(vaultAddress), VAULT_ABI, this.provider);
+    const decimals = Number(await vault.decimals());
+    const assetsWei = ethers7.parseUnits(amount, decimals);
+    const shares = await vault.previewDeposit(assetsWei);
+    return { assetsIn: amount, sharesOut: ethers7.formatUnits(shares, decimals) };
+  }
+  /** Build txs to deposit into an ERC-4626 vault: [approve, deposit] */
+  async buildVaultDeposit(wallet, vaultAddress, amount) {
+    const vaultAddr = ethers7.getAddress(vaultAddress);
+    const vault = new ethers7.Contract(vaultAddr, VAULT_ABI, this.provider);
+    const assetAddr = await vault.asset();
+    const assetToken = new ethers7.Contract(assetAddr, ERC20_ABI2, this.provider);
+    const decimals = Number(await assetToken.decimals());
+    let depositAmount;
+    if (amount === "max") {
+      depositAmount = await assetToken.balanceOf(wallet);
+    } else {
+      depositAmount = ethers7.parseUnits(amount, decimals);
+    }
+    if (depositAmount === 0n) throw new Error("Zero balance to deposit");
+    const erc20Iface = new ethers7.Interface(ERC20_ABI2);
+    const approveData = erc20Iface.encodeFunctionData("approve", [vaultAddr, depositAmount]);
+    const vaultIface = new ethers7.Interface(VAULT_ABI);
+    const depositData = vaultIface.encodeFunctionData("deposit", [depositAmount, wallet]);
+    return {
+      transactions: [
+        { to: assetAddr, data: approveData, value: "0", chainId: CHAIN_ID, gasLimit: "60000", description: `Approve asset for vault deposit` },
+        { to: vaultAddr, data: depositData, value: "0", chainId: CHAIN_ID, gasLimit: "300000", description: `Deposit ${ethers7.formatUnits(depositAmount, decimals)} into vault` }
+      ]
+    };
+  }
+  /** Build tx to withdraw from an ERC-4626 vault */
+  async buildVaultWithdraw(wallet, vaultAddress, amount) {
+    const vaultAddr = ethers7.getAddress(vaultAddress);
+    const vault = new ethers7.Contract(vaultAddr, VAULT_ABI, this.provider);
+    const decimals = Number(await vault.decimals());
+    let withdrawAmount;
+    if (amount === "max") {
+      const shares = await vault.balanceOf(wallet);
+      withdrawAmount = await vault.convertToAssets(shares);
+    } else {
+      withdrawAmount = ethers7.parseUnits(amount, decimals);
+    }
+    if (withdrawAmount === 0n) throw new Error("Nothing to withdraw");
+    const iface = new ethers7.Interface(VAULT_ABI);
+    const data = iface.encodeFunctionData("withdraw", [withdrawAmount, wallet, wallet]);
+    return {
+      transactions: [{
+        to: vaultAddr,
+        data,
+        value: "0",
+        chainId: CHAIN_ID,
+        gasLimit: "300000",
+        description: `Withdraw ${ethers7.formatUnits(withdrawAmount, decimals)} from vault`
+      }]
+    };
   }
 };
 
 // src/client.ts
-var DEFAULT_BASE_URL = "https://brave-alignment-production-1706.up.railway.app";
-var LogiqicalClient = class {
+var Logiqical = class _Logiqical {
   /** Buy/sell ARENA tokens via LFJ DEX */
   swap;
   /** Stake ARENA tokens for rewards */
   staking;
   /** Discover, research, and trade launchpad tokens on bonding curves */
   launchpad;
-  /** Swap any Avalanche token via LFJ + Arena DEX */
+  /** Swap any Avalanche token via LFJ DEX */
   dex;
   /** Trade perpetual futures on Hyperliquid via Arena */
   perps;
-  /** Cross-chain token bridging via Li.Fi — any token, any chain */
+  /** Cross-chain token bridging via Li.Fi */
   bridge;
-  http;
-  wallet;
-  agentName;
-  registrationPromise = null;
+  /** Buy/sell Arena tickets */
+  tickets;
+  /** Arena social: chat, DMs, posts, follow, user discovery */
+  social;
+  /** Market signals intelligence — scan, funding rates, whale tracking */
+  signals;
+  /** Market data — prices, trending, top coins via CoinGecko */
+  market;
+  /** DeFi — sAVAX liquid staking + ERC-4626 vaults */
+  defi;
+  /** The agent's wallet address */
+  address;
+  /** The local wallet (null if read-only mode) */
+  agentWallet;
+  /** The JSON-RPC provider for direct chain reads */
+  provider;
+  /** The spending policy engine */
+  policyEngine;
+  config;
   constructor(config) {
-    this.wallet = config.wallet;
-    this.agentName = config.name ?? "agent";
-    this.http = new HttpClient(config.baseUrl ?? DEFAULT_BASE_URL, config.apiKey);
-    const auth = () => this.ensureRegistered();
-    this.swap = new SwapModule(this.http, auth);
-    this.staking = new StakingModule(this.http, auth);
-    this.launchpad = new LaunchpadModule(this.http, auth);
-    this.dex = new DexModule(this.http, auth);
-    this.perps = new PerpsModule(this.http, auth);
-    this.bridge = new BridgeModule(this.http, auth);
-  }
-  /** The API key (available after first call or if provided in config) */
-  get apiKey() {
-    return this.http.getApiKey();
+    this.config = config;
+    this.policyEngine = new PolicyEngine(config.policy);
+    if (config.privateKey) {
+      this.agentWallet = AgentWallet.fromPrivateKey(config.privateKey, {
+        network: config.network,
+        rpcUrl: config.rpcUrl
+      });
+      this.provider = this.agentWallet.provider;
+      this.address = this.agentWallet.address;
+    } else if (config.mnemonic) {
+      const hdWallet = ethers8.HDNodeWallet.fromPhrase(config.mnemonic);
+      this.agentWallet = AgentWallet.fromPrivateKey(hdWallet.privateKey, {
+        network: config.network,
+        rpcUrl: config.rpcUrl
+      });
+      this.provider = this.agentWallet.provider;
+      this.address = this.agentWallet.address;
+    } else if (config.wallet) {
+      this.agentWallet = null;
+      const { provider } = _Logiqical.resolveProvider(config);
+      this.provider = provider;
+      this.address = config.wallet;
+    } else {
+      throw new Error("Provide privateKey, mnemonic, or wallet (read-only).");
+    }
+    this.swap = new SwapModule(this.provider);
+    this.staking = new StakingModule(this.provider);
+    this.launchpad = new LaunchpadModule(this.provider);
+    this.dex = new DexModule(this.provider);
+    this.tickets = new TicketsModule(this.provider);
+    this.perps = new PerpsModule(config.arenaApiKey);
+    this.social = new SocialModule(config.arenaApiKey);
+    this.bridge = new BridgeModule();
+    this.signals = new SignalsModule();
+    this.market = new MarketModule();
+    this.defi = new DefiModule(this.provider);
+  }
+  // ── Factory Methods ──
+  /** Generate a brand new agent wallet */
+  static generate(config = {}) {
+    const wallet = AgentWallet.generate({ network: config.network, rpcUrl: config.rpcUrl });
+    return new _Logiqical({ ...config, privateKey: wallet.privateKey });
+  }
+  /** Boot from encrypted keystore — creates wallet on first run, loads on subsequent runs */
+  static async boot(config = {}) {
+    const wallet = await AgentWallet.boot({
+      network: config.network,
+      rpcUrl: config.rpcUrl,
+      password: config.password,
+      keystoreName: config.keystoreName
+    });
+    return new _Logiqical({ ...config, privateKey: wallet.privateKey });
   }
+  // ── Core Agent Operations ──
   /**
-   * Broadcast a signed transaction to the Avalanche network.
-   * @param signedTx - Signed transaction hex string
-   * @returns Transaction hash
+   * Execute any module result — policy check + simulate + sign + broadcast.
+   *
+   * ```ts
+   * await agent.execute(agent.dex.buildSwap(agent.address, "AVAX", "USDC", "1.0"));
+   * await agent.execute(agent.launchpad.buildBuy(agent.address, "42", "0.5"));
+   * ```
    */
-  async broadcast(signedTx) {
-    await this.ensureRegistered();
-    return this.http.post("/broadcast", { signedTx });
+  async execute(resultOrPromise, confirmations = 1) {
+    this.requireWallet("execute");
+    const result = await resultOrPromise;
+    const txs = result.transactions ?? (result.transaction ? [result.transaction] : []);
+    if (txs.length === 0) throw new Error("No transactions to execute.");
+    const results = [];
+    for (const utx of txs) {
+      this.policyEngine.check(utx);
+      if (this.policyEngine.shouldSimulate) {
+        await this.simulate(utx);
+      }
+      if (this.policyEngine.isDryRun) {
+        results.push({
+          hash: "0x_dry_run",
+          receipt: { status: 1, blockNumber: 0, gasUsed: "0", transactionHash: "0x_dry_run" }
+        });
+        continue;
+      }
+      const txResponse = await this.agentWallet.signAndBroadcast(utx);
+      const receipt = await txResponse.wait(confirmations);
+      if (!receipt) throw new Error(`Transaction ${txResponse.hash} failed \u2014 no receipt.`);
+      const value = utx.value ? BigInt(utx.value) : 0n;
+      if (value > 0n) this.policyEngine.recordSpend(value);
+      results.push({
+        hash: txResponse.hash,
+        receipt: {
+          status: receipt.status ?? 0,
+          blockNumber: receipt.blockNumber,
+          gasUsed: receipt.gasUsed.toString(),
+          transactionHash: receipt.hash
+        }
+      });
+    }
+    return results;
   }
   /**
-   * Get the full agent instructions document — describes all available capabilities.
+   * Call any smart contract method — policy check + simulate + sign + broadcast.
+   *
+   * ```ts
+   * await agent.call({
+   *   contract: "0x...",
+   *   abi: ["function transfer(address,uint256) returns (bool)"],
+   *   method: "transfer",
+   *   args: ["0xRecipient", ethers.parseUnits("100", 18)],
+   * });
+   * ```
    */
-  async getInstructions() {
-    await this.ensureRegistered();
-    return this.http.get("/agent-instructions");
+  async call(intent) {
+    this.requireWallet("call");
+    const iface = new ethers8.Interface(intent.abi);
+    const data = iface.encodeFunctionData(intent.method, intent.args ?? []);
+    const valueWei = intent.value ? ethers8.parseEther(intent.value).toString() : "0";
+    const policyTx = { to: intent.contract, data, value: valueWei, chainId: 43114 };
+    this.policyEngine.check(policyTx);
+    if (this.policyEngine.shouldSimulate) {
+      await this.simulate(policyTx);
+    }
+    if (this.policyEngine.isDryRun) {
+      return { hash: "0x_dry_run", receipt: { status: 1, blockNumber: 0, gasUsed: "0", transactionHash: "0x_dry_run" } };
+    }
+    const contract = new Contract(
+      ethers8.getAddress(intent.contract),
+      intent.abi,
+      this.agentWallet.wallet
+    );
+    const tx = await contract[intent.method](
+      ...intent.args ?? [],
+      {
+        value: intent.value ? ethers8.parseEther(intent.value) : void 0,
+        gasLimit: intent.gasLimit ?? void 0
+      }
+    );
+    const receipt = await tx.wait(1);
+    if (!receipt) throw new Error(`Transaction ${tx.hash} failed \u2014 no receipt.`);
+    if (intent.value) {
+      this.policyEngine.recordSpend(ethers8.parseEther(intent.value));
+    }
+    return {
+      hash: tx.hash,
+      receipt: {
+        status: receipt.status ?? 0,
+        blockNumber: receipt.blockNumber,
+        gasUsed: receipt.gasUsed.toString(),
+        transactionHash: receipt.hash
+      }
+    };
+  }
+  /** Send native token (AVAX) — policy check + simulate + sign + broadcast */
+  async send(to, amount) {
+    this.requireWallet("send");
+    const valueWei = ethers8.parseEther(amount);
+    const policyTx = { to, data: "0x", value: valueWei.toString(), chainId: 43114 };
+    this.policyEngine.check(policyTx);
+    if (this.policyEngine.isDryRun) {
+      return { hash: "0x_dry_run", receipt: { status: 1, blockNumber: 0, gasUsed: "0", transactionHash: "0x_dry_run" } };
+    }
+    const tx = await this.agentWallet.send(to, amount);
+    const receipt = await tx.wait(1);
+    if (!receipt) throw new Error(`Transaction ${tx.hash} failed \u2014 no receipt.`);
+    this.policyEngine.recordSpend(valueWei);
+    return {
+      hash: tx.hash,
+      receipt: {
+        status: receipt.status ?? 0,
+        blockNumber: receipt.blockNumber,
+        gasUsed: receipt.gasUsed.toString(),
+        transactionHash: receipt.hash
+      }
+    };
+  }
+  /** Simulate a transaction via eth_call — throws PolicyError if it would revert */
+  async simulate(tx) {
+    try {
+      await this.provider.call({
+        to: tx.to,
+        data: tx.data,
+        value: tx.value ? BigInt(tx.value) : void 0,
+        from: this.address
+      });
+    } catch (e) {
+      throw new PolicyError(
+        `Simulation failed: ${e.reason || e.message || "transaction would revert"}`,
+        "SIMULATION_FAILED"
+      );
+    }
   }
-  /**
-   * Check if the API is healthy and responsive.
-   */
-  async health() {
-    return this.http.get("/health", void 0, true);
+  // ── Policy ──
+  /** Get the current spending policy */
+  getPolicy() {
+    return this.policyEngine.getPolicy();
+  }
+  /** Replace the entire spending policy */
+  setPolicy(policy) {
+    this.policyEngine.setPolicy(policy);
+  }
+  /** Update specific policy fields */
+  updatePolicy(updates) {
+    this.policyEngine.updatePolicy(updates);
+  }
+  /** Get budget status: spent this hour, today, remaining */
+  getBudgetStatus() {
+    return this.policyEngine.getBudgetStatus();
+  }
+  // ── Read Operations (no signing needed) ──
+  /** Check if this client has a local wallet for signing */
+  get canSign() {
+    return this.agentWallet !== null;
+  }
+  /** The private key (only available in wallet mode) */
+  get privateKey() {
+    this.requireWallet("privateKey");
+    return this.agentWallet.privateKey;
+  }
+  /** Get native token balance (formatted) */
+  async getBalance() {
+    if (this.agentWallet) return this.agentWallet.getBalance();
+    const balance = await this.provider.getBalance(this.address);
+    return ethers8.formatEther(balance);
+  }
+  /** Sign a message */
+  async signMessage(message) {
+    this.requireWallet("signMessage");
+    return this.agentWallet.signMessage(message);
+  }
+  /** Sign EIP-712 typed data */
+  async signTypedData(domain, types, value) {
+    this.requireWallet("signTypedData");
+    return this.agentWallet.signTypedData(domain, types, value);
+  }
+  /** Switch to a different network (returns new Logiqical instance with same keys) */
+  switchNetwork(network) {
+    this.requireWallet("switchNetwork");
+    return new _Logiqical({
+      ...this.config,
+      privateKey: this.agentWallet.privateKey,
+      mnemonic: void 0,
+      wallet: void 0,
+      network
+    });
   }
-  /**
-   * Manually register and get an API key.
-   * Usually not needed — the client auto-registers on first call.
-   */
-  async register() {
-    const data = await this.http.get("/register", {
-      wallet: this.wallet,
-      name: this.agentName
-    }, true);
-    const apiKey = data.apiKey || data.key;
-    this.http.setApiKey(apiKey);
-    return { apiKey, wallet: data.wallet, name: data.name };
-  }
-  async ensureRegistered() {
-    if (this.http.getApiKey()) return;
-    if (!this.registrationPromise) {
-      this.registrationPromise = this.register().then(() => {
-      }).catch((e) => {
-        this.registrationPromise = null;
-        throw e;
-      });
+  /** Save the wallet to an encrypted keystore file */
+  async saveKeystore(password, name) {
+    this.requireWallet("saveKeystore");
+    return this.agentWallet.saveKeystore(password, name);
+  }
+  // ── Low-level (advanced — bypasses policy) ──
+  /** Sign and broadcast a single unsigned tx — bypasses policy engine */
+  async signAndBroadcast(unsignedTx) {
+    this.requireWallet("signAndBroadcast");
+    return this.agentWallet.signAndBroadcast(unsignedTx);
+  }
+  /** Sign and broadcast multiple unsigned txs — bypasses policy engine */
+  async signAndBroadcastAll(unsignedTxs, confirmations = 1) {
+    this.requireWallet("signAndBroadcastAll");
+    return this.agentWallet.signAndBroadcastAll(unsignedTxs, confirmations);
+  }
+  // ── Internal ──
+  requireWallet(method) {
+    if (!this.agentWallet) throw new Error(`No local wallet \u2014 cannot ${method}(). Provide privateKey or use Logiqical.boot().`);
+  }
+  static resolveProvider(config) {
+    const networkKey = config.network ?? "avalanche";
+    const chain = CHAINS[networkKey];
+    if (!chain && !config.rpcUrl) {
+      throw new Error(`Unknown network "${networkKey}". Use: ${Object.keys(CHAINS).join(", ")} \u2014 or provide rpcUrl.`);
     }
-    return this.registrationPromise;
+    const rpcUrl = config.rpcUrl ?? chain.rpcUrl;
+    const chainId = chain?.chainId ?? void 0;
+    return { provider: new JsonRpcProvider2(rpcUrl, chainId) };
+  }
+};
+var LogiqicalClient = Logiqical;
+
+// src/errors.ts
+var LogiqicalError = class _LogiqicalError extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "LogiqicalError";
+  }
+  static from(e, code = "UNKNOWN") {
+    if (e instanceof _LogiqicalError) return e;
+    const cause = e instanceof Error ? e : new Error(String(e));
+    return new _LogiqicalError(cause.message, code, cause);
   }
 };
 export {
+  AgentWallet,
   BridgeModule,
+  CHAINS,
+  DefiModule,
   DexModule,
   LaunchpadModule,
-  LogiqicalAuthError,
+  Logiqical,
   LogiqicalClient,
   LogiqicalError,
+  MarketModule,
   PerpsModule,
+  PolicyEngine,
+  PolicyError,
+  SignalsModule,
+  SocialModule,
   StakingModule,
-  SwapModule
+  SwapModule,
+  TicketsModule
 };
+//# sourceMappingURL=index.mjs.map