@exagent/agent 0.1.17 → 0.1.19

package/dist/cli.js

@@ -32,8 +32,9 @@ var path2 = __toESM(require("path"));
 
 // src/runtime.ts
 var import_sdk2 = require("@exagent/sdk");
-var import_viem3 = require("viem");
-var import_chains2 = require("viem/chains");
+var import_viem6 = require("viem");
+var import_chains4 = require("viem/chains");
+var import_accounts5 = require("viem/accounts");
 
 // src/llm/openai.ts
 var import_openai = __toESM(require("openai"));
@@ -893,6 +894,26 @@ var RelayConfigSchema = import_zod.z.object({
   apiUrl: import_zod.z.string().url(),
   heartbeatIntervalMs: import_zod.z.number().min(5e3).default(3e4)
 }).optional();
+var PerpConfigSchema = import_zod.z.object({
+  /** Enable perp trading */
+  enabled: import_zod.z.boolean().default(false),
+  /** Hyperliquid REST API URL */
+  apiUrl: import_zod.z.string().url().default("https://api.hyperliquid.xyz"),
+  /** Hyperliquid WebSocket URL */
+  wsUrl: import_zod.z.string().default("wss://api.hyperliquid.xyz/ws"),
+  /** Builder address for fee collection (must have >= 100 USDC on HL) */
+  builderAddress: import_zod.z.string(),
+  /** Builder fee in tenths of basis points (100 = 10 bps = 0.10%) */
+  builderFeeTenthsBps: import_zod.z.number().min(0).max(500).default(100),
+  /** Private key for the perp relayer (calls recordPerpTrade on Base). Falls back to agent wallet. */
+  perpRelayerKey: import_zod.z.string().optional(),
+  /** Maximum leverage per position (default: 10) */
+  maxLeverage: import_zod.z.number().min(1).max(50).default(10),
+  /** Maximum notional position size in USD (default: 50000) */
+  maxNotionalUSD: import_zod.z.number().min(100).default(5e4),
+  /** Allowed perp instruments (e.g. ["ETH", "BTC", "SOL"]). If empty, all instruments allowed. */
+  allowedInstruments: import_zod.z.array(import_zod.z.string()).optional()
+}).optional();
 var AgentConfigSchema = import_zod.z.object({
   // Identity (from on-chain registration)
   agentId: import_zod.z.union([import_zod.z.number().positive(), import_zod.z.string()]),
@@ -910,6 +931,8 @@ var AgentConfigSchema = import_zod.z.object({
   vault: VaultConfigSchema.default({}),
   // Relay configuration (command center)
   relay: RelayConfigSchema,
+  // Perp trading configuration (Hyperliquid)
+  perp: PerpConfigSchema,
   // Allowed tokens (addresses)
   allowedTokens: import_zod.z.array(import_zod.z.string()).optional()
 });
@@ -1465,6 +1488,101 @@ var RiskManager = class {
       isLimitHit: pv > 0 ? this.dailyPnL < -maxLossUSD : false
     };
   }
+  // ============================================================
+  // PERP RISK FILTERING
+  // ============================================================
+  /**
+   * Filter perp trade signals through risk checks.
+   * Reduce-only signals (closes) always pass.
+   *
+   * @param signals - Raw perp signals from strategy
+   * @param positions - Current open positions on Hyperliquid
+   * @param account - Current account equity and margin
+   * @param maxLeverage - Maximum allowed leverage
+   * @param maxNotionalUSD - Maximum notional per position
+   * @returns Signals that pass risk checks
+   */
+  filterPerpSignals(signals, positions, account, maxLeverage, maxNotionalUSD) {
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    if (today !== this.lastResetDate) {
+      this.dailyPnL = 0;
+      this.dailyFees = 0;
+      this.lastResetDate = today;
+    }
+    if (this.isDailyLossLimitHit(account.totalEquity)) {
+      console.warn("Daily loss limit reached \u2014 blocking new perp trades");
+      return signals.filter((s) => s.reduceOnly);
+    }
+    return signals.filter((signal) => this.validatePerpSignal(signal, positions, account, maxLeverage, maxNotionalUSD));
+  }
+  /**
+   * Validate an individual perp signal.
+   */
+  validatePerpSignal(signal, positions, account, maxLeverage, maxNotionalUSD) {
+    if (signal.action === "hold") {
+      return true;
+    }
+    if (signal.reduceOnly || signal.action === "close_long" || signal.action === "close_short") {
+      return true;
+    }
+    if (signal.confidence < 0.5) {
+      console.warn(`Perp signal confidence too low: ${signal.confidence} for ${signal.instrument}`);
+      return false;
+    }
+    if (signal.leverage > maxLeverage) {
+      console.warn(`Perp signal leverage ${signal.leverage}x exceeds max ${maxLeverage}x for ${signal.instrument}`);
+      return false;
+    }
+    const signalNotional = signal.size * signal.price;
+    if (signalNotional > maxNotionalUSD) {
+      console.warn(`Perp signal notional $${signalNotional.toFixed(0)} exceeds max $${maxNotionalUSD} for ${signal.instrument}`);
+      return false;
+    }
+    const currentNotional = account.totalNotional;
+    const projectedNotional = currentNotional + signalNotional;
+    const projectedLeverage = account.totalEquity > 0 ? projectedNotional / account.totalEquity : 0;
+    if (projectedLeverage > maxLeverage) {
+      console.warn(
+        `Perp signal would push aggregate leverage to ${projectedLeverage.toFixed(1)}x (max: ${maxLeverage}x) \u2014 blocked`
+      );
+      return false;
+    }
+    const existingPos = positions.find((p) => p.instrument === signal.instrument);
+    if (existingPos) {
+      const liqProximity = this.calculateLiquidationProximity(existingPos);
+      if (liqProximity > 0.7) {
+        console.warn(
+          `Position ${signal.instrument} liquidation proximity ${(liqProximity * 100).toFixed(0)}% \u2014 blocking new entry`
+        );
+        return false;
+      }
+    }
+    const requiredMargin = signalNotional / signal.leverage;
+    if (requiredMargin > account.availableMargin) {
+      console.warn(
+        `Insufficient margin for ${signal.instrument}: need $${requiredMargin.toFixed(0)}, have $${account.availableMargin.toFixed(0)}`
+      );
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Calculate liquidation proximity for a position (0.0 = safe, 1.0 = liquidated).
+   */
+  calculateLiquidationProximity(pos) {
+    if (pos.liquidationPrice <= 0 || pos.markPrice <= 0) return 0;
+    if (pos.size > 0) {
+      if (pos.markPrice <= pos.liquidationPrice) return 1;
+      const distance = pos.markPrice - pos.liquidationPrice;
+      const total = pos.entryPrice - pos.liquidationPrice;
+      return total > 0 ? 1 - distance / total : 0;
+    } else {
+      if (pos.markPrice >= pos.liquidationPrice) return 1;
+      const distance = pos.liquidationPrice - pos.markPrice;
+      const total = pos.liquidationPrice - pos.entryPrice;
+      return total > 0 ? 1 - distance / total : 0;
+    }
+  }
 };
 
 // src/vault/manager.ts
@@ -2032,139 +2150,1494 @@ function openBrowser(url) {
   }
 }
 
-// src/runtime.ts
-var FUNDS_LOW_THRESHOLD = 5e-3;
-var FUNDS_CRITICAL_THRESHOLD = 1e-3;
-var AgentRuntime = class {
-  config;
-  client;
-  llm;
-  strategy;
-  executor;
-  riskManager;
-  marketData;
-  vaultManager;
-  relay = null;
-  isRunning = false;
-  mode = "idle";
-  configHash;
-  cycleCount = 0;
-  lastCycleAt = 0;
-  lastPortfolioValue = 0;
-  lastEthBalance = "0";
-  processAlive = true;
-  riskUniverse = 0;
-  allowedTokens = /* @__PURE__ */ new Set();
+// src/perp/client.ts
+var HyperliquidClient = class {
+  apiUrl;
+  meta = null;
+  assetIndexCache = /* @__PURE__ */ new Map();
   constructor(config) {
-    this.config = config;
+    this.apiUrl = config.apiUrl;
+  }
+  // ============================================================
+  // INFO API (read-only)
+  // ============================================================
+  /** Fetch perpetuals metadata (asset specs, names, indices) */
+  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;
+  }
+  /** Get asset index from symbol (e.g. "ETH" -> 1). Caches after first getMeta() call. */
+  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;
+  }
+  /** Get mid-market prices for all perpetuals */
+  async getAllMids() {
+    return this.infoRequest({ type: "allMids" });
+  }
+  /** Get clearinghouse state (positions, margin, equity) for a user */
+  async getClearinghouseState(user) {
+    return this.infoRequest({ type: "clearinghouseState", user });
+  }
+  /** Get user's recent fills */
+  async getUserFills(user, startTime) {
+    return this.infoRequest({
+      type: "userFills",
+      user,
+      ...startTime !== void 0 && { startTime }
+    });
+  }
+  /** Get user's fills in a time range */
+  async getUserFillsByTime(user, startTime, endTime) {
+    return this.infoRequest({
+      type: "userFillsByTime",
+      user,
+      startTime,
+      ...endTime !== void 0 && { endTime }
+    });
+  }
+  /** Get user's open orders */
+  async getOpenOrders(user) {
+    return this.infoRequest({ type: "openOrders", user });
+  }
+  /** Get user's funding history */
+  async getUserFunding(user, startTime) {
+    return this.infoRequest({ type: "userFunding", user, startTime });
+  }
+  /** Check max approved builder fee for a user */
+  async getMaxBuilderFee(user, builder) {
+    const resp = await this.infoRequest({ type: "maxBuilderFee", user, builder });
+    return resp;
+  }
+  /** Get L2 order book for a coin */
+  async getL2Book(coin, depth) {
+    return this.infoRequest({
+      type: "l2Book",
+      coin,
+      ...depth !== void 0 && { nSigFigs: depth }
+    });
+  }
+  // ============================================================
+  // HIGH-LEVEL HELPERS
+  // ============================================================
+  /** Get parsed positions for a user address */
+  async getPositions(user) {
+    const state = await this.getClearinghouseState(user);
+    return state.assetPositions.filter((p) => parseFloat(p.position.szi) !== 0).map((p) => this.parsePosition(p));
+  }
+  /** Get account summary (equity, margin, leverage) */
+  async getAccountSummary(user) {
+    const state = await this.getClearinghouseState(user);
+    const crossMarginSummary = state.crossMarginSummary;
+    const totalEquity = parseFloat(crossMarginSummary.accountValue);
+    const totalNotional = parseFloat(crossMarginSummary.totalNtlPos);
+    const totalMarginUsed = parseFloat(crossMarginSummary.totalMarginUsed);
+    return {
+      totalEquity,
+      availableMargin: totalEquity - totalMarginUsed,
+      totalMarginUsed,
+      totalUnrealizedPnl: parseFloat(crossMarginSummary.totalRawUsd) - totalEquity,
+      totalNotional,
+      maintenanceMargin: totalMarginUsed * 0.5,
+      // Approximate
+      effectiveLeverage: totalEquity > 0 ? totalNotional / totalEquity : 0,
+      cashBalance: parseFloat(state.crossMarginSummary.accountValue) - state.assetPositions.reduce(
+        (sum, p) => sum + parseFloat(p.position.unrealizedPnl),
+        0
+      )
+    };
+  }
+  /** Get market data for a list of instruments */
+  async getMarketData(instruments) {
+    const mids = await this.getAllMids();
+    const meta = await this.getMeta();
+    return instruments.filter((inst) => mids[inst] !== void 0).map((inst) => {
+      const midPrice = parseFloat(mids[inst]);
+      const assetMeta = meta.find((m) => m.name === inst);
+      return {
+        instrument: inst,
+        midPrice,
+        bestBid: midPrice,
+        // Approximate — use L2 book for exact
+        bestAsk: midPrice,
+        funding8h: 0,
+        // Would need separate funding API call
+        openInterest: 0,
+        // Would need separate meta call
+        volume24h: 0,
+        priceChange24h: 0
+      };
+    });
+  }
+  /** Convert fills to our PerpFill type */
+  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,
+      // Approximate maker detection
+      builderFee: fill.builderFee,
+      liquidation: fill.liquidation
+    };
+  }
+  // ============================================================
+  // PRIVATE HELPERS
+  // ============================================================
+  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
+var import_viem3 = require("viem");
+var HYPERLIQUID_DOMAIN = {
+  name: "HyperliquidSignTransaction",
+  version: "1",
+  chainId: 42161n,
+  // Always Arbitrum chain ID
+  verifyingContract: "0x0000000000000000000000000000000000000000"
+};
+var HYPERLIQUID_TYPES = {
+  HyperliquidTransaction: [
+    { name: "hyperliquidChain", type: "string" },
+    { name: "action", type: "string" },
+    { name: "nonce", type: "uint64" }
+  ]
+};
+var lastNonce = 0n;
+function getNextNonce() {
+  const now = BigInt(Date.now());
+  if (now <= lastNonce) {
+    lastNonce = lastNonce + 1n;
+  } else {
+    lastNonce = now;
+  }
+  return lastNonce;
+}
+var HyperliquidSigner = class {
+  constructor(walletClient) {
+    this.walletClient = walletClient;
   }
   /**
-   * Initialize the agent runtime
+   * Sign an exchange action (order, cancel, etc.)
+   *
+   * @param action - The action object (will be JSON-serialized)
+   * @param nonce - Nonce (defaults to current timestamp)
+   * @returns Signature hex string
    */
-  async initialize() {
-    console.log(`Initializing agent: ${this.config.name} (ID: ${this.config.agentId})`);
-    this.client = new import_sdk2.ExagentClient({
-      privateKey: this.config.privateKey,
-      network: this.config.network
+  async signAction(action, nonce) {
+    const actionNonce = nonce ?? getNextNonce();
+    const actionStr = JSON.stringify(action);
+    const account = this.walletClient.account;
+    if (!account) throw new Error("Wallet client has no account");
+    const signature = await this.walletClient.signTypedData({
+      account,
+      domain: HYPERLIQUID_DOMAIN,
+      types: HYPERLIQUID_TYPES,
+      primaryType: "HyperliquidTransaction",
+      message: {
+        hyperliquidChain: "Mainnet",
+        action: actionStr,
+        nonce: actionNonce
+      }
     });
-    console.log(`Wallet: ${this.client.address}`);
-    const agent = await this.client.registry.getAgent(BigInt(this.config.agentId));
-    if (!agent) {
-      throw new Error(`Agent ID ${this.config.agentId} not found on-chain. Please register first.`);
-    }
-    console.log(`Agent verified: ${agent.name}`);
-    await this.ensureWalletLinked();
-    await this.loadTradingRestrictions();
-    console.log(`Initializing LLM: ${this.config.llm.provider}`);
-    this.llm = await createLLMAdapter(this.config.llm);
-    const llmMeta = this.llm.getMetadata();
-    console.log(`LLM ready: ${llmMeta.provider} (${llmMeta.model})`);
-    await this.syncConfigHash();
-    this.strategy = await loadStrategy();
-    this.executor = new TradeExecutor(this.client, this.config, () => this.getConfigHash());
-    this.riskManager = new RiskManager(this.config.trading);
-    this.marketData = new MarketDataService(this.getRpcUrl());
-    await this.initializeVaultManager();
-    await this.initializeRelay();
-    console.log("Agent initialized successfully");
+    return { signature, nonce: actionNonce };
   }
   /**
-   * Initialize the relay client for command center connectivity
+   * Sign a user-level approval action (approve builder fee, approve agent).
+   * These use the same EIP-712 structure but with different action payloads.
    */
-  async initializeRelay() {
-    const relayConfig = this.config.relay;
-    const relayEnabled = process.env.EXAGENT_RELAY_ENABLED !== "false";
-    if (!relayConfig?.enabled || !relayEnabled) {
-      console.log("Relay: Disabled");
-      return;
+  async signApproval(action, nonce) {
+    return this.signAction(action, nonce);
+  }
+  /**
+   * Get the signer's address
+   */
+  getAddress() {
+    const account = this.walletClient.account;
+    if (!account) throw new Error("Wallet client has no account");
+    return account.address;
+  }
+};
+function fillHashToBytes32(fillHash) {
+  if (fillHash.startsWith("0x") && fillHash.length === 66) {
+    return fillHash;
+  }
+  return (0, import_viem3.keccak256)((0, import_viem3.encodePacked)(["string"], [fillHash]));
+}
+
+// src/perp/orders.ts
+var OrderManager = class {
+  client;
+  signer;
+  config;
+  constructor(client, signer, config) {
+    this.client = client;
+    this.signer = signer;
+    this.config = config;
+  }
+  /**
+   * Place an order on Hyperliquid from a trade signal.
+   * Attaches builder fee for revenue collection.
+   */
+  async placeOrder(signal) {
+    try {
+      const assetIndex = await this.client.getAssetIndex(signal.instrument);
+      const isBuy = signal.action === "open_long" || signal.action === "close_short";
+      const side = isBuy ? "B" : "A";
+      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",
+        builder: {
+          b: this.config.builderAddress,
+          f: this.config.builderFeeTenthsBps
+        }
+      };
+      const nonce = getNextNonce();
+      const { signature } = await this.signer.signAction(action, nonce);
+      const address = this.signer.getAddress();
+      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(`Order placement failed for ${signal.instrument}:`, message);
+      return {
+        success: false,
+        status: "error",
+        error: message
+      };
     }
-    const apiUrl = process.env.EXAGENT_API_URL || relayConfig.apiUrl;
-    if (!apiUrl) {
-      console.log("Relay: No API URL configured, skipping");
-      return;
+  }
+  /**
+   * Cancel an open order by ID.
+   */
+  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(`Cancelled order ${orderId} for ${instrument}`);
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Cancel failed for order ${orderId}:`, message);
+      return false;
     }
-    this.relay = new RelayClient({
-      agentId: String(this.config.agentId),
-      privateKey: this.config.privateKey,
-      relay: {
-        ...relayConfig,
-        apiUrl
-      },
-      onCommand: (cmd) => this.handleCommand(cmd)
-    });
+  }
+  /**
+   * Close an entire position for an instrument.
+   * Uses a market order with reduceOnly flag.
+   */
+  async closePosition(instrument, positionSize) {
+    const isLong = positionSize > 0;
+    const signal = {
+      action: isLong ? "close_long" : "close_short",
+      instrument,
+      size: Math.abs(positionSize),
+      price: 0,
+      leverage: 1,
+      orderType: "market",
+      reduceOnly: true,
+      confidence: 1,
+      reasoning: "Position close"
+    };
+    return this.placeOrder(signal);
+  }
+  /**
+   * Update leverage for an instrument.
+   */
+  async updateLeverage(instrument, leverage, isCross = true) {
     try {
-      await this.relay.connect();
-      console.log("Relay: Connected to command center");
-      this.sendRelayStatus();
+      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(`Leverage updated for ${instrument}: ${leverage}x (${isCross ? "cross" : "isolated"})`);
+      return true;
     } catch (error) {
-      console.warn(
-        "Relay: Failed to connect (agent will work locally):",
-        error instanceof Error ? error.message : error
-      );
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Leverage update failed for ${instrument}:`, message);
+      return false;
     }
   }
+  // ============================================================
+  // PRIVATE HELPERS
+  // ============================================================
   /**
-   * Initialize the vault manager based on config
+   * Get a market price string for IOC orders.
+   * Uses a generous slippage buffer to ensure fills.
    */
-  async initializeVaultManager() {
-    const vaultConfig = this.config.vault || { policy: "disabled", preferVaultTrading: false };
-    this.vaultManager = new VaultManager({
-      agentId: BigInt(this.config.agentId),
-      agentName: this.config.name,
-      network: this.config.network,
-      walletKey: this.config.privateKey,
-      vaultConfig
-    });
-    console.log(`Vault policy: ${vaultConfig.policy}`);
-    const status = await this.vaultManager.getVaultStatus();
-    if (status.hasVault) {
-      console.log(`Vault exists: ${status.vaultAddress}`);
-      console.log(`Vault TVL: ${Number(status.totalAssets) / 1e6} USDC`);
-    } else {
-      console.log("No vault exists for this agent");
-      if (vaultConfig.policy === "manual") {
-        console.log("Vault creation is manual \u2014 use the command center to create one");
+  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";
+  }
+  /**
+   * Parse Hyperliquid exchange response into OrderResult.
+   */
+  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)}`
+    };
   }
   /**
-   * Ensure the current wallet is linked to the agent.
-   * If the trading wallet differs from the owner, enters a recovery loop
-   * that waits for the owner to link it from the website.
+   * Send a signed request to the Hyperliquid Exchange API.
    */
-  async ensureWalletLinked() {
-    const agentId = BigInt(this.config.agentId);
-    const address = this.client.address;
-    const isLinked = await this.client.registry.isLinkedWallet(agentId, address);
-    if (!isLinked) {
-      console.log("Wallet not linked, linking now...");
-      const agent = await this.client.registry.getAgent(agentId);
-      if (agent?.owner.toLowerCase() !== address.toLowerCase()) {
-        const ccUrl = `https://exagent.io/agents/${encodeURIComponent(this.config.name)}/command-center`;
-        const nonce = await this.client.registry.getNonce(address);
-        const linkMessage = import_sdk2.ExagentRegistry.generateLinkMessage(
-          address,
-          agentId,
+  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 PositionManager = class {
+  client;
+  userAddress;
+  /** Cached positions (updated each cycle) */
+  cachedPositions = [];
+  cachedAccount = null;
+  lastRefreshAt = 0;
+  /** Cache TTL in ms (5 seconds — positions refresh each cycle anyway) */
+  cacheTtlMs = 5e3;
+  constructor(client, userAddress) {
+    this.client = client;
+    this.userAddress = userAddress;
+  }
+  // ============================================================
+  // POSITION QUERIES
+  // ============================================================
+  /**
+   * Get all open positions. Uses cache if fresh.
+   */
+  async getPositions(forceRefresh = false) {
+    if (!forceRefresh && this.isCacheFresh()) {
+      return this.cachedPositions;
+    }
+    await this.refresh();
+    return this.cachedPositions;
+  }
+  /**
+   * Get a specific position by instrument.
+   * Returns null if no position is open.
+   */
+  async getPosition(instrument) {
+    const positions = await this.getPositions();
+    return positions.find((p) => p.instrument === instrument) ?? null;
+  }
+  /**
+   * Get account summary (equity, margin, leverage).
+   */
+  async getAccountSummary(forceRefresh = false) {
+    if (!forceRefresh && this.isCacheFresh() && this.cachedAccount) {
+      return this.cachedAccount;
+    }
+    await this.refresh();
+    return this.cachedAccount;
+  }
+  // ============================================================
+  // LIQUIDATION MONITORING
+  // ============================================================
+  /**
+   * Get liquidation proximity for all positions.
+   * Returns a value between 0.0 (safe) and 1.0 (at liquidation price).
+   * Values above 0.7 should trigger risk warnings.
+   */
+  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;
+  }
+  /**
+   * Check if any position is dangerously close to liquidation.
+   * Returns instruments with proximity > threshold.
+   */
+  async getDangerousPositions(threshold = 0.7) {
+    const positions = await this.getPositions();
+    const proximities = await this.getLiquidationProximity();
+    return positions.filter((p) => {
+      const prox = proximities.get(p.instrument) ?? 0;
+      return prox > threshold;
+    });
+  }
+  // ============================================================
+  // SUMMARY HELPERS
+  // ============================================================
+  /**
+   * Get total unrealized PnL across all positions.
+   */
+  async getTotalUnrealizedPnl() {
+    const positions = await this.getPositions();
+    return positions.reduce((sum, p) => sum + p.unrealizedPnl, 0);
+  }
+  /**
+   * Get total notional exposure.
+   */
+  async getTotalNotional() {
+    const positions = await this.getPositions();
+    return positions.reduce((sum, p) => sum + p.notionalUSD, 0);
+  }
+  /**
+   * Get position count.
+   */
+  async getPositionCount() {
+    const positions = await this.getPositions();
+    return positions.length;
+  }
+  // ============================================================
+  // CACHE MANAGEMENT
+  // ============================================================
+  /**
+   * Force refresh positions and account from Hyperliquid.
+   */
+  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("Failed to refresh positions:", message);
+    }
+  }
+  /**
+   * Check if cache is still fresh.
+   */
+  isCacheFresh() {
+    return Date.now() - this.lastRefreshAt < this.cacheTtlMs;
+  }
+};
+
+// src/perp/websocket.ts
+var import_ws2 = __toESM(require("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;
+  /** Last processed fill time (ms) — used for REST backfill on reconnect */
+  lastProcessedFillTime = 0;
+  /** Callbacks */
+  onFill = null;
+  onFunding = null;
+  onLiquidation = null;
+  constructor(config, userAddress, client) {
+    this.wsUrl = config.wsUrl;
+    this.userAddress = userAddress;
+    this.client = client;
+  }
+  // ============================================================
+  // CONNECTION
+  // ============================================================
+  /**
+   * Connect to Hyperliquid WebSocket and subscribe to user events.
+   */
+  async connect() {
+    if (this.ws?.readyState === import_ws2.default.OPEN || this.isConnecting) {
+      return;
+    }
+    this.isConnecting = true;
+    this.shouldReconnect = true;
+    return new Promise((resolve, reject) => {
+      try {
+        this.ws = new import_ws2.default(this.wsUrl);
+        this.ws.on("open", () => {
+          this.isConnecting = false;
+          this.reconnectAttempts = 0;
+          console.log("Hyperliquid WebSocket 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("Fill backfill failed:", err instanceof Error ? err.message : err);
+          });
+          resolve();
+        });
+        this.ws.on("message", (data) => {
+          this.handleMessage(data);
+        });
+        this.ws.on("close", (code, reason) => {
+          this.isConnecting = false;
+          console.log(`Hyperliquid WebSocket closed: ${code} ${reason.toString()}`);
+          this.stopPing();
+          this.scheduleReconnect();
+        });
+        this.ws.on("error", (error) => {
+          this.isConnecting = false;
+          console.error("Hyperliquid WebSocket error:", error.message);
+          if (this.reconnectAttempts === 0) {
+            reject(error);
+          }
+        });
+      } catch (error) {
+        this.isConnecting = false;
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Disconnect and stop reconnecting.
+   */
+  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 === import_ws2.default.OPEN) {
+        this.ws.close(1e3, "Client disconnect");
+      }
+      this.ws = null;
+    }
+    console.log("Hyperliquid WebSocket disconnected");
+  }
+  /**
+   * Check if WebSocket is connected.
+   */
+  get isConnected() {
+    return this.ws?.readyState === import_ws2.default.OPEN;
+  }
+  // ============================================================
+  // EVENT HANDLERS
+  // ============================================================
+  /**
+   * Register callback for fill events.
+   */
+  onFillReceived(callback) {
+    this.onFill = callback;
+  }
+  /**
+   * Register callback for funding payment events.
+   */
+  onFundingReceived(callback) {
+    this.onFunding = callback;
+  }
+  /**
+   * Register callback for liquidation events.
+   */
+  onLiquidationDetected(callback) {
+    this.onLiquidation = callback;
+  }
+  /**
+   * Get the last processed fill time (for external checkpoint management).
+   */
+  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 (error) {
+    }
+  }
+  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
+  // ============================================================
+  /**
+   * Backfill fills that may have been missed during WebSocket downtime.
+   * Uses the last processed fill time as the starting point.
+   */
+  async backfillMissedFills() {
+    if (this.lastProcessedFillTime === 0 || !this.onFill) {
+      return;
+    }
+    console.log(`Backfilling fills since ${new Date(this.lastProcessedFillTime).toISOString()}`);
+    const fills = await this.client.getUserFillsByTime(
+      this.userAddress,
+      this.lastProcessedFillTime + 1
+      // +1 to avoid duplicate
+    );
+    if (fills.length > 0) {
+      console.log(`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(`Hyperliquid WebSocket: max reconnect attempts (${this.maxReconnectAttempts}) reached`);
+      }
+      return;
+    }
+    const delay = Math.min(
+      this.baseReconnectMs * Math.pow(2, this.reconnectAttempts),
+      this.maxReconnectMs
+    );
+    this.reconnectAttempts++;
+    console.log(`Hyperliquid WebSocket: reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    this.reconnectTimer = setTimeout(() => {
+      this.connect().catch((err) => {
+        console.error("Reconnect failed:", err instanceof Error ? err.message : err);
+      });
+    }, delay);
+  }
+  // ============================================================
+  // KEEPALIVE
+  // ============================================================
+  startPing() {
+    this.stopPing();
+    this.pingTimer = setInterval(() => {
+      if (this.ws?.readyState === import_ws2.default.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 === import_ws2.default.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+};
+
+// src/perp/recorder.ts
+var import_viem4 = require("viem");
+var import_chains2 = require("viem/chains");
+var import_accounts3 = require("viem/accounts");
+var ROUTER_ADDRESS = "0x1BCFa13f677fDCf697D8b7d5120f544817F1de1A";
+var ROUTER_ABI = [
+  {
+    type: "function",
+    name: "recordPerpTrade",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "configHash", type: "bytes32" },
+      { name: "instrument", type: "string" },
+      { name: "isLong", type: "bool" },
+      { name: "notionalUSD", type: "uint256" },
+      { name: "feeUSD", type: "uint256" },
+      { name: "fillId", type: "bytes32" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  }
+];
+var MAX_RETRIES = 3;
+var RETRY_DELAY_MS = 5e3;
+var PerpTradeRecorder = class {
+  // Use `any` for viem client types to avoid L2 chain type conflicts (Base has "deposit" tx type)
+  publicClient;
+  // eslint-disable-line @typescript-eslint/no-explicit-any
+  walletClient;
+  // eslint-disable-line @typescript-eslint/no-explicit-any
+  account;
+  agentId;
+  configHash;
+  /** Retry queue for failed recordings */
+  retryQueue = [];
+  /** Set of fill IDs already recorded (or in-progress) to prevent local dups */
+  recordedFills = /* @__PURE__ */ new Set();
+  /** Timer for processing retry queue */
+  retryTimer = null;
+  constructor(opts) {
+    this.agentId = opts.agentId;
+    this.configHash = opts.configHash;
+    this.account = (0, import_accounts3.privateKeyToAccount)(opts.privateKey);
+    const rpcUrl = opts.rpcUrl || "https://mainnet.base.org";
+    const transport = (0, import_viem4.http)(rpcUrl);
+    this.publicClient = (0, import_viem4.createPublicClient)({
+      chain: import_chains2.base,
+      transport
+    });
+    this.walletClient = (0, import_viem4.createWalletClient)({
+      chain: import_chains2.base,
+      transport,
+      account: this.account
+    });
+    this.retryTimer = setInterval(() => this.processRetryQueue(), RETRY_DELAY_MS);
+  }
+  // ============================================================
+  // PUBLIC API
+  // ============================================================
+  /**
+   * Record a fill on-chain.
+   * Converts the Hyperliquid fill into recordPerpTrade params and submits.
+   */
+  async recordFill(fill) {
+    const fillId = fillHashToBytes32(fill.hash);
+    const fillIdStr = fillId.toLowerCase();
+    if (this.recordedFills.has(fillIdStr)) {
+      return { success: true };
+    }
+    this.recordedFills.add(fillIdStr);
+    const params = {
+      agentId: this.agentId,
+      configHash: this.configHash,
+      instrument: fill.coin,
+      isLong: fill.side === "B",
+      notionalUSD: this.calculateNotionalUSD(fill),
+      feeUSD: this.calculateFeeUSD(fill),
+      fillId
+    };
+    return this.submitRecord(params);
+  }
+  /**
+   * Update the config hash (when epoch changes).
+   */
+  updateConfigHash(configHash) {
+    this.configHash = configHash;
+  }
+  /**
+   * Get the number of fills pending retry.
+   */
+  get pendingRetries() {
+    return this.retryQueue.length;
+  }
+  /**
+   * Get the number of fills recorded (local dedup set size).
+   */
+  get recordedCount() {
+    return this.recordedFills.size;
+  }
+  /**
+   * Stop the recorder (clear retry timer).
+   */
+  stop() {
+    if (this.retryTimer) {
+      clearInterval(this.retryTimer);
+      this.retryTimer = null;
+    }
+  }
+  // ============================================================
+  // PRIVATE
+  // ============================================================
+  /**
+   * Submit a recordPerpTrade transaction on Base.
+   */
+  async submitRecord(params) {
+    try {
+      const { request } = await this.publicClient.simulateContract({
+        address: ROUTER_ADDRESS,
+        abi: ROUTER_ABI,
+        functionName: "recordPerpTrade",
+        args: [
+          params.agentId,
+          params.configHash,
+          params.instrument,
+          params.isLong,
+          params.notionalUSD,
+          params.feeUSD,
+          params.fillId
+        ],
+        account: this.account
+      });
+      const txHash = await this.walletClient.writeContract(request);
+      console.log(`Perp trade recorded: ${params.instrument} ${params.isLong ? "LONG" : "SHORT"} $${Number(params.notionalUSD) / 1e6} \u2014 tx: ${txHash}`);
+      return { success: true, txHash };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("DuplicateFill") || message.includes("already recorded")) {
+        console.log(`Fill already recorded on-chain: ${params.fillId}`);
+        return { success: true };
+      }
+      console.error(`Failed to record perp trade: ${message}`);
+      this.retryQueue.push({
+        params,
+        retries: 0,
+        lastAttempt: Date.now()
+      });
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Process the retry queue — attempt to re-submit failed recordings.
+   */
+  async processRetryQueue() {
+    if (this.retryQueue.length === 0) return;
+    const now = Date.now();
+    const toRetry = this.retryQueue.filter(
+      (item) => now - item.lastAttempt >= RETRY_DELAY_MS
+    );
+    for (const item of toRetry) {
+      item.retries++;
+      item.lastAttempt = now;
+      if (item.retries > MAX_RETRIES) {
+        console.error(
+          `Perp trade recording permanently failed after ${MAX_RETRIES} retries: ${item.params.instrument} ${item.params.fillId}`
+        );
+        const idx = this.retryQueue.indexOf(item);
+        if (idx >= 0) this.retryQueue.splice(idx, 1);
+        continue;
+      }
+      console.log(
+        `Retrying perp trade recording (attempt ${item.retries}/${MAX_RETRIES}): ${item.params.instrument}`
+      );
+      const result = await this.submitRecord(item.params);
+      if (result.success) {
+        const idx = this.retryQueue.indexOf(item);
+        if (idx >= 0) this.retryQueue.splice(idx, 1);
+      }
+    }
+  }
+  // ============================================================
+  // CONVERSION HELPERS
+  // ============================================================
+  /**
+   * Calculate notional USD from a fill (6-decimal).
+   * notionalUSD = px * sz * 1e6
+   */
+  calculateNotionalUSD(fill) {
+    const px = parseFloat(fill.px);
+    const sz = parseFloat(fill.sz);
+    return BigInt(Math.round(px * sz * 1e6));
+  }
+  /**
+   * Calculate fee USD from a fill (6-decimal).
+   * feeUSD = fee * 1e6 (fee is already in USD on Hyperliquid)
+   */
+  calculateFeeUSD(fill) {
+    const fee = parseFloat(fill.fee);
+    const builderFee = fill.builderFee ? parseFloat(fill.builderFee) : 0;
+    return BigInt(Math.round((fee + builderFee) * 1e6));
+  }
+};
+
+// src/perp/onboarding.ts
+var PerpOnboarding = class {
+  client;
+  signer;
+  config;
+  constructor(client, signer, config) {
+    this.client = client;
+    this.signer = signer;
+    this.config = config;
+  }
+  // ============================================================
+  // BUILDER FEE
+  // ============================================================
+  /**
+   * Check if the user has approved the builder fee.
+   * Builder fee must be approved before orders can include builder fees.
+   */
+  async isBuilderFeeApproved() {
+    try {
+      const maxFee = await this.client.getMaxBuilderFee(
+        this.signer.getAddress(),
+        this.config.builderAddress
+      );
+      return maxFee >= this.config.builderFeeTenthsBps;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Approve the builder fee on Hyperliquid.
+   * This is a one-time approval per builder address.
+   */
+  async approveBuilderFee() {
+    try {
+      const action = {
+        type: "approveBuilderFee",
+        hyperliquidChain: "Mainnet",
+        maxFeeRate: `${this.config.builderFeeTenthsBps / 1e4}%`,
+        builder: this.config.builderAddress,
+        nonce: Number(getNextNonce())
+      };
+      const { signature } = await this.signer.signApproval(action);
+      const resp = await fetch(`${this.config.apiUrl}/exchange`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          action,
+          signature: {
+            r: signature.slice(0, 66),
+            s: `0x${signature.slice(66, 130)}`,
+            v: parseInt(signature.slice(130, 132), 16)
+          },
+          nonce: action.nonce,
+          vaultAddress: null
+        })
+      });
+      if (!resp.ok) {
+        const text = await resp.text();
+        console.error(`Builder fee approval failed: ${resp.status} ${text}`);
+        return false;
+      }
+      console.log(`Builder fee approved: ${this.config.builderFeeTenthsBps / 10} bps for ${this.config.builderAddress}`);
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Builder fee approval failed: ${message}`);
+      return false;
+    }
+  }
+  // ============================================================
+  // BALANCE & REQUIREMENTS
+  // ============================================================
+  /**
+   * Check if the user has sufficient USDC balance on Hyperliquid.
+   * Returns the account equity in USD.
+   */
+  async checkBalance() {
+    try {
+      const account = await this.client.getAccountSummary(this.signer.getAddress());
+      return {
+        hasBalance: account.totalEquity > 0,
+        equity: account.totalEquity
+      };
+    } catch {
+      return { hasBalance: false, equity: 0 };
+    }
+  }
+  /**
+   * Verify that the agent's risk universe allows perp trading.
+   * Perps require risk universe >= 2 (Derivatives or higher).
+   */
+  verifyRiskUniverse(riskUniverse) {
+    if (riskUniverse >= 2) {
+      return {
+        allowed: true,
+        message: `Risk universe ${riskUniverse} allows perp trading`
+      };
+    }
+    return {
+      allowed: false,
+      message: `Risk universe ${riskUniverse} does not allow perp trading. Perps require Derivatives (2) or higher.`
+    };
+  }
+  // ============================================================
+  // FULL ONBOARDING CHECK
+  // ============================================================
+  /**
+   * Run all onboarding checks and return status.
+   * Does NOT auto-approve — caller must explicitly approve after review.
+   */
+  async checkOnboardingStatus(riskUniverse) {
+    const riskCheck = this.verifyRiskUniverse(riskUniverse);
+    const balanceCheck = await this.checkBalance();
+    const builderFeeApproved = await this.isBuilderFeeApproved();
+    const ready = riskCheck.allowed && balanceCheck.hasBalance && builderFeeApproved;
+    return {
+      ready,
+      riskUniverseOk: riskCheck.allowed,
+      riskUniverseMessage: riskCheck.message,
+      hasBalance: balanceCheck.hasBalance,
+      equity: balanceCheck.equity,
+      builderFeeApproved,
+      builderAddress: this.config.builderAddress,
+      builderFeeBps: this.config.builderFeeTenthsBps / 10
+    };
+  }
+  /**
+   * Run full onboarding: check status and auto-approve builder fee if needed.
+   * Returns the final status after all actions.
+   */
+  async onboard(riskUniverse) {
+    let status = await this.checkOnboardingStatus(riskUniverse);
+    if (!status.riskUniverseOk) {
+      console.error(`Perp onboarding blocked: ${status.riskUniverseMessage}`);
+      return status;
+    }
+    if (!status.hasBalance) {
+      console.warn("No USDC balance on Hyperliquid \u2014 deposit required before trading");
+      return status;
+    }
+    if (!status.builderFeeApproved) {
+      console.log("Approving builder fee...");
+      const approved = await this.approveBuilderFee();
+      if (approved) {
+        status = { ...status, builderFeeApproved: true, ready: true };
+      }
+    }
+    if (status.ready) {
+      console.log(`Perp onboarding complete \u2014 equity: $${status.equity.toFixed(2)}`);
+    }
+    return status;
+  }
+};
+
+// src/perp/funding.ts
+var import_viem5 = require("viem");
+var import_chains3 = require("viem/chains");
+var import_accounts4 = require("viem/accounts");
+var ERC20_ABI = (0, import_viem5.parseAbi)([
+  "function approve(address spender, uint256 amount) external returns (bool)",
+  "function balanceOf(address account) external view returns (uint256)",
+  "function allowance(address owner, address spender) external view returns (uint256)"
+]);
+var TOKEN_MESSENGER_V2_ABI = (0, import_viem5.parseAbi)([
+  "function depositForBurn(uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken) external returns (uint64 nonce)",
+  "event DepositForBurn(uint64 indexed nonce, address indexed burnToken, uint256 amount, address indexed depositor, bytes32 mintRecipient, uint32 destinationDomain, bytes32 destinationTokenMessenger, bytes32 destinationCaller)"
+]);
+var MESSAGE_TRANSMITTER_V2_ABI = (0, import_viem5.parseAbi)([
+  "function receiveMessage(bytes message, bytes attestation) external returns (bool success)",
+  "event MessageSent(bytes message)"
+]);
+var CORE_DEPOSIT_WALLET_ABI = (0, import_viem5.parseAbi)([
+  "function deposit(uint256 amount, uint32 destinationDex) external"
+]);
+
+// src/runtime.ts
+var FUNDS_LOW_THRESHOLD = 5e-3;
+var FUNDS_CRITICAL_THRESHOLD = 1e-3;
+var AgentRuntime = class {
+  config;
+  client;
+  llm;
+  strategy;
+  executor;
+  riskManager;
+  marketData;
+  vaultManager;
+  relay = null;
+  isRunning = false;
+  mode = "idle";
+  configHash;
+  cycleCount = 0;
+  lastCycleAt = 0;
+  lastPortfolioValue = 0;
+  lastEthBalance = "0";
+  processAlive = true;
+  riskUniverse = 0;
+  allowedTokens = /* @__PURE__ */ new Set();
+  // Perp trading components (null if perp not enabled)
+  perpClient = null;
+  perpSigner = null;
+  perpOrders = null;
+  perpPositions = null;
+  perpWebSocket = null;
+  perpRecorder = null;
+  perpOnboarding = null;
+  perpStrategy = null;
+  // Two-layer perp control:
+  //   perpConnected = Hyperliquid infrastructure is initialized (WS, signer, recorder ready)
+  //   perpTradingActive = Dedicated perp trading cycle is mandated to run
+  // When perpConnected && !perpTradingActive: agent's strategy can optionally return perp signals
+  // When perpConnected && perpTradingActive: dedicated runPerpCycle() runs every interval
+  perpConnected = false;
+  perpTradingActive = false;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Initialize the agent runtime
+   */
+  async initialize() {
+    console.log(`Initializing agent: ${this.config.name} (ID: ${this.config.agentId})`);
+    this.client = new import_sdk2.ExagentClient({
+      privateKey: this.config.privateKey,
+      network: this.config.network
+    });
+    console.log(`Wallet: ${this.client.address}`);
+    const agent = await this.client.registry.getAgent(BigInt(this.config.agentId));
+    if (!agent) {
+      throw new Error(`Agent ID ${this.config.agentId} not found on-chain. Please register first.`);
+    }
+    console.log(`Agent verified: ${agent.name}`);
+    await this.ensureWalletLinked();
+    await this.loadTradingRestrictions();
+    console.log(`Initializing LLM: ${this.config.llm.provider}`);
+    this.llm = await createLLMAdapter(this.config.llm);
+    const llmMeta = this.llm.getMetadata();
+    console.log(`LLM ready: ${llmMeta.provider} (${llmMeta.model})`);
+    await this.syncConfigHash();
+    this.strategy = await loadStrategy();
+    this.executor = new TradeExecutor(this.client, this.config, () => this.getConfigHash());
+    this.riskManager = new RiskManager(this.config.trading);
+    this.marketData = new MarketDataService(this.getRpcUrl());
+    await this.initializeVaultManager();
+    await this.initializePerp();
+    await this.initializeRelay();
+    console.log("Agent initialized successfully");
+  }
+  /**
+   * Initialize the relay client for command center connectivity
+   */
+  async initializeRelay() {
+    const relayConfig = this.config.relay;
+    const relayEnabled = process.env.EXAGENT_RELAY_ENABLED !== "false";
+    if (!relayConfig?.enabled || !relayEnabled) {
+      console.log("Relay: Disabled");
+      return;
+    }
+    const apiUrl = process.env.EXAGENT_API_URL || relayConfig.apiUrl;
+    if (!apiUrl) {
+      console.log("Relay: No API URL configured, skipping");
+      return;
+    }
+    this.relay = new RelayClient({
+      agentId: String(this.config.agentId),
+      privateKey: this.config.privateKey,
+      relay: {
+        ...relayConfig,
+        apiUrl
+      },
+      onCommand: (cmd) => this.handleCommand(cmd)
+    });
+    try {
+      await this.relay.connect();
+      console.log("Relay: Connected to command center");
+      this.sendRelayStatus();
+    } catch (error) {
+      console.warn(
+        "Relay: Failed to connect (agent will work locally):",
+        error instanceof Error ? error.message : error
+      );
+    }
+  }
+  /**
+   * Initialize the vault manager based on config
+   */
+  async initializeVaultManager() {
+    const vaultConfig = this.config.vault || { policy: "disabled", preferVaultTrading: false };
+    this.vaultManager = new VaultManager({
+      agentId: BigInt(this.config.agentId),
+      agentName: this.config.name,
+      network: this.config.network,
+      walletKey: this.config.privateKey,
+      vaultConfig
+    });
+    console.log(`Vault policy: ${vaultConfig.policy}`);
+    const status = await this.vaultManager.getVaultStatus();
+    if (status.hasVault) {
+      console.log(`Vault exists: ${status.vaultAddress}`);
+      console.log(`Vault TVL: ${Number(status.totalAssets) / 1e6} USDC`);
+    } else {
+      console.log("No vault exists for this agent");
+      if (vaultConfig.policy === "manual") {
+        console.log("Vault creation is manual \u2014 use the command center to create one");
+      }
+    }
+  }
+  /**
+   * Initialize Hyperliquid perp trading components.
+   * Only initializes if perp is enabled in config AND risk universe >= 2.
+   */
+  async initializePerp() {
+    const perpConfig = this.config.perp;
+    if (!perpConfig?.enabled) {
+      console.log("Perp trading: Disabled");
+      return;
+    }
+    if (this.riskUniverse < 2) {
+      console.warn(`Perp trading: Blocked by risk universe ${this.riskUniverse} (need >= 2)`);
+      return;
+    }
+    try {
+      const config = {
+        enabled: true,
+        apiUrl: perpConfig.apiUrl || "https://api.hyperliquid.xyz",
+        wsUrl: perpConfig.wsUrl || "wss://api.hyperliquid.xyz/ws",
+        builderAddress: perpConfig.builderAddress,
+        builderFeeTenthsBps: perpConfig.builderFeeTenthsBps ?? 100,
+        maxLeverage: perpConfig.maxLeverage ?? 10,
+        maxNotionalUSD: perpConfig.maxNotionalUSD ?? 5e4,
+        allowedInstruments: perpConfig.allowedInstruments
+      };
+      this.perpClient = new HyperliquidClient(config);
+      const perpKey = perpConfig.perpRelayerKey || this.config.privateKey;
+      const account = (0, import_accounts5.privateKeyToAccount)(perpKey);
+      const walletClient = (0, import_viem6.createWalletClient)({
+        chain: { id: 42161, name: "Arbitrum", nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 }, rpcUrls: { default: { http: ["https://arb1.arbitrum.io/rpc"] } } },
+        transport: (0, import_viem6.http)("https://arb1.arbitrum.io/rpc"),
+        account
+      });
+      this.perpSigner = new HyperliquidSigner(walletClient);
+      this.perpOrders = new OrderManager(this.perpClient, this.perpSigner, config);
+      this.perpPositions = new PositionManager(this.perpClient, this.perpSigner.getAddress());
+      this.perpOnboarding = new PerpOnboarding(this.perpClient, this.perpSigner, config);
+      const recorderKey = perpConfig.perpRelayerKey || this.config.privateKey;
+      this.perpRecorder = new PerpTradeRecorder({
+        privateKey: recorderKey,
+        rpcUrl: this.getRpcUrl(),
+        agentId: BigInt(this.config.agentId),
+        configHash: this.configHash
+      });
+      this.perpWebSocket = new HyperliquidWebSocket(config, this.perpSigner.getAddress(), this.perpClient);
+      this.perpWebSocket.onFillReceived(async (fill) => {
+        console.log(`Perp fill: ${fill.coin} ${fill.side === "B" ? "LONG" : "SHORT"} ${fill.sz}@${fill.px}`);
+        const result = await this.perpRecorder.recordFill(fill);
+        if (result.success) {
+          this.relay?.sendMessage(
+            "perp_fill",
+            "success",
+            "Perp Fill",
+            `${fill.coin} ${fill.side === "B" ? "LONG" : "SHORT"} ${fill.sz} @ $${fill.px}`,
+            { instrument: fill.coin, side: fill.side, size: fill.sz, price: fill.px, txHash: result.txHash }
+          );
+        }
+      });
+      this.perpWebSocket.onLiquidationDetected((instrument, size) => {
+        console.error(`LIQUIDATION: ${instrument} position (${size}) was liquidated`);
+        this.relay?.sendMessage(
+          "perp_liquidation_warning",
+          "error",
+          "Position Liquidated",
+          `${instrument} position of ${Math.abs(size)} was liquidated.`,
+          { instrument, size }
+        );
+      });
+      this.perpWebSocket.onFundingReceived((funding) => {
+        const amount = parseFloat(funding.usdc);
+        if (Math.abs(amount) > 0.01) {
+          this.relay?.sendMessage(
+            "perp_funding",
+            "info",
+            "Funding Payment",
+            `${funding.coin}: ${amount > 0 ? "+" : ""}$${amount.toFixed(4)}`,
+            { instrument: funding.coin, amount: funding.usdc, rate: funding.fundingRate }
+          );
+        }
+      });
+      const onboardingStatus = await this.perpOnboarding.onboard(this.riskUniverse);
+      if (!onboardingStatus.ready) {
+        console.warn(`Perp onboarding incomplete \u2014 trading will be limited`);
+        if (!onboardingStatus.hasBalance) {
+          console.warn("  No USDC balance on Hyperliquid \u2014 deposit required");
+        }
+        if (!onboardingStatus.builderFeeApproved) {
+          console.warn("  Builder fee not approved \u2014 orders may fail");
+        }
+      }
+      try {
+        await this.perpWebSocket.connect();
+        console.log("Perp WebSocket: Connected");
+      } catch (error) {
+        console.warn("Perp WebSocket: Failed to connect (will retry):", error instanceof Error ? error.message : error);
+      }
+      this.perpConnected = true;
+      console.log(`Hyperliquid: Connected (${config.allowedInstruments?.join(", ") || "all instruments"})`);
+      console.log(`  Builder: ${config.builderAddress} (${config.builderFeeTenthsBps / 10} bps)`);
+      console.log(`  Max leverage: ${config.maxLeverage}x, Max notional: $${config.maxNotionalUSD.toLocaleString()}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Perp initialization failed: ${message}`);
+      console.warn("Perp trading will be disabled for this session");
+    }
+  }
+  /**
+   * Ensure the current wallet is linked to the agent.
+   * If the trading wallet differs from the owner, enters a recovery loop
+   * that waits for the owner to link it from the website.
+   */
+  async ensureWalletLinked() {
+    const agentId = BigInt(this.config.agentId);
+    const address = this.client.address;
+    const isLinked = await this.client.registry.isLinkedWallet(agentId, address);
+    if (!isLinked) {
+      console.log("Wallet not linked, linking now...");
+      const agent = await this.client.registry.getAgent(agentId);
+      if (agent?.owner.toLowerCase() !== address.toLowerCase()) {
+        const ccUrl = `https://exagent.io/agents/${encodeURIComponent(this.config.name)}/command-center`;
+        const nonce = await this.client.registry.getNonce(address);
+        const linkMessage = import_sdk2.ExagentRegistry.generateLinkMessage(
+          address,
+          agentId,
           nonce
         );
         const linkSignature = await this.client.signMessage({ raw: linkMessage });
@@ -2266,10 +3739,10 @@ var AgentRuntime = class {
         const message = error instanceof Error ? error.message : String(error);
         if (message.includes("insufficient funds") || message.includes("gas") || message.includes("intrinsic gas too low") || message.includes("exceeds the balance")) {
           const ccUrl = `https://exagent.io/agents/${encodeURIComponent(this.config.name)}/command-center`;
-          const chain = import_chains2.base;
-          const publicClientInstance = (0, import_viem3.createPublicClient)({
+          const chain = import_chains4.base;
+          const publicClientInstance = (0, import_viem6.createPublicClient)({
             chain,
-            transport: (0, import_viem3.http)(this.getRpcUrl())
+            transport: (0, import_viem6.http)(this.getRpcUrl())
           });
           console.log("");
           console.log("=== ETH NEEDED FOR GAS ===");
@@ -2480,6 +3953,131 @@ var AgentRuntime = class {
           }
           break;
         }
+        case "enable_hyperliquid":
+          if (this.perpConnected) {
+            this.relay?.sendCommandResult(cmd.id, true, "Hyperliquid already connected");
+            break;
+          }
+          if (!this.config.perp?.enabled) {
+            this.relay?.sendCommandResult(cmd.id, false, "Perp trading not configured in agent config");
+            break;
+          }
+          if (this.riskUniverse < 2) {
+            this.relay?.sendCommandResult(cmd.id, false, `Risk universe ${this.riskUniverse} too low (need >= 2)`);
+            break;
+          }
+          try {
+            await this.initializePerp();
+            if (this.perpConnected) {
+              this.relay?.sendCommandResult(cmd.id, true, "Hyperliquid connected");
+              this.relay?.sendMessage(
+                "system",
+                "success",
+                "Hyperliquid Enabled",
+                'Hyperliquid infrastructure connected. Agent can now include perp signals in its strategy. Use "Start Perp Trading" to mandate a dedicated perp cycle.'
+              );
+            } else {
+              this.relay?.sendCommandResult(cmd.id, false, "Failed to connect to Hyperliquid");
+            }
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.relay?.sendCommandResult(cmd.id, false, `Hyperliquid init failed: ${msg}`);
+          }
+          this.sendRelayStatus();
+          break;
+        case "disable_hyperliquid":
+          if (!this.perpConnected) {
+            this.relay?.sendCommandResult(cmd.id, true, "Hyperliquid already disconnected");
+            break;
+          }
+          this.perpTradingActive = false;
+          if (this.perpWebSocket) {
+            this.perpWebSocket.disconnect();
+          }
+          if (this.perpRecorder) {
+            this.perpRecorder.stop();
+          }
+          this.perpConnected = false;
+          console.log("Hyperliquid disabled via command center");
+          this.relay?.sendCommandResult(cmd.id, true, "Hyperliquid disconnected");
+          this.relay?.sendMessage(
+            "system",
+            "info",
+            "Hyperliquid Disabled",
+            "Hyperliquid infrastructure disconnected. Agent will trade spot only."
+          );
+          this.sendRelayStatus();
+          break;
+        case "start_perp_trading":
+          if (!this.perpConnected) {
+            this.relay?.sendCommandResult(cmd.id, false, "Hyperliquid not connected. Enable Hyperliquid first.");
+            break;
+          }
+          if (this.perpTradingActive) {
+            this.relay?.sendCommandResult(cmd.id, true, "Perp trading already active");
+            break;
+          }
+          this.perpTradingActive = true;
+          if (this.mode !== "trading") {
+            this.mode = "trading";
+            this.isRunning = true;
+          }
+          console.log("Perp trading mandated via command center");
+          this.relay?.sendCommandResult(cmd.id, true, "Perp trading cycle active");
+          this.relay?.sendMessage(
+            "system",
+            "success",
+            "Perp Trading Active",
+            "Dedicated perp trading cycle is now running every interval."
+          );
+          this.sendRelayStatus();
+          break;
+        case "stop_perp_trading":
+          if (!this.perpTradingActive) {
+            this.relay?.sendCommandResult(cmd.id, true, "Perp trading already stopped");
+            break;
+          }
+          this.perpTradingActive = false;
+          console.log("Perp trading cycle stopped via command center");
+          this.relay?.sendCommandResult(cmd.id, true, "Perp trading cycle stopped");
+          this.relay?.sendMessage(
+            "system",
+            "info",
+            "Perp Trading Stopped",
+            "Dedicated perp cycle stopped. Hyperliquid remains connected \u2014 strategy can still include perp signals."
+          );
+          this.sendRelayStatus();
+          break;
+        case "update_perp_params": {
+          const perpParams = cmd.params || {};
+          let perpUpdated = false;
+          if (this.config.perp && perpParams.maxLeverage !== void 0) {
+            const val = Number(perpParams.maxLeverage);
+            if (val >= 1 && val <= 50) {
+              this.config.perp.maxLeverage = val;
+              perpUpdated = true;
+            }
+          }
+          if (this.config.perp && perpParams.maxNotionalUSD !== void 0) {
+            const val = Number(perpParams.maxNotionalUSD);
+            if (val >= 100) {
+              this.config.perp.maxNotionalUSD = val;
+              perpUpdated = true;
+            }
+          }
+          if (perpUpdated) {
+            this.relay?.sendCommandResult(cmd.id, true, "Perp parameters updated");
+            this.relay?.sendMessage(
+              "config_updated",
+              "info",
+              "Perp Params Updated",
+              `Max leverage: ${this.config.perp?.maxLeverage}x, Max notional: $${this.config.perp?.maxNotionalUSD?.toLocaleString()}`
+            );
+          } else {
+            this.relay?.sendCommandResult(cmd.id, false, "No valid perp parameters provided");
+          }
+          break;
+        }
         case "refresh_status":
           this.sendRelayStatus();
           this.relay?.sendCommandResult(cmd.id, true, "Status refreshed");
@@ -2534,8 +4132,33 @@ var AgentRuntime = class {
         policy: vaultConfig.policy,
         hasVault: false,
         vaultAddress: null
-      }
+      },
+      perp: this.perpConnected ? {
+        enabled: true,
+        trading: this.perpTradingActive,
+        equity: 0,
+        unrealizedPnl: 0,
+        marginUsed: 0,
+        openPositions: 0,
+        effectiveLeverage: 0,
+        pendingRecords: this.perpRecorder?.pendingRetries ?? 0
+      } : void 0
     };
+    if (this.perpConnected && this.perpPositions && status.perp) {
+      this.perpPositions.getAccountSummary().then((account) => {
+        if (status.perp) {
+          status.perp.equity = account.totalEquity;
+          status.perp.unrealizedPnl = account.totalUnrealizedPnl;
+          status.perp.marginUsed = account.totalMarginUsed;
+          status.perp.effectiveLeverage = account.effectiveLeverage;
+        }
+      }).catch(() => {
+      });
+      this.perpPositions.getPositionCount().then((count) => {
+        if (status.perp) status.perp.openPositions = count;
+      }).catch(() => {
+      });
+    }
     this.relay.sendHeartbeat(status);
   }
   /**
@@ -2634,8 +4257,75 @@ var AgentRuntime = class {
       const postNativeEthBal = postTradeData.balances[NATIVE_ETH.toLowerCase()] || BigInt(0);
       this.lastEthBalance = (Number(postNativeEthBal) / 1e18).toFixed(6);
     }
+    if (this.perpConnected && this.perpTradingActive) {
+      try {
+        await this.runPerpCycle();
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error("Error in perp cycle:", message);
+        this.relay?.sendMessage("system", "error", "Perp Cycle Error", message);
+      }
+    }
     this.sendRelayStatus();
   }
+  /**
+   * Run a single perp trading cycle.
+   * Fetches market data, positions, calls perp strategy, applies risk filters, executes.
+   * Fills arrive async via WebSocket and are auto-recorded on Base.
+   */
+  async runPerpCycle() {
+    if (!this.perpClient || !this.perpPositions || !this.perpOrders || !this.perpConnected) return;
+    const perpConfig = this.config.perp;
+    if (!perpConfig?.enabled) return;
+    console.log("  [PERP] Running perp cycle...");
+    const [positions, account] = await Promise.all([
+      this.perpPositions.getPositions(true),
+      this.perpPositions.getAccountSummary(true)
+    ]);
+    console.log(`  [PERP] Equity: $${account.totalEquity.toFixed(2)}, Positions: ${positions.length}, Leverage: ${account.effectiveLeverage.toFixed(1)}x`);
+    const dangerousPositions = await this.perpPositions.getDangerousPositions(0.7);
+    for (const pos of dangerousPositions) {
+      console.warn(`  [PERP] WARNING: ${pos.instrument} near liquidation`);
+      this.relay?.sendMessage(
+        "perp_liquidation_warning",
+        "warning",
+        "Near Liquidation",
+        `${pos.instrument} ${pos.size > 0 ? "LONG" : "SHORT"} \u2014 close to liquidation price $${pos.liquidationPrice.toFixed(2)}`,
+        { instrument: pos.instrument, liquidationPrice: pos.liquidationPrice, markPrice: pos.markPrice }
+      );
+    }
+    const instruments = perpConfig.allowedInstruments || ["ETH", "BTC", "SOL"];
+    const marketData = await this.perpClient.getMarketData(instruments);
+    if (!this.perpStrategy) {
+      return;
+    }
+    let signals;
+    try {
+      signals = await this.perpStrategy(marketData, positions, account, this.llm, this.config);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("  [PERP] Strategy error:", message);
+      return;
+    }
+    console.log(`  [PERP] Strategy generated ${signals.length} signals`);
+    const maxLeverage = perpConfig.maxLeverage ?? 10;
+    const maxNotionalUSD = perpConfig.maxNotionalUSD ?? 5e4;
+    const filteredSignals = this.riskManager.filterPerpSignals(signals, positions, account, maxLeverage, maxNotionalUSD);
+    console.log(`  [PERP] ${filteredSignals.length} signals passed risk checks`);
+    for (const signal of filteredSignals) {
+      if (signal.action === "hold") continue;
+      if (signal.price === 0) {
+        const md = marketData.find((m) => m.instrument === signal.instrument);
+        if (md) signal.price = md.midPrice;
+      }
+      const result = await this.perpOrders.placeOrder(signal);
+      if (result.success) {
+        console.log(`  [PERP] Order placed: ${signal.instrument} ${signal.action} \u2014 ${result.status}`);
+      } else {
+        console.warn(`  [PERP] Order failed: ${signal.instrument} ${signal.action} \u2014 ${result.error}`);
+      }
+    }
+  }
   /**
    * Check if ETH balance is below threshold and notify.
    * Returns true if trading should continue, false if ETH is critically low.
@@ -2681,6 +4371,12 @@ var AgentRuntime = class {
     this.isRunning = false;
     this.processAlive = false;
     this.mode = "idle";
+    if (this.perpWebSocket) {
+      this.perpWebSocket.disconnect();
+    }
+    if (this.perpRecorder) {
+      this.perpRecorder.stop();
+    }
     if (this.relay) {
       this.relay.disconnect();
     }
@@ -2830,7 +4526,7 @@ var AgentRuntime = class {
 };
 
 // src/cli.ts
-var import_accounts3 = require("viem/accounts");
+var import_accounts6 = require("viem/accounts");
 
 // src/secure-env.ts
 var crypto = __toESM(require("crypto"));
@@ -3093,8 +4789,8 @@ async function checkFirstRunSetup(configPath) {
   if (walletSetup === "generate") {
     console.log("[WALLET] Generating a new wallet for your agent...");
     console.log("");
-    const generatedKey = (0, import_accounts3.generatePrivateKey)();
-    const account = (0, import_accounts3.privateKeyToAccount)(generatedKey);
+    const generatedKey = (0, import_accounts6.generatePrivateKey)();
+    const account = (0, import_accounts6.privateKeyToAccount)(generatedKey);
     privateKey = generatedKey;
     walletAddress = account.address;
     console.log("  New wallet created!");
@@ -3124,7 +4820,7 @@ async function checkFirstRunSetup(configPath) {
       process.exit(1);
     }
     try {
-      const account = (0, import_accounts3.privateKeyToAccount)(privateKey);
+      const account = (0, import_accounts6.privateKeyToAccount)(privateKey);
       walletAddress = account.address;
       console.log("");
       console.log(`  Wallet address: ${walletAddress}`);