logiqical 0.3.1 → 0.5.0

package/dist/admin.mjs

@@ -0,0 +1,2946 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/client.ts
+import { ethers as ethers9, JsonRpcProvider as JsonRpcProvider3, Contract as Contract2 } 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(wallet2, provider, chain) {
+    this.wallet = wallet2;
+    this.provider = provider;
+    this.chain = chain;
+    this.address = wallet2.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 wallet2 = new Wallet(hdWallet.privateKey, provider);
+    return new _AgentWallet(wallet2, provider, chain);
+  }
+  /** Import an existing wallet from a private key */
+  static fromPrivateKey(privateKey, config = {}) {
+    const { provider, chain } = _AgentWallet.resolveProvider(config);
+    const wallet2 = new Wallet(privateKey, provider);
+    return new _AgentWallet(wallet2, 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 wallet2 = new Wallet(hdWallet.privateKey, provider);
+    const agentWallet = new _AgentWallet(wallet2, 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 wallet2 = new Wallet(this.privateKey, provider);
+    return new _AgentWallet(wallet2, 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(policy2 = {}) {
+    this.policy = policy2;
+  }
+  getPolicy() {
+    return { ...this.policy };
+  }
+  setPolicy(policy2) {
+    this.policy = policy2;
+  }
+  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 HL_DEPOSIT_ADDRESS = "0x2Df1c51E09aECF9cacB7bc98cB1742757f163dF7";
+var USDC_ARBITRUM = "0xaf88d065e77c8cC2239327C5EDb3A432268e5831";
+var ARBITRUM_CHAIN_ID = 42161;
+var ARBITRUM_RPC = "https://arb1.arbitrum.io/rpc";
+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(wallet2) {
+    const [avax, arena] = await Promise.all([
+      this.provider.getBalance(wallet2),
+      this.arenaToken.balanceOf(wallet2)
+    ]);
+    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(wallet2, 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, wallet2, 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(wallet2, arenaAmount, slippageBps = DEFAULT_SLIPPAGE_BPS) {
+    const decimals = await this.arenaToken.decimals();
+    let sellAmount;
+    if (arenaAmount === "max") {
+      sellAmount = await this.arenaToken.balanceOf(wallet2);
+      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, wallet2, 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(wallet2) {
+    const decimals = await this.arenaToken.decimals();
+    const [stakedRaw] = await this.staking.getUserInfo(wallet2, ethers3.getAddress(ARENA_TOKEN));
+    const pendingRaw = await this.staking.pendingReward(wallet2, 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(wallet2, amount) {
+    const decimals = await this.arenaToken.decimals();
+    let stakeAmount;
+    if (amount === "max") {
+      stakeAmount = await this.arenaToken.balanceOf(wallet2);
+    } 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(wallet2, amount) {
+    const decimals = await this.arenaToken.decimals();
+    let withdrawAmount;
+    if (amount === "max") {
+      const [stakedRaw] = await this.staking.getUserInfo(wallet2, 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(wallet2, 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, wallet2, 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(wallet2, 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(wallet2, 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(wallet2);
+    } 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(wallet2, tokenOrAddress) {
+    const address = this.resolveToken(tokenOrAddress);
+    if (address.toLowerCase() === WAVAX.toLowerCase() && tokenOrAddress.toUpperCase() === "AVAX") {
+      const balance2 = await this.provider.getBalance(wallet2);
+      return { wallet: wallet2, 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(wallet2), token.symbol(), token.decimals()]);
+    return { wallet: wallet2, 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(wallet2, 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(wallet2);
+      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, wallet2, 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, wallet2, 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
+import { ethers as ethers6, JsonRpcProvider as JsonRpcProvider2, Contract } from "ethers";
+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(wallet2) {
+    return this.hlPost({ type: "clearinghouseState", user: wallet2 });
+  }
+  async getOpenOrders(wallet2) {
+    return this.hlPost({ type: "openOrders", user: wallet2 });
+  }
+  // ── USDC Deposit to Hyperliquid (on Arbitrum) ──
+  /** Check USDC balance on Arbitrum */
+  async getArbitrumUSDCBalance(wallet2) {
+    const provider = new JsonRpcProvider2(ARBITRUM_RPC, ARBITRUM_CHAIN_ID);
+    const usdc = new Contract(USDC_ARBITRUM, ERC20_ABI, provider);
+    const balance = await usdc.balanceOf(wallet2);
+    return ethers6.formatUnits(balance, 6);
+  }
+  /** Check ETH balance on Arbitrum (needed for gas) */
+  async getArbitrumETHBalance(wallet2) {
+    const provider = new JsonRpcProvider2(ARBITRUM_RPC, ARBITRUM_CHAIN_ID);
+    const balance = await provider.getBalance(wallet2);
+    return ethers6.formatEther(balance);
+  }
+  /**
+   * Build a USDC deposit transaction for Hyperliquid on Arbitrum.
+   * Returns an unsigned tx — use with agent.execute() after switching to Arbitrum network.
+   *
+   * Flow: agent.switchNetwork("arbitrum") → agent.execute(agent.perps.buildDepositUSDC(...))
+   */
+  buildDepositUSDC(amount) {
+    const iface = new ethers6.Interface(["function transfer(address to, uint256 amount) returns (bool)"]);
+    const amountWei = ethers6.parseUnits(amount, 6);
+    const data = iface.encodeFunctionData("transfer", [HL_DEPOSIT_ADDRESS, amountWei]);
+    return {
+      transaction: {
+        to: USDC_ARBITRUM,
+        data,
+        value: "0",
+        chainId: ARBITRUM_CHAIN_ID,
+        description: `Deposit ${amount} USDC to Hyperliquid`
+      }
+    };
+  }
+  /** Get deposit info (addresses + chain details) */
+  getDepositInfo() {
+    return {
+      chain: "Arbitrum One",
+      chainId: ARBITRUM_CHAIN_ID,
+      usdcAddress: USDC_ARBITRUM,
+      depositAddress: HL_DEPOSIT_ADDRESS,
+      decimals: 6,
+      tip: "Bridge USDC to Arbitrum first (use bridge module), then deposit to Hyperliquid"
+    };
+  }
+};
+
+// 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 ethers7 } from "ethers";
+var TicketsModule = class {
+  constructor(provider) {
+    this.provider = provider;
+    this.contract = new ethers7.Contract(ethers7.getAddress(ARENA_SHARES_CONTRACT), SHARES_ABI, provider);
+  }
+  contract;
+  async getBuyPrice(subject, amount = "1") {
+    const fractionalAmount = this.ticketsToFractional(amount);
+    const subjectAddr = ethers7.getAddress(subject);
+    const [price, priceWithFee] = await Promise.all([
+      this.contract.getBuyPriceForFractionalShares(subjectAddr, fractionalAmount),
+      this.contract.getBuyPriceForFractionalSharesAfterFee(subjectAddr, fractionalAmount)
+    ]);
+    return { price: ethers7.formatEther(price), priceWithFee: ethers7.formatEther(priceWithFee), tickets: amount, fractionalAmount };
+  }
+  async getSellPrice(subject, amount = "1") {
+    const fractionalAmount = this.ticketsToFractional(amount);
+    const subjectAddr = ethers7.getAddress(subject);
+    const [price, priceAfterFee] = await Promise.all([
+      this.contract.getSellPriceForFractionalShares(subjectAddr, fractionalAmount),
+      this.contract.getSellPriceForFractionalSharesAfterFee(subjectAddr, fractionalAmount)
+    ]);
+    return { price: ethers7.formatEther(price), priceAfterFee: ethers7.formatEther(priceAfterFee), tickets: amount, fractionalAmount };
+  }
+  async getBalance(subject, user) {
+    const frac = await this.contract.getMyFractionalShares(ethers7.getAddress(subject), ethers7.getAddress(user));
+    return { tickets: (Number(frac) / FRACTION_SCALER).toString(), fractionalAmount: frac.toString() };
+  }
+  async getSupply(subject) {
+    const subjectAddr = ethers7.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(wallet2, subject, amount = "1") {
+    const fractionalAmount = this.ticketsToFractional(amount);
+    const subjectAddr = ethers7.getAddress(subject);
+    const userAddr = ethers7.getAddress(wallet2);
+    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 ethers7.Interface(SHARES_ABI);
+    const data = iface.encodeFunctionData("buyFractionalShares", [subjectAddr, userAddr, fractionalAmount]);
+    return {
+      transaction: {
+        to: ethers7.getAddress(ARENA_SHARES_CONTRACT),
+        data,
+        value: ethers7.toBeHex(cost, 32),
+        chainId: CHAIN_ID,
+        gasLimit: "200000",
+        description: `Buy ${amount} ticket(s) for ~${ethers7.formatEther(cost)} AVAX`
+      }
+    };
+  }
+  async buildSellTx(wallet2, subject, amount = "1") {
+    const fractionalAmount = this.ticketsToFractional(amount);
+    const subjectAddr = ethers7.getAddress(subject);
+    const userAddr = ethers7.getAddress(wallet2);
+    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 ethers7.Interface(SHARES_ABI);
+    const data = iface.encodeFunctionData("sellFractionalShares", [subjectAddr, userAddr, fractionalAmount]);
+    return {
+      transaction: {
+        to: ethers7.getAddress(ARENA_SHARES_CONTRACT),
+        data,
+        value: "0x0",
+        chainId: CHAIN_ID,
+        gasLimit: "200000",
+        description: `Sell ${amount} ticket(s) for ~${ethers7.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;
+  }
+  // ── Agent Registration (no auth needed — returns API key) ──
+  /**
+   * Register a new AI agent on Arena. Returns API key (shown once — save immediately).
+   * After registration, owner must claim by posting: "I'm claiming my AI Agent \"<name>\"\nVerification Code: <code>"
+   */
+  static async registerAgent(opts) {
+    const res = await fetch(`${ARENA_SOCIAL_API}/agents/register`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(opts)
+    });
+    const data = await res.json();
+    if (!res.ok) throw new Error(data.message || data.error || `Registration failed (${res.status})`);
+    return data;
+  }
+  // ── Feed Auto-Posting (trade updates) ──
+  /** Post a formatted trade update to the Arena feed */
+  async postTradeUpdate(trade) {
+    const lines = [];
+    const emoji = {
+      buy: "\u{1F7E2}",
+      sell: "\u{1F534}",
+      swap: "\u{1F504}",
+      bridge: "\u{1F309}",
+      stake: "\u{1F512}",
+      long: "\u{1F4C8}",
+      short: "\u{1F4C9}",
+      close: "\u2705"
+    };
+    const icon = emoji[trade.action] || "\u{1F4B0}";
+    if (trade.action === "swap" && trade.fromToken && trade.toToken) {
+      lines.push(`${icon} Swapped ${trade.amount || ""} ${trade.fromToken} \u2192 ${trade.toToken}`);
+    } else if (trade.action === "bridge" && trade.fromToken) {
+      lines.push(`${icon} Bridged ${trade.amount || ""} ${trade.fromToken}`);
+    } else if (trade.action === "long" || trade.action === "short") {
+      lines.push(`${icon} Opened ${trade.action.toUpperCase()} ${trade.token || ""} ${trade.amount ? `(${trade.amount})` : ""}`);
+    } else if (trade.action === "close") {
+      lines.push(`${icon} Closed ${trade.token || ""} position${trade.pnl ? ` | PnL: ${trade.pnl}` : ""}`);
+    } else {
+      lines.push(`${icon} ${trade.action.toUpperCase()} ${trade.amount || ""} ${trade.token || ""}`);
+    }
+    if (trade.price) lines.push(`Price: $${trade.price}`);
+    if (trade.hash) lines.push(`tx: ${trade.hash}`);
+    if (trade.extra) lines.push(trade.extra);
+    const content = lines.join("<br>");
+    return this.createThread(content);
+  }
+  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 ethers8 } 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 ethers8.Contract(ethers8.getAddress(SAVAX_ADDRESS), SAVAX_ABI, provider);
+  }
+  savax;
+  // ── sAVAX Liquid Staking ──
+  /** Get sAVAX staking info: exchange rate, total staked, your balance */
+  async sAvaxInfo(wallet2) {
+    const [totalPooled, totalShares] = await Promise.all([
+      this.savax.totalPooledAvax(),
+      this.savax.totalShares()
+    ]);
+    const exchangeRate = totalShares > 0n ? ethers8.formatEther(totalPooled * ethers8.parseEther("1") / totalShares) : "1.0";
+    const result = {
+      exchangeRate,
+      totalPooledAvax: ethers8.formatEther(totalPooled),
+      totalShares: ethers8.formatEther(totalShares)
+    };
+    if (wallet2) {
+      const balance = await this.savax.balanceOf(wallet2);
+      const avaxValue = await this.savax.getPooledAvaxByShares(balance);
+      result.balance = ethers8.formatEther(balance);
+      result.balanceInAvax = ethers8.formatEther(avaxValue);
+    }
+    return result;
+  }
+  /** Quote: how much sAVAX for staking AVAX */
+  async sAvaxStakeQuote(avaxAmount) {
+    const avaxWei = ethers8.parseEther(avaxAmount);
+    const shares = await this.savax.getSharesByPooledAvax(avaxWei);
+    return { avaxIn: avaxAmount, savaxOut: ethers8.formatEther(shares) };
+  }
+  /** Build tx to stake AVAX → sAVAX */
+  async buildSAvaxStake(avaxAmount) {
+    const avaxWei = ethers8.parseEther(avaxAmount);
+    const iface = new ethers8.Interface(SAVAX_ABI);
+    const data = iface.encodeFunctionData("submit", []);
+    return {
+      transactions: [{
+        to: ethers8.getAddress(SAVAX_ADDRESS),
+        data,
+        value: ethers8.toBeHex(avaxWei, 32),
+        chainId: CHAIN_ID,
+        gasLimit: "300000",
+        description: `Stake ${avaxAmount} AVAX \u2192 sAVAX`
+      }]
+    };
+  }
+  /** Build tx to request unstake sAVAX → AVAX (delayed) */
+  async buildSAvaxUnstake(wallet2, amount) {
+    let shareAmount;
+    if (amount === "max") {
+      shareAmount = await this.savax.balanceOf(wallet2);
+    } else {
+      shareAmount = ethers8.parseEther(amount);
+    }
+    if (shareAmount === 0n) throw new Error("Zero sAVAX balance");
+    const iface = new ethers8.Interface(SAVAX_ABI);
+    const data = iface.encodeFunctionData("requestUnlock", [shareAmount]);
+    return {
+      transactions: [{
+        to: ethers8.getAddress(SAVAX_ADDRESS),
+        data,
+        value: "0",
+        chainId: CHAIN_ID,
+        gasLimit: "300000",
+        description: `Request unstake ${ethers8.formatEther(shareAmount)} sAVAX`
+      }]
+    };
+  }
+  // ── ERC-4626 Vaults ──
+  /** Get info about any ERC-4626 vault */
+  async vaultInfo(vaultAddress, wallet2) {
+    const vault = new ethers8.Contract(ethers8.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 ? ethers8.formatUnits(totalAssets * 10n ** BigInt(decimals) / totalSupply, decimals) : "1.0";
+    const result = {
+      name,
+      symbol,
+      asset,
+      totalAssets: ethers8.formatUnits(totalAssets, decimals),
+      totalSupply: ethers8.formatUnits(totalSupply, decimals),
+      sharePrice
+    };
+    if (wallet2) {
+      const shares = await vault.balanceOf(wallet2);
+      const assets = shares > 0n ? await vault.convertToAssets(shares) : 0n;
+      result.userShares = ethers8.formatUnits(shares, decimals);
+      result.userAssets = ethers8.formatUnits(assets, decimals);
+    }
+    return result;
+  }
+  /** Quote vault deposit — how many shares for given assets */
+  async vaultDepositQuote(vaultAddress, amount) {
+    const vault = new ethers8.Contract(ethers8.getAddress(vaultAddress), VAULT_ABI, this.provider);
+    const decimals = Number(await vault.decimals());
+    const assetsWei = ethers8.parseUnits(amount, decimals);
+    const shares = await vault.previewDeposit(assetsWei);
+    return { assetsIn: amount, sharesOut: ethers8.formatUnits(shares, decimals) };
+  }
+  /** Build txs to deposit into an ERC-4626 vault: [approve, deposit] */
+  async buildVaultDeposit(wallet2, vaultAddress, amount) {
+    const vaultAddr = ethers8.getAddress(vaultAddress);
+    const vault = new ethers8.Contract(vaultAddr, VAULT_ABI, this.provider);
+    const assetAddr = await vault.asset();
+    const assetToken = new ethers8.Contract(assetAddr, ERC20_ABI2, this.provider);
+    const decimals = Number(await assetToken.decimals());
+    let depositAmount;
+    if (amount === "max") {
+      depositAmount = await assetToken.balanceOf(wallet2);
+    } else {
+      depositAmount = ethers8.parseUnits(amount, decimals);
+    }
+    if (depositAmount === 0n) throw new Error("Zero balance to deposit");
+    const erc20Iface = new ethers8.Interface(ERC20_ABI2);
+    const approveData = erc20Iface.encodeFunctionData("approve", [vaultAddr, depositAmount]);
+    const vaultIface = new ethers8.Interface(VAULT_ABI);
+    const depositData = vaultIface.encodeFunctionData("deposit", [depositAmount, wallet2]);
+    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 ${ethers8.formatUnits(depositAmount, decimals)} into vault` }
+      ]
+    };
+  }
+  /** Build tx to withdraw from an ERC-4626 vault */
+  async buildVaultWithdraw(wallet2, vaultAddress, amount) {
+    const vaultAddr = ethers8.getAddress(vaultAddress);
+    const vault = new ethers8.Contract(vaultAddr, VAULT_ABI, this.provider);
+    const decimals = Number(await vault.decimals());
+    let withdrawAmount;
+    if (amount === "max") {
+      const shares = await vault.balanceOf(wallet2);
+      withdrawAmount = await vault.convertToAssets(shares);
+    } else {
+      withdrawAmount = ethers8.parseUnits(amount, decimals);
+    }
+    if (withdrawAmount === 0n) throw new Error("Nothing to withdraw");
+    const iface = new ethers8.Interface(VAULT_ABI);
+    const data = iface.encodeFunctionData("withdraw", [withdrawAmount, wallet2, wallet2]);
+    return {
+      transactions: [{
+        to: vaultAddr,
+        data,
+        value: "0",
+        chainId: CHAIN_ID,
+        gasLimit: "300000",
+        description: `Withdraw ${ethers8.formatUnits(withdrawAmount, decimals)} from vault`
+      }]
+    };
+  }
+};
+
+// src/modules/copytrading.ts
+var CopyTradingModule = class {
+  perps;
+  constructor(perps) {
+    this.perps = perps;
+  }
+  /** Fetch all open positions for a Hyperliquid wallet */
+  async getTargetPositions(targetWallet) {
+    const state = await this.perps.getPositions(targetWallet);
+    const assetPositions = state?.assetPositions ?? [];
+    return assetPositions.map((ap) => ap.position).filter((p) => p && parseFloat(p.szi) !== 0);
+  }
+  /** Fetch your agent's current positions */
+  async getAgentPositions(agentWallet) {
+    const state = await this.perps.getPositions(agentWallet);
+    const assetPositions = state?.assetPositions ?? [];
+    return assetPositions.map((ap) => ap.position).filter((p) => p && parseFloat(p.szi) !== 0);
+  }
+  /**
+   * Compare target wallet positions with agent positions and return orders needed to mirror.
+   * Uses proportional sizing based on the scale factor.
+   *
+   * @param targetWallet - Wallet to copy from
+   * @param agentWallet - Your agent's wallet
+   * @param scaleFactor - Position scale (0.1 = 10% of target size, 1.0 = same size)
+   */
+  async calculateMirrorOrders(targetWallet, agentWallet, scaleFactor = 0.1) {
+    const [targetPositions, agentPositions] = await Promise.all([
+      this.getTargetPositions(targetWallet),
+      this.getAgentPositions(agentWallet)
+    ]);
+    const agentMap = /* @__PURE__ */ new Map();
+    for (const p of agentPositions) {
+      agentMap.set(p.coin, p);
+    }
+    const targetMap = /* @__PURE__ */ new Map();
+    for (const p of targetPositions) {
+      targetMap.set(p.coin, p);
+    }
+    const orders = [];
+    for (const [coin, targetPos] of targetMap) {
+      const targetSize = parseFloat(targetPos.szi);
+      const direction = targetSize > 0 ? "long" : "short";
+      const desiredSize = Math.abs(targetSize) * scaleFactor;
+      const agentPos = agentMap.get(coin);
+      if (!agentPos) {
+        orders.push({ symbol: coin, direction, size: desiredSize, action: "open", reason: `Mirror ${coin} ${direction} from target` });
+      } else {
+        const agentSize = parseFloat(agentPos.szi);
+        const agentDir = agentSize > 0 ? "long" : "short";
+        if (agentDir !== direction) {
+          orders.push({ symbol: coin, direction: agentDir, size: Math.abs(agentSize), action: "close", reason: `Close ${agentDir} to flip to ${direction}` });
+          orders.push({ symbol: coin, direction, size: desiredSize, action: "open", reason: `Mirror ${coin} ${direction} from target` });
+        }
+      }
+    }
+    for (const [coin, agentPos] of agentMap) {
+      if (!targetMap.has(coin)) {
+        const agentSize = parseFloat(agentPos.szi);
+        const dir = agentSize > 0 ? "long" : "short";
+        orders.push({ symbol: coin, direction: dir, size: Math.abs(agentSize), action: "close", reason: `Target closed ${coin} position` });
+      }
+    }
+    return { orders, targetPositions, agentPositions };
+  }
+  /**
+   * Execute mirror orders via the perps module (Arena API).
+   * Returns results for each order.
+   */
+  async executeMirrorOrders(orders, currentPrices) {
+    const results = [];
+    for (const order of orders) {
+      const price = currentPrices[order.symbol];
+      if (!price) {
+        results.push({ order, error: `No price for ${order.symbol}` });
+        continue;
+      }
+      try {
+        if (order.action === "close") {
+          const result = await this.perps.closePosition(order.symbol, order.direction, order.size, price);
+          results.push({ order, result });
+        } else {
+          const result = await this.perps.placeOrder([{
+            symbol: order.symbol,
+            direction: order.direction,
+            orderType: "market",
+            leverageType: "cross",
+            size: order.size,
+            leverage: 1
+          }]);
+          results.push({ order, result });
+        }
+      } catch (e) {
+        results.push({ order, error: e.message });
+      }
+    }
+    return results;
+  }
+  /**
+   * One-shot copy: calculate + execute mirror orders in one call.
+   * Fetches current prices from Hyperliquid for execution.
+   */
+  async copyOnce(targetWallet, agentWallet, scaleFactor = 0.1) {
+    const { orders } = await this.calculateMirrorOrders(targetWallet, agentWallet, scaleFactor);
+    if (orders.length === 0) return { orders, results: [] };
+    const pairs = await this.perps.getTradingPairs();
+    const midPrices = await this.fetchMidPrices(orders.map((o) => o.symbol), pairs.pairs);
+    const results = await this.executeMirrorOrders(orders, midPrices);
+    return { orders, results };
+  }
+  /** Fetch mid-market prices from Hyperliquid for given symbols */
+  async fetchMidPrices(symbols, pairs) {
+    const res = await fetch(HL_INFO, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ type: "allMids" })
+    });
+    if (!res.ok) throw new Error(`Failed to fetch mid prices: ${res.status}`);
+    const mids = await res.json();
+    const prices = {};
+    for (const sym of symbols) {
+      if (mids[sym]) prices[sym] = parseFloat(mids[sym]);
+    }
+    return prices;
+  }
+};
+
+// 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;
+  /** Copy trading — mirror Hyperliquid wallet positions */
+  copyTrading;
+  /** 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 = ethers9.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);
+    this.copyTrading = new CopyTradingModule(this.perps);
+  }
+  // ── Factory Methods ──
+  /** Generate a brand new agent wallet */
+  static generate(config = {}) {
+    const wallet2 = AgentWallet.generate({ network: config.network, rpcUrl: config.rpcUrl });
+    return new _Logiqical({ ...config, privateKey: wallet2.privateKey });
+  }
+  /** Boot from encrypted keystore — creates wallet on first run, loads on subsequent runs */
+  static async boot(config = {}) {
+    const wallet2 = await AgentWallet.boot({
+      network: config.network,
+      rpcUrl: config.rpcUrl,
+      password: config.password,
+      keystoreName: config.keystoreName
+    });
+    return new _Logiqical({ ...config, privateKey: wallet2.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 ethers9.Interface(intent.abi);
+    const data = iface.encodeFunctionData(intent.method, intent.args ?? []);
+    const valueWei = intent.value ? ethers9.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 Contract2(
+      ethers9.getAddress(intent.contract),
+      intent.abi,
+      this.agentWallet.wallet
+    );
+    const tx = await contract[intent.method](
+      ...intent.args ?? [],
+      {
+        value: intent.value ? ethers9.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(ethers9.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 = ethers9.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(policy2) {
+    this.policyEngine.setPolicy(policy2);
+  }
+  /** 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 ethers9.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 JsonRpcProvider3(rpcUrl, chainId) };
+  }
+};
+
+// src/cli/admin.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { createInterface } from "readline";
+var CONFIG_DIR = join2(homedir2(), ".logiqical");
+var CONFIG_FILE = join2(CONFIG_DIR, "config.json");
+var KEYS_DIR = join2(CONFIG_DIR, "keys");
+function ensureDir(dir) {
+  if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
+}
+function loadConfig() {
+  if (existsSync2(CONFIG_FILE)) return JSON.parse(readFileSync2(CONFIG_FILE, "utf-8"));
+  return {};
+}
+function saveConfig(config) {
+  ensureDir(CONFIG_DIR);
+  writeFileSync2(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function ask(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function log(msg) {
+  console.log(msg);
+}
+function bold(s) {
+  return `\x1B[1m${s}\x1B[0m`;
+}
+function green(s) {
+  return `\x1B[32m${s}\x1B[0m`;
+}
+function yellow(s) {
+  return `\x1B[33m${s}\x1B[0m`;
+}
+function dim(s) {
+  return `\x1B[2m${s}\x1B[0m`;
+}
+async function setup() {
+  log("");
+  log(bold("  Logiqical Agent Setup"));
+  log(dim("  Non-custodial agent wallet for Avalanche + Arena"));
+  log("");
+  const keystorePath = join2(KEYS_DIR, "agent.json");
+  let agent;
+  if (existsSync2(keystorePath)) {
+    log(green("  [1/4] Wallet found"));
+    agent = await Logiqical.boot();
+    log(`        Address: ${agent.address}`);
+  } else {
+    log(bold("  [1/4] Creating wallet..."));
+    agent = await Logiqical.boot();
+    log(green(`        Created: ${agent.address}`));
+    log(`        Keystore: ~/.logiqical/keys/agent.json`);
+  }
+  log("");
+  log(bold("  [2/4] Checking balance..."));
+  const balance = await agent.getBalance();
+  log(`        AVAX: ${balance}`);
+  if (parseFloat(balance) === 0) {
+    log(yellow("        Wallet is empty. Send AVAX to your agent address to start trading."));
+    log(`        ${agent.address}`);
+  }
+  log("");
+  const config = loadConfig();
+  if (config.arenaApiKey) {
+    log(green("  [3/4] Arena API key configured"));
+  } else {
+    log(bold("  [3/4] Arena API key"));
+    log(dim("        Required for social, perps, and tickets."));
+    log(dim("        Get one at https://arena.social or use agent_register tool."));
+    const key = await ask("        Arena API key (or press Enter to skip): ");
+    if (key) {
+      config.arenaApiKey = key;
+      saveConfig(config);
+      log(green("        Saved!"));
+    } else {
+      log(dim("        Skipped. You can set it later with: logiqical config arena-key <key>"));
+    }
+  }
+  log("");
+  if (config.policy) {
+    log(green("  [4/4] Spending policy configured"));
+    log(`        Max per tx: ${config.policy.maxPerTx || "none"}`);
+    log(`        Max per day: ${config.policy.maxPerDay || "none"}`);
+  } else {
+    log(bold("  [4/4] Spending policy"));
+    log(dim("        Protect your agent with guardrails."));
+    const maxPerTx = await ask("        Max AVAX per transaction (or Enter for 1.0): ");
+    const maxPerDay = await ask("        Max AVAX per day (or Enter for 10.0): ");
+    const simulate = await ask("        Simulate before sending? (Y/n): ");
+    config.policy = {
+      maxPerTx: maxPerTx || "1.0",
+      maxPerDay: maxPerDay || "10.0",
+      simulateBeforeSend: simulate.toLowerCase() !== "n"
+    };
+    saveConfig(config);
+    log(green("        Policy saved!"));
+  }
+  log("");
+  log(green("  Setup complete!"));
+  log("");
+  log("  Next steps:");
+  log(`    ${dim("1.")} Fund your wallet: send AVAX to ${agent.address}`);
+  log(`    ${dim("2.")} Start MCP server: ${bold("npx logiqical-mcp")}`);
+  log(`    ${dim("3.")} Or use the SDK: ${bold("import { Logiqical } from 'logiqical'")}`);
+  log("");
+}
+async function wallet() {
+  const agent = await Logiqical.boot();
+  const balance = await agent.getBalance();
+  log("");
+  log(bold("  Agent Wallet"));
+  log(`  Address:  ${agent.address}`);
+  log(`  Balance:  ${balance} AVAX`);
+  log(`  Network:  Avalanche C-Chain (43114)`);
+  log(`  Keystore: ~/.logiqical/keys/agent.json`);
+  log(`  Can sign: ${agent.canSign ? green("yes") : "no"}`);
+  log("");
+}
+async function status() {
+  const config = loadConfig();
+  const keystorePath = join2(KEYS_DIR, "agent.json");
+  const hasWallet = existsSync2(keystorePath);
+  log("");
+  log(bold("  Logiqical Status"));
+  log("");
+  if (hasWallet) {
+    const agent = await Logiqical.boot();
+    const balance = await agent.getBalance();
+    log(`  Wallet:      ${green(agent.address)}`);
+    log(`  Balance:     ${balance} AVAX`);
+  } else {
+    log(`  Wallet:      ${yellow("not created")} \u2014 run ${bold("logiqical setup")}`);
+  }
+  log(`  Arena key:   ${config.arenaApiKey ? green("configured") : yellow("not set")}`);
+  if (config.policy) {
+    log(`  Policy:      max/tx: ${config.policy.maxPerTx}, max/day: ${config.policy.maxPerDay}, simulate: ${config.policy.simulateBeforeSend}`);
+  } else {
+    log(`  Policy:      ${yellow("not set")} \u2014 run ${bold("logiqical setup")}`);
+  }
+  log(`  Config:      ${CONFIG_FILE}`);
+  log(`  Keystore:    ${KEYS_DIR}/`);
+  log("");
+}
+async function policy(args) {
+  const config = loadConfig();
+  if (args.length === 0) {
+    if (!config.policy) {
+      log("  No policy set. Run: logiqical setup");
+      return;
+    }
+    log("");
+    log(bold("  Spending Policy"));
+    log(`  Max per tx:    ${config.policy.maxPerTx || "none"}`);
+    log(`  Max per hour:  ${config.policy.maxPerHour || "none"}`);
+    log(`  Max per day:   ${config.policy.maxPerDay || "none"}`);
+    log(`  Simulate:      ${config.policy.simulateBeforeSend ?? true}`);
+    log(`  Dry run:       ${config.policy.dryRun ?? false}`);
+    log("");
+    return;
+  }
+  const [key, value] = args;
+  if (!config.policy) config.policy = {};
+  const keyMap = {
+    "max-per-tx": "maxPerTx",
+    "max-per-hour": "maxPerHour",
+    "max-per-day": "maxPerDay",
+    "simulate": "simulateBeforeSend",
+    "dry-run": "dryRun"
+  };
+  const configKey = keyMap[key];
+  if (!configKey) {
+    log(`  Unknown policy key: ${key}`);
+    log(`  Valid keys: ${Object.keys(keyMap).join(", ")}`);
+    return;
+  }
+  if (configKey === "simulateBeforeSend" || configKey === "dryRun") {
+    config.policy[configKey] = value === "true" || value === "yes" || value === "1";
+  } else {
+    config.policy[configKey] = value;
+  }
+  saveConfig(config);
+  log(green(`  Policy updated: ${key} = ${value}`));
+}
+async function configCmd(args) {
+  const config = loadConfig();
+  if (args.length === 0) {
+    log(JSON.stringify(config, null, 2));
+    return;
+  }
+  const [key, ...rest] = args;
+  const value = rest.join(" ");
+  if (key === "arena-key") {
+    config.arenaApiKey = value;
+    saveConfig(config);
+    log(green(`  Arena API key saved.`));
+  } else if (key === "network") {
+    if (!CHAINS[value]) {
+      log(`  Unknown network: ${value}`);
+      log(`  Available: ${Object.keys(CHAINS).join(", ")}`);
+      return;
+    }
+    config.network = value;
+    saveConfig(config);
+    log(green(`  Network set to: ${value}`));
+  } else {
+    log(`  Unknown config key: ${key}`);
+    log(`  Valid keys: arena-key, network`);
+  }
+}
+function help() {
+  log("");
+  log(bold("  logiqical") + " \u2014 agent wallet CLI for Avalanche + Arena");
+  log("");
+  log("  Commands:");
+  log(`    ${bold("setup")}              Interactive wallet + policy setup`);
+  log(`    ${bold("wallet")}             Show wallet address and balance`);
+  log(`    ${bold("status")}             Show full agent status`);
+  log(`    ${bold("policy")}             Show spending policy`);
+  log(`    ${bold("policy")} <key> <val> Set a policy value`);
+  log(`    ${bold("config")}             Show config`);
+  log(`    ${bold("config")} arena-key   Set Arena API key`);
+  log(`    ${bold("config")} network     Set default network`);
+  log(`    ${bold("mcp")}                Start MCP server (stdio)`);
+  log(`    ${bold("vault")}              Start vault daemon (signer)`);
+  log(`    ${bold("help")}               Show this help`);
+  log("");
+  log("  Examples:");
+  log(`    logiqical setup`);
+  log(`    logiqical policy max-per-tx 2.0`);
+  log(`    logiqical config arena-key arena_abc123`);
+  log(`    logiqical mcp`);
+  log("");
+}
+async function main() {
+  const [cmd, ...args] = process.argv.slice(2);
+  switch (cmd) {
+    case "setup":
+      return setup();
+    case "wallet":
+      return wallet();
+    case "status":
+      return status();
+    case "policy":
+      return policy(args);
+    case "config":
+      return configCmd(args);
+    case "help":
+    case "--help":
+    case "-h":
+    case void 0:
+      return help();
+    default:
+      log(`  Unknown command: ${cmd}`);
+      help();
+  }
+}
+main().catch((e) => {
+  console.error("Error:", e.message);
+  process.exit(1);
+});