logiqical 0.2.0 → 0.3.1

package/dist/cli.mjs

@@ -0,0 +1,3278 @@
+#!/usr/bin/env node
+
+// src/mcp/cli.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// 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 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/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"
+        );
+      }
+    }
+    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"
+        );
+      }
+    }
+  }
+  /** 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 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
+    };
+  }
+  get shouldSimulate() {
+    return this.policy.simulateBeforeSend ?? false;
+  }
+  get isDryRun() {
+    return this.policy.dryRun ?? false;
+  }
+  getSpendSince(since) {
+    return this.spendLog.filter((r) => r.timestamp > since).reduce((sum, r) => sum + r.amount, 0n);
+  }
+};
+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(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);
+  }
+  arenaToken;
+  staking;
+  /** Get staking info — staked amount, pending rewards */
+  async getInfo(wallet) {
+    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) {
+    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) {
+    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(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() {
+    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,
+      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(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) {
+    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 */
+  async quote(from, to, amount) {
+    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(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;
+  }
+  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();
+  }
+  // ── Setup (via Arena API) ──
+  async register() {
+    return this.arenaRequest("POST", "/agents/perp/register", { provider: "HYPERLIQUID" });
+  }
+  async getRegistrationStatus() {
+    return this.arenaRequest("GET", "/agents/perp/registration-status", void 0, { provider: "HYPERLIQUID" });
+  }
+  async getWalletAddress() {
+    return this.arenaRequest("GET", "/agents/perp/wallet-address", void 0, { provider: "HYPERLIQUID" });
+  }
+  // ── Auth Flow (via Arena API — EIP-712 signing) ──
+  async getAuthStatus() {
+    return this.arenaRequest("POST", "/agents/perp/auth/status", { provider: "HYPERLIQUID" });
+  }
+  async getAuthPayload(step, mainWalletAddress) {
+    const body = { provider: "HYPERLIQUID" };
+    if (mainWalletAddress) body.mainWalletAddress = mainWalletAddress;
+    return this.arenaRequest("POST", `/agents/perp/auth/${step}/payload`, body);
+  }
+  async submitAuthSignature(step, signature, mainWalletAddress, metadata) {
+    return this.arenaRequest("POST", `/agents/perp/auth/${step}/submit`, { provider: "HYPERLIQUID", mainWalletAddress, signature, metadata });
+  }
+  async enableHip3() {
+    return this.arenaRequest("POST", "/agents/perp/auth/enable-hip3", { provider: "HYPERLIQUID" });
+  }
+  // ── Market Data (direct Hyperliquid) ──
+  async getTradingPairs() {
+    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") {
+    return this.arenaRequest("POST", "/agents/perp/leverage/update", { provider: "HYPERLIQUID", symbol, leverage, leverageType });
+  }
+  async placeOrder(orders) {
+    return this.arenaRequest("POST", "/agents/perp/orders/place", { provider: "HYPERLIQUID", orders });
+  }
+  async cancelOrders(cancels) {
+    return this.arenaRequest("POST", "/agents/perp/orders/cancel", { provider: "HYPERLIQUID", cancels });
+  }
+  async closePosition(symbol, positionSide, size, currentPrice, closePercent = 100) {
+    return this.arenaRequest("POST", "/agents/perp/orders/close-position", { provider: "HYPERLIQUID", symbol, positionSide, size, currentPrice, closePercent });
+  }
+  async getOrders() {
+    return this.arenaRequest("GET", "/agents/perp/orders", void 0, { provider: "HYPERLIQUID" });
+  }
+  async getTradeExecutions() {
+    return this.arenaRequest("GET", "/agents/perp/trade-executions", void 0, { provider: "HYPERLIQUID" });
+  }
+  // ── Positions (direct Hyperliquid — read-only, no auth needed) ──
+  async getPositions(wallet) {
+    return this.hlPost({ type: "clearinghouseState", user: wallet });
+  }
+  async getOpenOrders(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 {
+  async getChains() {
+    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 };
+  }
+  async getTokens(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 };
+  }
+  async getToken(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();
+  }
+  async getConnections(fromChainId, toChainId, fromToken, toToken) {
+    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 };
+  }
+  async getQuote(fromChainId, toChainId, fromToken, toToken, fromAmount, fromAddress, toAddress, slippage, fromDecimals) {
+    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());
+  }
+  async getRoutes(fromChainId, toChainId, fromToken, toToken, fromAmount, fromAddress, toAddress, slippage, fromDecimals) {
+    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 };
+  }
+  async getStatus(txHash, fromChainId, toChainId, bridge) {
+    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"
+    };
+  }
+};
+
+// 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 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 DEX */
+  dex;
+  /** Trade perpetual futures on Hyperliquid via Arena */
+  perps;
+  /** Cross-chain token bridging via Li.Fi */
+  bridge;
+  /** 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.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 ──
+  /**
+   * 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 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;
+  }
+  /**
+   * 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 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"
+      );
+    }
+  }
+  // ── 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
+    });
+  }
+  /** 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.`);
+    }
+    const rpcUrl = config.rpcUrl ?? chain.rpcUrl;
+    const chainId = chain?.chainId ?? void 0;
+    return { provider: new JsonRpcProvider2(rpcUrl, chainId) };
+  }
+};
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+function ok(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function err(e) {
+  const msg = e instanceof Error ? e.message : String(e);
+  return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
+}
+function createMcpServer(agent) {
+  const server = new McpServer({ name: "logiqical", version: "0.3.0" });
+  const w = agent.address;
+  server.tool("get_address", "Get the agent's wallet address", {}, async () => {
+    return ok({ address: w, canSign: agent.canSign });
+  });
+  server.tool("get_balance", "Get native token balance (AVAX)", {}, async () => {
+    try {
+      return ok({ balance: await agent.getBalance(), token: "AVAX" });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("send_avax", "Send AVAX to an address", {
+    to: z.string().describe("Recipient address"),
+    amount: z.string().describe("Amount of AVAX (e.g. '0.1')")
+  }, async ({ to, amount }) => {
+    try {
+      return ok(await agent.send(to, amount));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("sign_message", "Sign a message with the agent's wallet", {
+    message: z.string().describe("Message to sign")
+  }, async ({ message }) => {
+    try {
+      return ok({ signature: await agent.signMessage(message) });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("get_balances", "Get AVAX and ARENA balances", {
+    wallet: z.string().optional().describe("Wallet address (defaults to agent wallet)")
+  }, async ({ wallet }) => {
+    try {
+      return ok(await agent.swap.getBalances(wallet || w));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("swap_quote_buy", "Quote: how much ARENA for a given AVAX amount", {
+    avax: z.string().describe("AVAX amount (e.g. '0.1')")
+  }, async ({ avax }) => {
+    try {
+      return ok(await agent.swap.quote(avax));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("swap_quote_sell", "Quote: how much AVAX for selling ARENA", {
+    arena: z.string().describe("ARENA amount")
+  }, async ({ arena }) => {
+    try {
+      return ok(await agent.swap.sellQuote(arena));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("swap_buy_arena", "Buy ARENA with AVAX \u2014 signs and broadcasts", {
+    avax: z.string().describe("AVAX to spend"),
+    slippage: z.number().optional().describe("Slippage bps (default 500)")
+  }, async ({ avax, slippage }) => {
+    try {
+      return ok(await agent.execute(agent.swap.buildBuy(w, avax, slippage)));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("swap_sell_arena", "Sell ARENA for AVAX \u2014 signs and broadcasts", {
+    amount: z.string().describe("ARENA to sell, or 'max'"),
+    slippage: z.number().optional().describe("Slippage bps (default 500)")
+  }, async ({ amount, slippage }) => {
+    try {
+      return ok(await agent.execute(agent.swap.buildSell(w, amount, slippage)));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("stake_info", "Get staking position: staked amount + pending rewards", {
+    wallet: z.string().optional().describe("Wallet address")
+  }, async ({ wallet }) => {
+    try {
+      return ok(await agent.staking.getInfo(wallet || w));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("stake_arena", "Stake ARENA tokens \u2014 signs and broadcasts", {
+    amount: z.string().describe("ARENA to stake, or 'max'")
+  }, async ({ amount }) => {
+    try {
+      return ok(await agent.execute(agent.staking.buildStake(w, amount)));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("unstake_arena", "Unstake ARENA + claim rewards \u2014 signs and broadcasts", {
+    amount: z.string().describe("ARENA to unstake, or 'max'")
+  }, async ({ amount }) => {
+    try {
+      return ok(await agent.execute(agent.staking.buildUnstake(w, amount)));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("buy_and_stake", "Buy ARENA with AVAX and stake in one flow \u2014 signs and broadcasts", {
+    avax: z.string().describe("AVAX to spend")
+  }, async ({ avax }) => {
+    try {
+      return ok(await agent.execute(agent.staking.buildBuyAndStake(w, avax)));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("dex_tokens", "List known tokens available for swapping on Avalanche", {}, async () => {
+    try {
+      return ok(agent.dex.getTokens());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("dex_token_info", "Look up any ERC-20 token by address", {
+    address: z.string().describe("Token contract address")
+  }, async ({ address }) => {
+    try {
+      return ok(await agent.dex.getTokenInfo(address));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("dex_balance", "Check balance of any token", {
+    token: z.string().describe("Token symbol (USDC, JOE) or address"),
+    wallet: z.string().optional().describe("Wallet address")
+  }, async ({ token, wallet }) => {
+    try {
+      return ok(await agent.dex.getBalance(wallet || w, token));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("dex_quote", "Get a swap quote between any two tokens", {
+    from: z.string().describe("Source token"),
+    to: z.string().describe("Destination token"),
+    amount: z.string().describe("Amount of source token")
+  }, async ({ from, to, amount }) => {
+    try {
+      return ok(await agent.dex.quote(from, to, amount));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("dex_swap", "Swap any tokens \u2014 signs and broadcasts", {
+    from: z.string().describe("Source token"),
+    to: z.string().describe("Destination token"),
+    amount: z.string().describe("Amount to swap, or 'max'"),
+    slippage: z.number().optional().describe("Slippage bps (default 500)")
+  }, async ({ from, to, amount, slippage }) => {
+    try {
+      return ok(await agent.execute(agent.dex.buildSwap(w, from, to, amount, slippage)));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("launchpad_overview", "Get platform overview: total tokens, fees, contracts", {}, async () => {
+    try {
+      return ok(await agent.launchpad.getOverview());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("launchpad_recent", "Get recently launched tokens", {
+    count: z.number().optional().describe("Number of tokens (default 10)")
+  }, async ({ count }) => {
+    try {
+      return ok(await agent.launchpad.getRecent(count));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("launchpad_token", "Get full token info by ID", {
+    tokenId: z.string().describe("Token ID")
+  }, async ({ tokenId }) => {
+    try {
+      return ok(await agent.launchpad.getToken(tokenId));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("launchpad_quote", "Get buy or sell quote for a launchpad token", {
+    tokenId: z.string().describe("Token ID"),
+    side: z.enum(["buy", "sell"]).describe("Trade side"),
+    amount: z.string().describe("AVAX amount (buy) or token amount (sell)")
+  }, async ({ tokenId, side, amount }) => {
+    try {
+      return ok(await agent.launchpad.quote(tokenId, side, amount));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("launchpad_buy", "Buy a launchpad token \u2014 signs and broadcasts", {
+    tokenId: z.string().describe("Token ID"),
+    avax: z.string().describe("AVAX to spend"),
+    slippage: z.number().optional().describe("Slippage bps")
+  }, async ({ tokenId, avax, slippage }) => {
+    try {
+      return ok(await agent.execute(agent.launchpad.buildBuy(w, tokenId, avax, slippage)));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("launchpad_sell", "Sell a launchpad token \u2014 signs and broadcasts", {
+    tokenId: z.string().describe("Token ID"),
+    amount: z.string().describe("Token amount, or 'max'"),
+    slippage: z.number().optional().describe("Slippage bps")
+  }, async ({ tokenId, amount, slippage }) => {
+    try {
+      return ok(await agent.execute(agent.launchpad.buildSell(w, tokenId, amount, slippage)));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("tickets_buy_price", "Get buy price for Arena tickets", {
+    subject: z.string().describe("Subject wallet address"),
+    amount: z.string().optional().describe("Tickets (default 1, supports 0.5)")
+  }, async ({ subject, amount }) => {
+    try {
+      return ok(await agent.tickets.getBuyPrice(subject, amount));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("tickets_sell_price", "Get sell price for Arena tickets", {
+    subject: z.string().describe("Subject wallet address"),
+    amount: z.string().optional().describe("Tickets (default 1)")
+  }, async ({ subject, amount }) => {
+    try {
+      return ok(await agent.tickets.getSellPrice(subject, amount));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("tickets_balance", "Get ticket balance", {
+    subject: z.string().describe("Subject wallet"),
+    user: z.string().optional().describe("User wallet")
+  }, async ({ subject, user }) => {
+    try {
+      return ok(await agent.tickets.getBalance(subject, user || w));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("tickets_supply", "Get total ticket supply for a subject", {
+    subject: z.string().describe("Subject wallet")
+  }, async ({ subject }) => {
+    try {
+      return ok(await agent.tickets.getSupply(subject));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("tickets_fees", "Get ticket fee structure", {}, async () => {
+    try {
+      return ok(await agent.tickets.getFees());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("tickets_buy", "Buy Arena tickets \u2014 signs and broadcasts", {
+    subject: z.string().describe("Subject wallet"),
+    amount: z.string().optional().describe("Tickets (default 1)")
+  }, async ({ subject, amount }) => {
+    try {
+      return ok(await agent.execute(agent.tickets.buildBuyTx(w, subject, amount)));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("tickets_sell", "Sell Arena tickets \u2014 signs and broadcasts", {
+    subject: z.string().describe("Subject wallet"),
+    amount: z.string().optional().describe("Tickets (default 1)")
+  }, async ({ subject, amount }) => {
+    try {
+      return ok(await agent.execute(agent.tickets.buildSellTx(w, subject, amount)));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("bridge_info", "Get supported chains, USDC addresses, native token constant", {}, async () => {
+    try {
+      return ok(agent.bridge.getInfo());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("bridge_chains", "Get all supported chains for bridging", {}, async () => {
+    try {
+      return ok(await agent.bridge.getChains());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("bridge_tokens", "Get tokens available on specified chains", {
+    chains: z.string().describe("Comma-separated chain IDs (e.g. '43114,42161')")
+  }, async ({ chains }) => {
+    try {
+      return ok(await agent.bridge.getTokens(chains));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("bridge_quote", "Get a cross-chain bridge quote with transaction", {
+    fromChainId: z.number().describe("Source chain ID"),
+    toChainId: z.number().describe("Destination chain ID"),
+    fromToken: z.string().describe("Source token address"),
+    toToken: z.string().describe("Destination token address"),
+    fromAmount: z.string().describe("Amount (human-readable)"),
+    fromAddress: z.string().optional().describe("Sender (defaults to agent)"),
+    slippage: z.number().optional().describe("Slippage decimal (default 0.03)")
+  }, async ({ fromChainId, toChainId, fromToken, toToken, fromAmount, fromAddress, slippage }) => {
+    try {
+      return ok(await agent.bridge.getQuote(
+        fromChainId,
+        toChainId,
+        fromToken,
+        toToken,
+        fromAmount,
+        fromAddress || w,
+        void 0,
+        slippage
+      ));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("bridge_routes", "Get multiple route options for bridging", {
+    fromChainId: z.number().describe("Source chain ID"),
+    toChainId: z.number().describe("Destination chain ID"),
+    fromToken: z.string().describe("Source token address"),
+    toToken: z.string().describe("Destination token address"),
+    fromAmount: z.string().describe("Amount (human-readable)"),
+    fromAddress: z.string().optional().describe("Sender (defaults to agent)")
+  }, async ({ fromChainId, toChainId, fromToken, toToken, fromAmount, fromAddress }) => {
+    try {
+      return ok(await agent.bridge.getRoutes(
+        fromChainId,
+        toChainId,
+        fromToken,
+        toToken,
+        fromAmount,
+        fromAddress || w
+      ));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("bridge_status", "Check status of a cross-chain transfer", {
+    txHash: z.string().describe("Source chain tx hash"),
+    fromChainId: z.number().describe("Source chain ID"),
+    toChainId: z.number().describe("Destination chain ID")
+  }, async ({ txHash, fromChainId, toChainId }) => {
+    try {
+      return ok(await agent.bridge.getStatus(txHash, fromChainId, toChainId));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("perps_register", "Register for perpetual futures on Hyperliquid", {}, async () => {
+    try {
+      return ok(await agent.perps.register());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("perps_registration_status", "Check perps registration status", {}, async () => {
+    try {
+      return ok(await agent.perps.getRegistrationStatus());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("perps_wallet_address", "Get Hyperliquid wallet address", {}, async () => {
+    try {
+      return ok(await agent.perps.getWalletAddress());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("perps_trading_pairs", "Get all 250+ perpetual trading pairs", {}, async () => {
+    try {
+      return ok(await agent.perps.getTradingPairs());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("perps_update_leverage", "Set leverage for a market", {
+    symbol: z.string().describe("Market symbol (BTC, ETH, SOL)"),
+    leverage: z.number().describe("Leverage (1-50)"),
+    leverageType: z.enum(["cross", "isolated"]).optional()
+  }, async ({ symbol, leverage, leverageType }) => {
+    try {
+      return ok(await agent.perps.updateLeverage(symbol, leverage, leverageType));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("perps_place_order", "Place a perpetual futures order", {
+    orders: z.array(z.record(z.any())).describe("Array of order objects")
+  }, async ({ orders }) => {
+    try {
+      return ok(await agent.perps.placeOrder(orders));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("perps_cancel_orders", "Cancel open perps orders", {
+    cancels: z.array(z.object({
+      assetIndex: z.number(),
+      oid: z.number()
+    })).describe("Orders to cancel")
+  }, async ({ cancels }) => {
+    try {
+      return ok(await agent.perps.cancelOrders(cancels));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("perps_close_position", "Close a perpetual position", {
+    symbol: z.string(),
+    positionSide: z.enum(["long", "short"]),
+    size: z.number(),
+    currentPrice: z.number(),
+    closePercent: z.number().optional()
+  }, async ({ symbol, positionSide, size, currentPrice, closePercent }) => {
+    try {
+      return ok(await agent.perps.closePosition(symbol, positionSide, size, currentPrice, closePercent));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("perps_orders", "Get open perps orders", {}, async () => {
+    try {
+      return ok(await agent.perps.getOrders());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("perps_positions", "Get perps positions and margin summary", {
+    wallet: z.string().describe("Hyperliquid wallet address")
+  }, async ({ wallet }) => {
+    try {
+      return ok(await agent.perps.getPositions(wallet));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("signals_market", "Get market signal for an asset (price, funding, OI, volume)", {
+    coin: z.string().describe("Asset symbol (BTC, ETH, SOL)")
+  }, async ({ coin }) => {
+    try {
+      return ok(await agent.signals.getMarketSignal(coin));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("signals_technical", "Get technical analysis (SMA, RSI, trend, support/resistance)", {
+    coin: z.string().describe("Asset symbol"),
+    interval: z.string().optional().describe("Candle interval (1m, 5m, 15m, 1h, 4h, 1d)")
+  }, async ({ coin, interval }) => {
+    try {
+      return ok(await agent.signals.getTechnicalSignal(coin, interval));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("signals_whales", "Get whale positions from orderbook depth", {
+    coin: z.string().describe("Asset symbol"),
+    minUsd: z.number().optional().describe("Minimum position USD (default 100000)")
+  }, async ({ coin, minUsd }) => {
+    try {
+      return ok(await agent.signals.getWhalePositions(coin, minUsd));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("signals_funding", "Get funding rate extremes across all markets", {
+    count: z.number().optional().describe("Top N (default 10)")
+  }, async ({ count }) => {
+    try {
+      return ok(await agent.signals.getFundingExtremes(count));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("signals_summary", "Full signal summary: market + technicals + whales + verdict", {
+    coin: z.string().describe("Asset symbol")
+  }, async ({ coin }) => {
+    try {
+      return ok(await agent.signals.summary(coin));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("signals_scan", "Scan all markets for top trading opportunities", {
+    count: z.number().optional().describe("Max opportunities (default 5)")
+  }, async ({ count }) => {
+    try {
+      return ok(await agent.signals.scan(count));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("social_search_users", "Search Arena users", {
+    q: z.string().describe("Search query")
+  }, async ({ q }) => {
+    try {
+      return ok(await agent.social.searchUsers(q));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("social_user_by_handle", "Get user by Arena handle", {
+    handle: z.string().describe("Arena handle")
+  }, async ({ handle }) => {
+    try {
+      return ok(await agent.social.getUserByHandle(handle));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("social_me", "Get your agent's Arena profile", {}, async () => {
+    try {
+      return ok(await agent.social.getMe());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("social_top_users", "Get top Arena users", {}, async () => {
+    try {
+      return ok(await agent.social.getTopUsers());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("social_follow", "Follow an Arena user", {
+    userId: z.string().describe("User UUID")
+  }, async ({ userId }) => {
+    try {
+      return ok(await agent.social.follow(userId));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("social_unfollow", "Unfollow an Arena user", {
+    userId: z.string().describe("User UUID")
+  }, async ({ userId }) => {
+    try {
+      return ok(await agent.social.unfollow(userId));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("social_update_profile", "Update Arena profile", {
+    userName: z.string().optional(),
+    bio: z.string().optional(),
+    profilePicture: z.string().optional()
+  }, async (params) => {
+    try {
+      return ok(await agent.social.updateProfile(params));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("social_conversations", "List chat conversations", {}, async () => {
+    try {
+      return ok(await agent.social.getConversations());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("social_send_message", "Send a chat message", {
+    groupId: z.string().describe("Chat group UUID"),
+    text: z.string().describe("Message text"),
+    replyId: z.string().optional()
+  }, async ({ groupId, text, replyId }) => {
+    try {
+      return ok(await agent.social.sendMessage(groupId, text, replyId));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("social_messages", "Read messages from a chat", {
+    groupId: z.string().describe("Chat group UUID"),
+    after: z.string().optional().describe("Get messages after this timestamp")
+  }, async ({ groupId, after }) => {
+    try {
+      return ok(await agent.social.getMessages(groupId, after));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("social_create_thread", "Create a post/thread", {
+    content: z.string().describe("Post content"),
+    replyToId: z.string().optional()
+  }, async ({ content, replyToId }) => {
+    try {
+      return ok(await agent.social.createThread(content, replyToId));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("social_like_thread", "Like a thread", {
+    threadId: z.string()
+  }, async ({ threadId }) => {
+    try {
+      return ok(await agent.social.likeThread(threadId));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("market_price", "Get price, 24h change, market cap, volume for coins", {
+    ids: z.string().describe("CoinGecko IDs, comma-separated (e.g. 'bitcoin,ethereum,avalanche-2')")
+  }, async ({ ids }) => {
+    try {
+      return ok(await agent.market.price(ids.split(",").map((s) => s.trim())));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("market_trending", "Get trending coins on CoinGecko", {}, async () => {
+    try {
+      return ok(await agent.market.trending());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("market_top", "Get top coins by market cap", {
+    count: z.number().optional().describe("Number of coins (default 20)"),
+    page: z.number().optional().describe("Page number (default 1)")
+  }, async ({ count, page }) => {
+    try {
+      return ok(await agent.market.markets(count, page));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("market_search", "Search for coins by name or symbol", {
+    query: z.string().describe("Search query")
+  }, async ({ query }) => {
+    try {
+      return ok(await agent.market.search(query));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("market_avax_price", "Get current AVAX price and 24h change", {}, async () => {
+    try {
+      return ok(await agent.market.avaxPrice());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("market_arena_price", "Get current ARENA price and 24h change", {}, async () => {
+    try {
+      return ok(await agent.market.arenaPrice());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("defi_savax_info", "Get sAVAX staking info: exchange rate, total staked, your balance", {
+    wallet: z.string().optional().describe("Wallet to check balance (defaults to agent)")
+  }, async ({ wallet }) => {
+    try {
+      return ok(await agent.defi.sAvaxInfo(wallet || w));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("defi_savax_quote", "Quote: how much sAVAX for staking AVAX", {
+    avax: z.string().describe("AVAX amount to stake")
+  }, async ({ avax }) => {
+    try {
+      return ok(await agent.defi.sAvaxStakeQuote(avax));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("defi_savax_stake", "Stake AVAX \u2192 sAVAX (Benqi liquid staking) \u2014 signs and broadcasts", {
+    avax: z.string().describe("AVAX to stake")
+  }, async ({ avax }) => {
+    try {
+      return ok(await agent.execute(agent.defi.buildSAvaxStake(avax)));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("defi_savax_unstake", "Request unstake sAVAX \u2192 AVAX (delayed) \u2014 signs and broadcasts", {
+    amount: z.string().describe("sAVAX amount, or 'max'")
+  }, async ({ amount }) => {
+    try {
+      return ok(await agent.execute(agent.defi.buildSAvaxUnstake(w, amount)));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("defi_vault_info", "Get info about an ERC-4626 vault", {
+    vault: z.string().describe("Vault contract address"),
+    wallet: z.string().optional().describe("Wallet to check position")
+  }, async ({ vault, wallet }) => {
+    try {
+      return ok(await agent.defi.vaultInfo(vault, wallet || w));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("defi_vault_quote", "Quote vault deposit \u2014 how many shares for given assets", {
+    vault: z.string().describe("Vault contract address"),
+    amount: z.string().describe("Asset amount to deposit")
+  }, async ({ vault, amount }) => {
+    try {
+      return ok(await agent.defi.vaultDepositQuote(vault, amount));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("defi_vault_deposit", "Deposit into an ERC-4626 vault \u2014 signs and broadcasts", {
+    vault: z.string().describe("Vault contract address"),
+    amount: z.string().describe("Asset amount, or 'max'")
+  }, async ({ vault, amount }) => {
+    try {
+      return ok(await agent.execute(agent.defi.buildVaultDeposit(w, vault, amount)));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("defi_vault_withdraw", "Withdraw from an ERC-4626 vault \u2014 signs and broadcasts", {
+    vault: z.string().describe("Vault contract address"),
+    amount: z.string().describe("Asset amount, or 'max'")
+  }, async ({ vault, amount }) => {
+    try {
+      return ok(await agent.execute(agent.defi.buildVaultWithdraw(w, vault, amount)));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("policy_get", "Get the current spending policy", {}, async () => {
+    try {
+      return ok(agent.getPolicy());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("policy_set", "Replace the entire spending policy", {
+    maxPerTx: z.string().optional().describe("Max AVAX per transaction"),
+    maxPerHour: z.string().optional().describe("Max AVAX per hour"),
+    maxPerDay: z.string().optional().describe("Max AVAX per day"),
+    allowedContracts: z.array(z.string()).optional().describe("Allowlisted contract addresses"),
+    blockedContracts: z.array(z.string()).optional().describe("Blocklisted contract addresses"),
+    simulateBeforeSend: z.boolean().optional().describe("Simulate transactions before sending"),
+    dryRun: z.boolean().optional().describe("Dry run mode (no broadcasting)")
+  }, async (policy) => {
+    try {
+      agent.setPolicy(policy);
+      return ok({ status: "policy_updated", policy: agent.getPolicy() });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("policy_budget", "Get budget status: spent this hour, today, remaining", {}, async () => {
+    try {
+      return ok(agent.getBudgetStatus());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("call_contract", "Call any smart contract method \u2014 signs and broadcasts", {
+    contract: z.string().describe("Contract address"),
+    abi: z.array(z.string()).describe("Human-readable ABI array"),
+    method: z.string().describe("Method name"),
+    args: z.array(z.any()).optional().describe("Method arguments"),
+    value: z.string().optional().describe("Native token to send (e.g. '0.1')")
+  }, async ({ contract, abi, method, args, value }) => {
+    try {
+      return ok(await agent.call({ contract, abi, method, args, value }));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  return server;
+}
+
+// src/mcp/cli.ts
+async function main() {
+  const privateKey = process.env.LOGIQICAL_PRIVATE_KEY;
+  const network = process.env.LOGIQICAL_NETWORK || "avalanche";
+  const rpcUrl = process.env.LOGIQICAL_RPC_URL;
+  const arenaApiKey = process.env.ARENA_API_KEY;
+  let agent;
+  if (privateKey) {
+    agent = new Logiqical({ privateKey, network, rpcUrl, arenaApiKey });
+    console.error(`Logiqical MCP \u2014 wallet ${agent.address}`);
+  } else {
+    agent = await Logiqical.boot({ network, rpcUrl, arenaApiKey });
+    console.error(`Logiqical MCP \u2014 booted from keystore: ${agent.address}`);
+  }
+  const server = createMcpServer(agent);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Logiqical MCP server running (stdio)");
+}
+main().catch((e) => {
+  console.error("Fatal:", e);
+  process.exit(1);
+});