logiqical 0.3.0 → 0.4.0

package/dist/cli.mjs

@@ -4,7 +4,7 @@
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/client.ts
-import { ethers as ethers8, JsonRpcProvider as JsonRpcProvider2, Contract } from "ethers";
+import { ethers as ethers9, JsonRpcProvider as JsonRpcProvider3, Contract as Contract2 } from "ethers";
 
 // src/wallet.ts
 import {
@@ -445,6 +445,10 @@ 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)",
@@ -1141,6 +1145,7 @@ var DexModule = class {
 };
 
 // src/modules/perps.ts
+import { ethers as ethers6, JsonRpcProvider as JsonRpcProvider2, Contract } from "ethers";
 var PerpsModule = class {
   constructor(arenaApiKey) {
     this.arenaApiKey = arenaApiKey;
@@ -1234,6 +1239,51 @@ var PerpsModule = class {
   async getOpenOrders(wallet) {
     return this.hlPost({ type: "openOrders", user: wallet });
   }
+  // ── USDC Deposit to Hyperliquid (on Arbitrum) ──
+  /** Check USDC balance on Arbitrum */
+  async getArbitrumUSDCBalance(wallet) {
+    const provider = new JsonRpcProvider2(ARBITRUM_RPC, ARBITRUM_CHAIN_ID);
+    const usdc = new Contract(USDC_ARBITRUM, ERC20_ABI, provider);
+    const balance = await usdc.balanceOf(wallet);
+    return ethers6.formatUnits(balance, 6);
+  }
+  /** Check ETH balance on Arbitrum (needed for gas) */
+  async getArbitrumETHBalance(wallet) {
+    const provider = new JsonRpcProvider2(ARBITRUM_RPC, ARBITRUM_CHAIN_ID);
+    const balance = await provider.getBalance(wallet);
+    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
@@ -1390,37 +1440,37 @@ var BridgeModule = class {
 };
 
 // src/modules/tickets.ts
-import { ethers as ethers6 } from "ethers";
+import { ethers as ethers7 } from "ethers";
 var TicketsModule = class {
   constructor(provider) {
     this.provider = provider;
-    this.contract = new ethers6.Contract(ethers6.getAddress(ARENA_SHARES_CONTRACT), SHARES_ABI, 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 = ethers6.getAddress(subject);
+    const subjectAddr = ethers7.getAddress(subject);
     const [price, priceWithFee] = await Promise.all([
       this.contract.getBuyPriceForFractionalShares(subjectAddr, fractionalAmount),
       this.contract.getBuyPriceForFractionalSharesAfterFee(subjectAddr, fractionalAmount)
     ]);
-    return { price: ethers6.formatEther(price), priceWithFee: ethers6.formatEther(priceWithFee), tickets: amount, fractionalAmount };
+    return { price: ethers7.formatEther(price), priceWithFee: ethers7.formatEther(priceWithFee), tickets: amount, fractionalAmount };
   }
   async getSellPrice(subject, amount = "1") {
     const fractionalAmount = this.ticketsToFractional(amount);
-    const subjectAddr = ethers6.getAddress(subject);
+    const subjectAddr = ethers7.getAddress(subject);
     const [price, priceAfterFee] = await Promise.all([
       this.contract.getSellPriceForFractionalShares(subjectAddr, fractionalAmount),
       this.contract.getSellPriceForFractionalSharesAfterFee(subjectAddr, fractionalAmount)
     ]);
-    return { price: ethers6.formatEther(price), priceAfterFee: ethers6.formatEther(priceAfterFee), tickets: amount, fractionalAmount };
+    return { price: ethers7.formatEther(price), priceAfterFee: ethers7.formatEther(priceAfterFee), tickets: amount, fractionalAmount };
   }
   async getBalance(subject, user) {
-    const frac = await this.contract.getMyFractionalShares(ethers6.getAddress(subject), ethers6.getAddress(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 = ethers6.getAddress(subject);
+    const subjectAddr = ethers7.getAddress(subject);
     const [wholeSupply, fracSupply] = await Promise.all([
       this.contract.getSharesSupply(subjectAddr),
       this.contract.getTotalFractionalSupply(subjectAddr)
@@ -1438,42 +1488,42 @@ var TicketsModule = class {
   }
   async buildBuyTx(wallet, subject, amount = "1") {
     const fractionalAmount = this.ticketsToFractional(amount);
-    const subjectAddr = ethers6.getAddress(subject);
-    const userAddr = ethers6.getAddress(wallet);
+    const subjectAddr = ethers7.getAddress(subject);
+    const userAddr = ethers7.getAddress(wallet);
     const cost = await this.contract.getBuyPriceForFractionalSharesAfterFee(subjectAddr, fractionalAmount);
     if (cost === 0n) throw new Error("Could not get buy price \u2014 subject may not exist");
-    const iface = new ethers6.Interface(SHARES_ABI);
+    const iface = new ethers7.Interface(SHARES_ABI);
     const data = iface.encodeFunctionData("buyFractionalShares", [subjectAddr, userAddr, fractionalAmount]);
     return {
       transaction: {
-        to: ethers6.getAddress(ARENA_SHARES_CONTRACT),
+        to: ethers7.getAddress(ARENA_SHARES_CONTRACT),
         data,
-        value: ethers6.toBeHex(cost, 32),
+        value: ethers7.toBeHex(cost, 32),
         chainId: CHAIN_ID,
         gasLimit: "200000",
-        description: `Buy ${amount} ticket(s) for ~${ethers6.formatEther(cost)} AVAX`
+        description: `Buy ${amount} ticket(s) for ~${ethers7.formatEther(cost)} AVAX`
       }
     };
   }
   async buildSellTx(wallet, subject, amount = "1") {
     const fractionalAmount = this.ticketsToFractional(amount);
-    const subjectAddr = ethers6.getAddress(subject);
-    const userAddr = ethers6.getAddress(wallet);
+    const subjectAddr = ethers7.getAddress(subject);
+    const userAddr = ethers7.getAddress(wallet);
     const balance = await this.contract.getMyFractionalShares(subjectAddr, userAddr);
     if (balance < BigInt(fractionalAmount)) {
       throw new Error(`Insufficient tickets: have ${Number(balance) / FRACTION_SCALER}, trying to sell ${amount}`);
     }
     const proceeds = await this.contract.getSellPriceForFractionalSharesAfterFee(subjectAddr, fractionalAmount);
-    const iface = new ethers6.Interface(SHARES_ABI);
+    const iface = new ethers7.Interface(SHARES_ABI);
     const data = iface.encodeFunctionData("sellFractionalShares", [subjectAddr, userAddr, fractionalAmount]);
     return {
       transaction: {
-        to: ethers6.getAddress(ARENA_SHARES_CONTRACT),
+        to: ethers7.getAddress(ARENA_SHARES_CONTRACT),
         data,
         value: "0x0",
         chainId: CHAIN_ID,
         gasLimit: "200000",
-        description: `Sell ${amount} ticket(s) for ~${ethers6.formatEther(proceeds)} AVAX`
+        description: `Sell ${amount} ticket(s) for ~${ethers7.formatEther(proceeds)} AVAX`
       }
     };
   }
@@ -1492,6 +1542,53 @@ var SocialModule = class {
   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}`;
@@ -1945,7 +2042,7 @@ var MarketModule = class {
 };
 
 // src/modules/defi.ts
-import { ethers as ethers7 } from "ethers";
+import { ethers as ethers8 } from "ethers";
 var SAVAX_ADDRESS = "0x2b2C81e08f1Af8835a78Bb2A90AE924ACE0eA4bE";
 var SAVAX_ABI = [
   "function submit() payable returns (uint256)",
@@ -1986,7 +2083,7 @@ var ERC20_ABI2 = [
 var DefiModule = class {
   constructor(provider) {
     this.provider = provider;
-    this.savax = new ethers7.Contract(ethers7.getAddress(SAVAX_ADDRESS), SAVAX_ABI, provider);
+    this.savax = new ethers8.Contract(ethers8.getAddress(SAVAX_ADDRESS), SAVAX_ABI, provider);
   }
   savax;
   // ── sAVAX Liquid Staking ──
@@ -1996,36 +2093,36 @@ var DefiModule = class {
       this.savax.totalPooledAvax(),
       this.savax.totalShares()
     ]);
-    const exchangeRate = totalShares > 0n ? ethers7.formatEther(totalPooled * ethers7.parseEther("1") / totalShares) : "1.0";
+    const exchangeRate = totalShares > 0n ? ethers8.formatEther(totalPooled * ethers8.parseEther("1") / totalShares) : "1.0";
     const result = {
       exchangeRate,
-      totalPooledAvax: ethers7.formatEther(totalPooled),
-      totalShares: ethers7.formatEther(totalShares)
+      totalPooledAvax: ethers8.formatEther(totalPooled),
+      totalShares: ethers8.formatEther(totalShares)
     };
     if (wallet) {
       const balance = await this.savax.balanceOf(wallet);
       const avaxValue = await this.savax.getPooledAvaxByShares(balance);
-      result.balance = ethers7.formatEther(balance);
-      result.balanceInAvax = ethers7.formatEther(avaxValue);
+      result.balance = ethers8.formatEther(balance);
+      result.balanceInAvax = ethers8.formatEther(avaxValue);
     }
     return result;
   }
   /** Quote: how much sAVAX for staking AVAX */
   async sAvaxStakeQuote(avaxAmount) {
-    const avaxWei = ethers7.parseEther(avaxAmount);
+    const avaxWei = ethers8.parseEther(avaxAmount);
     const shares = await this.savax.getSharesByPooledAvax(avaxWei);
-    return { avaxIn: avaxAmount, savaxOut: ethers7.formatEther(shares) };
+    return { avaxIn: avaxAmount, savaxOut: ethers8.formatEther(shares) };
   }
   /** Build tx to stake AVAX → sAVAX */
   async buildSAvaxStake(avaxAmount) {
-    const avaxWei = ethers7.parseEther(avaxAmount);
-    const iface = new ethers7.Interface(SAVAX_ABI);
+    const avaxWei = ethers8.parseEther(avaxAmount);
+    const iface = new ethers8.Interface(SAVAX_ABI);
     const data = iface.encodeFunctionData("submit", []);
     return {
       transactions: [{
-        to: ethers7.getAddress(SAVAX_ADDRESS),
+        to: ethers8.getAddress(SAVAX_ADDRESS),
         data,
-        value: ethers7.toBeHex(avaxWei, 32),
+        value: ethers8.toBeHex(avaxWei, 32),
         chainId: CHAIN_ID,
         gasLimit: "300000",
         description: `Stake ${avaxAmount} AVAX \u2192 sAVAX`
@@ -2038,26 +2135,26 @@ var DefiModule = class {
     if (amount === "max") {
       shareAmount = await this.savax.balanceOf(wallet);
     } else {
-      shareAmount = ethers7.parseEther(amount);
+      shareAmount = ethers8.parseEther(amount);
     }
     if (shareAmount === 0n) throw new Error("Zero sAVAX balance");
-    const iface = new ethers7.Interface(SAVAX_ABI);
+    const iface = new ethers8.Interface(SAVAX_ABI);
     const data = iface.encodeFunctionData("requestUnlock", [shareAmount]);
     return {
       transactions: [{
-        to: ethers7.getAddress(SAVAX_ADDRESS),
+        to: ethers8.getAddress(SAVAX_ADDRESS),
         data,
         value: "0",
         chainId: CHAIN_ID,
         gasLimit: "300000",
-        description: `Request unstake ${ethers7.formatEther(shareAmount)} sAVAX`
+        description: `Request unstake ${ethers8.formatEther(shareAmount)} sAVAX`
       }]
     };
   }
   // ── ERC-4626 Vaults ──
   /** Get info about any ERC-4626 vault */
   async vaultInfo(vaultAddress, wallet) {
-    const vault = new ethers7.Contract(ethers7.getAddress(vaultAddress), VAULT_ABI, this.provider);
+    const 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(),
@@ -2066,70 +2163,70 @@ var DefiModule = class {
       vault.totalSupply(),
       vault.decimals()
     ]);
-    const sharePrice = totalSupply > 0n ? ethers7.formatUnits(totalAssets * 10n ** BigInt(decimals) / totalSupply, decimals) : "1.0";
+    const sharePrice = totalSupply > 0n ? ethers8.formatUnits(totalAssets * 10n ** BigInt(decimals) / totalSupply, decimals) : "1.0";
     const result = {
       name,
       symbol,
       asset,
-      totalAssets: ethers7.formatUnits(totalAssets, decimals),
-      totalSupply: ethers7.formatUnits(totalSupply, decimals),
+      totalAssets: ethers8.formatUnits(totalAssets, decimals),
+      totalSupply: ethers8.formatUnits(totalSupply, decimals),
       sharePrice
     };
     if (wallet) {
       const shares = await vault.balanceOf(wallet);
       const assets = shares > 0n ? await vault.convertToAssets(shares) : 0n;
-      result.userShares = ethers7.formatUnits(shares, decimals);
-      result.userAssets = ethers7.formatUnits(assets, decimals);
+      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 ethers7.Contract(ethers7.getAddress(vaultAddress), VAULT_ABI, this.provider);
+    const vault = new ethers8.Contract(ethers8.getAddress(vaultAddress), VAULT_ABI, this.provider);
     const decimals = Number(await vault.decimals());
-    const assetsWei = ethers7.parseUnits(amount, decimals);
+    const assetsWei = ethers8.parseUnits(amount, decimals);
     const shares = await vault.previewDeposit(assetsWei);
-    return { assetsIn: amount, sharesOut: ethers7.formatUnits(shares, decimals) };
+    return { assetsIn: amount, sharesOut: ethers8.formatUnits(shares, decimals) };
   }
   /** Build txs to deposit into an ERC-4626 vault: [approve, deposit] */
   async buildVaultDeposit(wallet, vaultAddress, amount) {
-    const vaultAddr = ethers7.getAddress(vaultAddress);
-    const vault = new ethers7.Contract(vaultAddr, VAULT_ABI, this.provider);
+    const vaultAddr = ethers8.getAddress(vaultAddress);
+    const vault = new ethers8.Contract(vaultAddr, VAULT_ABI, this.provider);
     const assetAddr = await vault.asset();
-    const assetToken = new ethers7.Contract(assetAddr, ERC20_ABI2, this.provider);
+    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(wallet);
     } else {
-      depositAmount = ethers7.parseUnits(amount, decimals);
+      depositAmount = ethers8.parseUnits(amount, decimals);
     }
     if (depositAmount === 0n) throw new Error("Zero balance to deposit");
-    const erc20Iface = new ethers7.Interface(ERC20_ABI2);
+    const erc20Iface = new ethers8.Interface(ERC20_ABI2);
     const approveData = erc20Iface.encodeFunctionData("approve", [vaultAddr, depositAmount]);
-    const vaultIface = new ethers7.Interface(VAULT_ABI);
+    const vaultIface = new ethers8.Interface(VAULT_ABI);
     const depositData = vaultIface.encodeFunctionData("deposit", [depositAmount, wallet]);
     return {
       transactions: [
         { to: assetAddr, data: approveData, value: "0", chainId: CHAIN_ID, gasLimit: "60000", description: `Approve asset for vault deposit` },
-        { to: vaultAddr, data: depositData, value: "0", chainId: CHAIN_ID, gasLimit: "300000", description: `Deposit ${ethers7.formatUnits(depositAmount, decimals)} into vault` }
+        { 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(wallet, vaultAddress, amount) {
-    const vaultAddr = ethers7.getAddress(vaultAddress);
-    const vault = new ethers7.Contract(vaultAddr, VAULT_ABI, this.provider);
+    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(wallet);
       withdrawAmount = await vault.convertToAssets(shares);
     } else {
-      withdrawAmount = ethers7.parseUnits(amount, decimals);
+      withdrawAmount = ethers8.parseUnits(amount, decimals);
     }
     if (withdrawAmount === 0n) throw new Error("Nothing to withdraw");
-    const iface = new ethers7.Interface(VAULT_ABI);
+    const iface = new ethers8.Interface(VAULT_ABI);
     const data = iface.encodeFunctionData("withdraw", [withdrawAmount, wallet, wallet]);
     return {
       transactions: [{
@@ -2138,12 +2235,139 @@ var DefiModule = class {
         value: "0",
         chainId: CHAIN_ID,
         gasLimit: "300000",
-        description: `Withdraw ${ethers7.formatUnits(withdrawAmount, decimals)} from vault`
+        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 */
@@ -2168,6 +2392,8 @@ var Logiqical = class _Logiqical {
   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) */
@@ -2188,7 +2414,7 @@ var Logiqical = class _Logiqical {
       this.provider = this.agentWallet.provider;
       this.address = this.agentWallet.address;
     } else if (config.mnemonic) {
-      const hdWallet = ethers8.HDNodeWallet.fromPhrase(config.mnemonic);
+      const hdWallet = ethers9.HDNodeWallet.fromPhrase(config.mnemonic);
       this.agentWallet = AgentWallet.fromPrivateKey(hdWallet.privateKey, {
         network: config.network,
         rpcUrl: config.rpcUrl
@@ -2214,6 +2440,7 @@ var Logiqical = class _Logiqical {
     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 */
@@ -2289,9 +2516,9 @@ var Logiqical = class _Logiqical {
    */
   async call(intent) {
     this.requireWallet("call");
-    const iface = new ethers8.Interface(intent.abi);
+    const iface = new ethers9.Interface(intent.abi);
     const data = iface.encodeFunctionData(intent.method, intent.args ?? []);
-    const valueWei = intent.value ? ethers8.parseEther(intent.value).toString() : "0";
+    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) {
@@ -2300,22 +2527,22 @@ var Logiqical = class _Logiqical {
     if (this.policyEngine.isDryRun) {
       return { hash: "0x_dry_run", receipt: { status: 1, blockNumber: 0, gasUsed: "0", transactionHash: "0x_dry_run" } };
     }
-    const contract = new Contract(
-      ethers8.getAddress(intent.contract),
+    const contract = new Contract2(
+      ethers9.getAddress(intent.contract),
       intent.abi,
       this.agentWallet.wallet
     );
     const tx = await contract[intent.method](
       ...intent.args ?? [],
       {
-        value: intent.value ? ethers8.parseEther(intent.value) : void 0,
+        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(ethers8.parseEther(intent.value));
+      this.policyEngine.recordSpend(ethers9.parseEther(intent.value));
     }
     return {
       hash: tx.hash,
@@ -2330,7 +2557,7 @@ var Logiqical = class _Logiqical {
   /** Send native token (AVAX) — policy check + simulate + sign + broadcast */
   async send(to, amount) {
     this.requireWallet("send");
-    const valueWei = ethers8.parseEther(amount);
+    const valueWei = ethers9.parseEther(amount);
     const policyTx = { to, data: "0x", value: valueWei.toString(), chainId: 43114 };
     this.policyEngine.check(policyTx);
     if (this.policyEngine.isDryRun) {
@@ -2397,7 +2624,7 @@ var Logiqical = class _Logiqical {
   async getBalance() {
     if (this.agentWallet) return this.agentWallet.getBalance();
     const balance = await this.provider.getBalance(this.address);
-    return ethers8.formatEther(balance);
+    return ethers9.formatEther(balance);
   }
   /** Sign a message */
   async signMessage(message) {
@@ -2448,7 +2675,7 @@ var Logiqical = class _Logiqical {
     }
     const rpcUrl = config.rpcUrl ?? chain.rpcUrl;
     const chainId = chain?.chainId ?? void 0;
-    return { provider: new JsonRpcProvider2(rpcUrl, chainId) };
+    return { provider: new JsonRpcProvider3(rpcUrl, chainId) };
   }
 };
 
@@ -3237,6 +3464,93 @@ function createMcpServer(agent) {
       return err(e);
     }
   });
+  server.tool("agent_register", "Register a new AI agent on Arena (returns API key \u2014 save immediately)", {
+    name: z.string().describe("Agent display name"),
+    handle: z.string().describe("Unique agent handle"),
+    address: z.string().describe("Agent wallet address"),
+    bio: z.string().optional().describe("Agent bio"),
+    profilePictureUrl: z.string().optional().describe("Profile picture URL"),
+    bannerUrl: z.string().optional().describe("Banner image URL")
+  }, async (opts) => {
+    try {
+      return ok(await SocialModule.registerAgent(opts));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("social_post_trade", "Auto-post a trade update to Arena feed", {
+    action: z.enum(["buy", "sell", "swap", "bridge", "stake", "long", "short", "close"]).describe("Trade action"),
+    token: z.string().optional().describe("Token symbol"),
+    amount: z.string().optional().describe("Amount traded"),
+    price: z.string().optional().describe("Price in USD"),
+    fromToken: z.string().optional().describe("Source token (for swaps)"),
+    toToken: z.string().optional().describe("Destination token (for swaps)"),
+    pnl: z.string().optional().describe("PnL for closed positions"),
+    hash: z.string().optional().describe("Transaction hash"),
+    extra: z.string().optional().describe("Additional info")
+  }, async (trade) => {
+    try {
+      return ok(await agent.social.postTradeUpdate(trade));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("copy_get_positions", "Get open positions of a Hyperliquid wallet (target for copy trading)", {
+    wallet: z.string().describe("Target wallet address to copy")
+  }, async ({ wallet }) => {
+    try {
+      return ok(await agent.copyTrading.getTargetPositions(wallet));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("copy_calculate_orders", "Compare target vs agent positions and calculate mirror orders", {
+    targetWallet: z.string().describe("Wallet to copy from"),
+    agentWallet: z.string().optional().describe("Your agent wallet (defaults to agent address)"),
+    scaleFactor: z.number().optional().describe("Position scale (0.1 = 10% of target size, default 0.1)")
+  }, async ({ targetWallet, agentWallet, scaleFactor }) => {
+    try {
+      return ok(await agent.copyTrading.calculateMirrorOrders(targetWallet, agentWallet || w, scaleFactor));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("copy_execute", "One-shot copy trade: mirror a wallet's positions (calculate + execute)", {
+    targetWallet: z.string().describe("Wallet to copy from"),
+    agentWallet: z.string().optional().describe("Your agent wallet (defaults to agent address)"),
+    scaleFactor: z.number().optional().describe("Position scale (0.1 = 10% of target size, default 0.1)")
+  }, async ({ targetWallet, agentWallet, scaleFactor }) => {
+    try {
+      return ok(await agent.copyTrading.copyOnce(targetWallet, agentWallet || w, scaleFactor));
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("perps_deposit_info", "Get Hyperliquid deposit info (addresses, chain, USDC)", {}, async () => {
+    try {
+      return ok(agent.perps.getDepositInfo());
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("perps_arbitrum_usdc_balance", "Check USDC balance on Arbitrum", {
+    wallet: z.string().optional().describe("Wallet (defaults to agent)")
+  }, async ({ wallet }) => {
+    try {
+      return ok({ balance: await agent.perps.getArbitrumUSDCBalance(wallet || w), token: "USDC", chain: "Arbitrum" });
+    } catch (e) {
+      return err(e);
+    }
+  });
+  server.tool("perps_deposit_usdc", "Build USDC deposit tx for Hyperliquid (execute on Arbitrum network)", {
+    amount: z.string().describe("USDC amount to deposit")
+  }, async ({ amount }) => {
+    try {
+      return ok(agent.perps.buildDepositUSDC(amount));
+    } catch (e) {
+      return err(e);
+    }
+  });
   server.tool("call_contract", "Call any smart contract method \u2014 signs and broadcasts", {
     contract: z.string().describe("Contract address"),
     abi: z.array(z.string()).describe("Human-readable ABI array"),