@exagent/agent 0.3.2 → 0.3.4

package/dist/chunk-CIEZAYOU.js

@@ -1,4701 +0,0 @@
-// src/config.ts
-import { readFileSync, existsSync, writeFileSync } from "fs";
-import { z } from "zod";
-var configSchema = z.object({
-  agentId: z.string(),
-  apiUrl: z.string().url(),
-  apiToken: z.string(),
-  wallet: z.object({
-    privateKey: z.string()
-  }).optional(),
-  llm: z.object({
-    provider: z.enum(["openai", "anthropic", "google", "deepseek", "mistral", "groq", "together", "ollama"]),
-    model: z.string().optional(),
-    apiKey: z.string().optional(),
-    endpoint: z.string().optional(),
-    temperature: z.number().min(0).max(2).optional(),
-    maxTokens: z.number().optional()
-  }),
-  strategy: z.object({
-    file: z.string().optional(),
-    template: z.string().optional()
-  }),
-  trading: z.object({
-    mode: z.enum(["live", "paper"]).default("paper"),
-    timeHorizon: z.enum(["intraday", "swing", "position"]).default("swing"),
-    maxPositionSizeBps: z.number().min(100).max(1e4).default(2e3),
-    maxDailyLossBps: z.number().min(0).max(1e4).default(500),
-    maxConcurrentPositions: z.number().min(1).max(100).default(5),
-    tradingIntervalMs: z.number().min(1e3).default(6e4),
-    maxSlippageBps: z.number().min(10).max(1e3).default(100),
-    minTradeValueUSD: z.number().min(0).default(10),
-    initialCapitalUSD: z.number().optional()
-  }),
-  venues: z.object({
-    hyperliquid_perp: z.object({
-      enabled: z.boolean().default(false),
-      apiUrl: z.string().default("https://api.hyperliquid.xyz"),
-      wsUrl: z.string().default("wss://api.hyperliquid.xyz/ws"),
-      maxLeverage: z.number().min(1).max(50).default(10),
-      maxNotionalUSD: z.number().default(5e4),
-      allowedInstruments: z.array(z.string()).optional()
-    }).optional(),
-    polymarket: z.object({
-      enabled: z.boolean().default(false),
-      clobApiUrl: z.string().default("https://clob.polymarket.com"),
-      gammaApiUrl: z.string().default("https://gamma-api.polymarket.com"),
-      maxNotionalUSD: z.number().default(1e3),
-      maxTotalExposureUSD: z.number().default(5e3),
-      allowedCategories: z.array(z.string()).optional()
-    }).optional(),
-    spot: z.object({
-      enabled: z.boolean().default(false),
-      chains: z.array(z.string()).default(["base"]),
-      defaultChain: z.string().default("base"),
-      maxSlippageBps: z.number().min(1).max(1e3).default(50),
-      maxSwapValueUSD: z.number().default(1e4)
-    }).optional(),
-    bridge: z.object({
-      enabled: z.boolean().default(false),
-      defaultBridge: z.string().default("across"),
-      maxBridgeValueUSD: z.number().default(1e4),
-      fillTimeoutMs: z.number().default(3e5),
-      pollIntervalMs: z.number().default(2e3)
-    }).optional()
-  }).optional(),
-  relay: z.object({
-    url: z.string(),
-    heartbeatIntervalMs: z.number().default(3e4),
-    reconnectMaxAttempts: z.number().default(50)
-  })
-});
-function loadConfig(path = "agent-config.json") {
-  if (!existsSync(path)) {
-    throw new Error(`Config file not found: ${path}. Run 'exagent init' first.`);
-  }
-  const raw = readFileSync(path, "utf-8");
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new Error(`Invalid JSON in ${path}`);
-  }
-  const config = parsed;
-  const llm = config.llm || {};
-  if (process.env.EXAGENT_LLM_PROVIDER) llm.provider = process.env.EXAGENT_LLM_PROVIDER;
-  if (process.env.EXAGENT_LLM_MODEL) llm.model = process.env.EXAGENT_LLM_MODEL;
-  if (process.env.EXAGENT_LLM_API_KEY) llm.apiKey = process.env.EXAGENT_LLM_API_KEY;
-  if (process.env.EXAGENT_API_URL) config.apiUrl = process.env.EXAGENT_API_URL;
-  if (process.env.EXAGENT_API_TOKEN) config.apiToken = process.env.EXAGENT_API_TOKEN;
-  if (process.env.EXAGENT_WALLET_PRIVATE_KEY) {
-    config.wallet = { privateKey: process.env.EXAGENT_WALLET_PRIVATE_KEY };
-  }
-  config.llm = llm;
-  const result = configSchema.safeParse(config);
-  if (!result.success) {
-    const issues = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
-    throw new Error(`Invalid config:
-${issues}`);
-  }
-  return result.data;
-}
-function generateSampleConfig(agentId, apiUrl) {
-  const config = {
-    agentId,
-    apiUrl,
-    apiToken: "<your-jwt-token>",
-    wallet: {
-      privateKey: "<your-hex-private-key>"
-    },
-    llm: {
-      provider: "openai",
-      model: "gpt-4o",
-      apiKey: "<your-api-key>"
-    },
-    strategy: {
-      template: "momentum"
-    },
-    trading: {
-      mode: "paper",
-      timeHorizon: "swing",
-      maxPositionSizeBps: 2e3,
-      maxDailyLossBps: 500,
-      maxConcurrentPositions: 5,
-      tradingIntervalMs: 6e4,
-      maxSlippageBps: 100,
-      minTradeValueUSD: 10,
-      initialCapitalUSD: 1e4
-    },
-    venues: {
-      hyperliquid_perp: {
-        enabled: false,
-        apiUrl: "https://api.hyperliquid.xyz",
-        wsUrl: "wss://api.hyperliquid.xyz/ws",
-        maxLeverage: 10,
-        maxNotionalUSD: 5e4
-      },
-      polymarket: {
-        enabled: false,
-        clobApiUrl: "https://clob.polymarket.com",
-        gammaApiUrl: "https://gamma-api.polymarket.com",
-        maxNotionalUSD: 1e3,
-        maxTotalExposureUSD: 5e3
-      },
-      spot: {
-        enabled: false,
-        chains: ["base"],
-        defaultChain: "base",
-        maxSlippageBps: 50,
-        maxSwapValueUSD: 1e4
-      },
-      bridge: {
-        enabled: false,
-        defaultBridge: "across",
-        maxBridgeValueUSD: 1e4,
-        fillTimeoutMs: 3e5,
-        pollIntervalMs: 2e3
-      }
-    },
-    relay: {
-      url: apiUrl.replace(/^http/, "ws") + "/ws/agent",
-      heartbeatIntervalMs: 3e4,
-      reconnectMaxAttempts: 50
-    }
-  };
-  return JSON.stringify(config, null, 2);
-}
-function writeSampleConfig(agentId, apiUrl, path = "agent-config.json") {
-  writeFileSync(path, generateSampleConfig(agentId, apiUrl));
-}
-
-// src/chains.ts
-import { base, arbitrum, polygon, mainnet } from "viem/chains";
-var CHAIN_CONFIGS = {
-  base: {
-    chainId: 8453,
-    name: "base",
-    viemChain: base,
-    rpcUrl: "https://mainnet.base.org",
-    nativeCurrency: "ETH",
-    blockExplorer: "https://basescan.org",
-    wethAddress: "0x4200000000000000000000000000000000000006",
-    usdcAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-    dexRouters: {
-      uniswap: "0x2626664c2603336E57B271c5C0b26F421741e481",
-      aerodrome: "0xcF77a3Ba9A5CA399B7c97c74d54e5b1Beb874E43"
-    },
-    uniswapQuoter: "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a",
-    acrossSpokePool: "0x09aea4b2242abC8bb4BB78D537A67a245A7bEC64"
-  },
-  ethereum: {
-    chainId: 1,
-    name: "ethereum",
-    viemChain: mainnet,
-    rpcUrl: "https://eth.llamarpc.com",
-    nativeCurrency: "ETH",
-    blockExplorer: "https://etherscan.io",
-    wethAddress: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-    usdcAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-    dexRouters: {
-      uniswap: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
-    },
-    uniswapQuoter: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
-    acrossSpokePool: "0x5c7BCd6E7De5423a257D81B442095A1a6ced35C5"
-  },
-  arbitrum: {
-    chainId: 42161,
-    name: "arbitrum",
-    viemChain: arbitrum,
-    rpcUrl: "https://arb1.arbitrum.io/rpc",
-    nativeCurrency: "ETH",
-    blockExplorer: "https://arbiscan.io",
-    wethAddress: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
-    usdcAddress: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
-    dexRouters: {
-      uniswap: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
-    },
-    uniswapQuoter: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
-    acrossSpokePool: "0xe35e9842fceaCA96570B734083f4a58e8F7C5f2A"
-  },
-  polygon: {
-    chainId: 137,
-    name: "polygon",
-    viemChain: polygon,
-    rpcUrl: "https://polygon-bor-rpc.publicnode.com",
-    nativeCurrency: "POL",
-    blockExplorer: "https://polygonscan.com",
-    wethAddress: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
-    usdcAddress: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
-    dexRouters: {
-      uniswap: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
-    },
-    uniswapQuoter: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
-    acrossSpokePool: "0x9295ee1d8C5b022Be115A2AD3c30C72E34e7F096"
-  }
-};
-function getChainConfig(nameOrId) {
-  if (typeof nameOrId === "number") {
-    return Object.values(CHAIN_CONFIGS).find((c) => c.chainId === nameOrId);
-  }
-  return CHAIN_CONFIGS[nameOrId.toLowerCase()];
-}
-
-// src/spot/types.ts
-var DEFAULT_SPOT_CONFIG = {
-  enabled: false,
-  chains: ["base"],
-  defaultChain: "base",
-  maxSlippageBps: 50,
-  maxSwapValueUSD: 1e4
-};
-var ERC20_ABI = [
-  {
-    type: "function",
-    name: "approve",
-    inputs: [
-      { name: "spender", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ type: "bool" }],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "allowance",
-    inputs: [
-      { name: "owner", type: "address" },
-      { name: "spender", type: "address" }
-    ],
-    outputs: [{ type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "balanceOf",
-    inputs: [{ name: "account", type: "address" }],
-    outputs: [{ type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "decimals",
-    inputs: [],
-    outputs: [{ type: "uint8" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "symbol",
-    inputs: [],
-    outputs: [{ type: "string" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "transfer",
-    inputs: [
-      { name: "to", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ type: "bool" }],
-    stateMutability: "nonpayable"
-  }
-];
-var UNISWAP_QUOTER_V2_ABI = [
-  {
-    type: "function",
-    name: "quoteExactInputSingle",
-    inputs: [
-      {
-        name: "params",
-        type: "tuple",
-        components: [
-          { name: "tokenIn", type: "address" },
-          { name: "tokenOut", type: "address" },
-          { name: "amountIn", type: "uint256" },
-          { name: "fee", type: "uint24" },
-          { name: "sqrtPriceLimitX96", type: "uint160" }
-        ]
-      }
-    ],
-    outputs: [
-      { name: "amountOut", type: "uint256" },
-      { name: "sqrtPriceX96After", type: "uint160" },
-      { name: "initializedTicksCrossed", type: "uint32" },
-      { name: "gasEstimate", type: "uint256" }
-    ],
-    stateMutability: "nonpayable"
-  }
-];
-var UNISWAP_SWAP_ROUTER_ABI = [
-  {
-    type: "function",
-    name: "exactInputSingle",
-    inputs: [
-      {
-        name: "params",
-        type: "tuple",
-        components: [
-          { name: "tokenIn", type: "address" },
-          { name: "tokenOut", type: "address" },
-          { name: "fee", type: "uint24" },
-          { name: "recipient", type: "address" },
-          { name: "amountIn", type: "uint256" },
-          { name: "amountOutMinimum", type: "uint256" },
-          { name: "sqrtPriceLimitX96", type: "uint160" }
-        ]
-      }
-    ],
-    outputs: [{ name: "amountOut", type: "uint256" }],
-    stateMutability: "payable"
-  }
-];
-var AERODROME_ROUTER_ABI = [
-  {
-    type: "function",
-    name: "swapExactTokensForTokens",
-    inputs: [
-      { name: "amountIn", type: "uint256" },
-      { name: "amountOutMin", type: "uint256" },
-      {
-        name: "routes",
-        type: "tuple[]",
-        components: [
-          { name: "from", type: "address" },
-          { name: "to", type: "address" },
-          { name: "stable", type: "bool" },
-          { name: "factory", type: "address" }
-        ]
-      },
-      { name: "to", type: "address" },
-      { name: "deadline", type: "uint256" }
-    ],
-    outputs: [{ name: "amounts", type: "uint256[]" }],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "getAmountsOut",
-    inputs: [
-      { name: "amountIn", type: "uint256" },
-      {
-        name: "routes",
-        type: "tuple[]",
-        components: [
-          { name: "from", type: "address" },
-          { name: "to", type: "address" },
-          { name: "stable", type: "bool" },
-          { name: "factory", type: "address" }
-        ]
-      }
-    ],
-    outputs: [{ name: "amounts", type: "uint256[]" }],
-    stateMutability: "view"
-  }
-];
-var AERODROME_DEFAULT_FACTORY = "0x420DD381b31aEf6683db6B902084cB0FFECe40Da";
-
-// src/relay.ts
-import WebSocket from "ws";
-var RelayClient = class {
-  ws = null;
-  config;
-  heartbeatTimer = null;
-  reconnectTimer = null;
-  reconnectAttempts = 0;
-  intentionalClose = false;
-  authenticated = false;
-  lastStatus = null;
-  onCommand;
-  onConnected;
-  onDisconnected;
-  constructor(config) {
-    this.config = {
-      url: config.url,
-      agentId: config.agentId,
-      token: config.token,
-      heartbeatIntervalMs: config.heartbeatIntervalMs ?? 3e4,
-      reconnectMaxAttempts: config.reconnectMaxAttempts ?? 50
-    };
-    this.onCommand = config.onCommand;
-    this.onConnected = config.onConnected;
-    this.onDisconnected = config.onDisconnected;
-  }
-  get isConnected() {
-    return this.ws?.readyState === WebSocket.OPEN && this.authenticated;
-  }
-  async connect() {
-    return new Promise((resolve2, reject) => {
-      try {
-        this.intentionalClose = false;
-        this.ws = new WebSocket(this.config.url);
-        const timeout = setTimeout(() => {
-          if (this.ws && this.ws.readyState !== WebSocket.OPEN) {
-            this.ws.terminate();
-            reject(new Error("Connection timeout (15s)"));
-          }
-        }, 15e3);
-        this.ws.on("open", () => {
-          clearTimeout(timeout);
-          this.reconnectAttempts = 0;
-          this.authenticate();
-        });
-        this.ws.on("message", (data) => {
-          try {
-            const msg = JSON.parse(data.toString());
-            this.handleMessage(msg, resolve2);
-          } catch {
-            console.error("[relay] Failed to parse message");
-          }
-        });
-        this.ws.on("close", () => {
-          this.cleanup();
-          this.onDisconnected?.();
-          if (!this.intentionalClose) {
-            this.scheduleReconnect();
-          }
-        });
-        this.ws.on("error", (err) => {
-          console.error("[relay] WebSocket error:", err.message);
-          if (!this.authenticated) {
-            clearTimeout(timeout);
-            reject(err);
-          }
-        });
-      } catch (err) {
-        reject(err);
-      }
-    });
-  }
-  disconnect() {
-    this.intentionalClose = true;
-    this.cleanup();
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-  authenticate() {
-    this.send({
-      type: "auth",
-      agentId: this.config.agentId,
-      token: this.config.token
-    });
-  }
-  handleMessage(msg, onAuth) {
-    switch (msg.type) {
-      case "auth_success":
-        this.authenticated = true;
-        this.startHeartbeat();
-        this.onConnected?.();
-        onAuth?.();
-        console.log(`[relay] Authenticated as agent ${this.config.agentId}`);
-        break;
-      case "auth_error":
-        console.error("[relay] Auth failed:", msg.error);
-        this.disconnect();
-        break;
-      case "command":
-        this.onCommand?.(msg.command);
-        break;
-      case "pong":
-        break;
-    }
-  }
-  sendCommandAck(commandId, success, message) {
-    this.send({
-      type: "command_ack",
-      agentId: this.config.agentId,
-      commandId,
-      success,
-      message,
-      timestamp: Date.now()
-    });
-  }
-  send(msg) {
-    if (this.ws?.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(msg));
-    }
-  }
-  sendHeartbeat(status) {
-    this.lastStatus = status;
-    this.send({
-      type: "heartbeat",
-      agentId: this.config.agentId,
-      status,
-      timestamp: Date.now()
-    });
-  }
-  sendMessage(messageType, level, title, body, data) {
-    this.send({
-      type: "message",
-      agentId: this.config.agentId,
-      messageType,
-      level,
-      title,
-      body,
-      data,
-      timestamp: Date.now()
-    });
-  }
-  sendTradeSignal(signal) {
-    this.send({
-      type: "trade_signal",
-      agentId: this.config.agentId,
-      signal,
-      timestamp: Date.now()
-    });
-  }
-  startHeartbeat() {
-    this.stopHeartbeat();
-    this.heartbeatTimer = setInterval(() => {
-      if (this.lastStatus) {
-        this.sendHeartbeat(this.lastStatus);
-      }
-    }, this.config.heartbeatIntervalMs);
-  }
-  stopHeartbeat() {
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = null;
-    }
-  }
-  cleanup() {
-    this.stopHeartbeat();
-    this.authenticated = false;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-  }
-  scheduleReconnect() {
-    if (this.reconnectAttempts >= this.config.reconnectMaxAttempts) {
-      console.error(`[relay] Max reconnect attempts (${this.config.reconnectMaxAttempts}) reached`);
-      return;
-    }
-    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
-    this.reconnectAttempts++;
-    console.log(`[relay] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
-    this.reconnectTimer = setTimeout(async () => {
-      try {
-        await this.connect();
-      } catch (err) {
-        console.error("[relay] Reconnect failed:", err.message);
-      }
-    }, delay);
-  }
-};
-
-// src/signal.ts
-var SignalReporter = class {
-  relay;
-  constructor(relay) {
-    this.relay = relay;
-  }
-  reportTrade(signal) {
-    if (!this.relay.isConnected) {
-      console.warn("[signal] Not connected to relay \u2014 trade signal queued locally");
-      return;
-    }
-    this.relay.sendTradeSignal(signal);
-    this.relay.sendMessage(
-      "trade_executed",
-      "success",
-      `${signal.side.toUpperCase()} ${signal.symbol}`,
-      `${signal.side} ${signal.size} ${signal.symbol} @ $${signal.price.toFixed(2)} on ${signal.venue}`,
-      { signal }
-    );
-  }
-  reportPerpFill(signal) {
-    if (!this.relay.isConnected) return;
-    this.relay.sendTradeSignal(signal);
-    this.relay.sendMessage(
-      "perp_fill",
-      "success",
-      `Perp ${signal.side.toUpperCase()} ${signal.symbol}`,
-      `${signal.side} ${signal.size} ${signal.symbol} @ $${signal.price.toFixed(2)} (${signal.leverage ?? 1}x)`,
-      { signal }
-    );
-  }
-  reportPredictionFill(signal) {
-    if (!this.relay.isConnected) return;
-    this.relay.sendTradeSignal(signal);
-    this.relay.sendMessage(
-      "prediction_fill",
-      "success",
-      `Prediction ${signal.side.toUpperCase()}`,
-      `${signal.side} $${signal.size.toFixed(2)} on ${signal.symbol} @ ${signal.price.toFixed(4)}`,
-      { signal }
-    );
-  }
-  reportSpotFill(signal) {
-    if (!this.relay.isConnected) return;
-    this.relay.sendTradeSignal(signal);
-    this.relay.sendMessage(
-      "spot_fill",
-      "success",
-      `Spot ${signal.side.toUpperCase()} ${signal.symbol}`,
-      `${signal.side} ${signal.size} ${signal.symbol} @ $${signal.price.toFixed(4)} on ${signal.venue} (${signal.chain ?? "unknown"})`,
-      { signal }
-    );
-  }
-  reportBridgeFill(signal) {
-    if (!this.relay.isConnected) return;
-    this.relay.sendTradeSignal(signal);
-    this.relay.sendMessage(
-      "bridge_fill",
-      "success",
-      `Bridge ${signal.symbol}`,
-      `Bridged ${signal.size} ${signal.symbol} to ${signal.chain ?? "unknown"} via ${signal.venue}`,
-      { signal }
-    );
-  }
-  reportError(title, body, data) {
-    if (!this.relay.isConnected) return;
-    this.relay.sendMessage("error", "error", title, body, data);
-  }
-  reportInfo(title, body, data) {
-    if (!this.relay.isConnected) return;
-    this.relay.sendMessage("info", "info", title, body, data);
-  }
-};
-
-// src/store.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync, existsSync as existsSync2 } from "fs";
-import { dirname } from "path";
-var FileStore = class {
-  data = {};
-  filePath;
-  constructor(filePath = "data/strategy-store.json") {
-    this.filePath = filePath;
-    this.load();
-  }
-  load() {
-    try {
-      if (existsSync2(this.filePath)) {
-        const raw = readFileSync2(this.filePath, "utf-8");
-        this.data = JSON.parse(raw);
-      }
-    } catch {
-      this.data = {};
-    }
-  }
-  flush() {
-    const dir = dirname(this.filePath);
-    if (!existsSync2(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-    writeFileSync2(this.filePath, JSON.stringify(this.data, null, 2));
-  }
-  get(key) {
-    return this.data[key];
-  }
-  set(key, value) {
-    this.data[key] = value;
-    this.flush();
-  }
-  delete(key) {
-    delete this.data[key];
-    this.flush();
-  }
-  keys() {
-    return Object.keys(this.data);
-  }
-};
-
-// src/position-tracker.ts
-var QUOTE_ASSETS = /* @__PURE__ */ new Set(["USDC", "USDbC", "DAI", "USDT", "EURC"]);
-var PERP_VENUES = /* @__PURE__ */ new Set(["hyperliquid_perp"]);
-var PREDICTION_VENUES = /* @__PURE__ */ new Set(["polymarket"]);
-var PositionTracker = class {
-  positions = /* @__PURE__ */ new Map();
-  trades = [];
-  realizedPnL = 0;
-  store;
-  constructor(store) {
-    this.store = store;
-    this.load();
-  }
-  /** Build a unique position key: venue-scoped when venue is provided */
-  positionKey(token, venue) {
-    return venue ? `${venue}:${token}` : token;
-  }
-  load() {
-    const saved = this.store.get("position_tracker");
-    if (saved) {
-      this.positions = new Map(saved.positions);
-      this.trades = saved.trades;
-      this.realizedPnL = saved.realizedPnL;
-    }
-  }
-  save() {
-    this.store.set("position_tracker", {
-      positions: Array.from(this.positions.entries()),
-      trades: this.trades.slice(-1e3),
-      realizedPnL: this.realizedPnL
-    });
-  }
-  /** Returns realized PnL from this trade (non-zero when closing/reducing a position) */
-  recordBuy(token, quantity, price, fee, venue, chain, venueFillId) {
-    const isPerp = venue ? PERP_VENUES.has(venue) : false;
-    const isPrediction = venue ? PREDICTION_VENUES.has(venue) : false;
-    if (!isPerp && !isPrediction && QUOTE_ASSETS.has(token)) return;
-    const key = this.positionKey(token, venue);
-    const existing = this.positions.get(key);
-    let tradePnL = 0;
-    if (existing) {
-      if (isPerp && existing.quantity < 0) {
-        const closedQty = Math.min(quantity, Math.abs(existing.quantity));
-        tradePnL = (existing.costBasisPerUnit - price) * closedQty - fee;
-        this.realizedPnL += tradePnL;
-        existing.quantity += quantity;
-        if (Math.abs(existing.quantity) <= 1e-6) {
-          this.positions.delete(key);
-        } else if (existing.quantity > 0) {
-          existing.costBasisPerUnit = price;
-        }
-      } else {
-        const totalQty = existing.quantity + quantity;
-        const totalCost = existing.costBasisPerUnit * existing.quantity + price * quantity;
-        existing.costBasisPerUnit = totalCost / totalQty;
-        existing.quantity = totalQty;
-      }
-    } else {
-      this.positions.set(key, {
-        token,
-        quantity,
-        costBasisPerUnit: price,
-        entryTimestamp: Date.now(),
-        venue,
-        chain
-      });
-    }
-    this.trades.push({
-      token,
-      action: "buy",
-      quantity,
-      price,
-      fee,
-      timestamp: Date.now(),
-      venue,
-      chain,
-      venueFillId
-    });
-    this.save();
-    return tradePnL;
-  }
-  /** Returns realized PnL from this trade (non-zero when closing/reducing a position) */
-  recordSell(token, quantity, price, fee, venue, chain, venueFillId) {
-    const isPerp = venue ? PERP_VENUES.has(venue) : false;
-    const isPrediction = venue ? PREDICTION_VENUES.has(venue) : false;
-    if (!isPerp && !isPrediction && QUOTE_ASSETS.has(token)) return;
-    const key = this.positionKey(token, venue);
-    const existing = this.positions.get(key);
-    if (existing) {
-      if (isPerp && existing.quantity > 0) {
-        const closedQty = Math.min(quantity, existing.quantity);
-        const pnl = (price - existing.costBasisPerUnit) * closedQty - fee;
-        this.realizedPnL += pnl;
-        existing.quantity -= quantity;
-        if (Math.abs(existing.quantity) <= 1e-6) {
-          this.positions.delete(key);
-        } else if (existing.quantity < 0) {
-          existing.costBasisPerUnit = price;
-        }
-      } else if (isPerp && existing.quantity <= 0) {
-        const totalQty = Math.abs(existing.quantity) + quantity;
-        const totalCost = existing.costBasisPerUnit * Math.abs(existing.quantity) + price * quantity;
-        existing.costBasisPerUnit = totalCost / totalQty;
-        existing.quantity -= quantity;
-      } else {
-        const pnl = (price - existing.costBasisPerUnit) * quantity - fee;
-        this.realizedPnL += pnl;
-        existing.quantity -= quantity;
-        if (existing.quantity <= 1e-6) {
-          this.positions.delete(key);
-        }
-      }
-    } else if (isPerp) {
-      this.positions.set(key, {
-        token,
-        quantity: -quantity,
-        costBasisPerUnit: price,
-        entryTimestamp: Date.now(),
-        venue,
-        chain
-      });
-    }
-    this.trades.push({
-      token,
-      action: "sell",
-      quantity,
-      price,
-      fee,
-      timestamp: Date.now(),
-      venue,
-      chain,
-      venueFillId
-    });
-    this.save();
-  }
-  getSummary(prices) {
-    let totalUnrealizedPnL = 0;
-    const openPositions = Array.from(this.positions.values());
-    for (const pos of openPositions) {
-      const currentPrice = prices[pos.token];
-      if (currentPrice) {
-        if (pos.quantity >= 0) {
-          totalUnrealizedPnL += (currentPrice - pos.costBasisPerUnit) * pos.quantity;
-        } else {
-          totalUnrealizedPnL += (pos.costBasisPerUnit - currentPrice) * Math.abs(pos.quantity);
-        }
-      }
-    }
-    return {
-      openPositions,
-      totalUnrealizedPnL,
-      totalRealizedPnL: this.realizedPnL
-    };
-  }
-  getPositions() {
-    return Array.from(this.positions.values());
-  }
-  getTrades(limit) {
-    if (limit) return this.trades.slice(-limit);
-    return [...this.trades];
-  }
-  getRealizedPnL() {
-    return this.realizedPnL;
-  }
-  reset() {
-    this.positions.clear();
-    this.trades = [];
-    this.realizedPnL = 0;
-    this.save();
-  }
-};
-
-// src/llm/base.ts
-var BaseLLMAdapter = class {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  getTemperature() {
-    return this.config.temperature ?? 0.7;
-  }
-  getMaxTokens() {
-    return this.config.maxTokens ?? 4096;
-  }
-};
-
-// src/llm/openai.ts
-var OpenAIAdapter = class extends BaseLLMAdapter {
-  endpoint;
-  constructor(config) {
-    super(config);
-    this.endpoint = config.endpoint || "https://api.openai.com/v1";
-  }
-  async chat(messages) {
-    const res = await fetch(`${this.endpoint}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.config.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.config.model || "gpt-4o",
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
-        temperature: this.getTemperature(),
-        max_tokens: this.getMaxTokens()
-      })
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`OpenAI API error ${res.status}: ${body}`);
-    }
-    const data = await res.json();
-    return {
-      content: data.choices[0]?.message?.content || "",
-      tokens: data.usage ? { input: data.usage.prompt_tokens, output: data.usage.completion_tokens } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "openai",
-      model: this.config.model || "gpt-4o"
-    };
-  }
-};
-
-// src/llm/anthropic.ts
-var AnthropicAdapter = class extends BaseLLMAdapter {
-  endpoint;
-  constructor(config) {
-    super(config);
-    this.endpoint = config.endpoint || "https://api.anthropic.com";
-  }
-  async chat(messages) {
-    const systemMessage = messages.find((m) => m.role === "system");
-    const nonSystemMessages = messages.filter((m) => m.role !== "system");
-    const body = {
-      model: this.config.model || "claude-sonnet-4-20250514",
-      messages: nonSystemMessages.map((m) => ({ role: m.role, content: m.content })),
-      max_tokens: this.getMaxTokens(),
-      temperature: this.getTemperature()
-    };
-    if (systemMessage) {
-      body.system = systemMessage.content;
-    }
-    const res = await fetch(`${this.endpoint}/v1/messages`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": this.config.apiKey || "",
-        "anthropic-version": "2023-06-01"
-      },
-      body: JSON.stringify(body)
-    });
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Anthropic API error ${res.status}: ${text}`);
-    }
-    const data = await res.json();
-    const textContent = data.content.find((c) => c.type === "text");
-    return {
-      content: textContent?.text || "",
-      tokens: data.usage ? { input: data.usage.input_tokens, output: data.usage.output_tokens } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "anthropic",
-      model: this.config.model || "claude-sonnet-4-20250514"
-    };
-  }
-};
-
-// src/llm/google.ts
-var GoogleAdapter = class extends BaseLLMAdapter {
-  constructor(config) {
-    super(config);
-  }
-  async chat(messages) {
-    const model = this.config.model || "gemini-2.5-flash";
-    const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${this.config.apiKey}`;
-    const systemMessage = messages.find((m) => m.role === "system");
-    const nonSystemMessages = messages.filter((m) => m.role !== "system");
-    const body = {
-      contents: nonSystemMessages.map((m) => ({
-        role: m.role === "assistant" ? "model" : "user",
-        parts: [{ text: m.content }]
-      })),
-      generationConfig: {
-        temperature: this.getTemperature(),
-        maxOutputTokens: this.getMaxTokens()
-      }
-    };
-    if (systemMessage) {
-      body.systemInstruction = { parts: [{ text: systemMessage.content }] };
-    }
-    const res = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-    if (!res.ok) {
-      const text2 = await res.text();
-      throw new Error(`Google AI error ${res.status}: ${text2}`);
-    }
-    const data = await res.json();
-    const text = data.candidates[0]?.content?.parts[0]?.text || "";
-    return {
-      content: text,
-      tokens: data.usageMetadata ? { input: data.usageMetadata.promptTokenCount, output: data.usageMetadata.candidatesTokenCount } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "google",
-      model: this.config.model || "gemini-2.5-flash"
-    };
-  }
-};
-
-// src/llm/deepseek.ts
-var DeepSeekAdapter = class extends BaseLLMAdapter {
-  constructor(config) {
-    super(config);
-  }
-  async chat(messages) {
-    const res = await fetch("https://api.deepseek.com/chat/completions", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.config.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.config.model || "deepseek-chat",
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
-        temperature: this.getTemperature(),
-        max_tokens: this.getMaxTokens()
-      })
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`DeepSeek API error ${res.status}: ${body}`);
-    }
-    const data = await res.json();
-    return {
-      content: data.choices[0]?.message?.content || "",
-      tokens: data.usage ? { input: data.usage.prompt_tokens, output: data.usage.completion_tokens } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "deepseek",
-      model: this.config.model || "deepseek-chat"
-    };
-  }
-};
-
-// src/llm/mistral.ts
-var MistralAdapter = class extends BaseLLMAdapter {
-  constructor(config) {
-    super(config);
-  }
-  async chat(messages) {
-    const res = await fetch("https://api.mistral.ai/v1/chat/completions", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.config.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.config.model || "mistral-large-latest",
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
-        temperature: this.getTemperature(),
-        max_tokens: this.getMaxTokens()
-      })
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`Mistral API error ${res.status}: ${body}`);
-    }
-    const data = await res.json();
-    return {
-      content: data.choices[0]?.message?.content || "",
-      tokens: data.usage ? { input: data.usage.prompt_tokens, output: data.usage.completion_tokens } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "mistral",
-      model: this.config.model || "mistral-large-latest"
-    };
-  }
-};
-
-// src/llm/groq.ts
-var GroqAdapter = class extends BaseLLMAdapter {
-  constructor(config) {
-    super(config);
-  }
-  async chat(messages) {
-    const res = await fetch("https://api.groq.com/openai/v1/chat/completions", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.config.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.config.model || "llama-3.3-70b-versatile",
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
-        temperature: this.getTemperature(),
-        max_tokens: this.getMaxTokens()
-      })
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`Groq API error ${res.status}: ${body}`);
-    }
-    const data = await res.json();
-    return {
-      content: data.choices[0]?.message?.content || "",
-      tokens: data.usage ? { input: data.usage.prompt_tokens, output: data.usage.completion_tokens } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "groq",
-      model: this.config.model || "llama-3.3-70b-versatile"
-    };
-  }
-};
-
-// src/llm/together.ts
-var TogetherAdapter = class extends BaseLLMAdapter {
-  constructor(config) {
-    super(config);
-  }
-  async chat(messages) {
-    const res = await fetch("https://api.together.xyz/v1/chat/completions", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.config.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.config.model || "meta-llama/Llama-3.3-70B-Instruct-Turbo",
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
-        temperature: this.getTemperature(),
-        max_tokens: this.getMaxTokens()
-      })
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`Together API error ${res.status}: ${body}`);
-    }
-    const data = await res.json();
-    return {
-      content: data.choices[0]?.message?.content || "",
-      tokens: data.usage ? { input: data.usage.prompt_tokens, output: data.usage.completion_tokens } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "together",
-      model: this.config.model || "meta-llama/Llama-3.3-70B-Instruct-Turbo"
-    };
-  }
-};
-
-// src/llm/ollama.ts
-var OllamaAdapter = class extends BaseLLMAdapter {
-  endpoint;
-  constructor(config) {
-    super(config);
-    this.endpoint = config.endpoint || "http://localhost:11434";
-  }
-  async chat(messages) {
-    const res = await fetch(`${this.endpoint}/api/chat`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model: this.config.model || "llama3.3",
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
-        stream: false,
-        options: {
-          temperature: this.getTemperature(),
-          num_predict: this.getMaxTokens()
-        }
-      })
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`Ollama error ${res.status}: ${body}`);
-    }
-    const data = await res.json();
-    return {
-      content: data.message?.content || "",
-      tokens: data.prompt_eval_count ? { input: data.prompt_eval_count, output: data.eval_count || 0 } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "ollama",
-      model: this.config.model || "llama3.3"
-    };
-  }
-};
-
-// src/llm/index.ts
-function createLLMAdapter(config) {
-  switch (config.provider) {
-    case "openai":
-      return new OpenAIAdapter(config);
-    case "anthropic":
-      return new AnthropicAdapter(config);
-    case "google":
-      return new GoogleAdapter(config);
-    case "deepseek":
-      return new DeepSeekAdapter(config);
-    case "mistral":
-      return new MistralAdapter(config);
-    case "groq":
-      return new GroqAdapter(config);
-    case "together":
-      return new TogetherAdapter(config);
-    case "ollama":
-      return new OllamaAdapter(config);
-    default:
-      throw new Error(`Unknown LLM provider: ${config.provider}`);
-  }
-}
-
-// src/strategy/templates.ts
-var templates = [
-  {
-    id: "momentum",
-    name: "Momentum Trader",
-    description: "Identifies tokens with strong upward price momentum and rides the trend. Uses LLM to analyze price action and market sentiment.",
-    category: "momentum",
-    venues: ["hyperliquid_perp", "hyperliquid_spot"],
-    riskLevel: "moderate",
-    systemPrompt: `You are a momentum trading agent. Analyze the provided market data and identify tokens with strong upward momentum.
-
-Rules:
-- Only trade tokens with clear directional momentum (avoid choppy markets)
-- Use trailing stops to protect gains
-- Size positions based on conviction (higher confidence = larger position)
-- Cut losses quickly if momentum reverses
-- Consider volume as confirmation of momentum
-
-Return a JSON array of trade signals.`,
-    code: `
-const prices = context.market.getPrices();
-const positions = context.position.openPositions;
-
-const messages = [
-  { role: 'system', content: 'You are a momentum trading agent. Analyze market data and return trade signals as a JSON array. Each signal: { symbol, side: "buy"|"sell", confidence: 0-1, reasoning }. Return [] if no opportunities.' },
-  { role: 'user', content: 'Current prices: ' + JSON.stringify(prices) + '\\nOpen positions: ' + JSON.stringify(positions.map(p => p.token)) + '\\nAnalyze for momentum opportunities.' }
-];
-
-const response = await context.llm.chat(messages);
-try {
-  const signals = JSON.parse(response.content);
-  return Array.isArray(signals) ? signals : [];
-} catch {
-  return [];
-}
-`
-  },
-  {
-    id: "value",
-    name: "Value Investor",
-    description: "Identifies undervalued tokens based on fundamental analysis. Buys dips and holds for mean reversion.",
-    category: "value",
-    venues: ["hyperliquid_spot"],
-    riskLevel: "conservative",
-    systemPrompt: `You are a value investing agent. Identify tokens trading below their intrinsic value.
-
-Rules:
-- Focus on established tokens with strong fundamentals
-- Buy on significant dips (>10% from recent highs)
-- Hold positions longer (swing/position timeframe)
-- Avoid chasing pumps
-- Diversify across sectors
-
-Return a JSON array of trade signals.`,
-    code: `
-const prices = context.market.getPrices();
-const positions = context.position.openPositions;
-
-const messages = [
-  { role: 'system', content: 'You are a value investing agent. Identify undervalued tokens. Return trade signals as JSON array: { symbol, side: "buy"|"sell", confidence: 0-1, reasoning }. Return [] if nothing is compelling.' },
-  { role: 'user', content: 'Current prices: ' + JSON.stringify(prices) + '\\nPositions: ' + JSON.stringify(positions.map(p => ({ token: p.token, entry: p.costBasisPerUnit }))) + '\\nLook for value opportunities.' }
-];
-
-const response = await context.llm.chat(messages);
-try {
-  const signals = JSON.parse(response.content);
-  return Array.isArray(signals) ? signals : [];
-} catch {
-  return [];
-}
-`
-  },
-  {
-    id: "arbitrage",
-    name: "Arbitrage Hunter",
-    description: "Scans for price discrepancies across venues and chains. Executes quickly to capture spreads.",
-    category: "arbitrage",
-    venues: ["hyperliquid_perp", "hyperliquid_spot", "uniswap", "aerodrome"],
-    riskLevel: "aggressive",
-    systemPrompt: `You are an arbitrage agent. Find price discrepancies between venues.
-
-Rules:
-- Speed is critical \u2014 execute quickly before spreads close
-- Account for fees and slippage in profitability calculations
-- Only trade when net profit > 0.5% after all costs
-- Monitor cross-chain opportunities (CEX vs DEX spreads)
-
-Return a JSON array of trade signals.`,
-    code: `
-const prices = context.market.getPrices();
-
-const messages = [
-  { role: 'system', content: 'You are an arbitrage agent. Find price discrepancies. Return trade signals as JSON array: { symbol, side: "buy"|"sell", venue, confidence: 0-1, reasoning }. Return [] if no arb opportunities.' },
-  { role: 'user', content: 'Market prices: ' + JSON.stringify(prices) + '\\nScan for cross-venue arbitrage opportunities.' }
-];
-
-const response = await context.llm.chat(messages);
-try {
-  const signals = JSON.parse(response.content);
-  return Array.isArray(signals) ? signals : [];
-} catch {
-  return [];
-}
-`
-  },
-  {
-    id: "hold",
-    name: "Hold (No Trading)",
-    description: "Passive strategy that makes no trades. Useful for monitoring only.",
-    category: "custom",
-    venues: [],
-    riskLevel: "conservative",
-    systemPrompt: "",
-    code: `return [];`
-  }
-];
-function getTemplate(id) {
-  return templates.find((t) => t.id === id);
-}
-function listTemplates() {
-  return [...templates];
-}
-
-// src/strategy/loader.ts
-import { existsSync as existsSync3 } from "fs";
-import { resolve } from "path";
-async function loadStrategy(config) {
-  if (config.file) {
-    return loadFromFile(config.file);
-  }
-  if (config.template) {
-    const template = getTemplate(config.template);
-    if (!template) {
-      throw new Error(`Unknown strategy template: ${config.template}. Available: momentum, value, arbitrage, hold`);
-    }
-    return loadFromCode(template.code);
-  }
-  return holdStrategy;
-}
-async function loadFromFile(filePath) {
-  const resolved = resolve(filePath);
-  if (!existsSync3(resolved)) {
-    throw new Error(`Strategy file not found: ${resolved}`);
-  }
-  try {
-    const mod = await import(resolved);
-    const fn = mod.default || mod.strategy;
-    if (typeof fn !== "function") {
-      throw new Error(`Strategy file must export a default function or 'strategy' function`);
-    }
-    return fn;
-  } catch (err) {
-    throw new Error(`Failed to load strategy from ${resolved}: ${err.message}`);
-  }
-}
-async function loadFromCode(code) {
-  const AsyncFunction = Object.getPrototypeOf(async function() {
-  }).constructor;
-  const fn = new AsyncFunction("context", code);
-  return fn;
-}
-var holdStrategy = async (_context) => {
-  return [];
-};
-
-// src/trading/risk.ts
-var RiskManager = class {
-  params;
-  dailyPnL = 0;
-  dailyFees = 0;
-  lastResetDate = "";
-  initialCapitalUSD;
-  constructor(params, initialCapitalUSD = 1e4) {
-    this.params = params;
-    this.initialCapitalUSD = initialCapitalUSD;
-    this.resetIfNewDay();
-  }
-  filterSignals(signals, market, openPositionCount) {
-    this.resetIfNewDay();
-    if (this.isDailyLossLimitHit()) {
-      console.log("[risk] Daily loss limit hit \u2014 blocking all trades");
-      return [];
-    }
-    return signals.filter((signal) => this.validateSignal(signal, market, openPositionCount));
-  }
-  validateSignal(signal, market, openPositionCount) {
-    const threshold = this.params.confidenceThreshold ?? 0.5;
-    if (signal.confidence !== void 0 && signal.confidence < threshold) {
-      console.log(`[risk] Blocked ${signal.symbol}: confidence ${signal.confidence} < ${threshold}`);
-      return false;
-    }
-    const tradeValue = signal.size * signal.price;
-    const maxPositionValue = this.params.maxPositionSizeBps / 1e4 * this.initialCapitalUSD;
-    if (tradeValue > maxPositionValue) {
-      console.log(`[risk] Blocked ${signal.symbol}: trade $${tradeValue.toFixed(0)} > max $${maxPositionValue.toFixed(0)}`);
-      return false;
-    }
-    if (tradeValue < this.params.minTradeValueUSD) {
-      console.log(`[risk] Blocked ${signal.symbol}: trade $${tradeValue.toFixed(2)} < min $${this.params.minTradeValueUSD}`);
-      return false;
-    }
-    if ((signal.side === "buy" || signal.side === "long") && openPositionCount >= this.params.maxConcurrentPositions) {
-      console.log(`[risk] Blocked ${signal.symbol}: ${openPositionCount} positions >= max ${this.params.maxConcurrentPositions}`);
-      return false;
-    }
-    if (signal.orderType === "market") {
-      const currentPrice = market.getPrice(signal.symbol);
-      if (currentPrice) {
-        const slippageBps = Math.abs(signal.price - currentPrice) / currentPrice * 1e4;
-        if (slippageBps > this.params.maxSlippageBps) {
-          console.log(`[risk] Blocked ${signal.symbol}: slippage ${slippageBps.toFixed(0)}bps > max ${this.params.maxSlippageBps}bps`);
-          return false;
-        }
-      }
-    }
-    return true;
-  }
-  updateParams(updates) {
-    if (updates.maxPositionSizeBps !== void 0) this.params.maxPositionSizeBps = updates.maxPositionSizeBps;
-    if (updates.maxDailyLossBps !== void 0) this.params.maxDailyLossBps = updates.maxDailyLossBps;
-    if (updates.maxConcurrentPositions !== void 0) this.params.maxConcurrentPositions = updates.maxConcurrentPositions;
-    if (updates.maxSlippageBps !== void 0) this.params.maxSlippageBps = updates.maxSlippageBps;
-    if (updates.minTradeValueUSD !== void 0) this.params.minTradeValueUSD = updates.minTradeValueUSD;
-    console.log("[risk] Params updated:", JSON.stringify(this.params));
-  }
-  recordTrade(pnl, fee) {
-    this.dailyPnL += pnl;
-    this.dailyFees += fee;
-  }
-  isDailyLossLimitHit() {
-    const limit = this.params.maxDailyLossBps / 1e4 * this.initialCapitalUSD;
-    return this.dailyPnL < -limit;
-  }
-  getDailyPnL() {
-    return this.dailyPnL;
-  }
-  getDailyLossLimit() {
-    return this.params.maxDailyLossBps / 1e4 * this.initialCapitalUSD;
-  }
-  resetIfNewDay() {
-    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    if (today !== this.lastResetDate) {
-      this.dailyPnL = 0;
-      this.dailyFees = 0;
-      this.lastResetDate = today;
-    }
-  }
-};
-
-// src/trading/market.ts
-var MarketDataService = class {
-  prices = {};
-  lastFetch = 0;
-  cacheTTL;
-  apiUrl;
-  ohlcvCache = /* @__PURE__ */ new Map();
-  constructor(cacheTTLMs = 3e4, apiUrl) {
-    this.cacheTTL = cacheTTLMs;
-    this.apiUrl = apiUrl || null;
-  }
-  async refreshPrices(symbols) {
-    if (symbols.length === 0) return this.prices;
-    const now = Date.now();
-    if (now - this.lastFetch < this.cacheTTL && Object.keys(this.prices).length > 0) {
-      return this.prices;
-    }
-    if (this.apiUrl) {
-      try {
-        const res = await fetch(`${this.apiUrl}/v1/prices`);
-        if (res.ok) {
-          const data = await res.json();
-          for (const [symbol, price] of Object.entries(data)) {
-            this.prices[symbol.toUpperCase()] = price;
-          }
-          this.lastFetch = now;
-          return this.prices;
-        }
-      } catch {
-      }
-    }
-    try {
-      const ids = symbols.map((s) => s.toLowerCase()).join(",");
-      const res = await fetch(
-        `https://api.coingecko.com/api/v3/simple/price?ids=${ids}&vs_currencies=usd`
-      );
-      if (res.ok) {
-        const data = await res.json();
-        for (const [id, price] of Object.entries(data)) {
-          this.prices[id.toUpperCase()] = price.usd;
-        }
-        this.lastFetch = now;
-      }
-    } catch (err) {
-      console.warn("[market] Price fetch failed:", err.message);
-    }
-    return this.prices;
-  }
-  getPrice(symbol) {
-    return this.prices[symbol.toUpperCase()];
-  }
-  getPrices() {
-    return { ...this.prices };
-  }
-  setPrice(symbol, price) {
-    this.prices[symbol.toUpperCase()] = price;
-  }
-  setPrices(prices) {
-    for (const [symbol, price] of Object.entries(prices)) {
-      this.prices[symbol.toUpperCase()] = price;
-    }
-  }
-  getOHLCV(symbol, timeframe) {
-    const cacheKey = `${symbol.toUpperCase()}:${timeframe}`;
-    const cached = this.ohlcvCache.get(cacheKey);
-    if (cached && Date.now() - cached.fetchedAt < this.cacheTTL) {
-      return cached.data;
-    }
-    this.fetchOHLCV(symbol, timeframe).catch(() => {
-    });
-    return cached?.data || [];
-  }
-  async fetchOHLCV(symbol, timeframe) {
-    const cacheKey = `${symbol.toUpperCase()}:${timeframe}`;
-    if (this.apiUrl) {
-      try {
-        const res = await fetch(
-          `${this.apiUrl}/v1/prices/${symbol.toUpperCase()}/ohlcv?interval=${timeframe}&limit=100`
-        );
-        if (res.ok) {
-          const bars = await res.json();
-          const ohlcv = bars.map((b) => ({
-            timestamp: b.t,
-            open: b.o,
-            high: b.h,
-            low: b.l,
-            close: b.c,
-            volume: b.v
-          }));
-          this.ohlcvCache.set(cacheKey, { data: ohlcv, fetchedAt: Date.now() });
-          return;
-        }
-      } catch {
-      }
-    }
-  }
-};
-
-// src/paper/executor.ts
-import { randomUUID } from "crypto";
-var PaperExecutor = class {
-  cash;
-  positions = /* @__PURE__ */ new Map();
-  trades = [];
-  equityCurve = [];
-  slippageBps;
-  feeRate;
-  peakEquity;
-  maxDrawdown = 0;
-  constructor(initialCash = 1e4, slippageBps = 50, feeRate = 2e-3) {
-    this.cash = initialCash;
-    this.slippageBps = slippageBps;
-    this.feeRate = feeRate;
-    this.peakEquity = initialCash;
-    this.recordEquity();
-  }
-  execute(signal, market) {
-    const marketPrice = market.getPrice(signal.symbol);
-    if (!marketPrice) {
-      console.warn(`[paper] No price for ${signal.symbol}`);
-      return null;
-    }
-    const isBuy = signal.side === "buy" || signal.side === "long";
-    const slippage = this.slippageBps / 1e4 * marketPrice;
-    const executedPrice = isBuy ? marketPrice + slippage : marketPrice - slippage;
-    const fee = signal.size * executedPrice * this.feeRate;
-    if (isBuy) {
-      const totalCost = signal.size * executedPrice + fee;
-      if (totalCost > this.cash) {
-        console.warn(`[paper] Insufficient funds: need $${totalCost.toFixed(2)}, have $${this.cash.toFixed(2)}`);
-        return null;
-      }
-      this.cash -= totalCost;
-      const existing = this.positions.get(signal.symbol);
-      if (existing) {
-        const totalQty = existing.quantity + signal.size;
-        existing.avgPrice = (existing.avgPrice * existing.quantity + executedPrice * signal.size) / totalQty;
-        existing.quantity = totalQty;
-      } else {
-        this.positions.set(signal.symbol, { quantity: signal.size, avgPrice: executedPrice });
-      }
-    } else {
-      const existing = this.positions.get(signal.symbol);
-      if (!existing || existing.quantity < signal.size) {
-        console.warn(`[paper] No position to sell: ${signal.symbol}`);
-        return null;
-      }
-      const proceeds = signal.size * executedPrice - fee;
-      this.cash += proceeds;
-      existing.quantity -= signal.size;
-      if (existing.quantity <= 1e-6) {
-        this.positions.delete(signal.symbol);
-      }
-    }
-    const trade = {
-      id: randomUUID(),
-      symbol: signal.symbol,
-      side: isBuy ? "buy" : "sell",
-      size: signal.size,
-      entryPrice: executedPrice,
-      fee,
-      timestamp: Date.now(),
-      venue: `paper_${signal.venue}`
-    };
-    this.trades.push(trade);
-    this.recordEquity();
-    return trade;
-  }
-  recordEquity() {
-    const equity = this.getEquity();
-    this.equityCurve.push({ timestamp: Date.now(), equity });
-    if (equity > this.peakEquity) this.peakEquity = equity;
-    const drawdown = (this.peakEquity - equity) / this.peakEquity;
-    if (drawdown > this.maxDrawdown) this.maxDrawdown = drawdown;
-  }
-  getEquity() {
-    let positionValue = 0;
-    for (const [, pos] of this.positions) {
-      positionValue += pos.quantity * pos.avgPrice;
-    }
-    return this.cash + positionValue;
-  }
-  getCash() {
-    return this.cash;
-  }
-  getPositions() {
-    return new Map(this.positions);
-  }
-  getTrades() {
-    return [...this.trades];
-  }
-  getEquityCurve() {
-    return [...this.equityCurve];
-  }
-  getMetrics() {
-    const initialEquity = this.equityCurve[0]?.equity || 0;
-    const currentEquity = this.getEquity();
-    const totalReturn = initialEquity > 0 ? (currentEquity - initialEquity) / initialEquity : 0;
-    const dailyReturns = this.calculateDailyReturns();
-    const sharpeRatio = this.calculateSharpe(dailyReturns);
-    let wins = 0;
-    let losses = 0;
-    let grossProfit = 0;
-    let grossLoss = 0;
-    const sellTrades = this.trades.filter((t) => t.side === "sell");
-    for (const sell of sellTrades) {
-      const buyTrades = this.trades.filter((t) => t.side === "buy" && t.symbol === sell.symbol);
-      const avgEntry = buyTrades.reduce((sum, t) => sum + t.entryPrice, 0) / (buyTrades.length || 1);
-      const pnl = (sell.entryPrice - avgEntry) * sell.size - sell.fee;
-      if (pnl > 0) {
-        wins++;
-        grossProfit += pnl;
-      } else {
-        losses++;
-        grossLoss += Math.abs(pnl);
-      }
-    }
-    return {
-      totalReturn,
-      sharpeRatio,
-      maxDrawdown: this.maxDrawdown,
-      winRate: wins + losses > 0 ? wins / (wins + losses) : 0,
-      profitFactor: grossLoss > 0 ? grossProfit / grossLoss : grossProfit > 0 ? Infinity : 0,
-      totalTrades: this.trades.length
-    };
-  }
-  calculateDailyReturns() {
-    if (this.equityCurve.length < 2) return [];
-    const dailyEquity = /* @__PURE__ */ new Map();
-    for (const point of this.equityCurve) {
-      const date = new Date(point.timestamp).toISOString().slice(0, 10);
-      dailyEquity.set(date, point.equity);
-    }
-    const dates = Array.from(dailyEquity.keys()).sort();
-    const returns = [];
-    for (let i = 1; i < dates.length; i++) {
-      const prev = dailyEquity.get(dates[i - 1]);
-      const curr = dailyEquity.get(dates[i]);
-      if (prev > 0) returns.push((curr - prev) / prev);
-    }
-    return returns;
-  }
-  calculateSharpe(returns) {
-    if (returns.length < 2) return 0;
-    const mean = returns.reduce((a, b) => a + b, 0) / returns.length;
-    const variance = returns.reduce((sum, r) => sum + (r - mean) ** 2, 0) / (returns.length - 1);
-    const std = Math.sqrt(variance);
-    if (std === 0) return 0;
-    return mean / std * Math.sqrt(365);
-  }
-};
-
-// src/perp/client.ts
-var HyperliquidClient = class {
-  apiUrl;
-  meta = null;
-  assetIndexCache = /* @__PURE__ */ new Map();
-  constructor(config) {
-    this.apiUrl = config.apiUrl;
-  }
-  // ── INFO API (read-only) ───────────────────────────────────
-  async getMeta() {
-    if (this.meta) return this.meta;
-    const resp = await this.infoRequest({ type: "meta" });
-    this.meta = resp.universe;
-    this.meta.forEach((asset, idx) => {
-      this.assetIndexCache.set(asset.name, idx);
-    });
-    return this.meta;
-  }
-  async getAssetIndex(coin) {
-    if (this.assetIndexCache.has(coin)) return this.assetIndexCache.get(coin);
-    await this.getMeta();
-    const idx = this.assetIndexCache.get(coin);
-    if (idx === void 0) throw new Error(`Unknown instrument: ${coin}`);
-    return idx;
-  }
-  async getAllMids() {
-    return this.infoRequest({ type: "allMids" });
-  }
-  async getClearinghouseState(user) {
-    return this.infoRequest({ type: "clearinghouseState", user });
-  }
-  async getUserFills(user, startTime) {
-    return this.infoRequest({
-      type: "userFills",
-      user,
-      ...startTime !== void 0 && { startTime }
-    });
-  }
-  async getUserFillsByTime(user, startTime, endTime) {
-    return this.infoRequest({
-      type: "userFillsByTime",
-      user,
-      startTime,
-      ...endTime !== void 0 && { endTime }
-    });
-  }
-  async getOpenOrders(user) {
-    return this.infoRequest({ type: "openOrders", user });
-  }
-  async getL2Book(coin, depth) {
-    return this.infoRequest({
-      type: "l2Book",
-      coin,
-      ...depth !== void 0 && { nSigFigs: depth }
-    });
-  }
-  // ── HIGH-LEVEL HELPERS ─────────────────────────────────────
-  async getPositions(user) {
-    const state = await this.getClearinghouseState(user);
-    return state.assetPositions.filter((p) => parseFloat(p.position.szi) !== 0).map((p) => this.parsePosition(p));
-  }
-  async getAccountSummary(user) {
-    const state = await this.getClearinghouseState(user);
-    const cms = state.crossMarginSummary;
-    const totalEquity = parseFloat(cms.accountValue);
-    const totalNotional = parseFloat(cms.totalNtlPos);
-    const totalMarginUsed = parseFloat(cms.totalMarginUsed);
-    return {
-      totalEquity,
-      availableMargin: totalEquity - totalMarginUsed,
-      totalMarginUsed,
-      totalUnrealizedPnl: parseFloat(cms.totalRawUsd) - totalEquity,
-      totalNotional,
-      maintenanceMargin: totalMarginUsed * 0.5,
-      effectiveLeverage: totalEquity > 0 ? totalNotional / totalEquity : 0,
-      cashBalance: parseFloat(cms.accountValue) - state.assetPositions.reduce(
-        (sum, p) => sum + parseFloat(p.position.unrealizedPnl),
-        0
-      )
-    };
-  }
-  async getMarketData(instruments) {
-    const mids = await this.getAllMids();
-    return instruments.filter((inst) => mids[inst] !== void 0).map((inst) => ({
-      instrument: inst,
-      midPrice: parseFloat(mids[inst]),
-      bestBid: parseFloat(mids[inst]),
-      bestAsk: parseFloat(mids[inst]),
-      funding8h: 0,
-      openInterest: 0,
-      volume24h: 0,
-      priceChange24h: 0
-    }));
-  }
-  parseFill(fill) {
-    return {
-      oid: fill.oid,
-      coin: fill.coin,
-      side: fill.side,
-      px: fill.px,
-      sz: fill.sz,
-      fee: fill.fee,
-      time: fill.time,
-      hash: fill.hash,
-      isMaker: fill.startPosition !== fill.px,
-      builderFee: fill.builderFee,
-      liquidation: fill.liquidation
-    };
-  }
-  // ── PRIVATE ────────────────────────────────────────────────
-  parsePosition(ap) {
-    const pos = ap.position;
-    const size = parseFloat(pos.szi);
-    const entryPrice = parseFloat(pos.entryPx || "0");
-    const markPrice = parseFloat(pos.positionValue || "0") / Math.abs(size || 1);
-    return {
-      instrument: pos.coin,
-      assetIndex: this.assetIndexCache.get(pos.coin) ?? -1,
-      size,
-      entryPrice,
-      markPrice,
-      unrealizedPnl: parseFloat(pos.unrealizedPnl),
-      leverage: parseFloat(pos.leverage?.value || "1"),
-      marginType: pos.leverage?.type === "isolated" ? "isolated" : "cross",
-      liquidationPrice: parseFloat(pos.liquidationPx || "0"),
-      notionalUSD: Math.abs(size) * markPrice,
-      marginUsed: parseFloat(pos.marginUsed)
-    };
-  }
-  async infoRequest(body) {
-    const resp = await fetch(`${this.apiUrl}/info`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-    if (!resp.ok) {
-      throw new Error(`Hyperliquid Info API error: ${resp.status} ${await resp.text()}`);
-    }
-    return resp.json();
-  }
-};
-
-// src/perp/signer.ts
-import { keccak256 } from "viem";
-
-// src/perp/msgpack.ts
-var FOUR_BITS = 16;
-var FIVE_BITS = 32;
-var SEVEN_BITS = 128;
-var EIGHT_BITS = 256;
-var FIFTEEN_BITS = 32768;
-var SIXTEEN_BITS = 65536;
-var THIRTY_ONE_BITS = 2147483648;
-var THIRTY_TWO_BITS = 4294967296;
-var SIXTY_THREE_BITS = 9223372036854775808n;
-var SIXTY_FOUR_BITS = 18446744073709551616n;
-var textEncoder = new TextEncoder();
-function encodeMsgpack(object) {
-  const byteParts = [];
-  encodeSlice(object, byteParts);
-  return concatBytes(...byteParts);
-}
-function concatBytes(...arrays) {
-  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const arr of arrays) {
-    result.set(arr, offset);
-    offset += arr.length;
-  }
-  return result;
-}
-function encodeFloat64(num) {
-  const dataView = new DataView(new ArrayBuffer(9));
-  dataView.setFloat64(1, num);
-  dataView.setUint8(0, 203);
-  return new Uint8Array(dataView.buffer);
-}
-function encodeNumber(num) {
-  if (!Number.isInteger(num)) return encodeFloat64(num);
-  if (num < 0) {
-    if (num >= -FIVE_BITS) return new Uint8Array([num & 255]);
-    if (num >= -SEVEN_BITS) return new Uint8Array([208, num & 255]);
-    if (num >= -FIFTEEN_BITS) {
-      const dv = new DataView(new ArrayBuffer(3));
-      dv.setInt16(1, num);
-      dv.setUint8(0, 209);
-      return new Uint8Array(dv.buffer);
-    }
-    if (num >= -THIRTY_ONE_BITS) {
-      const dv = new DataView(new ArrayBuffer(5));
-      dv.setInt32(1, num);
-      dv.setUint8(0, 210);
-      return new Uint8Array(dv.buffer);
-    }
-    return encodeFloat64(num);
-  }
-  if (num <= 127) return new Uint8Array([num]);
-  if (num < EIGHT_BITS) return new Uint8Array([204, num]);
-  if (num < SIXTEEN_BITS) {
-    const dv = new DataView(new ArrayBuffer(3));
-    dv.setUint16(1, num);
-    dv.setUint8(0, 205);
-    return new Uint8Array(dv.buffer);
-  }
-  if (num < THIRTY_TWO_BITS) {
-    const dv = new DataView(new ArrayBuffer(5));
-    dv.setUint32(1, num);
-    dv.setUint8(0, 206);
-    return new Uint8Array(dv.buffer);
-  }
-  return encodeFloat64(num);
-}
-function encodeSlice(object, byteParts) {
-  if (object === null) {
-    byteParts.push(new Uint8Array([192]));
-    return;
-  }
-  if (object === false) {
-    byteParts.push(new Uint8Array([194]));
-    return;
-  }
-  if (object === true) {
-    byteParts.push(new Uint8Array([195]));
-    return;
-  }
-  if (typeof object === "number") {
-    byteParts.push(encodeNumber(object));
-    return;
-  }
-  if (typeof object === "bigint") {
-    if (object < 0) {
-      if (object < -SIXTY_THREE_BITS)
-        throw new Error("Cannot safely encode bigint larger than 64 bits");
-      const dv2 = new DataView(new ArrayBuffer(9));
-      dv2.setBigInt64(1, object);
-      dv2.setUint8(0, 211);
-      byteParts.push(new Uint8Array(dv2.buffer));
-      return;
-    }
-    if (object >= SIXTY_FOUR_BITS)
-      throw new Error("Cannot safely encode bigint larger than 64 bits");
-    const dv = new DataView(new ArrayBuffer(9));
-    dv.setBigUint64(1, object);
-    dv.setUint8(0, 207);
-    byteParts.push(new Uint8Array(dv.buffer));
-    return;
-  }
-  if (typeof object === "string") {
-    const encoded = textEncoder.encode(object);
-    const len = encoded.length;
-    if (len < FIVE_BITS) byteParts.push(new Uint8Array([160 | len]));
-    else if (len < EIGHT_BITS) byteParts.push(new Uint8Array([217, len]));
-    else if (len < SIXTEEN_BITS) {
-      const dv = new DataView(new ArrayBuffer(3));
-      dv.setUint16(1, len);
-      dv.setUint8(0, 218);
-      byteParts.push(new Uint8Array(dv.buffer));
-    } else if (len < THIRTY_TWO_BITS) {
-      const dv = new DataView(new ArrayBuffer(5));
-      dv.setUint32(1, len);
-      dv.setUint8(0, 219);
-      byteParts.push(new Uint8Array(dv.buffer));
-    } else {
-      throw new Error("Cannot safely encode string with size larger than 32 bits");
-    }
-    byteParts.push(encoded);
-    return;
-  }
-  if (object instanceof Uint8Array) {
-    if (object.length < EIGHT_BITS) {
-      byteParts.push(new Uint8Array([196, object.length]));
-    } else if (object.length < SIXTEEN_BITS) {
-      const dv = new DataView(new ArrayBuffer(3));
-      dv.setUint16(1, object.length);
-      dv.setUint8(0, 197);
-      byteParts.push(new Uint8Array(dv.buffer));
-    } else if (object.length < THIRTY_TWO_BITS) {
-      const dv = new DataView(new ArrayBuffer(5));
-      dv.setUint32(1, object.length);
-      dv.setUint8(0, 198);
-      byteParts.push(new Uint8Array(dv.buffer));
-    } else {
-      throw new Error("Cannot safely encode Uint8Array with size larger than 32 bits");
-    }
-    byteParts.push(object);
-    return;
-  }
-  if (Array.isArray(object)) {
-    if (object.length < FOUR_BITS) byteParts.push(new Uint8Array([144 | object.length]));
-    else if (object.length < SIXTEEN_BITS) {
-      const dv = new DataView(new ArrayBuffer(3));
-      dv.setUint16(1, object.length);
-      dv.setUint8(0, 220);
-      byteParts.push(new Uint8Array(dv.buffer));
-    } else if (object.length < THIRTY_TWO_BITS) {
-      const dv = new DataView(new ArrayBuffer(5));
-      dv.setUint32(1, object.length);
-      dv.setUint8(0, 221);
-      byteParts.push(new Uint8Array(dv.buffer));
-    } else {
-      throw new Error("Cannot safely encode array with size larger than 32 bits");
-    }
-    for (const obj of object) encodeSlice(obj, byteParts);
-    return;
-  }
-  if (typeof object === "object") {
-    const entries = Object.entries(object);
-    const numKeys = entries.length;
-    if (numKeys < FOUR_BITS) byteParts.push(new Uint8Array([128 | numKeys]));
-    else if (numKeys < SIXTEEN_BITS) {
-      const dv = new DataView(new ArrayBuffer(3));
-      dv.setUint16(1, numKeys);
-      dv.setUint8(0, 222);
-      byteParts.push(new Uint8Array(dv.buffer));
-    } else if (numKeys < THIRTY_TWO_BITS) {
-      const dv = new DataView(new ArrayBuffer(5));
-      dv.setUint32(1, numKeys);
-      dv.setUint8(0, 223);
-      byteParts.push(new Uint8Array(dv.buffer));
-    } else {
-      throw new Error("Cannot safely encode map with size larger than 32 bits");
-    }
-    for (const [key, value] of entries) {
-      encodeSlice(key, byteParts);
-      encodeSlice(value, byteParts);
-    }
-    return;
-  }
-  throw new Error("Cannot safely encode value into messagepack");
-}
-function largeIntToBigInt(obj) {
-  if (typeof obj === "number" && Number.isInteger(obj) && (obj >= 4294967296 || obj < -2147483648)) {
-    return BigInt(obj);
-  }
-  if (Array.isArray(obj)) return obj.map(largeIntToBigInt);
-  if (typeof obj === "object" && obj !== null && !(obj instanceof Uint8Array)) {
-    const result = {};
-    for (const key in obj) {
-      result[key] = largeIntToBigInt(obj[key]);
-    }
-    return result;
-  }
-  return obj;
-}
-function removeUndefinedKeys(obj) {
-  if (Array.isArray(obj)) return obj.map(removeUndefinedKeys);
-  if (typeof obj === "object" && obj !== null && !(obj instanceof Uint8Array)) {
-    const result = {};
-    for (const key in obj) {
-      const val = obj[key];
-      if (val !== void 0) {
-        result[key] = removeUndefinedKeys(val);
-      }
-    }
-    return result;
-  }
-  return obj;
-}
-function toUint64Bytes(n) {
-  const bytes = new Uint8Array(8);
-  new DataView(bytes.buffer).setBigUint64(0, BigInt(n));
-  return bytes;
-}
-
-// src/perp/signer.ts
-var HYPERLIQUID_DOMAIN = {
-  name: "Exchange",
-  version: "1",
-  chainId: 1337,
-  verifyingContract: "0x0000000000000000000000000000000000000000"
-};
-var HYPERLIQUID_USER_DOMAIN = {
-  name: "HyperliquidSignTransaction",
-  version: "1",
-  chainId: 42161,
-  verifyingContract: "0x0000000000000000000000000000000000000000"
-};
-var USER_ACTION_TYPES = {
-  withdraw: {
-    "HyperliquidTransaction:Withdraw": [
-      { name: "hyperliquidChain", type: "string" },
-      { name: "destination", type: "string" },
-      { name: "amount", type: "string" },
-      { name: "time", type: "uint64" }
-    ]
-  },
-  usdSend: {
-    "HyperliquidTransaction:UsdSend": [
-      { name: "hyperliquidChain", type: "string" },
-      { name: "destination", type: "string" },
-      { name: "amount", type: "string" },
-      { name: "time", type: "uint64" }
-    ]
-  }
-};
-var PHANTOM_AGENT_TYPES = {
-  Agent: [
-    { name: "source", type: "string" },
-    { name: "connectionId", type: "bytes32" }
-  ]
-};
-var lastNonce = 0n;
-function getNextNonce() {
-  const now = BigInt(Date.now());
-  if (now <= lastNonce) {
-    lastNonce = lastNonce + 1n;
-  } else {
-    lastNonce = now;
-  }
-  return lastNonce;
-}
-function createL1ActionHash(args) {
-  const { action, nonce, vaultAddress } = args;
-  const cleaned = removeUndefinedKeys(action);
-  const withBigInts = largeIntToBigInt(cleaned);
-  const actionBytes = encodeMsgpack(withBigInts);
-  const nonceBytes = toUint64Bytes(nonce);
-  const vaultMarker = vaultAddress ? new Uint8Array([1]) : new Uint8Array([0]);
-  const vaultBytes = vaultAddress ? hexToBytes(vaultAddress.slice(2)) : new Uint8Array();
-  const bytes = concatBytes2(actionBytes, nonceBytes, vaultMarker, vaultBytes);
-  return keccak256(bytes);
-}
-var HyperliquidSigner = class {
-  constructor(walletClient, isTestnet = false) {
-    this.walletClient = walletClient;
-    this.isTestnet = isTestnet;
-  }
-  isTestnet;
-  /**
-   * Sign an L1 action (order, cancel, updateLeverage, etc.)
-   * using the phantom agent pattern.
-   */
-  async signAction(action, nonce, vaultAddress) {
-    const actionNonce = nonce ?? getNextNonce();
-    const nonceNumber = Number(actionNonce);
-    const account = this.walletClient.account;
-    if (!account) throw new Error("Wallet client has no account");
-    const connectionId = createL1ActionHash({
-      action,
-      nonce: nonceNumber,
-      vaultAddress
-    });
-    const signature = await this.walletClient.signTypedData({
-      account,
-      domain: HYPERLIQUID_DOMAIN,
-      types: PHANTOM_AGENT_TYPES,
-      primaryType: "Agent",
-      message: {
-        source: this.isTestnet ? "b" : "a",
-        connectionId
-      }
-    });
-    return { signature, nonce: actionNonce };
-  }
-  /**
-   * Sign a user-signed action (withdraw3, usdSend, approveAgent, etc.)
-   * using the HyperliquidSignTransaction domain (chainId 42161).
-   *
-   * Unlike trading actions, these use direct EIP-712 typed data signing
-   * with action-specific types — NOT the phantom agent pattern.
-   */
-  async signUserAction(actionType, message) {
-    const account = this.walletClient.account;
-    if (!account) throw new Error("Wallet client has no account");
-    const types = USER_ACTION_TYPES[actionType];
-    const primaryType = Object.keys(types)[0];
-    const signature = await this.walletClient.signTypedData({
-      account,
-      domain: HYPERLIQUID_USER_DOMAIN,
-      types,
-      primaryType,
-      message
-    });
-    return { signature };
-  }
-  /**
-   * Build and sign a withdraw3 action for withdrawing USDC from Hyperliquid to Arbitrum.
-   * Returns the complete payload ready to POST to /exchange.
-   *
-   * @param destination — The Arbitrum address to receive USDC
-   * @param amount — Amount as string (e.g., "10.0" for $10)
-   */
-  async signWithdraw(destination, amount) {
-    const timestamp = Date.now();
-    const message = {
-      hyperliquidChain: this.isTestnet ? "Testnet" : "Mainnet",
-      destination,
-      amount,
-      time: BigInt(timestamp)
-    };
-    const { signature } = await this.signUserAction("withdraw", message);
-    const action = {
-      type: "withdraw3",
-      hyperliquidChain: this.isTestnet ? "Testnet" : "Mainnet",
-      signatureChainId: "0xa4b1",
-      // Arbitrum chainId in hex
-      destination,
-      amount,
-      time: timestamp
-    };
-    return {
-      action,
-      signature: {
-        r: signature.slice(0, 66),
-        s: `0x${signature.slice(66, 130)}`,
-        v: parseInt(signature.slice(130, 132), 16)
-      },
-      nonce: timestamp
-    };
-  }
-  getAddress() {
-    const account = this.walletClient.account;
-    if (!account) throw new Error("Wallet client has no account");
-    return account.address;
-  }
-};
-function hexToBytes(hex) {
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < bytes.length; i++) {
-    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return bytes;
-}
-function concatBytes2(...arrays) {
-  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const arr of arrays) {
-    result.set(arr, offset);
-    offset += arr.length;
-  }
-  return result;
-}
-
-// src/perp/orders.ts
-var HyperliquidOrderManager = class {
-  client;
-  signer;
-  config;
-  constructor(client, signer, config) {
-    this.client = client;
-    this.signer = signer;
-    this.config = config;
-  }
-  async placeOrder(signal) {
-    try {
-      const assetIndex = await this.client.getAssetIndex(signal.instrument);
-      const isBuy = signal.action === "open_long" || signal.action === "close_short";
-      const orderWire = {
-        a: assetIndex,
-        b: isBuy,
-        p: signal.orderType === "market" ? this.getMarketPrice(signal) : signal.price.toString(),
-        s: signal.size.toString(),
-        r: signal.reduceOnly,
-        t: signal.orderType === "market" ? { limit: { tif: "Ioc" } } : { limit: { tif: "Gtc" } }
-      };
-      const action = {
-        type: "order",
-        orders: [orderWire],
-        grouping: "na"
-      };
-      const nonce = getNextNonce();
-      const { signature } = await this.signer.signAction(action, nonce);
-      const resp = await this.exchangeRequest({
-        action,
-        nonce: Number(nonce),
-        signature: {
-          r: signature.slice(0, 66),
-          s: `0x${signature.slice(66, 130)}`,
-          v: parseInt(signature.slice(130, 132), 16)
-        },
-        vaultAddress: null
-      });
-      return this.parseOrderResponse(resp);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error(`[perp] Order failed for ${signal.instrument}:`, message);
-      return { success: false, status: "error", error: message };
-    }
-  }
-  async cancelOrder(instrument, orderId) {
-    try {
-      const assetIndex = await this.client.getAssetIndex(instrument);
-      const action = {
-        type: "cancel",
-        cancels: [{ a: assetIndex, o: orderId }]
-      };
-      const nonce = getNextNonce();
-      const { signature } = await this.signer.signAction(action, nonce);
-      await this.exchangeRequest({
-        action,
-        nonce: Number(nonce),
-        signature: {
-          r: signature.slice(0, 66),
-          s: `0x${signature.slice(66, 130)}`,
-          v: parseInt(signature.slice(130, 132), 16)
-        },
-        vaultAddress: null
-      });
-      console.log(`[perp] Cancelled order ${orderId} for ${instrument}`);
-      return true;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error(`[perp] Cancel failed for order ${orderId}:`, message);
-      return false;
-    }
-  }
-  async closePosition(instrument, positionSize) {
-    const isLong = positionSize > 0;
-    return this.placeOrder({
-      action: isLong ? "close_long" : "close_short",
-      instrument,
-      size: Math.abs(positionSize),
-      price: 0,
-      leverage: 1,
-      orderType: "market",
-      reduceOnly: true,
-      confidence: 1,
-      reasoning: "Position close"
-    });
-  }
-  async updateLeverage(instrument, leverage, isCross = true) {
-    try {
-      const assetIndex = await this.client.getAssetIndex(instrument);
-      const action = {
-        type: "updateLeverage",
-        asset: assetIndex,
-        isCross,
-        leverage
-      };
-      const nonce = getNextNonce();
-      const { signature } = await this.signer.signAction(action, nonce);
-      await this.exchangeRequest({
-        action,
-        nonce: Number(nonce),
-        signature: {
-          r: signature.slice(0, 66),
-          s: `0x${signature.slice(66, 130)}`,
-          v: parseInt(signature.slice(130, 132), 16)
-        },
-        vaultAddress: null
-      });
-      console.log(`[perp] Leverage set for ${instrument}: ${leverage}x (${isCross ? "cross" : "isolated"})`);
-      return true;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error(`[perp] Leverage update failed for ${instrument}:`, message);
-      return false;
-    }
-  }
-  // ── PRIVATE ────────────────────────────────────────────────
-  getMarketPrice(signal) {
-    const isBuy = signal.action === "open_long" || signal.action === "close_short";
-    if (signal.price > 0) {
-      const slippage = isBuy ? 1.005 : 0.995;
-      return (signal.price * slippage).toString();
-    }
-    return "0";
-  }
-  parseOrderResponse(resp) {
-    if (resp?.status === "ok" && resp?.response?.type === "order") {
-      const statuses = resp.response.data?.statuses || [];
-      if (statuses.length > 0) {
-        const status = statuses[0];
-        if (status.filled) {
-          return {
-            success: true,
-            orderId: status.filled.oid,
-            status: "filled",
-            avgPrice: status.filled.avgPx,
-            filledSize: status.filled.totalSz
-          };
-        }
-        if (status.resting) {
-          return {
-            success: true,
-            orderId: status.resting.oid,
-            status: "resting"
-          };
-        }
-        if (status.error) {
-          return { success: false, status: "error", error: status.error };
-        }
-      }
-    }
-    return {
-      success: false,
-      status: "error",
-      error: `Unexpected response: ${JSON.stringify(resp)}`
-    };
-  }
-  async exchangeRequest(body) {
-    const resp = await fetch(`${this.config.apiUrl}/exchange`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-    if (!resp.ok) {
-      throw new Error(`Hyperliquid Exchange API error: ${resp.status} ${await resp.text()}`);
-    }
-    return resp.json();
-  }
-};
-
-// src/perp/positions.ts
-var HyperliquidPositionManager = class {
-  client;
-  userAddress;
-  cachedPositions = [];
-  cachedAccount = null;
-  lastRefreshAt = 0;
-  cacheTtlMs = 5e3;
-  constructor(client, userAddress) {
-    this.client = client;
-    this.userAddress = userAddress;
-  }
-  // ── POSITION QUERIES ───────────────────────────────────────
-  async getPositions(forceRefresh = false) {
-    if (!forceRefresh && this.isCacheFresh()) return this.cachedPositions;
-    await this.refresh();
-    return this.cachedPositions;
-  }
-  async getPosition(instrument) {
-    const positions = await this.getPositions();
-    return positions.find((p) => p.instrument === instrument) ?? null;
-  }
-  async getAccountSummary(forceRefresh = false) {
-    if (!forceRefresh && this.isCacheFresh() && this.cachedAccount) {
-      return this.cachedAccount;
-    }
-    await this.refresh();
-    return this.cachedAccount;
-  }
-  // ── LIQUIDATION MONITORING ─────────────────────────────────
-  async getLiquidationProximity() {
-    const positions = await this.getPositions();
-    const proximities = /* @__PURE__ */ new Map();
-    for (const pos of positions) {
-      if (pos.liquidationPrice <= 0 || pos.markPrice <= 0) {
-        proximities.set(pos.instrument, 0);
-        continue;
-      }
-      let proximity;
-      if (pos.size > 0) {
-        if (pos.markPrice <= pos.liquidationPrice) {
-          proximity = 1;
-        } else {
-          const distanceToLiq = pos.markPrice - pos.liquidationPrice;
-          const entryToLiq = pos.entryPrice - pos.liquidationPrice;
-          proximity = entryToLiq > 0 ? 1 - distanceToLiq / entryToLiq : 0;
-        }
-      } else {
-        if (pos.markPrice >= pos.liquidationPrice) {
-          proximity = 1;
-        } else {
-          const distanceToLiq = pos.liquidationPrice - pos.markPrice;
-          const entryToLiq = pos.liquidationPrice - pos.entryPrice;
-          proximity = entryToLiq > 0 ? 1 - distanceToLiq / entryToLiq : 0;
-        }
-      }
-      proximities.set(pos.instrument, Math.max(0, Math.min(1, proximity)));
-    }
-    return proximities;
-  }
-  async getDangerousPositions(threshold = 0.7) {
-    const positions = await this.getPositions();
-    const proximities = await this.getLiquidationProximity();
-    return positions.filter((p) => (proximities.get(p.instrument) ?? 0) > threshold);
-  }
-  // ── SUMMARY HELPERS ────────────────────────────────────────
-  async getTotalUnrealizedPnl() {
-    const positions = await this.getPositions();
-    return positions.reduce((sum, p) => sum + p.unrealizedPnl, 0);
-  }
-  async getTotalNotional() {
-    const positions = await this.getPositions();
-    return positions.reduce((sum, p) => sum + p.notionalUSD, 0);
-  }
-  async getPositionCount() {
-    return (await this.getPositions()).length;
-  }
-  // ── CACHE ──────────────────────────────────────────────────
-  async refresh() {
-    try {
-      const [positions, account] = await Promise.all([
-        this.client.getPositions(this.userAddress),
-        this.client.getAccountSummary(this.userAddress)
-      ]);
-      this.cachedPositions = positions;
-      this.cachedAccount = account;
-      this.lastRefreshAt = Date.now();
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error("[perp] Failed to refresh positions:", message);
-    }
-  }
-  isCacheFresh() {
-    return Date.now() - this.lastRefreshAt < this.cacheTtlMs;
-  }
-};
-
-// src/perp/websocket.ts
-import WebSocket2 from "ws";
-var HyperliquidWebSocket = class {
-  wsUrl;
-  userAddress;
-  client;
-  ws = null;
-  reconnectAttempts = 0;
-  maxReconnectAttempts = 20;
-  baseReconnectMs = 1e3;
-  maxReconnectMs = 6e4;
-  reconnectTimer = null;
-  pingTimer = null;
-  isConnecting = false;
-  shouldReconnect = true;
-  lastProcessedFillTime = 0;
-  onFill = null;
-  onFunding = null;
-  onLiquidation = null;
-  constructor(config, userAddress, client) {
-    this.wsUrl = config.wsUrl;
-    this.userAddress = userAddress;
-    this.client = client;
-  }
-  // ── CONNECTION ─────────────────────────────────────────────
-  async connect() {
-    if (this.ws?.readyState === WebSocket2.OPEN || this.isConnecting) return;
-    this.isConnecting = true;
-    this.shouldReconnect = true;
-    return new Promise((resolve2, reject) => {
-      try {
-        this.ws = new WebSocket2(this.wsUrl);
-        this.ws.on("open", () => {
-          this.isConnecting = false;
-          this.reconnectAttempts = 0;
-          console.log("[perp-ws] Connected");
-          this.subscribe({
-            type: "subscribe",
-            subscription: { type: "userFills", user: this.userAddress }
-          });
-          this.subscribe({
-            type: "subscribe",
-            subscription: { type: "userFundings", user: this.userAddress }
-          });
-          this.startPing();
-          this.backfillMissedFills().catch((err) => {
-            console.warn("[perp-ws] Backfill failed:", err instanceof Error ? err.message : err);
-          });
-          resolve2();
-        });
-        this.ws.on("message", (data) => {
-          this.handleMessage(data);
-        });
-        this.ws.on("close", (code, reason) => {
-          this.isConnecting = false;
-          console.log(`[perp-ws] Closed: ${code} ${reason.toString()}`);
-          this.stopPing();
-          this.scheduleReconnect();
-        });
-        this.ws.on("error", (error) => {
-          this.isConnecting = false;
-          console.error("[perp-ws] Error:", error.message);
-          if (this.reconnectAttempts === 0) reject(error);
-        });
-      } catch (error) {
-        this.isConnecting = false;
-        reject(error);
-      }
-    });
-  }
-  disconnect() {
-    this.shouldReconnect = false;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    this.stopPing();
-    if (this.ws) {
-      this.ws.removeAllListeners();
-      if (this.ws.readyState === WebSocket2.OPEN) {
-        this.ws.close(1e3, "Client disconnect");
-      }
-      this.ws = null;
-    }
-    console.log("[perp-ws] Disconnected");
-  }
-  get isConnected() {
-    return this.ws?.readyState === WebSocket2.OPEN;
-  }
-  // ── EVENT HANDLERS ─────────────────────────────────────────
-  onFillReceived(callback) {
-    this.onFill = callback;
-  }
-  onFundingReceived(callback) {
-    this.onFunding = callback;
-  }
-  onLiquidationDetected(callback) {
-    this.onLiquidation = callback;
-  }
-  getLastProcessedFillTime() {
-    return this.lastProcessedFillTime;
-  }
-  // ── MESSAGE HANDLING ───────────────────────────────────────
-  handleMessage(data) {
-    try {
-      const msg = JSON.parse(data.toString());
-      if (msg.channel === "userFills") {
-        this.handleFillMessage(msg.data);
-      } else if (msg.channel === "userFundings") {
-        this.handleFundingMessage(msg.data);
-      }
-    } catch {
-    }
-  }
-  handleFillMessage(fills) {
-    if (!Array.isArray(fills) || !this.onFill) return;
-    for (const rawFill of fills) {
-      const fill = this.client.parseFill(rawFill);
-      if (fill.time > this.lastProcessedFillTime) {
-        this.lastProcessedFillTime = fill.time;
-      }
-      if (fill.liquidation && this.onLiquidation) {
-        this.onLiquidation(fill.coin, parseFloat(fill.sz));
-      }
-      this.onFill(fill);
-    }
-  }
-  handleFundingMessage(fundings) {
-    if (!Array.isArray(fundings) || !this.onFunding) return;
-    for (const funding of fundings) {
-      this.onFunding({
-        time: funding.time,
-        coin: funding.coin,
-        usdc: funding.usdc,
-        szi: funding.szi,
-        fundingRate: funding.fundingRate
-      });
-    }
-  }
-  // ── BACKFILL ───────────────────────────────────────────────
-  async backfillMissedFills() {
-    if (this.lastProcessedFillTime === 0 || !this.onFill) return;
-    console.log(`[perp-ws] Backfilling fills since ${new Date(this.lastProcessedFillTime).toISOString()}`);
-    const fills = await this.client.getUserFillsByTime(
-      this.userAddress,
-      this.lastProcessedFillTime + 1
-    );
-    if (fills.length > 0) {
-      console.log(`[perp-ws] Backfilled ${fills.length} missed fills`);
-      for (const rawFill of fills) {
-        const fill = this.client.parseFill(rawFill);
-        if (fill.time > this.lastProcessedFillTime) {
-          this.lastProcessedFillTime = fill.time;
-        }
-        if (fill.liquidation && this.onLiquidation) {
-          this.onLiquidation(fill.coin, parseFloat(fill.sz));
-        }
-        this.onFill(fill);
-      }
-    }
-  }
-  // ── RECONNECTION ───────────────────────────────────────────
-  scheduleReconnect() {
-    if (!this.shouldReconnect || this.reconnectAttempts >= this.maxReconnectAttempts) {
-      if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-        console.error(`[perp-ws] Max reconnect attempts (${this.maxReconnectAttempts}) reached`);
-      }
-      return;
-    }
-    const delay = Math.min(
-      this.baseReconnectMs * Math.pow(2, this.reconnectAttempts),
-      this.maxReconnectMs
-    );
-    this.reconnectAttempts++;
-    console.log(`[perp-ws] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
-    this.reconnectTimer = setTimeout(() => {
-      this.connect().catch((err) => {
-        console.error("[perp-ws] Reconnect failed:", err instanceof Error ? err.message : err);
-      });
-    }, delay);
-  }
-  // ── KEEPALIVE ──────────────────────────────────────────────
-  startPing() {
-    this.stopPing();
-    this.pingTimer = setInterval(() => {
-      if (this.ws?.readyState === WebSocket2.OPEN) {
-        this.ws.send(JSON.stringify({ method: "ping" }));
-      }
-    }, 25e3);
-  }
-  stopPing() {
-    if (this.pingTimer) {
-      clearInterval(this.pingTimer);
-      this.pingTimer = null;
-    }
-  }
-  // ── HELPERS ────────────────────────────────────────────────
-  subscribe(msg) {
-    if (this.ws?.readyState === WebSocket2.OPEN) {
-      this.ws.send(JSON.stringify(msg));
-    }
-  }
-};
-
-// src/prediction/types.ts
-var DEFAULT_PREDICTION_CONFIG = {
-  enabled: false,
-  clobApiUrl: "https://clob.polymarket.com",
-  gammaApiUrl: "https://gamma-api.polymarket.com",
-  maxNotionalUSD: 1e3,
-  maxTotalExposureUSD: 5e3
-};
-var POLYGON_CHAIN_ID = 137;
-var PREDICTION_INSTRUMENT_PREFIX = "POLY:";
-function encodePredictionInstrument(conditionId, outcomeIndex) {
-  return `${PREDICTION_INSTRUMENT_PREFIX}${conditionId}:${outcomeIndex}`;
-}
-function decodePredictionInstrument(instrument) {
-  if (!instrument.startsWith(PREDICTION_INSTRUMENT_PREFIX)) return null;
-  const parts = instrument.slice(PREDICTION_INSTRUMENT_PREFIX.length).split(":");
-  if (parts.length !== 2) return null;
-  return { conditionId: parts[0], outcomeIndex: parseInt(parts[1], 10) };
-}
-
-// src/prediction/client.ts
-import { ClobClient } from "@polymarket/clob-client";
-import { Wallet } from "ethers";
-var PolymarketClient = class {
-  config;
-  clobClient = null;
-  apiCreds = null;
-  signer;
-  walletAddress;
-  marketCache = /* @__PURE__ */ new Map();
-  CACHE_TTL_MS = 6e4;
-  constructor(privateKey, config) {
-    this.config = { ...DEFAULT_PREDICTION_CONFIG, ...config };
-    this.signer = new Wallet(privateKey);
-    this.walletAddress = this.signer.address;
-  }
-  // ── INITIALIZATION ─────────────────────────────────────────
-  async initialize() {
-    const initClient = new ClobClient(
-      this.config.clobApiUrl,
-      POLYGON_CHAIN_ID,
-      this.signer
-    );
-    this.apiCreds = await initClient.createOrDeriveApiKey();
-    this.clobClient = new ClobClient(
-      this.config.clobApiUrl,
-      POLYGON_CHAIN_ID,
-      this.signer,
-      this.apiCreds,
-      0
-    );
-    console.log(`[prediction] CLOB initialized for ${this.walletAddress}`);
-  }
-  get isInitialized() {
-    return this.clobClient !== null && this.apiCreds !== null;
-  }
-  // ── CLOB API — ORDER BOOK & PRICES ─────────────────────────
-  async getOrderBook(tokenId) {
-    this.ensureInitialized();
-    const book = await this.clobClient.getOrderBook(tokenId);
-    return {
-      bids: (book.bids || []).map((b) => ({ price: parseFloat(b.price), size: parseFloat(b.size) })),
-      asks: (book.asks || []).map((a) => ({ price: parseFloat(a.price), size: parseFloat(a.size) }))
-    };
-  }
-  async getMidpointPrice(tokenId) {
-    const book = await this.getOrderBook(tokenId);
-    if (book.bids.length === 0 || book.asks.length === 0) return 0;
-    return (book.bids[0].price + book.asks[0].price) / 2;
-  }
-  async getLastTradePrice(tokenId) {
-    this.ensureInitialized();
-    const resp = await this.clobClient.getLastTradePrice(tokenId);
-    return parseFloat(resp?.price || "0");
-  }
-  // ── CLOB API — ORDERS ──────────────────────────────────────
-  async placeLimitOrder(params) {
-    this.ensureInitialized();
-    const order = await this.clobClient.createAndPostOrder({
-      tokenID: params.tokenId,
-      price: params.price,
-      side: params.side,
-      size: params.size
-    });
-    return {
-      orderId: order?.orderID || "",
-      success: !!order?.orderID
-    };
-  }
-  async placeMarketOrder(params) {
-    this.ensureInitialized();
-    const order = await this.clobClient.createMarketOrder({
-      tokenID: params.tokenId,
-      amount: params.amount,
-      side: params.side
-    });
-    const result = await this.clobClient.postOrder(order);
-    return {
-      orderId: result?.orderID || "",
-      success: !!result?.orderID
-    };
-  }
-  async cancelOrder(orderId) {
-    this.ensureInitialized();
-    try {
-      await this.clobClient.cancelOrder({ orderID: orderId });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async cancelAllOrders() {
-    this.ensureInitialized();
-    try {
-      await this.clobClient.cancelAll();
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async getOpenOrders() {
-    this.ensureInitialized();
-    return this.clobClient.getOpenOrders();
-  }
-  async getTradeHistory() {
-    this.ensureInitialized();
-    const trades = await this.clobClient.getTrades();
-    return (trades || []).map((t) => this.parseRawFill(t));
-  }
-  // ── GAMMA API — MARKET DISCOVERY (public) ──────────────────
-  async getMarkets(params) {
-    const query = new URLSearchParams();
-    if (params?.limit) query.set("limit", String(params.limit));
-    if (params?.offset) query.set("offset", String(params.offset));
-    if (params?.active !== void 0) query.set("active", String(params.active));
-    if (params?.category) query.set("tag", params.category);
-    const url = `${this.config.gammaApiUrl}/markets?${query.toString()}`;
-    const resp = await fetch(url);
-    if (!resp.ok) throw new Error(`Gamma API error: ${resp.status} ${await resp.text()}`);
-    const raw = await resp.json();
-    return (raw || []).map((m) => this.parseGammaMarket(m));
-  }
-  async getMarketByConditionId(conditionId) {
-    const cached = this.marketCache.get(conditionId);
-    if (cached && Date.now() - cached.cachedAt < this.CACHE_TTL_MS) {
-      return cached.market;
-    }
-    const url = `${this.config.gammaApiUrl}/markets?condition_id=${conditionId}`;
-    const resp = await fetch(url);
-    if (!resp.ok) return null;
-    const raw = await resp.json();
-    if (!raw || raw.length === 0) return null;
-    const market = this.parseGammaMarket(raw[0]);
-    this.marketCache.set(conditionId, { market, cachedAt: Date.now() });
-    return market;
-  }
-  async searchMarkets(query, limit = 20) {
-    const url = `${this.config.gammaApiUrl}/markets?_q=${encodeURIComponent(query)}&limit=${limit}&active=true`;
-    const resp = await fetch(url);
-    if (!resp.ok) return [];
-    const raw = await resp.json();
-    return (raw || []).map((m) => this.parseGammaMarket(m));
-  }
-  async getTrendingMarkets(limit = 10) {
-    const url = `${this.config.gammaApiUrl}/markets?active=true&limit=${limit}&order=volume24hr&ascending=false`;
-    const resp = await fetch(url);
-    if (!resp.ok) return [];
-    const raw = await resp.json();
-    return (raw || []).map((m) => this.parseGammaMarket(m));
-  }
-  // ── WALLET ─────────────────────────────────────────────────
-  getWalletAddress() {
-    return this.walletAddress;
-  }
-  // ── PRIVATE ────────────────────────────────────────────────
-  ensureInitialized() {
-    if (!this.clobClient) {
-      throw new Error("PolymarketClient not initialized. Call initialize() first.");
-    }
-  }
-  parseGammaMarket(raw) {
-    const outcomes = raw.outcomes ? JSON.parse(raw.outcomes) : ["Yes", "No"];
-    const outcomePrices = raw.outcomePrices ? JSON.parse(raw.outcomePrices) : [0, 0];
-    const outcomeTokenIds = raw.clobTokenIds ? JSON.parse(raw.clobTokenIds) : [];
-    return {
-      conditionId: raw.conditionId || raw.condition_id || "",
-      question: raw.question || "",
-      description: raw.description || "",
-      category: raw.groupItemTitle || raw.category || "Other",
-      outcomes,
-      outcomeTokenIds,
-      outcomePrices: outcomePrices.map((p) => parseFloat(p) || 0),
-      volume24h: parseFloat(raw.volume24hr || raw.volume24h || "0"),
-      liquidity: parseFloat(raw.liquidity || "0"),
-      endDate: raw.endDate ? new Date(raw.endDate).getTime() / 1e3 : 0,
-      active: raw.active !== false && raw.closed !== true,
-      resolved: raw.resolved === true,
-      winningOutcome: raw.winningOutcome,
-      resolutionSource: raw.resolutionSource || void 0,
-      uniqueTraders: raw.uniqueTraders || void 0
-    };
-  }
-  parseRawFill(raw) {
-    const tokenId = raw.asset_id || void 0;
-    const marketConditionId = raw.market || raw.asset_id || "";
-    return {
-      orderId: raw.orderId || raw.order_id || "",
-      tradeId: raw.id || raw.tradeId || "",
-      marketConditionId,
-      outcomeIndex: raw.outcome_index ?? (raw.side === "BUY" ? 0 : 1),
-      side: raw.side === "BUY" || raw.side === "buy" ? "BUY" : "SELL",
-      price: String(raw.price || "0"),
-      size: String(raw.size || "0"),
-      fee: String(raw.fee || "0"),
-      timestamp: raw.timestamp || raw.created_at ? new Date(raw.created_at).getTime() : Date.now(),
-      isMaker: raw.maker_order || raw.is_maker || false,
-      tokenId
-    };
-  }
-};
-
-// src/prediction/order-manager.ts
-var PolymarketOrderManager = class {
-  client;
-  config;
-  seenFillIds = /* @__PURE__ */ new Set();
-  recentFills = [];
-  positions = /* @__PURE__ */ new Map();
-  lastPriceRefresh = 0;
-  PRICE_REFRESH_MS = 1e4;
-  constructor(client, config) {
-    this.client = client;
-    this.config = config;
-  }
-  // ── SIGNAL EXECUTION ───────────────────────────────────────
-  async executeSignal(signal) {
-    if (signal.action === "hold") {
-      return { success: true, status: "cancelled", error: "Hold signal \u2014 no action" };
-    }
-    const violation = this.checkRiskLimits(signal);
-    if (violation) {
-      return { success: false, status: "error", error: violation };
-    }
-    try {
-      const market = await this.client.getMarketByConditionId(signal.marketConditionId);
-      if (!market) {
-        return { success: false, status: "error", error: `Market not found: ${signal.marketConditionId}` };
-      }
-      if (!market.active) {
-        return { success: false, status: "error", error: `Market is closed: ${market.question}` };
-      }
-      const tokenId = market.outcomeTokenIds[signal.outcomeIndex];
-      if (!tokenId) {
-        return { success: false, status: "error", error: `Invalid outcome index: ${signal.outcomeIndex}` };
-      }
-      const isBuy = signal.action === "buy_yes" || signal.action === "buy_no";
-      const side = isBuy ? "BUY" : "SELL";
-      let result;
-      if (signal.orderType === "market") {
-        result = await this.client.placeMarketOrder({
-          tokenId,
-          amount: signal.amount,
-          side
-        });
-      } else {
-        result = await this.client.placeLimitOrder({
-          tokenId,
-          price: signal.limitPrice,
-          size: signal.amount,
-          side
-        });
-      }
-      if (result.success) {
-        console.log(`[prediction] Order placed: ${signal.action} ${signal.amount} on "${market.question}" @ ${signal.limitPrice}`);
-        return { success: true, orderId: result.orderId, status: "resting" };
-      }
-      return { success: false, status: "error", error: "Order placement failed" };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error("[prediction] Order execution error:", message);
-      return { success: false, status: "error", error: message };
-    }
-  }
-  // ── FILL POLLING ───────────────────────────────────────────
-  async pollNewFills() {
-    try {
-      const allFills = await this.client.getTradeHistory();
-      const newFills = [];
-      for (const fill of allFills) {
-        if (!this.seenFillIds.has(fill.tradeId)) {
-          this.seenFillIds.add(fill.tradeId);
-          newFills.push(fill);
-          this.processFill(fill);
-          this.recentFills.push(fill);
-        }
-      }
-      if (this.recentFills.length > 100) {
-        this.recentFills = this.recentFills.slice(-100);
-      }
-      return newFills;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.warn("[prediction] Fill polling error:", message);
-      return [];
-    }
-  }
-  getRecentFills() {
-    return this.recentFills;
-  }
-  // ── POSITION QUERIES ───────────────────────────────────────
-  async getPositions(forceRefresh = false) {
-    if (forceRefresh || Date.now() - this.lastPriceRefresh > this.PRICE_REFRESH_MS) {
-      await this.refreshPrices();
-    }
-    return Array.from(this.positions.values()).filter((p) => p.balance > 0).map((p) => this.toExternalPosition(p));
-  }
-  async getAccountSummary() {
-    const positions = await this.getPositions();
-    const totalExposure = positions.reduce((sum, p) => sum + p.costBasis, 0);
-    const totalUnrealizedPnl = positions.reduce((sum, p) => sum + p.unrealizedPnl, 0);
-    const openMarkets = new Set(positions.map((p) => p.marketConditionId));
-    return {
-      totalExposure,
-      totalUnrealizedPnl,
-      openMarketCount: openMarkets.size,
-      openPositionCount: positions.length
-    };
-  }
-  getTotalExposure() {
-    let total = 0;
-    for (const pos of this.positions.values()) {
-      if (pos.balance > 0) total += pos.totalCostBasis;
-    }
-    return total;
-  }
-  // ── CANCELLATION ───────────────────────────────────────────
-  async cancelOrder(orderId) {
-    return this.client.cancelOrder(orderId);
-  }
-  async cancelAllOrders() {
-    return this.client.cancelAllOrders();
-  }
-  // ── PRIVATE ────────────────────────────────────────────────
-  checkRiskLimits(signal) {
-    if (signal.amount > this.config.maxNotionalUSD) {
-      return `Trade exceeds max notional: $${signal.amount} > $${this.config.maxNotionalUSD}`;
-    }
-    if (signal.limitPrice <= 0 || signal.limitPrice >= 1) {
-      return `Invalid price: ${signal.limitPrice} (must be 0.01-0.99)`;
-    }
-    if (signal.confidence < 0.3) {
-      return `Low confidence: ${signal.confidence} < 0.3`;
-    }
-    const isBuy = signal.action === "buy_yes" || signal.action === "buy_no";
-    if (isBuy) {
-      const currentExposure = this.getTotalExposure();
-      if (currentExposure + signal.amount > this.config.maxTotalExposureUSD) {
-        return `Total exposure exceeded: $${currentExposure + signal.amount} > $${this.config.maxTotalExposureUSD}`;
-      }
-    }
-    return null;
-  }
-  processFill(fill) {
-    const key = `${fill.marketConditionId}:${fill.outcomeIndex}`;
-    let pos = this.positions.get(key);
-    const price = parseFloat(fill.price);
-    const size = parseFloat(fill.size);
-    if (!pos) {
-      pos = {
-        marketConditionId: fill.marketConditionId,
-        outcomeIndex: fill.outcomeIndex,
-        marketQuestion: fill.marketQuestion || "",
-        tokenId: fill.tokenId || "",
-        balance: 0,
-        totalCostBasis: 0,
-        totalProceeds: 0,
-        averageEntryPrice: 0,
-        currentPrice: price,
-        category: void 0,
-        endDate: void 0
-      };
-      this.positions.set(key, pos);
-    } else if (!pos.tokenId && fill.tokenId) {
-      pos.tokenId = fill.tokenId;
-    }
-    if (fill.side === "BUY") {
-      const oldCost = pos.averageEntryPrice * pos.balance;
-      const newCost = price * size;
-      pos.balance += size;
-      pos.totalCostBasis += newCost;
-      pos.averageEntryPrice = pos.balance > 0 ? (oldCost + newCost) / pos.balance : 0;
-    } else {
-      pos.balance -= size;
-      pos.totalProceeds += price * size;
-      if (pos.balance < 0) pos.balance = 0;
-    }
-  }
-  async refreshPrices() {
-    const openPositions = Array.from(this.positions.values()).filter((p) => p.balance > 0);
-    await Promise.all(
-      openPositions.map(async (pos) => {
-        try {
-          if (!pos.tokenId) {
-            const market = await this.client.getMarketByConditionId(pos.marketConditionId);
-            if (market && market.outcomeTokenIds[pos.outcomeIndex]) {
-              pos.tokenId = market.outcomeTokenIds[pos.outcomeIndex];
-            }
-          }
-          if (pos.tokenId) {
-            const price = await this.client.getMidpointPrice(pos.tokenId);
-            if (price > 0) pos.currentPrice = price;
-          }
-        } catch {
-        }
-      })
-    );
-    this.lastPriceRefresh = Date.now();
-  }
-  toExternalPosition(pos) {
-    const unrealizedPnl = pos.balance > 0 ? (pos.currentPrice - pos.averageEntryPrice) * pos.balance : 0;
-    return {
-      marketConditionId: pos.marketConditionId,
-      marketQuestion: pos.marketQuestion,
-      outcomeIndex: pos.outcomeIndex,
-      outcomeLabel: pos.outcomeIndex === 0 ? "Yes" : "No",
-      tokenId: pos.tokenId,
-      balance: pos.balance,
-      averageEntryPrice: pos.averageEntryPrice,
-      currentPrice: pos.currentPrice,
-      unrealizedPnl,
-      costBasis: pos.totalCostBasis - pos.totalProceeds,
-      endDate: pos.endDate,
-      category: pos.category
-    };
-  }
-};
-
-// src/spot/client.ts
-import {
-  createPublicClient,
-  createWalletClient,
-  http,
-  maxUint256
-} from "viem";
-import { privateKeyToAccount } from "viem/accounts";
-var SpotDEXClient = class {
-  account;
-  clients = /* @__PURE__ */ new Map();
-  decimalsCache = /* @__PURE__ */ new Map();
-  symbolCache = /* @__PURE__ */ new Map();
-  constructor(privateKey) {
-    this.account = privateKeyToAccount(privateKey);
-  }
-  get address() {
-    return this.account.address;
-  }
-  getClients(chainName) {
-    const cached = this.clients.get(chainName);
-    if (cached) return cached;
-    const chainConfig = getChainConfig(chainName);
-    if (!chainConfig) {
-      throw new Error(`Unknown chain: ${chainName}`);
-    }
-    const publicClient = createPublicClient({
-      chain: chainConfig.viemChain,
-      transport: http(chainConfig.rpcUrl)
-    });
-    const walletClient = createWalletClient({
-      account: this.account,
-      chain: chainConfig.viemChain,
-      transport: http(chainConfig.rpcUrl)
-    });
-    const entry = { publicClient, walletClient, chainConfig };
-    this.clients.set(chainName, entry);
-    return entry;
-  }
-  async getDecimals(token, chainName) {
-    const key = `${chainName}:${token}`;
-    const cached = this.decimalsCache.get(key);
-    if (cached !== void 0) return cached;
-    const { publicClient } = this.getClients(chainName);
-    const decimals = await publicClient.readContract({
-      address: token,
-      abi: ERC20_ABI,
-      functionName: "decimals"
-    });
-    this.decimalsCache.set(key, decimals);
-    return decimals;
-  }
-  async getSymbol(token, chainName) {
-    const key = `${chainName}:${token}`;
-    const cached = this.symbolCache.get(key);
-    if (cached) return cached;
-    const { publicClient } = this.getClients(chainName);
-    const symbol = await publicClient.readContract({
-      address: token,
-      abi: ERC20_ABI,
-      functionName: "symbol"
-    });
-    this.symbolCache.set(key, symbol);
-    return symbol;
-  }
-  async getBalance(token, chainName) {
-    const { publicClient } = this.getClients(chainName);
-    return await publicClient.readContract({
-      address: token,
-      abi: ERC20_ABI,
-      functionName: "balanceOf",
-      args: [this.account.address]
-    });
-  }
-  /** Get the native token balance (ETH, POL, etc.) on a chain */
-  async getNativeBalance(chainName) {
-    const { publicClient } = this.getClients(chainName);
-    return await publicClient.getBalance({ address: this.account.address });
-  }
-  async ensureApproval(token, spender, amount, chainName) {
-    const { publicClient, walletClient } = this.getClients(chainName);
-    const allowance = await publicClient.readContract({
-      address: token,
-      abi: ERC20_ABI,
-      functionName: "allowance",
-      args: [this.account.address, spender]
-    });
-    if (allowance >= amount) return null;
-    const hash = await walletClient.writeContract({
-      address: token,
-      abi: ERC20_ABI,
-      functionName: "approve",
-      args: [spender, maxUint256]
-    });
-    await publicClient.waitForTransactionReceipt({ hash });
-    console.log(`[spot] Approved ${token} for ${spender} on ${chainName} (tx: ${hash})`);
-    return hash;
-  }
-};
-
-// src/spot/uniswap.ts
-var FEE_TIERS = [500, 3e3, 1e4];
-var UniswapAdapter = class {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async quote(params) {
-    const chainConfig = getChainConfig(params.chain);
-    if (!chainConfig?.uniswapQuoter) {
-      throw new Error(`No Uniswap QuoterV2 on ${params.chain}`);
-    }
-    const { publicClient } = this.client.getClients(params.chain);
-    let bestAmountOut = 0n;
-    let bestFeeTier = 0;
-    for (const fee of FEE_TIERS) {
-      try {
-        const result = await publicClient.simulateContract({
-          address: chainConfig.uniswapQuoter,
-          abi: UNISWAP_QUOTER_V2_ABI,
-          functionName: "quoteExactInputSingle",
-          args: [
-            {
-              tokenIn: params.tokenIn,
-              tokenOut: params.tokenOut,
-              amountIn: params.amountIn,
-              fee,
-              sqrtPriceLimitX96: 0n
-            }
-          ]
-        });
-        const amountOut = result.result[0];
-        if (amountOut > bestAmountOut) {
-          bestAmountOut = amountOut;
-          bestFeeTier = fee;
-        }
-      } catch {
-      }
-    }
-    if (bestAmountOut === 0n) {
-      throw new Error(`No Uniswap V3 pool found for ${params.tokenIn}/${params.tokenOut} on ${params.chain}`);
-    }
-    const tokenInSymbol = await this.client.getSymbol(params.tokenIn, params.chain);
-    const tokenOutSymbol = await this.client.getSymbol(params.tokenOut, params.chain);
-    return {
-      amountOut: bestAmountOut,
-      feeTier: bestFeeTier,
-      route: `${tokenInSymbol} \u2192 ${tokenOutSymbol} (${bestFeeTier / 1e4}%)`
-    };
-  }
-  async swap(params) {
-    const chainConfig = getChainConfig(params.chain);
-    if (!chainConfig) {
-      throw new Error(`Unknown chain: ${params.chain}`);
-    }
-    const routerAddress = chainConfig.dexRouters.uniswap;
-    if (!routerAddress) {
-      throw new Error(`No Uniswap router on ${params.chain}`);
-    }
-    const quoteResult = await this.quote(params);
-    const amountOutMinimum = quoteResult.amountOut * BigInt(1e4 - params.slippageBps) / 10000n;
-    await this.client.ensureApproval(params.tokenIn, routerAddress, params.amountIn, params.chain);
-    const { publicClient, walletClient } = this.client.getClients(params.chain);
-    const recipient = params.recipient ?? this.client.address;
-    try {
-      const hash = await walletClient.writeContract({
-        address: routerAddress,
-        abi: UNISWAP_SWAP_ROUTER_ABI,
-        functionName: "exactInputSingle",
-        args: [
-          {
-            tokenIn: params.tokenIn,
-            tokenOut: params.tokenOut,
-            fee: quoteResult.feeTier,
-            recipient,
-            amountIn: params.amountIn,
-            amountOutMinimum,
-            sqrtPriceLimitX96: 0n
-          }
-        ]
-      });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash });
-      const tokenInDecimals = await this.client.getDecimals(params.tokenIn, params.chain);
-      const tokenOutDecimals = await this.client.getDecimals(params.tokenOut, params.chain);
-      const amountInFloat = Number(params.amountIn) / 10 ** tokenInDecimals;
-      const amountOutFloat = Number(quoteResult.amountOut) / 10 ** tokenOutDecimals;
-      const effectivePrice = amountOutFloat / amountInFloat;
-      const gasUsed = receipt.gasUsed ?? 0n;
-      const gasPrice = receipt.effectiveGasPrice ?? 0n;
-      return {
-        success: true,
-        txHash: hash,
-        amountIn: params.amountIn,
-        amountOut: quoteResult.amountOut,
-        tokenIn: params.tokenIn,
-        tokenOut: params.tokenOut,
-        effectivePrice,
-        gasCost: gasUsed * gasPrice,
-        chain: params.chain,
-        dex: "uniswap"
-      };
-    } catch (err) {
-      return {
-        success: false,
-        txHash: "0x0",
-        amountIn: params.amountIn,
-        amountOut: 0n,
-        tokenIn: params.tokenIn,
-        tokenOut: params.tokenOut,
-        effectivePrice: 0,
-        gasCost: 0n,
-        chain: params.chain,
-        dex: "uniswap",
-        error: err.message
-      };
-    }
-  }
-};
-
-// src/spot/aerodrome.ts
-var AerodromeAdapter = class {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async quote(params) {
-    if (params.chain !== "base") {
-      throw new Error("Aerodrome is only available on Base");
-    }
-    const chainConfig = getChainConfig("base");
-    const routerAddress = chainConfig.dexRouters.aerodrome;
-    if (!routerAddress) {
-      throw new Error("No Aerodrome router configured for Base");
-    }
-    const { publicClient } = this.client.getClients("base");
-    let bestAmountOut = 0n;
-    let bestStable = false;
-    for (const stable of [true, false]) {
-      try {
-        const route = [
-          {
-            from: params.tokenIn,
-            to: params.tokenOut,
-            stable,
-            factory: AERODROME_DEFAULT_FACTORY
-          }
-        ];
-        const amounts = await publicClient.readContract({
-          address: routerAddress,
-          abi: AERODROME_ROUTER_ABI,
-          functionName: "getAmountsOut",
-          args: [params.amountIn, route]
-        });
-        const amountOut = amounts[amounts.length - 1];
-        if (amountOut > bestAmountOut) {
-          bestAmountOut = amountOut;
-          bestStable = stable;
-        }
-      } catch {
-      }
-    }
-    if (bestAmountOut === 0n) {
-      throw new Error(`No Aerodrome pool found for ${params.tokenIn}/${params.tokenOut}`);
-    }
-    const tokenInSymbol = await this.client.getSymbol(params.tokenIn, "base");
-    const tokenOutSymbol = await this.client.getSymbol(params.tokenOut, "base");
-    return {
-      amountOut: bestAmountOut,
-      stable: bestStable,
-      route: `${tokenInSymbol} \u2192 ${tokenOutSymbol} (${bestStable ? "stable" : "volatile"})`
-    };
-  }
-  async swap(params) {
-    if (params.chain !== "base") {
-      throw new Error("Aerodrome is only available on Base");
-    }
-    const chainConfig = getChainConfig("base");
-    const routerAddress = chainConfig.dexRouters.aerodrome;
-    if (!routerAddress) {
-      throw new Error("No Aerodrome router configured for Base");
-    }
-    const quoteResult = await this.quote(params);
-    const amountOutMin = quoteResult.amountOut * BigInt(1e4 - params.slippageBps) / 10000n;
-    await this.client.ensureApproval(params.tokenIn, routerAddress, params.amountIn, "base");
-    const { publicClient, walletClient } = this.client.getClients("base");
-    const recipient = params.recipient ?? this.client.address;
-    const route = [
-      {
-        from: params.tokenIn,
-        to: params.tokenOut,
-        stable: quoteResult.stable,
-        factory: AERODROME_DEFAULT_FACTORY
-      }
-    ];
-    const deadline = BigInt(Math.floor(Date.now() / 1e3) + 300);
-    try {
-      const hash = await walletClient.writeContract({
-        address: routerAddress,
-        abi: AERODROME_ROUTER_ABI,
-        functionName: "swapExactTokensForTokens",
-        args: [params.amountIn, amountOutMin, route, recipient, deadline]
-      });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash });
-      const tokenInDecimals = await this.client.getDecimals(params.tokenIn, "base");
-      const tokenOutDecimals = await this.client.getDecimals(params.tokenOut, "base");
-      const amountInFloat = Number(params.amountIn) / 10 ** tokenInDecimals;
-      const amountOutFloat = Number(quoteResult.amountOut) / 10 ** tokenOutDecimals;
-      const effectivePrice = amountOutFloat / amountInFloat;
-      const gasUsed = receipt.gasUsed ?? 0n;
-      const gasPrice = receipt.effectiveGasPrice ?? 0n;
-      return {
-        success: true,
-        txHash: hash,
-        amountIn: params.amountIn,
-        amountOut: quoteResult.amountOut,
-        tokenIn: params.tokenIn,
-        tokenOut: params.tokenOut,
-        effectivePrice,
-        gasCost: gasUsed * gasPrice,
-        chain: "base",
-        dex: "aerodrome"
-      };
-    } catch (err) {
-      return {
-        success: false,
-        txHash: "0x0",
-        amountIn: params.amountIn,
-        amountOut: 0n,
-        tokenIn: params.tokenIn,
-        tokenOut: params.tokenOut,
-        effectivePrice: 0,
-        gasCost: 0n,
-        chain: "base",
-        dex: "aerodrome",
-        error: err.message
-      };
-    }
-  }
-};
-
-// src/spot/swap-manager.ts
-var TOKEN_ALIASES = {
-  base: {
-    ETH: "0x4200000000000000000000000000000000000006",
-    WETH: "0x4200000000000000000000000000000000000006",
-    USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-    USDbC: "0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA",
-    DAI: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb"
-  },
-  ethereum: {
-    ETH: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-    WETH: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-    USDC: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-    USDT: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
-    DAI: "0x6B175474E89094C44Da98b954EedeAC495271d0F"
-  },
-  arbitrum: {
-    ETH: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
-    WETH: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
-    USDC: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
-    "USDC.e": "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8",
-    USDT: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9"
-  },
-  polygon: {
-    POL: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
-    WPOL: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
-    WMATIC: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
-    USDC: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
-    "USDC.e": "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
-    USDT: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F"
-  }
-};
-var SpotSwapManager = class {
-  dexClient;
-  uniswap;
-  aerodrome;
-  config;
-  constructor(privateKey, config) {
-    this.config = config;
-    this.dexClient = new SpotDEXClient(privateKey);
-    this.uniswap = new UniswapAdapter(this.dexClient);
-    this.aerodrome = new AerodromeAdapter(this.dexClient);
-  }
-  get client() {
-    return this.dexClient;
-  }
-  /** Resolve a token symbol or address to a hex address */
-  resolveToken(tokenOrSymbol, chain) {
-    if (tokenOrSymbol.startsWith("0x") && tokenOrSymbol.length === 42) {
-      return tokenOrSymbol;
-    }
-    const chainAliases = TOKEN_ALIASES[chain];
-    if (chainAliases) {
-      const upper = tokenOrSymbol.toUpperCase();
-      const address = chainAliases[upper] ?? chainAliases[tokenOrSymbol];
-      if (address) return address;
-    }
-    const chainConfig = getChainConfig(chain);
-    if (chainConfig) {
-      const upper = tokenOrSymbol.toUpperCase();
-      if (upper === "WETH" || upper === "ETH") return chainConfig.wethAddress;
-      if (upper === "USDC") return chainConfig.usdcAddress;
-    }
-    throw new Error(`Cannot resolve token "${tokenOrSymbol}" on ${chain}. Provide contract address.`);
-  }
-  /** Select DEX: explicit choice, or auto-detect */
-  selectDex(chain, dex) {
-    if (dex) return dex;
-    const chainConfig = getChainConfig(chain);
-    if (chain === "base" && chainConfig?.dexRouters.aerodrome) {
-      return "aerodrome";
-    }
-    return "uniswap";
-  }
-  async getQuote(params) {
-    const chain = params.chain ?? this.config.defaultChain;
-    const dex = this.selectDex(chain, params.dex);
-    const swapParams = {
-      tokenIn: this.resolveToken(params.tokenIn, chain),
-      tokenOut: this.resolveToken(params.tokenOut, chain),
-      amountIn: params.amountIn,
-      slippageBps: this.config.maxSlippageBps,
-      chain,
-      dex
-    };
-    if (dex === "aerodrome") {
-      return this.aerodrome.quote(swapParams);
-    }
-    return this.uniswap.quote(swapParams);
-  }
-  async executeSwap(params) {
-    const chain = params.chain ?? this.config.defaultChain;
-    const dex = this.selectDex(chain, params.dex);
-    if (!this.config.chains.includes(chain)) {
-      return {
-        success: false,
-        txHash: "0x0",
-        amountIn: params.amountIn,
-        amountOut: 0n,
-        tokenIn: "0x0",
-        tokenOut: "0x0",
-        effectivePrice: 0,
-        gasCost: 0n,
-        chain,
-        dex,
-        error: `Chain "${chain}" not enabled in spot config (enabled: ${this.config.chains.join(", ")})`
-      };
-    }
-    const MIN_GAS_WEI2 = 100000000000000n;
-    try {
-      const nativeBalance = await this.dexClient.getNativeBalance(chain);
-      if (nativeBalance < MIN_GAS_WEI2) {
-        const chainConfig = getChainConfig(chain);
-        const nativeName = chainConfig?.nativeCurrency ?? "ETH";
-        return {
-          success: false,
-          txHash: "0x0",
-          amountIn: params.amountIn,
-          amountOut: 0n,
-          tokenIn: "0x0",
-          tokenOut: "0x0",
-          effectivePrice: 0,
-          gasCost: 0n,
-          chain,
-          dex,
-          error: `Insufficient ${nativeName} for gas on ${chain}. Balance: ${nativeBalance} wei. Need at least 0.0001 ${nativeName}. Bridge gas to ${chain} before swapping.`
-        };
-      }
-    } catch {
-    }
-    const swapParams = {
-      tokenIn: this.resolveToken(params.tokenIn, chain),
-      tokenOut: this.resolveToken(params.tokenOut, chain),
-      amountIn: params.amountIn,
-      slippageBps: params.slippageBps ?? this.config.maxSlippageBps,
-      chain,
-      dex
-    };
-    console.log(`[spot] Swapping on ${dex}/${chain}: ${params.tokenIn} \u2192 ${params.tokenOut} (${params.amountIn})`);
-    if (dex === "aerodrome") {
-      return this.aerodrome.swap(swapParams);
-    }
-    return this.uniswap.swap(swapParams);
-  }
-};
-
-// src/bridge/types.ts
-var DEFAULT_BRIDGE_CONFIG = {
-  enabled: false,
-  defaultBridge: "across",
-  maxBridgeValueUSD: 1e4,
-  fillTimeoutMs: 3e5,
-  // 5 minutes
-  pollIntervalMs: 2e3
-  // 2 seconds
-};
-var ACROSS_SPOKE_POOL_ABI = [
-  {
-    type: "function",
-    name: "depositV3",
-    inputs: [
-      { name: "depositor", type: "address" },
-      { name: "recipient", type: "address" },
-      { name: "inputToken", type: "address" },
-      { name: "outputToken", type: "address" },
-      { name: "inputAmount", type: "uint256" },
-      { name: "outputAmount", type: "uint256" },
-      { name: "destinationChainId", type: "uint256" },
-      { name: "exclusiveRelayer", type: "address" },
-      { name: "quoteTimestamp", type: "uint32" },
-      { name: "fillDeadline", type: "uint32" },
-      { name: "exclusivityDeadline", type: "uint32" },
-      { name: "message", type: "bytes" }
-    ],
-    outputs: [],
-    stateMutability: "payable"
-  }
-];
-
-// src/bridge/across.ts
-var ACROSS_API_BASE = "https://app.across.to/api";
-var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-var AcrossAdapter = class {
-  client;
-  config;
-  constructor(client, config) {
-    this.client = client;
-    this.config = config;
-  }
-  async estimateFee(request) {
-    const fromChain = getChainConfig(request.fromChain);
-    const toChain = getChainConfig(request.toChain);
-    if (!fromChain) throw new Error(`Unknown source chain: ${request.fromChain}`);
-    if (!toChain) throw new Error(`Unknown destination chain: ${request.toChain}`);
-    const outputToken = this.resolveOutputToken(request.token, request.fromChain, request.toChain);
-    const params = new URLSearchParams({
-      inputToken: request.token,
-      outputToken,
-      originChainId: fromChain.chainId.toString(),
-      destinationChainId: toChain.chainId.toString(),
-      amount: request.amount.toString(),
-      recipient: request.recipient ?? this.client.address
-    });
-    const url = `${ACROSS_API_BASE}/suggested-fees?${params}`;
-    const res = await fetch(url);
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`Across fee API error (${res.status}): ${body}`);
-    }
-    const data = await res.json();
-    const totalFeePct = parseFloat(data.totalRelayFee.pct) / 1e18;
-    const feeAmount = BigInt(Math.floor(Number(request.amount) * totalFeePct));
-    const outputAmount = request.amount - feeAmount;
-    return {
-      totalRelayFeePct: totalFeePct * 100,
-      capitalFeePct: parseFloat(data.relayerCapitalFee.pct) / 1e18 * 100,
-      lpFeePct: parseFloat(data.lpFee.pct) / 1e18 * 100,
-      relayGasFeePct: parseFloat(data.relayerGasFee.pct) / 1e18 * 100,
-      timestamp: parseInt(data.timestamp),
-      estimatedFillTimeSec: data.estimatedFillTimeSec,
-      isAmountTooLow: data.isAmountTooLow,
-      outputAmount
-    };
-  }
-  async deposit(request) {
-    const fromChain = getChainConfig(request.fromChain);
-    const toChain = getChainConfig(request.toChain);
-    if (!fromChain?.acrossSpokePool) throw new Error(`No Across SpokePool on ${request.fromChain}`);
-    if (!toChain) throw new Error(`Unknown destination chain: ${request.toChain}`);
-    const spokePool = fromChain.acrossSpokePool;
-    const outputToken = this.resolveOutputToken(request.token, request.fromChain, request.toChain);
-    const recipient = request.recipient ?? this.client.address;
-    await this.client.ensureApproval(request.token, spokePool, request.amount, request.fromChain);
-    const feeEstimate = await this.estimateFee(request);
-    if (feeEstimate.isAmountTooLow) {
-      return {
-        success: false,
-        depositTxHash: "0x0",
-        fromChain: request.fromChain,
-        toChain: request.toChain,
-        token: request.token,
-        amount: request.amount,
-        fee: 0n,
-        error: "Amount too low for Across bridge"
-      };
-    }
-    const { publicClient, walletClient } = this.client.getClients(request.fromChain);
-    const fillDeadline = Math.floor(Date.now() / 1e3) + 21600;
-    try {
-      const hash = await walletClient.writeContract({
-        address: spokePool,
-        abi: ACROSS_SPOKE_POOL_ABI,
-        functionName: "depositV3",
-        args: [
-          this.client.address,
-          // depositor
-          recipient,
-          // recipient
-          request.token,
-          // inputToken
-          outputToken,
-          // outputToken
-          request.amount,
-          // inputAmount
-          feeEstimate.outputAmount,
-          // outputAmount (inputAmount - fees)
-          BigInt(toChain.chainId),
-          // destinationChainId
-          ZERO_ADDRESS,
-          // exclusiveRelayer (none)
-          feeEstimate.timestamp,
-          // quoteTimestamp
-          fillDeadline,
-          // fillDeadline
-          0,
-          // exclusivityDeadline (none)
-          "0x"
-          // message (empty)
-        ]
-      });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash });
-      const fee = request.amount - feeEstimate.outputAmount;
-      console.log(`[bridge] Across deposit: ${hash} (${request.fromChain} \u2192 ${request.toChain})`);
-      const result = {
-        success: true,
-        depositTxHash: hash,
-        fromChain: request.fromChain,
-        toChain: request.toChain,
-        token: request.token,
-        amount: request.amount,
-        fee
-      };
-      const fill = await this.waitForFill(hash, request.fromChain);
-      if (fill.filled) {
-        result.fillTxHash = fill.fillTxHash;
-        result.fillTimestamp = Date.now();
-        console.log(`[bridge] Across fill confirmed: ${fill.fillTxHash}`);
-      } else {
-        console.warn(`[bridge] Across fill not confirmed within timeout \u2014 deposit was successful, fill may still arrive`);
-      }
-      return result;
-    } catch (err) {
-      return {
-        success: false,
-        depositTxHash: "0x0",
-        fromChain: request.fromChain,
-        toChain: request.toChain,
-        token: request.token,
-        amount: request.amount,
-        fee: 0n,
-        error: err.message
-      };
-    }
-  }
-  async waitForFill(depositTxHash, originChain) {
-    const chainConfig = getChainConfig(originChain);
-    if (!chainConfig) return { filled: false };
-    const startTime = Date.now();
-    const timeout = this.config.fillTimeoutMs;
-    const interval = this.config.pollIntervalMs;
-    while (Date.now() - startTime < timeout) {
-      try {
-        const params = new URLSearchParams({
-          depositTxHash,
-          originChainId: chainConfig.chainId.toString()
-        });
-        const res = await fetch(`${ACROSS_API_BASE}/deposit/status?${params}`);
-        if (res.ok) {
-          const data = await res.json();
-          if (data.status === "filled" && data.fillTx) {
-            return { filled: true, fillTxHash: data.fillTx };
-          }
-          if (data.status === "expired" || data.status === "refunded") {
-            return { filled: false };
-          }
-        }
-      } catch {
-      }
-      await new Promise((resolve2) => setTimeout(resolve2, interval));
-    }
-    return { filled: false };
-  }
-  /** Resolve the equivalent token address on the destination chain */
-  resolveOutputToken(inputToken, fromChain, toChain) {
-    const from = getChainConfig(fromChain);
-    const to = getChainConfig(toChain);
-    if (!from || !to) return inputToken;
-    if (inputToken.toLowerCase() === from.usdcAddress.toLowerCase()) {
-      return to.usdcAddress;
-    }
-    if (inputToken.toLowerCase() === from.wethAddress.toLowerCase()) {
-      return to.wethAddress;
-    }
-    return inputToken;
-  }
-};
-
-// src/bridge/bridge-manager.ts
-var MIN_GAS_WEI = 100000000000000n;
-var BridgeManager = class {
-  across;
-  client;
-  config;
-  constructor(client, config) {
-    this.config = config;
-    this.client = client;
-    this.across = new AcrossAdapter(client, config);
-  }
-  async estimateFee(request) {
-    const bridge = request.bridge ?? this.config.defaultBridge;
-    if (bridge !== "across") {
-      throw new Error(`Unsupported bridge: ${bridge}. Only "across" is currently supported.`);
-    }
-    return this.across.estimateFee(request);
-  }
-  async bridge(request) {
-    const bridge = request.bridge ?? this.config.defaultBridge;
-    if (bridge !== "across") {
-      return {
-        success: false,
-        depositTxHash: "0x0",
-        fromChain: request.fromChain,
-        toChain: request.toChain,
-        token: request.token,
-        amount: request.amount,
-        fee: 0n,
-        error: `Unsupported bridge: ${bridge}. Only "across" is currently supported.`
-      };
-    }
-    try {
-      const nativeBalance = await this.client.getNativeBalance(request.fromChain);
-      if (nativeBalance < MIN_GAS_WEI) {
-        const chainConfig = getChainConfig(request.fromChain);
-        const nativeName = chainConfig?.nativeCurrency ?? "ETH";
-        return {
-          success: false,
-          depositTxHash: "0x0",
-          fromChain: request.fromChain,
-          toChain: request.toChain,
-          token: request.token,
-          amount: request.amount,
-          fee: 0n,
-          error: `Insufficient ${nativeName} for gas on ${request.fromChain}. Balance: ${nativeBalance} wei. Need at least 0.0001 ${nativeName}.`
-        };
-      }
-    } catch {
-    }
-    console.log(`[bridge] Bridging via Across: ${request.fromChain} \u2192 ${request.toChain} (${request.amount})`);
-    return this.across.deposit(request);
-  }
-};
-
-// src/runtime.ts
-import { createWalletClient as createWalletClient2, http as http2, formatUnits } from "viem";
-import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
-import { arbitrum as arbitrum2 } from "viem/chains";
-var SDK_VERSION = "0.1.0";
-var AgentRuntime = class _AgentRuntime {
-  config;
-  relay;
-  signal;
-  store;
-  positions;
-  llm;
-  strategy = null;
-  risk;
-  market;
-  paper = null;
-  // Venue clients
-  hlClient = null;
-  hlSigner = null;
-  hlOrders = null;
-  hlPositions = null;
-  hlWs = null;
-  pmClient = null;
-  pmOrders = null;
-  spotManager = null;
-  bridgeManager = null;
-  walletAddress = null;
-  mode = "idle";
-  cycleCount = 0;
-  lastCycleAt = 0;
-  tradingInterval = null;
-  running = false;
-  constructor(config) {
-    this.config = config;
-    this.store = new FileStore(`data/${config.agentId}-store.json`);
-    this.positions = new PositionTracker(this.store);
-    this.market = new MarketDataService(3e4, config.apiUrl);
-    this.risk = new RiskManager(
-      {
-        maxPositionSizeBps: config.trading.maxPositionSizeBps,
-        maxDailyLossBps: config.trading.maxDailyLossBps,
-        maxConcurrentPositions: config.trading.maxConcurrentPositions,
-        maxSlippageBps: config.trading.maxSlippageBps,
-        minTradeValueUSD: config.trading.minTradeValueUSD
-      },
-      config.trading.initialCapitalUSD
-    );
-    this.llm = createLLMAdapter(config.llm);
-    this.relay = new RelayClient({
-      url: config.relay.url,
-      agentId: config.agentId,
-      token: config.apiToken,
-      heartbeatIntervalMs: config.relay.heartbeatIntervalMs,
-      reconnectMaxAttempts: config.relay.reconnectMaxAttempts,
-      onCommand: (cmd) => this.handleCommand(cmd),
-      onConnected: () => {
-        console.log(`[runtime] Connected to command center`);
-        this.sendStatus();
-      },
-      onDisconnected: () => {
-        console.log(`[runtime] Disconnected from command center`);
-      }
-    });
-    this.signal = new SignalReporter(this.relay);
-    if (config.trading.mode === "paper") {
-      this.paper = new PaperExecutor(config.trading.initialCapitalUSD ?? 1e4);
-    }
-  }
-  async start() {
-    console.log(`[runtime] Starting agent ${this.config.agentId}`);
-    console.log(`[runtime] Mode: ${this.config.trading.mode}`);
-    console.log(`[runtime] LLM: ${this.config.llm.provider}/${this.config.llm.model}`);
-    try {
-      this.strategy = await loadStrategy(this.config.strategy);
-      console.log(`[runtime] Strategy loaded`);
-    } catch (err) {
-      console.error(`[runtime] Failed to load strategy:`, err.message);
-      this.strategy = null;
-    }
-    if (this.config.trading.mode === "live") {
-      await this.initializeVenues();
-    }
-    try {
-      await this.relay.connect();
-      this.signal.reportInfo("Agent Started", `Agent ${this.config.agentId} connected to command center`);
-    } catch (err) {
-      console.error(`[runtime] Failed to connect to relay:`, err.message);
-      console.log(`[runtime] Will retry in background...`);
-    }
-    this.running = true;
-    this.mode = "idle";
-    this.sendStatus();
-    if (this.config.trading.mode === "paper" || this.config.trading.mode === "live") {
-      this.startTrading();
-    }
-    process.on("SIGTERM", () => this.stop());
-    process.on("SIGINT", () => this.stop());
-  }
-  async stop() {
-    console.log(`[runtime] Stopping agent ${this.config.agentId}`);
-    this.running = false;
-    this.stopTrading();
-    if (this.hlWs) {
-      this.hlWs.disconnect();
-    }
-    this.signal.reportInfo("Agent Stopped", `Agent ${this.config.agentId} shutting down`);
-    this.relay.disconnect();
-    console.log(`[runtime] Agent stopped`);
-    process.exit(0);
-  }
-  // ── VENUE INITIALIZATION ───────────────────────────────────
-  async initializeVenues() {
-    const privateKey = this.config.wallet?.privateKey;
-    if (!privateKey) {
-      console.log("[runtime] No wallet configured \u2014 live trading disabled");
-      return;
-    }
-    const walletAccount = privateKeyToAccount2(privateKey);
-    this.walletAddress = walletAccount.address;
-    const hlConfig = this.config.venues?.hyperliquid_perp;
-    if (hlConfig?.enabled) {
-      try {
-        const account = walletAccount;
-        const walletClient = createWalletClient2({
-          account,
-          chain: arbitrum2,
-          transport: http2()
-        });
-        const perpConfig = {
-          enabled: true,
-          apiUrl: hlConfig.apiUrl,
-          wsUrl: hlConfig.wsUrl,
-          maxLeverage: hlConfig.maxLeverage,
-          maxNotionalUSD: hlConfig.maxNotionalUSD,
-          allowedInstruments: hlConfig.allowedInstruments
-        };
-        this.hlClient = new HyperliquidClient(perpConfig);
-        this.hlSigner = new HyperliquidSigner(walletClient);
-        this.hlOrders = new HyperliquidOrderManager(this.hlClient, this.hlSigner, perpConfig);
-        this.hlPositions = new HyperliquidPositionManager(this.hlClient, account.address);
-        this.hlWs = new HyperliquidWebSocket(perpConfig, account.address, this.hlClient);
-        await this.hlClient.getMeta();
-        this.hlWs.onFillReceived((fill) => {
-          this.handleHyperliquidFill(fill);
-        });
-        this.hlWs.onLiquidationDetected((instrument, size) => {
-          this.signal.reportError("Liquidation Detected", `${instrument}: ${size} liquidated`);
-        });
-        await this.hlWs.connect();
-        console.log(`[runtime] Hyperliquid initialized (${account.address})`);
-      } catch (err) {
-        console.error("[runtime] Failed to initialize Hyperliquid:", err.message);
-      }
-    }
-    const pmConfig = this.config.venues?.polymarket;
-    if (pmConfig?.enabled) {
-      try {
-        const predConfig = {
-          enabled: true,
-          clobApiUrl: pmConfig.clobApiUrl,
-          gammaApiUrl: pmConfig.gammaApiUrl,
-          maxNotionalUSD: pmConfig.maxNotionalUSD,
-          maxTotalExposureUSD: pmConfig.maxTotalExposureUSD,
-          allowedCategories: pmConfig.allowedCategories
-        };
-        this.pmClient = new PolymarketClient(privateKey, predConfig);
-        await this.pmClient.initialize();
-        this.pmOrders = new PolymarketOrderManager(this.pmClient, predConfig);
-        console.log(`[runtime] Polymarket initialized`);
-      } catch (err) {
-        console.error("[runtime] Failed to initialize Polymarket:", err.message);
-      }
-    }
-    const spotConfig = this.config.venues?.spot;
-    if (spotConfig?.enabled) {
-      try {
-        const cfg = {
-          enabled: true,
-          chains: spotConfig.chains,
-          defaultChain: spotConfig.defaultChain,
-          maxSlippageBps: spotConfig.maxSlippageBps,
-          maxSwapValueUSD: spotConfig.maxSwapValueUSD
-        };
-        this.spotManager = new SpotSwapManager(privateKey, cfg);
-        console.log(`[runtime] Spot DEX initialized (chains: ${spotConfig.chains.join(", ")})`);
-      } catch (err) {
-        console.error("[runtime] Failed to initialize Spot DEX:", err.message);
-      }
-    }
-    const bridgeConfig = this.config.venues?.bridge;
-    if (bridgeConfig?.enabled) {
-      try {
-        if (!this.spotManager) {
-          const minimalSpotConfig = {
-            enabled: true,
-            chains: ["base", "ethereum", "arbitrum", "polygon"],
-            defaultChain: "base",
-            maxSlippageBps: 50,
-            maxSwapValueUSD: 1e4
-          };
-          this.spotManager = new SpotSwapManager(privateKey, minimalSpotConfig);
-        }
-        const cfg = {
-          enabled: true,
-          defaultBridge: bridgeConfig.defaultBridge,
-          maxBridgeValueUSD: bridgeConfig.maxBridgeValueUSD,
-          fillTimeoutMs: bridgeConfig.fillTimeoutMs,
-          pollIntervalMs: bridgeConfig.pollIntervalMs
-        };
-        this.bridgeManager = new BridgeManager(this.spotManager.client, cfg);
-        console.log(`[runtime] Bridge initialized`);
-      } catch (err) {
-        console.error("[runtime] Failed to initialize Bridge:", err.message);
-      }
-    }
-  }
-  // ── TRADING LOOP ───────────────────────────────────────────
-  startTrading() {
-    if (this.tradingInterval) return;
-    this.mode = this.config.trading.mode === "paper" ? "paper" : "trading";
-    console.log(`[runtime] Trading started (${this.mode}, interval: ${this.config.trading.tradingIntervalMs}ms)`);
-    this.sendStatus();
-    this.signal.reportInfo("Trading Started", `Mode: ${this.mode}`);
-    this.runCycle();
-    this.tradingInterval = setInterval(() => {
-      this.runCycle();
-    }, this.config.trading.tradingIntervalMs);
-  }
-  stopTrading() {
-    if (this.tradingInterval) {
-      clearInterval(this.tradingInterval);
-      this.tradingInterval = null;
-    }
-    this.mode = "idle";
-    this.sendStatus();
-    console.log(`[runtime] Trading stopped`);
-  }
-  async runCycle() {
-    if (!this.running || !this.strategy) return;
-    this.cycleCount++;
-    this.lastCycleAt = Date.now();
-    try {
-      const prices = this.market.getPrices();
-      const positionSummary = this.positions.getSummary(prices);
-      const signals = await this.strategy({
-        llm: this.llm,
-        market: this.market,
-        position: positionSummary,
-        store: this.store,
-        config: this.config.trading,
-        log: (msg) => {
-          console.log(`[strategy] ${msg}`);
-          this.signal.reportInfo("Strategy Log", msg);
-        }
-      });
-      if (!Array.isArray(signals) || signals.length === 0) {
-        await this.pollPredictionFills();
-        this.sendStatus();
-        return;
-      }
-      const filtered = this.risk.filterSignals(signals, this.market, positionSummary.openPositions.length);
-      for (const sig of filtered) {
-        try {
-          await this.executeSignal(sig);
-        } catch (err) {
-          console.error(`[runtime] Trade execution error:`, err.message);
-          this.signal.reportError("Trade Error", err.message);
-        }
-      }
-      await this.pollPredictionFills();
-    } catch (err) {
-      console.error(`[runtime] Cycle error:`, err.message);
-      this.signal.reportError("Cycle Error", err.message);
-      this.mode = "idle";
-    }
-    this.sendStatus();
-  }
-  // ── SIGNAL EXECUTION ───────────────────────────────────────
-  async executeSignal(sig) {
-    const venue = sig.venue;
-    if (this.paper) {
-      const trade = this.paper.execute(sig, this.market);
-      if (trade) {
-        this.signal.reportTrade({
-          ...sig,
-          price: trade.entryPrice,
-          fee: trade.fee,
-          venue: trade.venue,
-          venueFillId: trade.id,
-          venueTimestamp: new Date(trade.timestamp).toISOString()
-        });
-      }
-      return;
-    }
-    if (venue === "hyperliquid_perp" && this.hlOrders) {
-      await this.executeHyperliquidSignal(sig);
-    } else if (venue === "polymarket" && this.pmOrders) {
-      await this.executePolymarketSignal(sig);
-    } else if ((venue === "uniswap" || venue === "aerodrome" || venue === "sushiswap") && this.spotManager) {
-      await this.executeSpotSignal(sig);
-    } else if (venue === "across" && this.bridgeManager) {
-      await this.executeBridgeSignal(sig);
-    } else if (venue === "hyperliquid_deposit" && this.hlSigner) {
-      await this.executeHyperliquidDeposit(sig);
-    } else if (venue === "hyperliquid_withdraw" && this.hlSigner) {
-      await this.executeHyperliquidWithdraw(sig);
-    } else {
-      console.log(`[runtime] No executor for venue "${venue}" \u2014 signal dropped`);
-    }
-  }
-  async executeHyperliquidSignal(sig) {
-    if (!this.hlOrders) return;
-    const action = sig.side === "long" ? "open_long" : sig.side === "short" ? "open_short" : sig.side === "buy" ? "open_long" : "close_long";
-    const result = await this.hlOrders.placeOrder({
-      action,
-      instrument: sig.symbol,
-      size: sig.size,
-      price: sig.price,
-      leverage: sig.leverage ?? 1,
-      orderType: sig.orderType ?? "market",
-      reduceOnly: action.startsWith("close"),
-      confidence: sig.confidence ?? 1,
-      reasoning: sig.reasoning
-    });
-    if (result.success && result.status === "filled") {
-      console.log(`[runtime] HL order filled: ${sig.symbol} ${result.avgPrice}`);
-    } else if (result.success && result.status === "resting") {
-      console.log(`[runtime] HL order resting: ${sig.symbol} (oid: ${result.orderId})`);
-    } else {
-      console.warn(`[runtime] HL order failed: ${result.error}`);
-      this.signal.reportError("Perp Order Failed", `${sig.symbol}: ${result.error}`);
-    }
-  }
-  async executePolymarketSignal(sig) {
-    if (!this.pmOrders) return;
-    const action = sig.side === "buy" ? "buy_yes" : sig.side === "sell" ? "sell_yes" : sig.side === "long" ? "buy_yes" : "sell_yes";
-    const result = await this.pmOrders.executeSignal({
-      action,
-      marketConditionId: sig.symbol,
-      marketQuestion: sig.reasoning ?? sig.symbol,
-      outcomeIndex: 0,
-      amount: sig.size,
-      limitPrice: sig.price,
-      orderType: sig.orderType ?? "limit",
-      confidence: sig.confidence ?? 1,
-      reasoning: sig.reasoning
-    });
-    if (result.success) {
-      console.log(`[runtime] PM order placed: ${sig.symbol}`);
-    } else {
-      console.warn(`[runtime] PM order failed: ${result.error}`);
-      this.signal.reportError("Prediction Order Failed", `${sig.symbol}: ${result.error}`);
-    }
-  }
-  async executeSpotSignal(sig) {
-    if (!this.spotManager) return;
-    const chain = sig.chain ?? this.config.venues?.spot?.defaultChain ?? "base";
-    const dex = sig.venue === "aerodrome" ? "aerodrome" : "uniswap";
-    const parts = sig.symbol.split("/");
-    const isBuy = sig.side === "buy" || sig.side === "long";
-    const tokenIn = isBuy ? parts[1] ?? "USDC" : parts[0] ?? sig.symbol;
-    const tokenOut = isBuy ? parts[0] ?? sig.symbol : parts[1] ?? "USDC";
-    const tokenInAddress = this.spotManager.resolveToken(tokenIn, chain);
-    const decimals = await this.spotManager.client.getDecimals(tokenInAddress, chain);
-    const amountIn = BigInt(Math.floor(sig.size * 10 ** decimals));
-    const result = await this.spotManager.executeSwap({
-      tokenIn,
-      tokenOut,
-      amountIn,
-      chain,
-      dex
-    });
-    if (result.success) {
-      const tokenOutSymbol = await this.spotManager.client.getSymbol(result.tokenOut, chain);
-      const tokenInSymbol = await this.spotManager.client.getSymbol(result.tokenIn, chain);
-      const tokenOutDecimals = await this.spotManager.client.getDecimals(result.tokenOut, chain);
-      const amountOutFloat = Number(result.amountOut) / 10 ** tokenOutDecimals;
-      const amountInFloat = Number(result.amountIn) / 10 ** decimals;
-      const tradeSignal = {
-        venue: result.dex,
-        chain,
-        symbol: `${parts[0] ?? sig.symbol}`,
-        side: sig.side,
-        size: isBuy ? amountOutFloat : amountInFloat,
-        price: result.effectivePrice,
-        fee: Number(result.gasCost) / 1e18,
-        venueFillId: result.txHash,
-        venueTimestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      const baseToken = parts[0] ?? sig.symbol;
-      if (isBuy) {
-        this.positions.recordBuy(
-          baseToken,
-          amountOutFloat,
-          result.effectivePrice,
-          tradeSignal.fee,
-          result.dex,
-          chain,
-          result.txHash
-        );
-      } else {
-        this.positions.recordSell(
-          baseToken,
-          amountInFloat,
-          result.effectivePrice,
-          tradeSignal.fee,
-          result.dex,
-          chain,
-          result.txHash
-        );
-      }
-      this.signal.reportSpotFill(tradeSignal);
-      console.log(`[runtime] Spot swap filled: ${tokenInSymbol} \u2192 ${tokenOutSymbol} on ${result.dex}/${chain}`);
-    } else {
-      console.warn(`[runtime] Spot swap failed: ${result.error}`);
-      this.signal.reportError("Spot Swap Failed", `${sig.symbol}: ${result.error}`);
-    }
-  }
-  async executeBridgeSignal(sig) {
-    if (!this.bridgeManager || !this.spotManager) return;
-    const toChain = sig.chain ?? "arbitrum";
-    const fromChain = sig.orderType ?? "base";
-    const tokenAddress = this.spotManager.resolveToken(sig.symbol, fromChain);
-    const decimals = await this.spotManager.client.getDecimals(tokenAddress, fromChain);
-    const amount = BigInt(Math.floor(sig.size * 10 ** decimals));
-    const result = await this.bridgeManager.bridge({
-      token: tokenAddress,
-      amount,
-      fromChain,
-      toChain
-    });
-    if (result.success) {
-      const tradeSignal = {
-        venue: "across",
-        chain: toChain,
-        symbol: sig.symbol,
-        side: "buy",
-        size: sig.size,
-        price: sig.price || 1,
-        fee: Number(result.fee) / 10 ** decimals,
-        venueFillId: result.depositTxHash,
-        venueTimestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      this.signal.reportBridgeFill(tradeSignal);
-      console.log(`[runtime] Bridge completed: ${fromChain} \u2192 ${toChain} via Across`);
-    } else {
-      console.warn(`[runtime] Bridge failed: ${result.error}`);
-      this.signal.reportError("Bridge Failed", `${sig.symbol} ${fromChain}\u2192${toChain}: ${result.error}`);
-    }
-  }
-  // ── HYPERLIQUID DEPOSIT / WITHDRAW ────────────────────────
-  /** Hyperliquid bridge contract on Arbitrum — accepts plain USDC transfers */
-  static HL_BRIDGE_CONTRACT = "0x2Df1c51E09aECF9cacB7bc98cB1742757f163dF7";
-  /**
-   * Deposit USDC into Hyperliquid by transferring to the bridge contract on Arbitrum.
-   * Signal format: venue='hyperliquid_deposit', size=amount in USDC, chain is ignored (always Arbitrum).
-   * The wallet must already have USDC + ETH for gas on Arbitrum.
-   */
-  async executeHyperliquidDeposit(sig) {
-    if (!this.spotManager) {
-      this.signal.reportError("HL Deposit Failed", "Spot manager not initialized (needed for chain clients)");
-      return;
-    }
-    const arbConfig = getChainConfig("arbitrum");
-    if (!arbConfig) {
-      this.signal.reportError("HL Deposit Failed", "Arbitrum chain config not found");
-      return;
-    }
-    const usdcAddress = arbConfig.usdcAddress;
-    const amount = BigInt(Math.floor(sig.size * 1e6));
-    const MIN_GAS_WEI2 = 100000000000000n;
-    try {
-      const gasBalance = await this.spotManager.client.getNativeBalance("arbitrum");
-      if (gasBalance < MIN_GAS_WEI2) {
-        this.signal.reportError("HL Deposit Failed", `Insufficient ETH for gas on Arbitrum. Balance: ${formatUnits(gasBalance, 18)} ETH. Need at least 0.0001 ETH.`);
-        return;
-      }
-    } catch {
-    }
-    try {
-      const usdcBalance = await this.spotManager.client.getBalance(usdcAddress, "arbitrum");
-      if (usdcBalance < amount) {
-        this.signal.reportError("HL Deposit Failed", `Insufficient USDC on Arbitrum. Have ${formatUnits(usdcBalance, 6)}, need ${formatUnits(amount, 6)}. Bridge USDC to Arbitrum first.`);
-        return;
-      }
-    } catch (err) {
-      this.signal.reportError("HL Deposit Failed", `Could not check USDC balance: ${err.message}`);
-      return;
-    }
-    try {
-      const { publicClient, walletClient } = this.spotManager.client.getClients("arbitrum");
-      const hash = await walletClient.writeContract({
-        address: usdcAddress,
-        abi: ERC20_ABI,
-        functionName: "transfer",
-        args: [_AgentRuntime.HL_BRIDGE_CONTRACT, amount]
-      });
-      const receipt = await publicClient.waitForTransactionReceipt({ hash });
-      if (receipt.status === "reverted") {
-        this.signal.reportError("HL Deposit Failed", `Transfer reverted: ${hash}`);
-        return;
-      }
-      console.log(`[runtime] HL deposit: ${formatUnits(amount, 6)} USDC \u2192 Hyperliquid (tx: ${hash})`);
-      this.signal.reportInfo("HL Deposit", `Deposited ${formatUnits(amount, 6)} USDC to Hyperliquid`);
-    } catch (err) {
-      console.error("[runtime] HL deposit failed:", err.message);
-      this.signal.reportError("HL Deposit Failed", err.message);
-    }
-  }
-  /**
-   * Withdraw USDC from Hyperliquid to the wallet on Arbitrum.
-   * Signal format: venue='hyperliquid_withdraw', size=amount in USDC.
-   * Uses the withdraw3 EIP-712 signing scheme.
-   */
-  async executeHyperliquidWithdraw(sig) {
-    if (!this.hlSigner || !this.hlClient) {
-      this.signal.reportError("HL Withdraw Failed", "Hyperliquid signer/client not initialized");
-      return;
-    }
-    const destination = this.hlSigner.getAddress();
-    const amount = sig.size.toString();
-    try {
-      const { action, signature, nonce } = await this.hlSigner.signWithdraw(destination, amount);
-      const apiUrl = this.config.venues?.hyperliquid_perp?.apiUrl ?? "https://api.hyperliquid.xyz";
-      const resp = await fetch(`${apiUrl}/exchange`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ action, nonce, signature, vaultAddress: null })
-      });
-      if (!resp.ok) {
-        const text = await resp.text();
-        throw new Error(`HL Exchange API error: ${resp.status} ${text}`);
-      }
-      const data = await resp.json();
-      if (data.status !== "ok") {
-        throw new Error(`HL withdraw3 failed: ${JSON.stringify(data)}`);
-      }
-      console.log(`[runtime] HL withdrawal: ${amount} USDC \u2192 ${destination} on Arbitrum`);
-      this.signal.reportInfo("HL Withdrawal", `Withdrew ${amount} USDC from Hyperliquid to ${destination}`);
-    } catch (err) {
-      console.error("[runtime] HL withdrawal failed:", err.message);
-      this.signal.reportError("HL Withdraw Failed", err.message);
-    }
-  }
-  // ── FILL HANDLING ──────────────────────────────────────────
-  handleHyperliquidFill(fill) {
-    const tradeSignal = {
-      venue: "hyperliquid_perp",
-      symbol: fill.coin,
-      side: fill.side === "B" ? "long" : "short",
-      size: parseFloat(fill.sz),
-      price: parseFloat(fill.px),
-      fee: parseFloat(fill.fee),
-      venueFillId: fill.hash,
-      venueTimestamp: new Date(fill.time).toISOString(),
-      orderType: fill.isMaker ? "limit" : "market"
-    };
-    const action = fill.side === "B" ? "buy" : "sell";
-    if (action === "buy") {
-      this.positions.recordBuy(
-        fill.coin,
-        parseFloat(fill.sz),
-        parseFloat(fill.px),
-        parseFloat(fill.fee),
-        "hyperliquid_perp",
-        void 0,
-        fill.hash
-      );
-    } else {
-      this.positions.recordSell(
-        fill.coin,
-        parseFloat(fill.sz),
-        parseFloat(fill.px),
-        parseFloat(fill.fee),
-        "hyperliquid_perp",
-        void 0,
-        fill.hash
-      );
-    }
-    this.signal.reportPerpFill(tradeSignal);
-  }
-  async pollPredictionFills() {
-    if (!this.pmOrders) return;
-    try {
-      const newFills = await this.pmOrders.pollNewFills();
-      for (const fill of newFills) {
-        const tradeSignal = {
-          venue: "polymarket",
-          chain: "polygon",
-          symbol: encodePredictionInstrument(fill.marketConditionId, fill.outcomeIndex),
-          side: fill.side === "BUY" ? "buy" : "sell",
-          size: parseFloat(fill.size),
-          price: parseFloat(fill.price),
-          fee: parseFloat(fill.fee),
-          venueFillId: fill.tradeId,
-          venueTimestamp: new Date(fill.timestamp).toISOString()
-        };
-        this.signal.reportPredictionFill(tradeSignal);
-      }
-    } catch (err) {
-      console.warn("[runtime] Prediction fill poll error:", err.message);
-    }
-  }
-  // ── COMMANDS ───────────────────────────────────────────────
-  handleCommand(command) {
-    console.log(`[runtime] Command received: ${command.type} (${command.id})`);
-    switch (command.type) {
-      case "start_trading":
-        this.startTrading();
-        this.relay.sendCommandAck(command.id, true, "Trading started");
-        break;
-      case "stop_trading":
-        this.stopTrading();
-        this.relay.sendCommandAck(command.id, true, "Trading stopped");
-        break;
-      case "pause_trading":
-        this.stopTrading();
-        this.relay.sendCommandAck(command.id, true, "Trading paused");
-        break;
-      case "update_risk_params":
-        if (command.params) {
-          this.risk.updateParams(command.params);
-          this.sendStatus();
-          this.relay.sendCommandAck(command.id, true, "Risk params updated");
-        } else {
-          this.relay.sendCommandAck(command.id, false, "No params provided");
-        }
-        break;
-      case "get_status":
-        this.sendStatus();
-        this.relay.sendCommandAck(command.id, true);
-        break;
-      case "reload_config":
-        this.reloadConfig(command);
-        break;
-      default:
-        console.warn(`[runtime] Unknown command: ${command.type}`);
-        this.relay.sendCommandAck(command.id, false, `Unknown command: ${command.type}`);
-    }
-  }
-  async reloadConfig(command) {
-    try {
-      const apiBase = this.config.apiUrl || this.config.relay.url.replace(/\/ws\/.*/, "");
-      const res = await fetch(`${apiBase}/v1/agents/${this.config.agentId}`, {
-        headers: { "Authorization": `Bearer ${this.config.apiToken}` }
-      });
-      if (!res.ok) {
-        throw new Error(`API returned ${res.status}`);
-      }
-      const agent = await res.json();
-      if (agent.config) {
-        const cfg = agent.config;
-        const risk = cfg.risk;
-        if (risk) {
-          const updates = {};
-          if (typeof risk.maxPositionSize === "number") updates.maxPositionSizeBps = risk.maxPositionSize * 100;
-          if (typeof risk.maxDailyLoss === "number") updates.maxDailyLossBps = risk.maxDailyLoss * 100;
-          if (typeof risk.maxConcurrentPositions === "number") updates.maxConcurrentPositions = risk.maxConcurrentPositions;
-          if (typeof risk.slippageTolerance === "number") updates.maxSlippageBps = risk.slippageTolerance * 100;
-          if (typeof risk.tradingInterval === "number") {
-            this.config.trading.tradingIntervalMs = risk.tradingInterval * 1e3;
-          }
-          if (Object.keys(updates).length > 0) {
-            this.risk.updateParams(updates);
-          }
-        }
-        console.log("[runtime] Config reloaded from API");
-        this.sendStatus();
-      }
-      this.relay.sendCommandAck(command.id, true, "Config reloaded");
-    } catch (err) {
-      console.error("[runtime] Config reload failed:", err.message);
-      this.relay.sendCommandAck(command.id, false, err.message);
-    }
-  }
-  // ── STATUS ─────────────────────────────────────────────────
-  sendStatus() {
-    const status = {
-      mode: this.mode,
-      agentId: this.config.agentId,
-      walletAddress: this.walletAddress || void 0,
-      sdkVersion: SDK_VERSION,
-      cycleCount: this.cycleCount,
-      lastCycleAt: this.lastCycleAt,
-      tradingIntervalMs: this.config.trading.tradingIntervalMs,
-      llm: {
-        provider: this.config.llm.provider,
-        model: this.config.llm.model || "default"
-      },
-      risk: {
-        dailyPnL: this.risk.getDailyPnL(),
-        dailyLossLimit: this.risk.getDailyLossLimit(),
-        isLimitHit: this.risk.isDailyLossLimitHit()
-      },
-      positions: {
-        openPositions: this.positions.getPositions().length,
-        totalUnrealizedPnL: 0,
-        totalRealizedPnL: this.positions.getRealizedPnL()
-      },
-      venues: {
-        hyperliquid: {
-          enabled: !!this.hlClient,
-          trading: !!this.hlOrders && this.mode === "trading"
-        },
-        polymarket: {
-          enabled: !!this.pmClient,
-          trading: !!this.pmOrders && this.mode === "trading"
-        },
-        spot: {
-          enabled: !!this.spotManager,
-          trading: !!this.spotManager && this.mode === "trading"
-        },
-        bridge: {
-          enabled: !!this.bridgeManager
-        }
-      }
-    };
-    if (this.paper) {
-      const metrics = this.paper.getMetrics();
-      status.paper = {
-        active: true,
-        simulatedValue: this.paper.getEquity(),
-        simulatedPnLPct: metrics.totalReturn * 100
-      };
-      status.portfolioValue = this.paper.getEquity();
-    }
-    this.relay.sendHeartbeat(status);
-  }
-};
-
-export {
-  loadConfig,
-  generateSampleConfig,
-  writeSampleConfig,
-  CHAIN_CONFIGS,
-  getChainConfig,
-  DEFAULT_SPOT_CONFIG,
-  RelayClient,
-  SignalReporter,
-  FileStore,
-  PositionTracker,
-  createLLMAdapter,
-  getTemplate,
-  listTemplates,
-  loadStrategy,
-  RiskManager,
-  MarketDataService,
-  PaperExecutor,
-  HyperliquidClient,
-  HYPERLIQUID_DOMAIN,
-  HYPERLIQUID_USER_DOMAIN,
-  USER_ACTION_TYPES,
-  getNextNonce,
-  HyperliquidSigner,
-  HyperliquidOrderManager,
-  HyperliquidPositionManager,
-  HyperliquidWebSocket,
-  encodePredictionInstrument,
-  decodePredictionInstrument,
-  PolymarketClient,
-  PolymarketOrderManager,
-  SpotDEXClient,
-  UniswapAdapter,
-  AerodromeAdapter,
-  SpotSwapManager,
-  DEFAULT_BRIDGE_CONFIG,
-  AcrossAdapter,
-  BridgeManager,
-  AgentRuntime
-};