@exagent/agent 0.1.39 → 0.1.41

package/dist/cli.js

@@ -3398,9 +3398,9 @@ var path7 = __toESM(require("path"));
 
 // src/runtime.ts
 var import_sdk = require("@exagent/sdk");
-var import_viem7 = require("viem");
-var import_chains5 = require("viem/chains");
-var import_accounts5 = require("viem/accounts");
+var import_viem11 = require("viem");
+var import_chains8 = require("viem/chains");
+var import_accounts8 = require("viem/accounts");
 
 // src/position-tracker.ts
 init_market();
@@ -4000,6 +4000,49 @@ var PerpConfigSchema = import_zod.z.object({
   /** 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 PredictionConfigSchema = import_zod.z.object({
+  /** Enable prediction market trading */
+  enabled: import_zod.z.boolean().default(false),
+  /** Polymarket CLOB API URL */
+  clobApiUrl: import_zod.z.string().url().default("https://clob.polymarket.com"),
+  /** Gamma API URL for market discovery */
+  gammaApiUrl: import_zod.z.string().url().default("https://gamma-api.polymarket.com"),
+  /** Polygon RPC URL */
+  polygonRpcUrl: import_zod.z.string().url().optional(),
+  /** CLOB API key (L2 auth) — derived from wallet signature if not provided */
+  clobApiKey: import_zod.z.string().optional(),
+  /** CLOB API secret (L2 auth) */
+  clobApiSecret: import_zod.z.string().optional(),
+  /** CLOB API passphrase (L2 auth) */
+  clobApiPassphrase: import_zod.z.string().optional(),
+  /** Private key for the prediction relayer (calls recordPerpTrade on Base). Falls back to agent wallet. */
+  predictionRelayerKey: import_zod.z.string().optional(),
+  /** Maximum notional per trade in USD (default: 500) */
+  maxNotionalUSD: import_zod.z.number().min(1).default(500),
+  /** Maximum total exposure across all markets in USD (default: 5000) */
+  maxTotalExposureUSD: import_zod.z.number().min(1).default(5e3),
+  /** Target USDC allocation on Polygon in USD (default: 100) */
+  polygonAllocationUSD: import_zod.z.number().min(1).default(100),
+  /** Allowed market categories (empty = all categories) */
+  allowedCategories: import_zod.z.array(import_zod.z.string()).optional(),
+  /** Fee bridge threshold in USD — accumulated fees are bridged to Base when exceeded (default: 10) */
+  feeBridgeThresholdUSD: import_zod.z.number().min(1).default(10),
+  /** Prediction vault configuration (ERC-4626 + ERC-1271 on Polygon) */
+  vault: import_zod.z.object({
+    /** Enable vault mode for prediction trading */
+    enabled: import_zod.z.boolean().default(false),
+    /** PredictionVaultFactory address on Polygon */
+    factoryAddress: import_zod.z.string(),
+    /** PredictionFeeCollector address on Polygon */
+    feeCollectorAddress: import_zod.z.string().optional(),
+    /** Existing vault address (if already created) */
+    vaultAddress: import_zod.z.string().optional(),
+    /** Agent's fee recipient address */
+    feeRecipient: import_zod.z.string().optional(),
+    /** Whether agent is verified (higher deposit cap) */
+    isVerified: import_zod.z.boolean().default(false)
+  }).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()]),
@@ -4019,6 +4062,8 @@ var AgentConfigSchema = import_zod.z.object({
   relay: RelayConfigSchema,
   // Perp trading configuration (Hyperliquid)
   perp: PerpConfigSchema,
+  // Prediction market configuration (Polymarket)
+  prediction: PredictionConfigSchema,
   // Allowed tokens (addresses)
   allowedTokens: import_zod.z.array(import_zod.z.string()).optional()
 });
@@ -4118,13 +4163,6 @@ var VAULT_FACTORY_ABI = [
     outputs: [{ type: "address" }],
     stateMutability: "view"
   },
-  {
-    type: "function",
-    name: "canCreateVault",
-    inputs: [{ name: "creator", type: "address" }],
-    outputs: [{ name: "canCreate", type: "bool" }, { name: "reason", type: "string" }],
-    stateMutability: "view"
-  },
   {
     type: "function",
     name: "createVault",
@@ -4141,10 +4179,17 @@ var VAULT_FACTORY_ABI = [
   },
   {
     type: "function",
-    name: "minimumVeEXARequired",
+    name: "MIN_SEED_AMOUNT",
     inputs: [],
     outputs: [{ type: "uint256" }],
     stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "allowedAssets",
+    inputs: [{ name: "asset", type: "address" }],
+    outputs: [{ type: "bool" }],
+    stateMutability: "view"
   }
 ];
 var VAULT_ABI = [
@@ -4242,23 +4287,34 @@ var VaultManager = class {
       } catch {
       }
     }
-    const [canCreateResult, requirements] = await Promise.all([
-      this.publicClient.readContract({
-        address: this.addresses.vaultFactory,
-        abi: VAULT_FACTORY_ABI,
-        functionName: "canCreateVault",
-        args: [this.account.address]
-      }),
-      this.getRequirements()
-    ]);
+    let canCreate = true;
+    let cannotCreateReason = null;
+    if (hasVault) {
+      canCreate = false;
+      cannotCreateReason = "Vault already exists for this agent";
+    } else {
+      try {
+        const isAssetAllowed = await this.publicClient.readContract({
+          address: this.addresses.vaultFactory,
+          abi: VAULT_FACTORY_ABI,
+          functionName: "allowedAssets",
+          args: [this.addresses.usdc]
+        });
+        if (!isAssetAllowed) {
+          canCreate = false;
+          cannotCreateReason = "USDC is not an allowed asset on the vault factory";
+        }
+      } catch {
+      }
+    }
     return {
       hasVault,
       vaultAddress,
       totalAssets,
-      canCreateVault: canCreateResult[0],
-      cannotCreateReason: canCreateResult[0] ? null : canCreateResult[1],
-      requirementsMet: canCreateResult[0] || requirements.isBypassed,
-      requirements
+      canCreateVault: canCreate,
+      cannotCreateReason,
+      requirementsMet: canCreate,
+      requirements: { isBypassed: true }
     };
   }
   /**
@@ -4306,11 +4362,67 @@ var VaultManager = class {
     if (existingVault) {
       return { success: false, error: "Vault already exists", vaultAddress: existingVault };
     }
-    const status = await this.getVaultStatus();
-    if (!status.canCreateVault) {
-      return { success: false, error: status.cannotCreateReason || "Requirements not met" };
-    }
     const seed = seedAmount || BigInt(1e8);
+    let usdcBalance;
+    try {
+      usdcBalance = await this.publicClient.readContract({
+        address: this.addresses.usdc,
+        abi: import_viem3.erc20Abi,
+        functionName: "balanceOf",
+        args: [this.account.address]
+      });
+    } catch {
+      return { success: false, error: "Failed to read USDC balance" };
+    }
+    if (usdcBalance < seed) {
+      const needed = Number(seed) / 1e6;
+      const have = Number(usdcBalance) / 1e6;
+      return {
+        success: false,
+        error: `Insufficient USDC: need ${needed} USDC seed but wallet has ${have} USDC. Fund ${this.account.address} with at least ${needed} USDC and retry.`
+      };
+    }
+    try {
+      const isAllowed = await this.publicClient.readContract({
+        address: this.addresses.vaultFactory,
+        abi: VAULT_FACTORY_ABI,
+        functionName: "allowedAssets",
+        args: [this.addresses.usdc]
+      });
+      if (!isAllowed) {
+        return { success: false, error: "USDC is not whitelisted on the vault factory. Contact protocol admin." };
+      }
+    } catch {
+    }
+    try {
+      const currentAllowance = await this.publicClient.readContract({
+        address: this.addresses.usdc,
+        abi: import_viem3.erc20Abi,
+        functionName: "allowance",
+        args: [this.account.address, this.addresses.vaultFactory]
+      });
+      if (currentAllowance < seed) {
+        console.log(`Approving ${Number(seed) / 1e6} USDC to VaultFactory...`);
+        const approveHash = await this.walletClient.writeContract({
+          address: this.addresses.usdc,
+          abi: import_viem3.erc20Abi,
+          functionName: "approve",
+          args: [this.addresses.vaultFactory, seed],
+          chain: import_chains2.base,
+          account: this.account
+        });
+        const approveReceipt = await this.publicClient.waitForTransactionReceipt({ hash: approveHash });
+        if (approveReceipt.status !== "success") {
+          return { success: false, error: "USDC approval transaction failed" };
+        }
+        console.log("USDC approved successfully");
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: `USDC approval failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      };
+    }
     const vaultName = this.config.vaultConfig.defaultName || `${this.config.agentName} Trading Vault`;
     const vaultSymbol = this.config.vaultConfig.defaultSymbol || `ex${this.config.agentName.replace(/[^a-zA-Z]/g, "").slice(0, 4).toUpperCase()}`;
     const feeRecipient = this.config.vaultConfig.feeRecipient || this.account.address;
@@ -4332,8 +4444,9 @@ var VaultManager = class {
       });
       const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
       if (receipt.status !== "success") {
-        return { success: false, error: "Transaction failed", txHash: hash };
+        return { success: false, error: "createVault transaction reverted on-chain", txHash: hash };
       }
+      this.lastVaultCheck = 0;
       const vaultAddress = await this.getVaultAddress();
       this.cachedVaultAddress = vaultAddress;
       return {
@@ -4342,10 +4455,23 @@ var VaultManager = class {
         txHash: hash
       };
     } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
+      const msg = error instanceof Error ? error.message : "Unknown error";
+      if (msg.includes("NotAgentOwner")) {
+        return { success: false, error: "This wallet is not the owner of the agent. Only the agent owner can create a fund." };
+      }
+      if (msg.includes("InsufficientStake")) {
+        return { success: false, error: "Staking requirement not met. This should not happen with StakingStub \u2014 contact protocol admin." };
+      }
+      if (msg.includes("FrontierCannotCreateVault")) {
+        return { success: false, error: "Frontier-risk agents cannot create funds. Change the agent risk universe first." };
+      }
+      if (msg.includes("VaultAlreadyExists")) {
+        return { success: false, error: "A fund already exists for this agent and asset." };
+      }
+      if (msg.includes("InsufficientSeed")) {
+        return { success: false, error: `Seed amount too low. Minimum is 100 USDC.` };
+      }
+      return { success: false, error: msg };
     }
   }
   /**
@@ -4390,7 +4516,7 @@ var VaultManager = class {
 
 // src/relay.ts
 var import_ws2 = __toESM(require("ws"));
-var import_accounts4 = require("viem/accounts");
+var import_accounts7 = require("viem/accounts");
 
 // src/index.ts
 init_store();
@@ -5643,172 +5769,1979 @@ var CORE_DEPOSIT_WALLET_ABI = (0, import_viem6.parseAbi)([
   "function deposit(uint256 amount, uint32 destinationDex) external"
 ]);
 
-// src/secure-env.ts
-var crypto = __toESM(require("crypto"));
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-var ALGORITHM = "aes-256-gcm";
-var PBKDF2_ITERATIONS = 1e5;
-var SALT_LENGTH = 32;
-var IV_LENGTH = 16;
-var KEY_LENGTH = 32;
-var SENSITIVE_PATTERNS = [
-  /PRIVATE_KEY$/i,
-  /_API_KEY$/i,
-  /API_KEY$/i,
-  /_SECRET$/i,
-  /^OPENAI_API_KEY$/i,
-  /^ANTHROPIC_API_KEY$/i,
-  /^GOOGLE_AI_API_KEY$/i,
-  /^DEEPSEEK_API_KEY$/i,
-  /^MISTRAL_API_KEY$/i,
-  /^GROQ_API_KEY$/i,
-  /^TOGETHER_API_KEY$/i
-];
-function isSensitiveKey(key) {
-  return SENSITIVE_PATTERNS.some((pattern) => pattern.test(key));
-}
-function deriveKey(passphrase, salt) {
-  return crypto.pbkdf2Sync(passphrase, salt, PBKDF2_ITERATIONS, KEY_LENGTH, "sha256");
-}
-function encryptValue(value, key) {
-  const iv = crypto.randomBytes(IV_LENGTH);
-  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
-  let encrypted = cipher.update(value, "utf8", "hex");
-  encrypted += cipher.final("hex");
-  const tag = cipher.getAuthTag();
-  return {
-    iv: iv.toString("hex"),
-    encrypted,
-    tag: tag.toString("hex")
-  };
-}
-function decryptValue(encrypted, key, iv, tag) {
-  const decipher = crypto.createDecipheriv(
-    ALGORITHM,
-    key,
-    Buffer.from(iv, "hex")
-  );
-  decipher.setAuthTag(Buffer.from(tag, "hex"));
-  let decrypted = decipher.update(encrypted, "hex", "utf8");
-  decrypted += decipher.final("utf8");
-  return decrypted;
-}
-function parseEnvFile(content) {
-  const entries = [];
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-    const eqIndex = trimmed.indexOf("=");
-    if (eqIndex === -1) continue;
-    const key = trimmed.slice(0, eqIndex).trim();
-    let value = trimmed.slice(eqIndex + 1).trim();
-    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-      value = value.slice(1, -1);
-    }
-    if (key && value) {
-      entries.push({ key, value });
-    }
+// src/prediction/types.ts
+var DEFAULT_PREDICTION_CONFIG = {
+  clobApiUrl: "https://clob.polymarket.com",
+  gammaApiUrl: "https://gamma-api.polymarket.com",
+  polygonRpcUrl: "https://polygon-rpc.com",
+  maxNotionalUSD: 1e3,
+  maxTotalExposureUSD: 5e3,
+  polygonAllocationUSD: 100,
+  feeBridgeThresholdUSD: 10
+};
+var POLYGON_CHAIN_ID = 137;
+var POLYMARKET_SIGNATURE_TYPE_EOA = 0;
+var POLYMARKET_SIGNATURE_TYPE_GNOSIS_SAFE = 1;
+var POLYGON_USDC_ADDRESS = "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359";
+var POLYGON_TOKEN_MESSENGER_V2 = "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d";
+var POLYGON_MESSAGE_TRANSMITTER_V2 = "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64";
+var CCTP_DOMAIN_BASE = 6;
+var CCTP_DOMAIN_POLYGON = 7;
+var PREDICTION_INSTRUMENT_PREFIX = "POLY:";
+
+// src/prediction/client.ts
+var import_clob_client = require("@polymarket/clob-client");
+var import_ethers = require("ethers");
+var PolymarketClient = class {
+  config;
+  clobClient = null;
+  apiCreds = null;
+  signer;
+  walletAddress;
+  /** Vault mode: when true, orders use maker=vaultAddress with POLY_GNOSIS_SAFE signature type */
+  vaultMode;
+  /** Vault contract address (only set in vault mode) */
+  vaultAddress;
+  /** Cache for Gamma API market data (conditionId -> market) */
+  marketCache = /* @__PURE__ */ new Map();
+  CACHE_TTL_MS = 6e4;
+  // 60 seconds
+  constructor(privateKey, config, vaultOpts) {
+    this.config = { ...DEFAULT_PREDICTION_CONFIG, ...config };
+    this.signer = new import_ethers.Wallet(privateKey);
+    this.walletAddress = this.signer.address;
+    this.vaultMode = vaultOpts?.vaultMode ?? false;
+    this.vaultAddress = vaultOpts?.vaultAddress;
   }
-  return entries;
-}
-function encryptEnvFile(envPath, passphrase, deleteOriginal = false) {
-  if (!fs.existsSync(envPath)) {
-    throw new Error(`File not found: ${envPath}`);
+  // ============================================================
+  // INITIALIZATION
+  // ============================================================
+  /**
+   * Initialize the CLOB client with L2 API credentials.
+   * Must be called once before placing orders.
+   */
+  async initialize() {
+    const initClient = new import_clob_client.ClobClient(
+      this.config.clobApiUrl,
+      POLYGON_CHAIN_ID,
+      this.signer
+    );
+    this.apiCreds = await initClient.createOrDeriveApiKey();
+    const signatureType = this.vaultMode ? POLYMARKET_SIGNATURE_TYPE_GNOSIS_SAFE : POLYMARKET_SIGNATURE_TYPE_EOA;
+    this.clobClient = new import_clob_client.ClobClient(
+      this.config.clobApiUrl,
+      POLYGON_CHAIN_ID,
+      this.signer,
+      this.apiCreds,
+      signatureType
+    );
+    if (this.vaultMode) {
+      console.log(`Polymarket CLOB initialized in VAULT MODE \u2014 maker: ${this.vaultAddress}, signer: ${this.walletAddress}`);
+    } else {
+      console.log(`Polymarket CLOB initialized for ${this.walletAddress}`);
+    }
   }
-  const content = fs.readFileSync(envPath, "utf-8");
-  const entries = parseEnvFile(content);
-  if (entries.length === 0) {
-    throw new Error("No environment variables found in file");
+  /**
+   * Check if the client is initialized with CLOB credentials.
+   */
+  get isInitialized() {
+    return this.clobClient !== null && this.apiCreds !== null;
   }
-  const salt = crypto.randomBytes(SALT_LENGTH);
-  const key = deriveKey(passphrase, salt);
-  const encryptedEntries = entries.map(({ key: envKey, value }) => {
-    if (isSensitiveKey(envKey)) {
-      const { iv, encrypted, tag } = encryptValue(value, key);
-      return {
-        key: envKey,
-        value: encrypted,
-        encrypted: true,
-        iv,
-        tag
-      };
-    }
+  // ============================================================
+  // CLOB API — ORDER BOOK & PRICES
+  // ============================================================
+  /**
+   * Get the order book for a specific outcome token.
+   */
+  async getOrderBook(tokenId) {
+    this.ensureInitialized();
+    const book = await this.clobClient.getOrderBook(tokenId);
     return {
-      key: envKey,
-      value,
-      encrypted: false
+      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) }))
     };
-  });
-  const encryptedEnv = {
-    version: 1,
-    salt: salt.toString("hex"),
-    entries: encryptedEntries
-  };
-  const encPath = envPath + ".enc";
-  fs.writeFileSync(encPath, JSON.stringify(encryptedEnv, null, 2), { mode: 384 });
-  if (deleteOriginal) {
-    fs.unlinkSync(envPath);
   }
-  const sensitiveCount = encryptedEntries.filter((e) => e.encrypted).length;
-  const plainCount = encryptedEntries.filter((e) => !e.encrypted).length;
-  console.log(
-    `Encrypted ${sensitiveCount} sensitive values (${plainCount} non-sensitive kept as plaintext)`
-  );
-  return encPath;
-}
-function decryptEnvFile(encPath, passphrase) {
-  if (!fs.existsSync(encPath)) {
-    throw new Error(`Encrypted env file not found: ${encPath}`);
+  /**
+   * Get the midpoint price for an outcome token.
+   */
+  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;
   }
-  const content = JSON.parse(fs.readFileSync(encPath, "utf-8"));
-  if (content.version !== 1) {
-    throw new Error(`Unsupported encrypted env version: ${content.version}`);
+  /**
+   * Get the last trade price for an outcome token.
+   */
+  async getLastTradePrice(tokenId) {
+    this.ensureInitialized();
+    const resp = await this.clobClient.getLastTradePrice(tokenId);
+    return parseFloat(resp?.price || "0");
   }
-  const salt = Buffer.from(content.salt, "hex");
-  const key = deriveKey(passphrase, salt);
-  const result = {};
-  for (const entry of content.entries) {
-    if (entry.encrypted) {
-      if (!entry.iv || !entry.tag) {
-        throw new Error(`Missing encryption metadata for ${entry.key}`);
-      }
-      try {
-        result[entry.key] = decryptValue(entry.value, key, entry.iv, entry.tag);
-      } catch {
-        throw new Error(
-          `Failed to decrypt ${entry.key}. Wrong passphrase or corrupted data.`
-        );
-      }
-    } else {
-      result[entry.key] = entry.value;
-    }
+  // ============================================================
+  // CLOB API — ORDERS
+  // ============================================================
+  /**
+   * Place a limit order on the CLOB.
+   */
+  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
+    };
   }
-  return result;
-}
-function loadSecureEnv(basePath, passphrase) {
-  const encPath = path.join(basePath, ".env.enc");
-  const envPath = path.join(basePath, ".env");
-  if (fs.existsSync(encPath)) {
-    if (!passphrase) {
-      passphrase = process.env.EXAGENT_PASSPHRASE;
-    }
-    if (!passphrase) {
-      console.warn("");
-      console.warn("WARNING: Found .env.enc but no passphrase provided.");
-      console.warn("  Set EXAGENT_PASSPHRASE environment variable or");
-      console.warn("  pass --passphrase when running the agent.");
-      console.warn("  Falling back to plaintext .env file.");
-      console.warn("");
-    } else {
-      const vars = decryptEnvFile(encPath, passphrase);
-      for (const [key, value] of Object.entries(vars)) {
-        process.env[key] = value;
-      }
+  /**
+   * Place a market order (aggressive limit at best available price).
+   */
+  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
+    };
+  }
+  /**
+   * Cancel an open order by ID.
+   */
+  async cancelOrder(orderId) {
+    this.ensureInitialized();
+    try {
+      await this.clobClient.cancelOrder({ orderID: orderId });
       return true;
+    } catch {
+      return false;
     }
   }
-  if (fs.existsSync(envPath)) {
+  /**
+   * Cancel all open orders.
+   */
+  async cancelAllOrders() {
+    this.ensureInitialized();
+    try {
+      await this.clobClient.cancelAll();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get open orders for the agent's wallet.
+   */
+  async getOpenOrders() {
+    this.ensureInitialized();
+    return this.clobClient.getOpenOrders();
+  }
+  /**
+   * Get trade history (fills) for the agent's wallet.
+   */
+  async getTradeHistory() {
+    this.ensureInitialized();
+    const trades = await this.clobClient.getTrades();
+    return (trades || []).map((t) => this.parseRawFill(t));
+  }
+  // ============================================================
+  // GAMMA API — MARKET DISCOVERY (public, no auth)
+  // ============================================================
+  /**
+   * Get active prediction markets from Gamma API.
+   */
+  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));
+  }
+  /**
+   * Get a single market by condition ID.
+   */
+  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;
+  }
+  /**
+   * Search markets by query string.
+   */
+  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));
+  }
+  /**
+   * Get trending markets sorted by volume.
+   */
+  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 ADDRESS
+  // ============================================================
+  getWalletAddress() {
+    return this.walletAddress;
+  }
+  /**
+   * Get the effective maker address for CLOB orders.
+   * In vault mode, this is the vault contract address.
+   * In normal mode, this is the agent's EOA address.
+   */
+  getMakerAddress() {
+    return this.vaultMode && this.vaultAddress ? this.vaultAddress : this.walletAddress;
+  }
+  /**
+   * Whether the client is operating in vault mode.
+   */
+  get isVaultMode() {
+    return this.vaultMode;
+  }
+  /**
+   * Get the vault address (null if not in vault mode).
+   */
+  getVaultAddress() {
+    return this.vaultAddress;
+  }
+  // ============================================================
+  // PRIVATE HELPERS
+  // ============================================================
+  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/signer.ts
+var import_viem7 = require("viem");
+function tradeIdToBytes32(tradeId) {
+  if (tradeId.startsWith("0x") && tradeId.length === 66) {
+    return tradeId;
+  }
+  return (0, import_viem7.keccak256)((0, import_viem7.encodePacked)(["string"], [tradeId]));
+}
+function encodePredictionInstrument(conditionId, outcomeIndex) {
+  return `${PREDICTION_INSTRUMENT_PREFIX}${conditionId}:${outcomeIndex}`;
+}
+function calculatePredictionFee(notionalUSD) {
+  return notionalUSD * 20n / 10000n;
+}
+
+// src/prediction/order-manager.ts
+var PredictionOrderManager = class {
+  client;
+  config;
+  /** Recent fills tracked for recording */
+  recentFills = [];
+  MAX_RECENT_FILLS = 100;
+  constructor(client, config) {
+    this.client = client;
+    this.config = config;
+  }
+  // ============================================================
+  // ORDER PLACEMENT
+  // ============================================================
+  /**
+   * Execute a prediction trade signal.
+   * Routes to limit or market order based on signal.orderType.
+   */
+  async executeSignal(signal) {
+    try {
+      const violation = this.checkRiskLimits(signal);
+      if (violation) {
+        return { success: false, status: "error", error: violation };
+      }
+      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: ${signal.marketQuestion}` };
+      }
+      const tokenId = market.outcomeTokenIds[signal.outcomeIndex];
+      if (!tokenId) {
+        return { success: false, status: "error", error: `Invalid outcome index ${signal.outcomeIndex} for market` };
+      }
+      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} @ $${signal.limitPrice} \u2014 "${signal.marketQuestion}" \u2014 order: ${result.orderId}`
+        );
+        return {
+          success: true,
+          orderId: result.orderId,
+          status: signal.orderType === "market" ? "filled" : "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 failed for "${signal.marketQuestion}":`, message);
+      return { success: false, status: "error", error: message };
+    }
+  }
+  /**
+   * Cancel an open order by ID.
+   */
+  async cancelOrder(orderId) {
+    return this.client.cancelOrder(orderId);
+  }
+  /**
+   * Cancel all open orders.
+   */
+  async cancelAllOrders() {
+    return this.client.cancelAllOrders();
+  }
+  // ============================================================
+  // FILL TRACKING
+  // ============================================================
+  /**
+   * Poll for new fills since last check.
+   * Returns fills that haven't been seen before.
+   */
+  async pollNewFills() {
+    try {
+      const allFills = await this.client.getTradeHistory();
+      const seenIds = new Set(this.recentFills.map((f) => f.tradeId));
+      const newFills = allFills.filter((f) => !seenIds.has(f.tradeId));
+      for (const fill of newFills) {
+        this.recentFills.push(fill);
+        if (this.recentFills.length > this.MAX_RECENT_FILLS) {
+          this.recentFills.shift();
+        }
+      }
+      return newFills;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("Failed to poll prediction fills:", message);
+      return [];
+    }
+  }
+  /**
+   * Get recent fills (from local cache).
+   */
+  getRecentFills() {
+    return [...this.recentFills];
+  }
+  // ============================================================
+  // RISK CHECKS
+  // ============================================================
+  /**
+   * Check if a signal violates risk limits.
+   * Returns error string if violated, null if OK.
+   */
+  checkRiskLimits(signal) {
+    if (signal.amount > this.config.maxNotionalUSD) {
+      return `Trade amount $${signal.amount} exceeds max notional $${this.config.maxNotionalUSD}`;
+    }
+    if (signal.limitPrice <= 0 || signal.limitPrice >= 1) {
+      return `Limit price ${signal.limitPrice} out of bounds (must be 0.01-0.99)`;
+    }
+    if (signal.confidence < 0.3) {
+      return `Confidence ${signal.confidence} below minimum threshold (0.3)`;
+    }
+    if (this.config.allowedCategories && this.config.allowedCategories.length > 0) {
+    }
+    return null;
+  }
+};
+
+// src/prediction/position-manager.ts
+var PredictionPositionManager = class {
+  client;
+  config;
+  /** Local position tracking (conditionId:outcomeIndex -> position data) */
+  positions = /* @__PURE__ */ new Map();
+  /** Cache TTL */
+  lastPriceRefresh = 0;
+  PRICE_REFRESH_MS = 1e4;
+  // 10 seconds
+  constructor(client, config) {
+    this.client = client;
+    this.config = config;
+  }
+  // ============================================================
+  // POSITION QUERIES
+  // ============================================================
+  /**
+   * Get all open prediction positions with current prices.
+   */
+  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));
+  }
+  /**
+   * Get a specific position.
+   */
+  async getPosition(conditionId, outcomeIndex) {
+    const key = `${conditionId}:${outcomeIndex}`;
+    const pos = this.positions.get(key);
+    if (!pos || pos.balance <= 0) return null;
+    return this.toExternalPosition(pos);
+  }
+  /**
+   * Get account summary (balances, exposure, PnL).
+   */
+  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 {
+      polygonUSDC: 0,
+      // Filled in by runtime from on-chain balance
+      baseUSDC: 0,
+      // Filled in by runtime from on-chain balance
+      totalExposure,
+      totalUnrealizedPnl,
+      openMarketCount: openMarkets.size,
+      openPositionCount: positions.length,
+      pendingFees: 0
+      // Filled in by recorder
+    };
+  }
+  /**
+   * Get total exposure across all positions.
+   */
+  getTotalExposure() {
+    let total = 0;
+    for (const pos of this.positions.values()) {
+      if (pos.balance > 0) total += pos.totalCostBasis;
+    }
+    return total;
+  }
+  /**
+   * Get total unrealized PnL.
+   */
+  getTotalUnrealizedPnl() {
+    let total = 0;
+    for (const pos of this.positions.values()) {
+      if (pos.balance > 0) {
+        total += (pos.currentPrice - pos.averageEntryPrice) * pos.balance;
+      }
+    }
+    return total;
+  }
+  // ============================================================
+  // FILL PROCESSING
+  // ============================================================
+  /**
+   * Process a fill and update position tracking.
+   * Called when a new fill is detected by the order manager.
+   */
+  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,
+        totalBought: 0,
+        totalSold: 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.totalBought += size;
+      pos.totalCostBasis += newCost;
+      pos.averageEntryPrice = pos.balance > 0 ? (oldCost + newCost) / pos.balance : 0;
+    } else {
+      pos.balance -= size;
+      pos.totalSold += size;
+      pos.totalProceeds += price * size;
+      if (pos.balance < 0) pos.balance = 0;
+    }
+  }
+  /**
+   * Process multiple fills (batch update).
+   */
+  processFills(fills) {
+    for (const fill of fills) {
+      this.processFill(fill);
+    }
+  }
+  // ============================================================
+  // MARKET RESOLUTION
+  // ============================================================
+  /**
+   * Mark a market as resolved. Positions settle at $0 or $1.
+   */
+  resolveMarket(conditionId, winningOutcome) {
+    for (const [key, pos] of this.positions.entries()) {
+      if (pos.marketConditionId === conditionId) {
+        const isWinner = pos.outcomeIndex === winningOutcome;
+        pos.currentPrice = isWinner ? 1 : 0;
+        if (pos.balance > 0) {
+          pos.totalProceeds += pos.currentPrice * pos.balance;
+          pos.totalSold += pos.balance;
+          pos.balance = 0;
+        }
+      }
+    }
+  }
+  // ============================================================
+  // PERSISTENCE
+  // ============================================================
+  /**
+   * Export position state for persistence across restarts.
+   */
+  exportState() {
+    return Array.from(this.positions.values());
+  }
+  /**
+   * Import position state from previous session.
+   */
+  importState(state) {
+    this.positions.clear();
+    for (const pos of state) {
+      const key = `${pos.marketConditionId}:${pos.outcomeIndex}`;
+      this.positions.set(key, pos);
+    }
+  }
+  // ============================================================
+  // PRIVATE
+  // ============================================================
+  /**
+   * Refresh current prices for all open positions from CLOB.
+   */
+  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/prediction/recorder.ts
+var import_viem8 = require("viem");
+var import_chains5 = require("viem/chains");
+var import_accounts4 = require("viem/accounts");
+var ROUTER_ADDRESS2 = "0x1BCFa13f677fDCf697D8b7d5120f544817F1de1A";
+var ROUTER_ABI2 = [
+  {
+    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_RETRIES2 = 3;
+var RETRY_DELAY_MS2 = 5e3;
+var PredictionTradeRecorder = class {
+  publicClient;
+  walletClient;
+  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;
+  /** Accumulated fees pending bridge to Base treasury (in USD, 6-decimal) */
+  accumulatedFees = 0n;
+  constructor(opts) {
+    this.agentId = opts.agentId;
+    this.configHash = opts.configHash;
+    this.account = (0, import_accounts4.privateKeyToAccount)(opts.privateKey);
+    const rpcUrl = opts.rpcUrl || "https://mainnet.base.org";
+    const transport = (0, import_viem8.http)(rpcUrl, { timeout: 6e4 });
+    this.publicClient = (0, import_viem8.createPublicClient)({
+      chain: import_chains5.base,
+      transport
+    });
+    this.walletClient = (0, import_viem8.createWalletClient)({
+      chain: import_chains5.base,
+      transport,
+      account: this.account
+    });
+    this.retryTimer = setInterval(() => this.processRetryQueue(), RETRY_DELAY_MS2);
+  }
+  // ============================================================
+  // PUBLIC API
+  // ============================================================
+  /**
+   * Record a prediction fill on-chain.
+   * Converts the Polymarket fill into recordPerpTrade params with POLY: prefix.
+   */
+  async recordFill(fill) {
+    const fillId = tradeIdToBytes32(fill.tradeId);
+    const fillIdStr = fillId.toLowerCase();
+    if (this.recordedFills.has(fillIdStr)) {
+      return { success: true };
+    }
+    this.recordedFills.add(fillIdStr);
+    const notionalUSD = this.calculateNotionalUSD(fill);
+    const feeUSD = calculatePredictionFee(notionalUSD);
+    const params = {
+      agentId: this.agentId,
+      configHash: this.configHash,
+      instrument: encodePredictionInstrument(fill.marketConditionId, fill.outcomeIndex),
+      isLong: fill.side === "BUY",
+      notionalUSD,
+      feeUSD,
+      fillId
+    };
+    this.accumulatedFees += feeUSD;
+    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;
+  }
+  /**
+   * Get accumulated fees pending bridge (6-decimal USD).
+   */
+  get pendingFees() {
+    return this.accumulatedFees;
+  }
+  /**
+   * Get accumulated fees as human-readable USD.
+   */
+  get pendingFeesUSD() {
+    return Number(this.accumulatedFees) / 1e6;
+  }
+  /**
+   * Reset accumulated fees (after bridge to treasury).
+   */
+  resetAccumulatedFees() {
+    this.accumulatedFees = 0n;
+  }
+  /**
+   * 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_ADDRESS2,
+        abi: ROUTER_ABI2,
+        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);
+      const action = params.isLong ? "BUY" : "SELL";
+      console.log(
+        `Prediction trade recorded: ${action} ${params.instrument} $${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("FillAlreadyProcessed") || message.includes("already recorded")) {
+        console.log(`Prediction fill already recorded on-chain: ${params.fillId}`);
+        return { success: true };
+      }
+      console.error(`Failed to record prediction 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_MS2
+    );
+    for (const item of toRetry) {
+      item.retries++;
+      item.lastAttempt = now;
+      if (item.retries > MAX_RETRIES2) {
+        console.error(
+          `Prediction trade recording permanently failed after ${MAX_RETRIES2} 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 prediction trade recording (attempt ${item.retries}/${MAX_RETRIES2}): ${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 = price * size * 1e6
+   */
+  calculateNotionalUSD(fill) {
+    const price = parseFloat(fill.price);
+    const size = parseFloat(fill.size);
+    return BigInt(Math.round(price * size * 1e6));
+  }
+};
+
+// src/prediction/market-browser.ts
+var MarketBrowser = class {
+  gammaUrl;
+  allowedCategories;
+  /** Cache for market listings */
+  listCache = /* @__PURE__ */ new Map();
+  CACHE_TTL_MS = 6e4;
+  constructor(config) {
+    const merged = { ...DEFAULT_PREDICTION_CONFIG, ...config };
+    this.gammaUrl = merged.gammaApiUrl;
+    this.allowedCategories = merged.allowedCategories || [];
+  }
+  // ============================================================
+  // PUBLIC API
+  // ============================================================
+  /**
+   * Get active markets, optionally filtered by category.
+   * Results are sorted by volume (highest first).
+   */
+  async getActiveMarkets(params) {
+    const limit = params?.limit || 20;
+    const offset = params?.offset || 0;
+    const cacheKey = `active:${params?.category || "all"}:${limit}:${offset}`;
+    const cached = this.listCache.get(cacheKey);
+    if (cached && Date.now() - cached.cachedAt < this.CACHE_TTL_MS) {
+      return cached.data;
+    }
+    const query = new URLSearchParams({
+      active: "true",
+      closed: "false",
+      limit: String(limit),
+      offset: String(offset),
+      order: "volume24hr",
+      ascending: "false"
+    });
+    if (params?.category) query.set("tag", params.category);
+    const markets = await this.fetchGamma(`/markets?${query.toString()}`);
+    const parsed = markets.map((m) => this.parseMarket(m));
+    const filtered = this.allowedCategories.length > 0 ? parsed.filter(
+      (m) => this.allowedCategories.some((c) => m.category.toLowerCase().includes(c.toLowerCase()))
+    ) : parsed;
+    this.listCache.set(cacheKey, { data: filtered, cachedAt: Date.now() });
+    return filtered;
+  }
+  /**
+   * Search markets by query text.
+   */
+  async searchMarkets(query, limit = 20) {
+    const params = new URLSearchParams({
+      _q: query,
+      limit: String(limit),
+      active: "true"
+    });
+    const markets = await this.fetchGamma(`/markets?${params.toString()}`);
+    return markets.map((m) => this.parseMarket(m));
+  }
+  /**
+   * Get trending markets (highest 24h volume).
+   */
+  async getTrendingMarkets(limit = 10) {
+    return this.getActiveMarkets({ limit });
+  }
+  /**
+   * Get markets expiring soon (within N days).
+   */
+  async getExpiringMarkets(withinDays = 7, limit = 20) {
+    const markets = await this.getActiveMarkets({ limit: 100 });
+    const cutoff = Date.now() / 1e3 + withinDays * 86400;
+    return markets.filter((m) => m.endDate > 0 && m.endDate < cutoff).sort((a, b) => a.endDate - b.endDate).slice(0, limit);
+  }
+  /**
+   * Get recently resolved markets (for PnL tracking).
+   */
+  async getRecentlyResolved(limit = 20) {
+    const params = new URLSearchParams({
+      closed: "true",
+      limit: String(limit),
+      order: "endDate",
+      ascending: "false"
+    });
+    const markets = await this.fetchGamma(`/markets?${params.toString()}`);
+    return markets.map((m) => this.parseMarket(m)).filter((m) => m.resolved);
+  }
+  /**
+   * Get a single market's details by condition ID.
+   */
+  async getMarketDetail(conditionId) {
+    const markets = await this.fetchGamma(`/markets?condition_id=${conditionId}`);
+    if (!markets || markets.length === 0) return null;
+    return this.parseMarket(markets[0]);
+  }
+  /**
+   * Build a concise market summary string for LLM context.
+   * Keeps the prompt token count manageable.
+   */
+  formatMarketsForLLM(markets, maxMarkets = 15) {
+    const subset = markets.slice(0, maxMarkets);
+    const lines = subset.map((m, i) => {
+      const prices = m.outcomePrices.map((p, j) => `${m.outcomes[j]}: ${(p * 100).toFixed(1)}%`).join(", ");
+      const vol = m.volume24h >= 1e3 ? `$${(m.volume24h / 1e3).toFixed(1)}K` : `$${m.volume24h.toFixed(0)}`;
+      const endStr = m.endDate > 0 ? new Date(m.endDate * 1e3).toISOString().split("T")[0] : "TBD";
+      return `${i + 1}. [${m.category}] "${m.question}" \u2014 ${prices} | Vol: ${vol} | Ends: ${endStr} | ID: ${m.conditionId}`;
+    });
+    return lines.join("\n");
+  }
+  // ============================================================
+  // PRIVATE
+  // ============================================================
+  async fetchGamma(path8) {
+    const url = `${this.gammaUrl}${path8}`;
+    const resp = await fetch(url);
+    if (!resp.ok) {
+      console.error(`Gamma API error: ${resp.status} for ${url}`);
+      return [];
+    }
+    const data = await resp.json();
+    return Array.isArray(data) ? data : [];
+  }
+  parseMarket(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
+    };
+  }
+};
+
+// src/prediction/funding.ts
+var import_viem9 = require("viem");
+var import_chains6 = require("viem/chains");
+var import_accounts5 = require("viem/accounts");
+var CONTRACTS = {
+  // Base
+  BASE_USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  BASE_TOKEN_MESSENGER_V2: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+  BASE_MESSAGE_TRANSMITTER_V2: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+  // Polygon
+  POLYGON_USDC: POLYGON_USDC_ADDRESS,
+  POLYGON_TOKEN_MESSENGER_V2,
+  POLYGON_MESSAGE_TRANSMITTER_V2
+};
+var IRIS_API_URL = "https://iris-api.circle.com/v1/attestations";
+var MIN_BRIDGE_AMOUNT = 1000000n;
+var ERC20_ABI2 = (0, import_viem9.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_ABI2 = (0, import_viem9.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_ABI2 = (0, import_viem9.parseAbi)([
+  "function receiveMessage(bytes message, bytes attestation) external returns (bool success)",
+  "event MessageSent(bytes message)"
+]);
+var PredictionFunding = class {
+  basePublic;
+  baseWallet;
+  polygonPublic;
+  polygonWallet;
+  account;
+  /** Override recipient for deposits to Polygon (vault address in vault mode) */
+  polygonRecipient;
+  constructor(config) {
+    this.account = (0, import_accounts5.privateKeyToAccount)(config.privateKey);
+    this.polygonRecipient = config.polygonRecipient;
+    const baseTransport = (0, import_viem9.http)(config.baseRpcUrl || "https://mainnet.base.org", { timeout: 6e4 });
+    const polygonTransport = (0, import_viem9.http)(config.polygonRpcUrl || "https://polygon-rpc.com", { timeout: 6e4 });
+    this.basePublic = (0, import_viem9.createPublicClient)({ chain: import_chains6.base, transport: baseTransport });
+    this.baseWallet = (0, import_viem9.createWalletClient)({ chain: import_chains6.base, transport: baseTransport, account: this.account });
+    this.polygonPublic = (0, import_viem9.createPublicClient)({ chain: import_chains6.polygon, transport: polygonTransport });
+    this.polygonWallet = (0, import_viem9.createWalletClient)({ chain: import_chains6.polygon, transport: polygonTransport, account: this.account });
+  }
+  // ============================================================
+  // BALANCE QUERIES
+  // ============================================================
+  /** Get USDC balance on Base (6-decimal) */
+  async getBaseUSDCBalance() {
+    return this.basePublic.readContract({
+      address: CONTRACTS.BASE_USDC,
+      abi: ERC20_ABI2,
+      functionName: "balanceOf",
+      args: [this.account.address]
+    });
+  }
+  /** Get USDC balance on Polygon (6-decimal) */
+  async getPolygonUSDCBalance() {
+    return this.polygonPublic.readContract({
+      address: CONTRACTS.POLYGON_USDC,
+      abi: ERC20_ABI2,
+      functionName: "balanceOf",
+      args: [this.account.address]
+    });
+  }
+  /** Get MATIC balance on Polygon for gas (wei) */
+  async getPolygonGasBalance() {
+    return this.polygonPublic.getBalance({ address: this.account.address });
+  }
+  // ============================================================
+  // DEPOSIT: Base → Polygon
+  // ============================================================
+  /**
+   * Bridge USDC from Base to Polygon via CCTP V2.
+   *
+   * Steps:
+   * 1. Approve USDC on Base for TokenMessengerV2
+   * 2. Call depositForBurn (Base → Polygon)
+   * 3. Wait for Circle attestation (~1-5 minutes)
+   * 4. Call receiveMessage on Polygon
+   */
+  async depositToPolygon(amount, onStep) {
+    const startTime = Date.now();
+    if (amount < MIN_BRIDGE_AMOUNT) {
+      return { success: false, amount, error: "Amount below minimum (1 USDC)" };
+    }
+    try {
+      onStep?.("approve_usdc");
+      await this.approveIfNeeded(
+        this.basePublic,
+        this.baseWallet,
+        CONTRACTS.BASE_USDC,
+        CONTRACTS.BASE_TOKEN_MESSENGER_V2,
+        amount
+      );
+      onStep?.("cctp_burn");
+      const recipient = this.polygonRecipient ?? this.account.address;
+      const mintRecipient = this.addressToBytes32(recipient);
+      const burnHash = await this.baseWallet.writeContract({
+        address: CONTRACTS.BASE_TOKEN_MESSENGER_V2,
+        abi: TOKEN_MESSENGER_V2_ABI2,
+        functionName: "depositForBurn",
+        args: [amount, CCTP_DOMAIN_POLYGON, mintRecipient, CONTRACTS.BASE_USDC]
+      });
+      const burnReceipt = await this.basePublic.waitForTransactionReceipt({ hash: burnHash });
+      const messageBytes = this.extractMessageFromReceipt(burnReceipt);
+      if (!messageBytes) {
+        return { success: false, amount, burnTxHash: burnHash, error: "Failed to extract CCTP message from burn tx" };
+      }
+      onStep?.("wait_attestation");
+      const attestation = await this.waitForAttestation(messageBytes);
+      if (!attestation) {
+        return { success: false, amount, burnTxHash: burnHash, error: "Attestation timeout (15 min)" };
+      }
+      onStep?.("cctp_receive");
+      const receiveHash = await this.polygonWallet.writeContract({
+        address: CONTRACTS.POLYGON_MESSAGE_TRANSMITTER_V2,
+        abi: MESSAGE_TRANSMITTER_V2_ABI2,
+        functionName: "receiveMessage",
+        args: [messageBytes, attestation]
+      });
+      await this.polygonPublic.waitForTransactionReceipt({ hash: receiveHash });
+      console.log(`CCTP deposit complete: ${Number(amount) / 1e6} USDC Base \u2192 Polygon in ${((Date.now() - startTime) / 1e3).toFixed(0)}s`);
+      return {
+        success: true,
+        amount,
+        burnTxHash: burnHash,
+        receiveTxHash: receiveHash,
+        duration: Date.now() - startTime
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("CCTP deposit to Polygon failed:", message);
+      return { success: false, amount, error: message, duration: Date.now() - startTime };
+    }
+  }
+  // ============================================================
+  // WITHDRAW: Polygon → Base
+  // ============================================================
+  /**
+   * Bridge USDC from Polygon back to Base via CCTP V2.
+   * Used for fee collection (bridge accumulated fees to Base treasury).
+   */
+  async withdrawToBase(amount, onStep) {
+    const startTime = Date.now();
+    if (amount < MIN_BRIDGE_AMOUNT) {
+      return { success: false, amount, error: "Amount below minimum (1 USDC)" };
+    }
+    try {
+      onStep?.("approve_usdc");
+      await this.approveIfNeeded(
+        this.polygonPublic,
+        this.polygonWallet,
+        CONTRACTS.POLYGON_USDC,
+        CONTRACTS.POLYGON_TOKEN_MESSENGER_V2,
+        amount
+      );
+      onStep?.("cctp_burn");
+      const mintRecipient = this.addressToBytes32(this.account.address);
+      const burnHash = await this.polygonWallet.writeContract({
+        address: CONTRACTS.POLYGON_TOKEN_MESSENGER_V2,
+        abi: TOKEN_MESSENGER_V2_ABI2,
+        functionName: "depositForBurn",
+        args: [amount, CCTP_DOMAIN_BASE, mintRecipient, CONTRACTS.POLYGON_USDC]
+      });
+      const burnReceipt = await this.polygonPublic.waitForTransactionReceipt({ hash: burnHash });
+      const messageBytes = this.extractMessageFromReceipt(burnReceipt);
+      if (!messageBytes) {
+        return { success: false, amount, burnTxHash: burnHash, error: "Failed to extract CCTP message" };
+      }
+      onStep?.("wait_attestation");
+      const attestation = await this.waitForAttestation(messageBytes);
+      if (!attestation) {
+        return { success: false, amount, burnTxHash: burnHash, error: "Attestation timeout" };
+      }
+      onStep?.("cctp_receive");
+      const receiveHash = await this.baseWallet.writeContract({
+        address: CONTRACTS.BASE_MESSAGE_TRANSMITTER_V2,
+        abi: MESSAGE_TRANSMITTER_V2_ABI2,
+        functionName: "receiveMessage",
+        args: [messageBytes, attestation]
+      });
+      await this.basePublic.waitForTransactionReceipt({ hash: receiveHash });
+      console.log(`CCTP withdrawal complete: ${Number(amount) / 1e6} USDC Polygon \u2192 Base in ${((Date.now() - startTime) / 1e3).toFixed(0)}s`);
+      return {
+        success: true,
+        amount,
+        burnTxHash: burnHash,
+        receiveTxHash: receiveHash,
+        duration: Date.now() - startTime
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("CCTP withdrawal to Base failed:", message);
+      return { success: false, amount, error: message, duration: Date.now() - startTime };
+    }
+  }
+  // ============================================================
+  // PRIVATE HELPERS
+  // ============================================================
+  /** Convert address to bytes32 (left-padded) for CCTP mintRecipient */
+  addressToBytes32(address) {
+    return `0x000000000000000000000000${address.slice(2)}`;
+  }
+  /** Approve USDC spend if needed (maxUint256 pattern) */
+  async approveIfNeeded(publicClient, walletClient, token, spender, amount) {
+    const allowance = await publicClient.readContract({
+      address: token,
+      abi: ERC20_ABI2,
+      functionName: "allowance",
+      args: [this.account.address, spender]
+    });
+    if (allowance < amount) {
+      const maxUint256 = 2n ** 256n - 1n;
+      const hash = await walletClient.writeContract({
+        address: token,
+        abi: ERC20_ABI2,
+        functionName: "approve",
+        args: [spender, maxUint256]
+      });
+      await publicClient.waitForTransactionReceipt({ hash });
+    }
+  }
+  /** Extract MessageSent bytes from a CCTP burn transaction receipt */
+  extractMessageFromReceipt(receipt) {
+    for (const log of receipt.logs || []) {
+      try {
+        if (log.topics[0] === "0x8c5261668696ce22758910d05bab8f186d6eb247ceac2af2e82c7dc17669b036") {
+          return log.data;
+        }
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  }
+  /** Wait for Circle attestation (polls Iris API) */
+  async waitForAttestation(messageBytes, timeoutMs = 9e5) {
+    const { keccak256: keccak2565 } = await import("viem");
+    const messageHash = keccak2565(messageBytes);
+    const start = Date.now();
+    const pollInterval = 5e3;
+    while (Date.now() - start < timeoutMs) {
+      try {
+        const resp = await fetch(`${IRIS_API_URL}/${messageHash}`);
+        if (resp.ok) {
+          const data = await resp.json();
+          if (data.status === "complete" && data.attestation) {
+            return data.attestation;
+          }
+        }
+      } catch {
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    return null;
+  }
+};
+
+// src/prediction/vault-manager.ts
+var import_viem10 = require("viem");
+var import_chains7 = require("viem/chains");
+var import_accounts6 = require("viem/accounts");
+var ERC20_ABI3 = (0, import_viem10.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 VAULT_FACTORY_ABI2 = (0, import_viem10.parseAbi)([
+  "function createVault(uint256 agentId, address agentWallet, uint256 seedAmount, string name, string symbol, address feeRecipient, bool isVerified, bytes agentSig) external returns (address)",
+  "function vaults(uint256 agentId) external view returns (address)",
+  "function isFactoryVault(address vault) external view returns (bool)",
+  "function MIN_SEED_AMOUNT() external view returns (uint256)"
+]);
+var VAULT_ABI2 = (0, import_viem10.parseAbi)([
+  // ERC-4626
+  "function deposit(uint256 assets, address receiver) external returns (uint256)",
+  "function withdraw(uint256 assets, address receiver, address owner) external returns (uint256)",
+  "function redeem(uint256 shares, address receiver, address owner) external returns (uint256)",
+  "function redeemMax(address receiver, address owner) external returns (uint256)",
+  "function totalAssets() external view returns (uint256)",
+  "function totalSupply() external view returns (uint256)",
+  "function balanceOf(address account) external view returns (uint256)",
+  "function convertToAssets(uint256 shares) external view returns (uint256)",
+  "function convertToShares(uint256 assets) external view returns (uint256)",
+  // Vault-specific views
+  "function sharePrice() external view returns (uint256)",
+  "function availableTradingBalance() external view returns (uint256)",
+  "function currentExposureBps() external view returns (uint256)",
+  "function cachedCtfValue() external view returns (uint256)",
+  "function lastCtfUpdate() external view returns (uint256)",
+  "function depositCap() external view returns (uint256)",
+  "function agentSeedAmount() external view returns (uint256)",
+  "function circuitBreakerActive() external view returns (bool)",
+  "function paused() external view returns (bool)",
+  "function pendingTradingVolume() external view returns (uint256)",
+  "function getTrackedTokenCount() external view returns (uint256)",
+  "function agentWallet() external view returns (address)",
+  "function agentId() external view returns (uint256)",
+  "function isVerified() external view returns (bool)",
+  "function maxExposureBps() external view returns (uint256)",
+  // Keeper functions
+  "function updatePositionValues(uint256[] tokenIds, uint256[] values) external",
+  "function collectTradingFees(uint256 volume) external",
+  // Emergency
+  "function emergencyWithdraw() external returns (uint256)"
+]);
+var PredictionVaultManager = class {
+  config;
+  publicClient;
+  walletClient;
+  account;
+  /** Resolved vault address (discovered or created) */
+  vaultAddress = null;
+  /** NAV update timer */
+  navTimer = null;
+  /** Fee collection timer */
+  feeTimer = null;
+  /** Last known accumulated trading volume (for delta tracking) */
+  lastReportedVolume = 0n;
+  constructor(privateKey, config) {
+    this.config = config;
+    this.account = (0, import_accounts6.privateKeyToAccount)(privateKey);
+    const transport = (0, import_viem10.http)(config.polygonRpcUrl, { timeout: 6e4 });
+    this.publicClient = (0, import_viem10.createPublicClient)({ chain: import_chains7.polygon, transport });
+    this.walletClient = (0, import_viem10.createWalletClient)({
+      chain: import_chains7.polygon,
+      transport,
+      account: this.account
+    });
+    if (config.vaultAddress) {
+      this.vaultAddress = config.vaultAddress;
+    }
+  }
+  // ============================================================
+  // INITIALIZATION
+  // ============================================================
+  /**
+   * Initialize the vault manager — discover existing vault or prepare for creation.
+   */
+  async initialize() {
+    if (!this.vaultAddress) {
+      try {
+        const vaultAddr = await this.publicClient.readContract({
+          address: this.config.factoryAddress,
+          abi: VAULT_FACTORY_ABI2,
+          functionName: "vaults",
+          args: [this.config.agentId]
+        });
+        if (vaultAddr && vaultAddr !== "0x0000000000000000000000000000000000000000") {
+          this.vaultAddress = vaultAddr;
+          console.log(`Discovered existing prediction vault: ${this.vaultAddress}`);
+        }
+      } catch {
+        console.log("No existing prediction vault found \u2014 create one via createVault()");
+      }
+    }
+    if (this.vaultAddress) {
+      console.log(`Prediction vault manager initialized for vault: ${this.vaultAddress}`);
+    }
+  }
+  /**
+   * Get the vault address (null if no vault exists).
+   */
+  getVaultAddress() {
+    return this.vaultAddress;
+  }
+  /**
+   * Whether a vault has been created/discovered.
+   */
+  get hasVault() {
+    return this.vaultAddress !== null;
+  }
+  // ============================================================
+  // VAULT CREATION
+  // ============================================================
+  /**
+   * Create a new prediction vault via PredictionVaultFactory.
+   *
+   * Deploys PredictionVault on Polygon with:
+   * - Agent's EOA as the authorized signer for ERC-1271
+   * - Seed USDC transferred from agent wallet to vault
+   * - Deposit cap = seed × multiplier (10x unverified, 100x verified)
+   */
+  async createVault(seedAmount, name, symbol) {
+    if (this.vaultAddress) {
+      return { success: false, error: `Vault already exists: ${this.vaultAddress}` };
+    }
+    try {
+      const message = (0, import_viem10.keccak256)(
+        (0, import_viem10.encodePacked)(
+          ["uint256", "address", "address"],
+          [this.config.agentId, this.account.address, this.config.factoryAddress]
+        )
+      );
+      const agentSig = await this.account.signMessage({ message: { raw: message } });
+      await this.approveIfNeeded(
+        POLYGON_USDC_ADDRESS,
+        this.config.factoryAddress,
+        seedAmount
+      );
+      const hash = await this.walletClient.writeContract({
+        address: this.config.factoryAddress,
+        abi: VAULT_FACTORY_ABI2,
+        functionName: "createVault",
+        args: [
+          this.config.agentId,
+          this.account.address,
+          seedAmount,
+          name,
+          symbol,
+          this.config.feeRecipient,
+          this.config.isVerified ?? false,
+          agentSig
+        ]
+      });
+      const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+      const vaultAddr = await this.publicClient.readContract({
+        address: this.config.factoryAddress,
+        abi: VAULT_FACTORY_ABI2,
+        functionName: "vaults",
+        args: [this.config.agentId]
+      });
+      this.vaultAddress = vaultAddr;
+      console.log(`Prediction vault created: ${this.vaultAddress} (seed: ${(0, import_viem10.formatUnits)(seedAmount, 6)} USDC)`);
+      return {
+        success: true,
+        vaultAddress: this.vaultAddress,
+        txHash: hash
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("Failed to create prediction vault:", message);
+      return { success: false, error: message };
+    }
+  }
+  // ============================================================
+  // DEPOSITS & WITHDRAWALS
+  // ============================================================
+  /**
+   * Deposit USDC into the prediction vault.
+   * Returns the number of shares received.
+   */
+  async deposit(amount) {
+    if (!this.vaultAddress) {
+      return { success: false, error: "No vault exists" };
+    }
+    try {
+      await this.approveIfNeeded(
+        POLYGON_USDC_ADDRESS,
+        this.vaultAddress,
+        amount
+      );
+      const hash = await this.walletClient.writeContract({
+        address: this.vaultAddress,
+        abi: VAULT_ABI2,
+        functionName: "deposit",
+        args: [amount, this.account.address]
+      });
+      const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+      const shares = await this.publicClient.readContract({
+        address: this.vaultAddress,
+        abi: VAULT_ABI2,
+        functionName: "balanceOf",
+        args: [this.account.address]
+      });
+      console.log(`Deposited ${(0, import_viem10.formatUnits)(amount, 6)} USDC into prediction vault`);
+      return { success: true, shares, txHash: hash };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("Vault deposit failed:", message);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Withdraw USDC from the prediction vault.
+   * Redeems all shares and returns the USDC received (net of fees).
+   */
+  async withdrawAll() {
+    if (!this.vaultAddress) {
+      return { success: false, error: "No vault exists" };
+    }
+    try {
+      const hash = await this.walletClient.writeContract({
+        address: this.vaultAddress,
+        abi: VAULT_ABI2,
+        functionName: "redeemMax",
+        args: [this.account.address, this.account.address]
+      });
+      const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+      const balance = await this.publicClient.readContract({
+        address: POLYGON_USDC_ADDRESS,
+        abi: ERC20_ABI3,
+        functionName: "balanceOf",
+        args: [this.account.address]
+      });
+      console.log("Withdrew all shares from prediction vault");
+      return { success: true, assets: balance, txHash: hash };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("Vault withdrawal failed:", message);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Emergency withdraw with penalty.
+   */
+  async emergencyWithdraw() {
+    if (!this.vaultAddress) {
+      return { success: false, error: "No vault exists" };
+    }
+    try {
+      const hash = await this.walletClient.writeContract({
+        address: this.vaultAddress,
+        abi: VAULT_ABI2,
+        functionName: "emergencyWithdraw",
+        args: []
+      });
+      await this.publicClient.waitForTransactionReceipt({ hash });
+      console.log("Emergency withdrew from prediction vault (penalty applied)");
+      return { success: true, txHash: hash };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { success: false, error: message };
+    }
+  }
+  // ============================================================
+  // VAULT STATUS
+  // ============================================================
+  /**
+   * Get comprehensive vault status.
+   */
+  async getVaultStatus() {
+    if (!this.vaultAddress) {
+      return {
+        vaultAddress: "0x0000000000000000000000000000000000000000",
+        hasVault: false,
+        totalAssets: 0n,
+        totalSupply: 0n,
+        sharePrice: 0,
+        usdcBalance: 0n,
+        cachedCtfValue: 0n,
+        currentExposureBps: 0,
+        depositCap: 0n,
+        seedAmount: 0n,
+        circuitBreakerActive: false,
+        isPaused: false,
+        lastCtfUpdate: 0,
+        pendingTradingVolume: 0n,
+        trackedTokenCount: 0
+      };
+    }
+    try {
+      const [
+        totalAssets,
+        totalSupply,
+        sharePrice,
+        usdcBalance,
+        cachedCtfValue,
+        currentExposureBps,
+        depositCap,
+        seedAmount,
+        circuitBreakerActive,
+        isPaused,
+        lastCtfUpdate,
+        pendingTradingVolume,
+        trackedTokenCount
+      ] = await Promise.all([
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "totalAssets" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "totalSupply" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "sharePrice" }),
+        this.publicClient.readContract({ address: POLYGON_USDC_ADDRESS, abi: ERC20_ABI3, functionName: "balanceOf", args: [this.vaultAddress] }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "cachedCtfValue" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "currentExposureBps" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "depositCap" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "agentSeedAmount" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "circuitBreakerActive" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "paused" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "lastCtfUpdate" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "pendingTradingVolume" }),
+        this.publicClient.readContract({ address: this.vaultAddress, abi: VAULT_ABI2, functionName: "getTrackedTokenCount" })
+      ]);
+      return {
+        vaultAddress: this.vaultAddress,
+        hasVault: true,
+        totalAssets,
+        totalSupply,
+        sharePrice: Number(sharePrice) / 1e6,
+        usdcBalance,
+        cachedCtfValue,
+        currentExposureBps: Number(currentExposureBps),
+        depositCap,
+        seedAmount,
+        circuitBreakerActive,
+        isPaused,
+        lastCtfUpdate: Number(lastCtfUpdate),
+        pendingTradingVolume,
+        trackedTokenCount: Number(trackedTokenCount)
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("Failed to read vault status:", message);
+      return {
+        vaultAddress: this.vaultAddress,
+        hasVault: true,
+        totalAssets: 0n,
+        totalSupply: 0n,
+        sharePrice: 0,
+        usdcBalance: 0n,
+        cachedCtfValue: 0n,
+        currentExposureBps: 0,
+        depositCap: 0n,
+        seedAmount: 0n,
+        circuitBreakerActive: false,
+        isPaused: false,
+        lastCtfUpdate: 0,
+        pendingTradingVolume: 0n,
+        trackedTokenCount: 0
+      };
+    }
+  }
+  // ============================================================
+  // KEEPER: NAV UPDATES
+  // ============================================================
+  /**
+   * Update cached CTF position values (keeper function).
+   * Fetches CLOB midpoint prices for all tracked tokens and updates the vault.
+   *
+   * @param tokenIds - CTF token IDs
+   * @param values - USD values in 6-decimal (midpoint price × balance for each token)
+   */
+  async updatePositionValues(tokenIds, values) {
+    if (!this.vaultAddress) {
+      return { success: false, error: "No vault exists" };
+    }
+    try {
+      const hash = await this.walletClient.writeContract({
+        address: this.vaultAddress,
+        abi: VAULT_ABI2,
+        functionName: "updatePositionValues",
+        args: [tokenIds, values]
+      });
+      await this.publicClient.waitForTransactionReceipt({ hash });
+      console.log(`Updated ${tokenIds.length} position values in prediction vault`);
+      return { success: true, txHash: hash };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("Failed to update position values:", message);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Collect trading fees based on reported volume (keeper function).
+   * Transfers 0.2% of volume as fees to PredictionFeeCollector.
+   *
+   * @param volume - Trading volume to report (6-decimal USDC)
+   */
+  async collectTradingFees(volume) {
+    if (!this.vaultAddress) {
+      return { success: false, error: "No vault exists" };
+    }
+    try {
+      const hash = await this.walletClient.writeContract({
+        address: this.vaultAddress,
+        abi: VAULT_ABI2,
+        functionName: "collectTradingFees",
+        args: [volume]
+      });
+      await this.publicClient.waitForTransactionReceipt({ hash });
+      const feeAmount = volume * 20n / 10000n;
+      console.log(`Collected trading fees: ${(0, import_viem10.formatUnits)(feeAmount, 6)} USDC from ${(0, import_viem10.formatUnits)(volume, 6)} USDC volume`);
+      return { success: true, txHash: hash };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("Failed to collect trading fees:", message);
+      return { success: false, error: message };
+    }
+  }
+  // ============================================================
+  // KEEPER LOOPS
+  // ============================================================
+  /**
+   * Start the keeper loops (NAV updates + fee collection).
+   * These run on timers and automatically update vault state.
+   *
+   * @param getPositionValues - Callback that returns current CTF position values
+   *        (token IDs and their midpoint-price USD values)
+   * @param getAccumulatedVolume - Callback that returns accumulated trading volume
+   *        since last fee collection
+   */
+  startKeeperLoops(getPositionValues, getAccumulatedVolume) {
+    if (!this.vaultAddress) {
+      console.log("Cannot start keeper loops \u2014 no vault exists");
+      return;
+    }
+    const navInterval = this.config.navUpdateIntervalMs ?? 15 * 60 * 1e3;
+    this.navTimer = setInterval(async () => {
+      try {
+        const { tokenIds, values } = await getPositionValues();
+        if (tokenIds.length > 0) {
+          await this.updatePositionValues(tokenIds, values);
+        }
+      } catch (error) {
+        console.error("Keeper NAV update failed:", error instanceof Error ? error.message : error);
+      }
+    }, navInterval);
+    const feeInterval = this.config.feeCollectionIntervalMs ?? 24 * 60 * 60 * 1e3;
+    this.feeTimer = setInterval(async () => {
+      try {
+        const currentVolume = getAccumulatedVolume();
+        const volumeDelta = currentVolume - this.lastReportedVolume;
+        if (volumeDelta > 0n) {
+          await this.collectTradingFees(volumeDelta);
+          this.lastReportedVolume = currentVolume;
+        }
+      } catch (error) {
+        console.error("Keeper fee collection failed:", error instanceof Error ? error.message : error);
+      }
+    }, feeInterval);
+    console.log(`Keeper loops started (NAV: every ${navInterval / 6e4}min, fees: every ${feeInterval / 36e5}h)`);
+  }
+  /**
+   * Stop keeper loops.
+   */
+  stopKeeperLoops() {
+    if (this.navTimer) {
+      clearInterval(this.navTimer);
+      this.navTimer = null;
+    }
+    if (this.feeTimer) {
+      clearInterval(this.feeTimer);
+      this.feeTimer = null;
+    }
+    console.log("Keeper loops stopped");
+  }
+  // ============================================================
+  // CLEANUP
+  // ============================================================
+  /**
+   * Stop all timers and clean up.
+   */
+  stop() {
+    this.stopKeeperLoops();
+  }
+  // ============================================================
+  // PRIVATE HELPERS
+  // ============================================================
+  /** Approve USDC spend if needed (maxUint256 pattern) */
+  async approveIfNeeded(token, spender, amount) {
+    const allowance = await this.publicClient.readContract({
+      address: token,
+      abi: ERC20_ABI3,
+      functionName: "allowance",
+      args: [this.account.address, spender]
+    });
+    if (allowance < amount) {
+      const maxUint256 = 2n ** 256n - 1n;
+      const hash = await this.walletClient.writeContract({
+        address: token,
+        abi: ERC20_ABI3,
+        functionName: "approve",
+        args: [spender, maxUint256]
+      });
+      await this.publicClient.waitForTransactionReceipt({ hash });
+    }
+  }
+};
+
+// src/secure-env.ts
+var crypto = __toESM(require("crypto"));
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var ALGORITHM = "aes-256-gcm";
+var PBKDF2_ITERATIONS = 1e5;
+var SALT_LENGTH = 32;
+var IV_LENGTH = 16;
+var KEY_LENGTH = 32;
+var SENSITIVE_PATTERNS = [
+  /PRIVATE_KEY$/i,
+  /_API_KEY$/i,
+  /API_KEY$/i,
+  /_SECRET$/i,
+  /^OPENAI_API_KEY$/i,
+  /^ANTHROPIC_API_KEY$/i,
+  /^GOOGLE_AI_API_KEY$/i,
+  /^DEEPSEEK_API_KEY$/i,
+  /^MISTRAL_API_KEY$/i,
+  /^GROQ_API_KEY$/i,
+  /^TOGETHER_API_KEY$/i
+];
+function isSensitiveKey(key) {
+  return SENSITIVE_PATTERNS.some((pattern) => pattern.test(key));
+}
+function deriveKey(passphrase, salt) {
+  return crypto.pbkdf2Sync(passphrase, salt, PBKDF2_ITERATIONS, KEY_LENGTH, "sha256");
+}
+function encryptValue(value, key) {
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+  let encrypted = cipher.update(value, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  const tag = cipher.getAuthTag();
+  return {
+    iv: iv.toString("hex"),
+    encrypted,
+    tag: tag.toString("hex")
+  };
+}
+function decryptValue(encrypted, key, iv, tag) {
+  const decipher = crypto.createDecipheriv(
+    ALGORITHM,
+    key,
+    Buffer.from(iv, "hex")
+  );
+  decipher.setAuthTag(Buffer.from(tag, "hex"));
+  let decrypted = decipher.update(encrypted, "hex", "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+function parseEnvFile(content) {
+  const entries = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key && value) {
+      entries.push({ key, value });
+    }
+  }
+  return entries;
+}
+function encryptEnvFile(envPath, passphrase, deleteOriginal = false) {
+  if (!fs.existsSync(envPath)) {
+    throw new Error(`File not found: ${envPath}`);
+  }
+  const content = fs.readFileSync(envPath, "utf-8");
+  const entries = parseEnvFile(content);
+  if (entries.length === 0) {
+    throw new Error("No environment variables found in file");
+  }
+  const salt = crypto.randomBytes(SALT_LENGTH);
+  const key = deriveKey(passphrase, salt);
+  const encryptedEntries = entries.map(({ key: envKey, value }) => {
+    if (isSensitiveKey(envKey)) {
+      const { iv, encrypted, tag } = encryptValue(value, key);
+      return {
+        key: envKey,
+        value: encrypted,
+        encrypted: true,
+        iv,
+        tag
+      };
+    }
+    return {
+      key: envKey,
+      value,
+      encrypted: false
+    };
+  });
+  const encryptedEnv = {
+    version: 1,
+    salt: salt.toString("hex"),
+    entries: encryptedEntries
+  };
+  const encPath = envPath + ".enc";
+  fs.writeFileSync(encPath, JSON.stringify(encryptedEnv, null, 2), { mode: 384 });
+  if (deleteOriginal) {
+    fs.unlinkSync(envPath);
+  }
+  const sensitiveCount = encryptedEntries.filter((e) => e.encrypted).length;
+  const plainCount = encryptedEntries.filter((e) => !e.encrypted).length;
+  console.log(
+    `Encrypted ${sensitiveCount} sensitive values (${plainCount} non-sensitive kept as plaintext)`
+  );
+  return encPath;
+}
+function decryptEnvFile(encPath, passphrase) {
+  if (!fs.existsSync(encPath)) {
+    throw new Error(`Encrypted env file not found: ${encPath}`);
+  }
+  const content = JSON.parse(fs.readFileSync(encPath, "utf-8"));
+  if (content.version !== 1) {
+    throw new Error(`Unsupported encrypted env version: ${content.version}`);
+  }
+  const salt = Buffer.from(content.salt, "hex");
+  const key = deriveKey(passphrase, salt);
+  const result = {};
+  for (const entry of content.entries) {
+    if (entry.encrypted) {
+      if (!entry.iv || !entry.tag) {
+        throw new Error(`Missing encryption metadata for ${entry.key}`);
+      }
+      try {
+        result[entry.key] = decryptValue(entry.value, key, entry.iv, entry.tag);
+      } catch {
+        throw new Error(
+          `Failed to decrypt ${entry.key}. Wrong passphrase or corrupted data.`
+        );
+      }
+    } else {
+      result[entry.key] = entry.value;
+    }
+  }
+  return result;
+}
+function loadSecureEnv(basePath, passphrase) {
+  const encPath = path.join(basePath, ".env.enc");
+  const envPath = path.join(basePath, ".env");
+  if (fs.existsSync(encPath)) {
+    if (!passphrase) {
+      passphrase = process.env.EXAGENT_PASSPHRASE;
+    }
+    if (!passphrase) {
+      console.warn("");
+      console.warn("WARNING: Found .env.enc but no passphrase provided.");
+      console.warn("  Set EXAGENT_PASSPHRASE environment variable or");
+      console.warn("  pass --passphrase when running the agent.");
+      console.warn("  Falling back to plaintext .env file.");
+      console.warn("");
+    } else {
+      const vars = decryptEnvFile(encPath, passphrase);
+      for (const [key, value] of Object.entries(vars)) {
+        process.env[key] = value;
+      }
+      return true;
+    }
+  }
+  if (fs.existsSync(envPath)) {
     const content = fs.readFileSync(envPath, "utf-8");
     const entries = parseEnvFile(content);
     const sensitiveKeys = entries.filter(({ key }) => isSensitiveKey(key)).map(({ key }) => key);
@@ -5828,7 +7761,7 @@ function loadSecureEnv(basePath, passphrase) {
 }
 
 // src/index.ts
-var AGENT_VERSION = "0.1.39";
+var AGENT_VERSION = "0.1.41";
 
 // src/relay.ts
 var RelayClient = class {
@@ -5921,10 +7854,10 @@ var RelayClient = class {
    * Authenticate with the relay server using wallet signature
    */
   async authenticate() {
-    const account = (0, import_accounts4.privateKeyToAccount)(this.config.privateKey);
+    const account = (0, import_accounts7.privateKeyToAccount)(this.config.privateKey);
     const timestamp = Math.floor(Date.now() / 1e3);
     const message = `ExagentRelay:${this.config.agentId}:${timestamp}`;
-    const signature = await (0, import_accounts4.signMessage)({
+    const signature = await (0, import_accounts7.signMessage)({
       message,
       privateKey: this.config.privateKey
     });
@@ -6153,6 +8086,30 @@ var AgentRuntime = class {
   cachedPerpMarginUsed = 0;
   cachedPerpLeverage = 0;
   cachedPerpOpenPositions = 0;
+  // Prediction market components (null if prediction not enabled)
+  predictionClient = null;
+  predictionOrders = null;
+  predictionPositions = null;
+  predictionRecorder = null;
+  predictionFunding = null;
+  predictionBrowser = null;
+  predictionStrategy = null;
+  // Two-layer prediction control (mirrors perp pattern):
+  //   predictionConnected = Polymarket infrastructure initialized (CLOB client, recorder ready)
+  //   predictionTradingActive = Dedicated prediction trading cycle is mandated to run
+  predictionConnected = false;
+  predictionTradingActive = false;
+  // Cached prediction data for synchronous heartbeat inclusion
+  cachedPredictionPolygonUSDC = 0;
+  cachedPredictionBaseUSDC = 0;
+  cachedPredictionExposure = 0;
+  cachedPredictionOpenMarkets = 0;
+  cachedPredictionOpenPositions = 0;
+  cachedPredictionUnrealizedPnl = 0;
+  // Prediction vault manager (null if vault mode not enabled)
+  predictionVaultManager = null;
+  // Cached vault status for synchronous heartbeat
+  cachedPredictionVaultStatus = void 0;
   constructor(config, options) {
     this.config = config;
     this.startInPaperMode = options?.paperMode ?? false;
@@ -6200,6 +8157,7 @@ var AgentRuntime = class {
     }
     await this.initializeVaultManager();
     await this.initializePerp();
+    await this.initializePrediction();
     await this.initializeRelay();
     console.log("Agent initialized successfully");
   }
@@ -6289,10 +8247,10 @@ var AgentRuntime = class {
       };
       this.perpClient = new HyperliquidClient(config);
       const perpKey = perpConfig.perpRelayerKey || this.config.privateKey;
-      const account = (0, import_accounts5.privateKeyToAccount)(perpKey);
-      const walletClient = (0, import_viem7.createWalletClient)({
+      const account = (0, import_accounts8.privateKeyToAccount)(perpKey);
+      const walletClient = (0, import_viem11.createWalletClient)({
         chain: { id: 42161, name: "Arbitrum", nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 }, rpcUrls: { default: { http: ["https://arb1.arbitrum.io/rpc"] } } },
-        transport: (0, import_viem7.http)("https://arb1.arbitrum.io/rpc", { timeout: 6e4 }),
+        transport: (0, import_viem11.http)("https://arb1.arbitrum.io/rpc", { timeout: 6e4 }),
         account
       });
       this.perpSigner = new HyperliquidSigner(walletClient);
@@ -6368,6 +8326,101 @@ var AgentRuntime = class {
       console.warn("Perp trading will be disabled for this session");
     }
   }
+  /**
+   * Initialize Polymarket prediction market components.
+   * Only initializes if prediction is enabled in config AND risk universe >= 2.
+   */
+  async initializePrediction() {
+    const predictionConfig = this.config.prediction;
+    if (!predictionConfig?.enabled) {
+      console.log("Prediction markets: Disabled");
+      return;
+    }
+    if (this.riskUniverse < 2) {
+      console.warn(`Prediction markets: Blocked by risk universe ${this.riskUniverse} (need >= 2)`);
+      return;
+    }
+    try {
+      const config = {
+        enabled: true,
+        clobApiUrl: predictionConfig.clobApiUrl || "https://clob.polymarket.com",
+        gammaApiUrl: predictionConfig.gammaApiUrl || "https://gamma-api.polymarket.com",
+        polygonRpcUrl: predictionConfig.polygonRpcUrl || "https://polygon-rpc.com",
+        maxNotionalUSD: predictionConfig.maxNotionalUSD ?? 500,
+        maxTotalExposureUSD: predictionConfig.maxTotalExposureUSD ?? 5e3,
+        polygonAllocationUSD: predictionConfig.polygonAllocationUSD ?? 100,
+        allowedCategories: predictionConfig.allowedCategories,
+        feeBridgeThresholdUSD: predictionConfig.feeBridgeThresholdUSD ?? 10
+      };
+      const vaultConfig = predictionConfig.vault;
+      let vaultOpts;
+      if (vaultConfig?.enabled && vaultConfig.factoryAddress) {
+        this.predictionVaultManager = new PredictionVaultManager(
+          this.config.privateKey,
+          {
+            enabled: true,
+            factoryAddress: vaultConfig.factoryAddress,
+            feeCollectorAddress: vaultConfig.feeCollectorAddress || "0x0000000000000000000000000000000000000000",
+            polygonRpcUrl: predictionConfig.polygonRpcUrl || "https://polygon-rpc.com",
+            vaultAddress: vaultConfig.vaultAddress,
+            agentId: BigInt(this.config.agentId),
+            feeRecipient: vaultConfig.feeRecipient || this.client.address,
+            isVerified: vaultConfig.isVerified ?? false
+          }
+        );
+        await this.predictionVaultManager.initialize();
+        if (this.predictionVaultManager.hasVault) {
+          const vaultAddr = this.predictionVaultManager.getVaultAddress();
+          vaultOpts = { vaultMode: true, vaultAddress: vaultAddr };
+          console.log(`  Vault mode: ENABLED \u2014 vault ${vaultAddr}`);
+        } else {
+          console.log("  Vault mode: configured but no vault exists \u2014 create one via command center");
+        }
+      }
+      this.predictionClient = new PolymarketClient(this.config.privateKey, config, vaultOpts);
+      await this.predictionClient.initialize();
+      this.predictionOrders = new PredictionOrderManager(this.predictionClient, config);
+      this.predictionPositions = new PredictionPositionManager(this.predictionClient, config);
+      this.predictionBrowser = new MarketBrowser(config);
+      const recorderKey = predictionConfig.predictionRelayerKey || this.config.privateKey;
+      this.predictionRecorder = new PredictionTradeRecorder({
+        privateKey: recorderKey,
+        rpcUrl: this.getRpcUrl(),
+        agentId: BigInt(this.config.agentId),
+        configHash: this.configHash
+      });
+      this.predictionFunding = new PredictionFunding({
+        privateKey: this.config.privateKey,
+        baseRpcUrl: this.getRpcUrl(),
+        polygonRpcUrl: predictionConfig.polygonRpcUrl,
+        ...vaultOpts?.vaultMode && vaultOpts?.vaultAddress && {
+          polygonRecipient: vaultOpts.vaultAddress
+        }
+      });
+      this.predictionConnected = true;
+      console.log(`Polymarket: Connected`);
+      console.log(`  CLOB: ${config.clobApiUrl}`);
+      console.log(`  Max notional: $${config.maxNotionalUSD}, Max exposure: $${config.maxTotalExposureUSD}`);
+      if (config.allowedCategories?.length) {
+        console.log(`  Categories: ${config.allowedCategories.join(", ")}`);
+      }
+      try {
+        const polygonBalance = await this.predictionFunding.getPolygonUSDCBalance();
+        const polygonUSDC = Number(polygonBalance) / 1e6;
+        this.cachedPredictionPolygonUSDC = polygonUSDC;
+        console.log(`  Polygon USDC: $${polygonUSDC.toFixed(2)}`);
+        if (polygonUSDC < 1) {
+          console.warn("  No USDC on Polygon \u2014 bridge required before trading");
+        }
+      } catch {
+        console.warn("  Could not check Polygon USDC balance");
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Prediction initialization failed: ${message}`);
+      console.warn("Prediction market 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
@@ -6532,9 +8585,9 @@ var AgentRuntime = class {
       const message = error instanceof Error ? error.message : String(error);
       if (message.includes("insufficient funds") || message.includes("intrinsic gas too low") || message.includes("exceeds the balance")) {
         const ccUrl = `https://exagent.io/agents/${encodeURIComponent(this.config.name)}/command-center`;
-        const publicClientInstance = (0, import_viem7.createPublicClient)({
-          chain: import_chains5.base,
-          transport: (0, import_viem7.http)(this.getRpcUrl(), { timeout: 6e4 })
+        const publicClientInstance = (0, import_viem11.createPublicClient)({
+          chain: import_chains8.base,
+          transport: (0, import_viem11.http)(this.getRpcUrl(), { timeout: 6e4 })
         });
         console.log("");
         console.log("=== ETH NEEDED FOR GAS ===");
@@ -6902,6 +8955,224 @@ var AgentRuntime = class {
           }
           break;
         }
+        case "enable_polymarket":
+          if (this.predictionConnected) {
+            this.relay?.sendCommandResult(cmd.id, true, "Polymarket already connected");
+            break;
+          }
+          if (!this.config.prediction?.enabled) {
+            this.relay?.sendCommandResult(cmd.id, false, "Prediction 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.initializePrediction();
+            if (this.predictionConnected) {
+              this.relay?.sendCommandResult(cmd.id, true, "Polymarket connected");
+              this.relay?.sendMessage(
+                "system",
+                "success",
+                "Polymarket Enabled",
+                'Polymarket infrastructure connected. Use "Start Prediction Trading" to begin a dedicated prediction cycle.'
+              );
+            } else {
+              this.relay?.sendCommandResult(cmd.id, false, "Failed to connect to Polymarket");
+            }
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.relay?.sendCommandResult(cmd.id, false, `Polymarket init failed: ${msg}`);
+          }
+          this.sendRelayStatus();
+          break;
+        case "disable_polymarket":
+          if (!this.predictionConnected) {
+            this.relay?.sendCommandResult(cmd.id, true, "Polymarket already disconnected");
+            break;
+          }
+          this.predictionTradingActive = false;
+          this.predictionConnected = false;
+          this.predictionClient = null;
+          this.predictionOrders = null;
+          this.predictionPositions = null;
+          this.predictionRecorder = null;
+          this.predictionFunding = null;
+          this.predictionBrowser = null;
+          console.log("Polymarket disabled via command center");
+          this.relay?.sendCommandResult(cmd.id, true, "Polymarket disconnected");
+          this.relay?.sendMessage(
+            "system",
+            "info",
+            "Polymarket Disabled",
+            "Polymarket infrastructure disconnected."
+          );
+          this.sendRelayStatus();
+          break;
+        case "start_prediction_trading":
+          if (!this.predictionConnected) {
+            this.relay?.sendCommandResult(cmd.id, false, "Polymarket not connected. Enable Polymarket first.");
+            break;
+          }
+          if (this.predictionTradingActive) {
+            this.relay?.sendCommandResult(cmd.id, true, "Prediction trading already active");
+            break;
+          }
+          this.predictionTradingActive = true;
+          if (this.mode !== "trading") {
+            this.mode = "trading";
+            this.isRunning = true;
+          }
+          console.log("Prediction trading mandated via command center");
+          this.relay?.sendCommandResult(cmd.id, true, "Prediction trading cycle active");
+          this.relay?.sendMessage(
+            "system",
+            "success",
+            "Prediction Trading Active",
+            "Dedicated prediction trading cycle is now running every interval."
+          );
+          this.sendRelayStatus();
+          break;
+        case "stop_prediction_trading":
+          if (!this.predictionTradingActive) {
+            this.relay?.sendCommandResult(cmd.id, true, "Prediction trading already stopped");
+            break;
+          }
+          this.predictionTradingActive = false;
+          console.log("Prediction trading cycle stopped via command center");
+          this.relay?.sendCommandResult(cmd.id, true, "Prediction trading cycle stopped");
+          this.relay?.sendMessage(
+            "system",
+            "info",
+            "Prediction Trading Stopped",
+            "Dedicated prediction cycle stopped. Polymarket remains connected."
+          );
+          this.sendRelayStatus();
+          break;
+        case "update_prediction_params": {
+          const predParams = cmd.params || {};
+          let predUpdated = false;
+          if (this.config.prediction && predParams.maxNotionalUSD !== void 0) {
+            const val = Number(predParams.maxNotionalUSD);
+            if (val >= 1) {
+              this.config.prediction.maxNotionalUSD = val;
+              predUpdated = true;
+            }
+          }
+          if (this.config.prediction && predParams.maxTotalExposureUSD !== void 0) {
+            const val = Number(predParams.maxTotalExposureUSD);
+            if (val >= 1) {
+              this.config.prediction.maxTotalExposureUSD = val;
+              predUpdated = true;
+            }
+          }
+          if (predUpdated) {
+            this.relay?.sendCommandResult(cmd.id, true, "Prediction parameters updated");
+            this.relay?.sendMessage(
+              "config_updated",
+              "info",
+              "Prediction Params Updated",
+              `Max notional: $${this.config.prediction?.maxNotionalUSD}, Max exposure: $${this.config.prediction?.maxTotalExposureUSD}`
+            );
+          } else {
+            this.relay?.sendCommandResult(cmd.id, false, "No valid prediction parameters provided");
+          }
+          break;
+        }
+        case "create_prediction_vault": {
+          if (!this.predictionVaultManager) {
+            this.relay?.sendCommandResult(cmd.id, false, "Vault mode not configured. Set prediction.vault config.");
+            break;
+          }
+          if (this.predictionVaultManager.hasVault) {
+            const addr = this.predictionVaultManager.getVaultAddress();
+            this.relay?.sendCommandResult(cmd.id, true, `Vault already exists: ${addr}`);
+            break;
+          }
+          try {
+            const vaultParams = cmd.params || {};
+            const seedAmount = BigInt(Number(vaultParams.seedAmount || 100) * 1e6);
+            const name = vaultParams.name || `Prediction Fund ${this.config.agentId}`;
+            const symbol = vaultParams.symbol || `pxAGT${this.config.agentId}`;
+            const result = await this.predictionVaultManager.createVault(seedAmount, name, symbol);
+            if (result.success) {
+              this.relay?.sendCommandResult(cmd.id, true, `Vault created: ${result.vaultAddress}`);
+              this.relay?.sendMessage(
+                "prediction_vault_created",
+                "success",
+                "Prediction Vault Created",
+                `Vault deployed at ${result.vaultAddress} with ${Number(seedAmount) / 1e6} USDC seed`,
+                { vaultAddress: result.vaultAddress, txHash: result.txHash }
+              );
+            } else {
+              this.relay?.sendCommandResult(cmd.id, false, result.error || "Vault creation failed");
+            }
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.relay?.sendCommandResult(cmd.id, false, `Vault creation failed: ${msg}`);
+          }
+          this.sendRelayStatus();
+          break;
+        }
+        case "deposit_prediction_vault": {
+          if (!this.predictionVaultManager?.hasVault) {
+            this.relay?.sendCommandResult(cmd.id, false, "No prediction vault exists");
+            break;
+          }
+          try {
+            const amount = BigInt(Number(cmd.params?.amount || 0) * 1e6);
+            if (amount <= 0n) {
+              this.relay?.sendCommandResult(cmd.id, false, "Amount must be positive");
+              break;
+            }
+            const result = await this.predictionVaultManager.deposit(amount);
+            if (result.success) {
+              this.relay?.sendCommandResult(cmd.id, true, `Deposited ${Number(amount) / 1e6} USDC`);
+              this.relay?.sendMessage(
+                "prediction_vault_deposit",
+                "success",
+                "Vault Deposit",
+                `${Number(amount) / 1e6} USDC deposited into prediction vault`,
+                { amount: Number(amount) / 1e6, txHash: result.txHash }
+              );
+            } else {
+              this.relay?.sendCommandResult(cmd.id, false, result.error || "Deposit failed");
+            }
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.relay?.sendCommandResult(cmd.id, false, `Deposit failed: ${msg}`);
+          }
+          this.sendRelayStatus();
+          break;
+        }
+        case "withdraw_prediction_vault": {
+          if (!this.predictionVaultManager?.hasVault) {
+            this.relay?.sendCommandResult(cmd.id, false, "No prediction vault exists");
+            break;
+          }
+          try {
+            const isEmergency = cmd.params?.emergency === true;
+            const result = isEmergency ? await this.predictionVaultManager.emergencyWithdraw() : await this.predictionVaultManager.withdrawAll();
+            if (result.success) {
+              this.relay?.sendCommandResult(cmd.id, true, isEmergency ? "Emergency withdrawn (penalty applied)" : "Withdrawn all shares");
+              this.relay?.sendMessage(
+                "prediction_vault_withdraw",
+                isEmergency ? "warning" : "success",
+                isEmergency ? "Emergency Withdrawal" : "Vault Withdrawal",
+                isEmergency ? "Emergency withdrawn with penalty" : "All shares redeemed from prediction vault",
+                { emergency: isEmergency, txHash: result.txHash }
+              );
+            } else {
+              this.relay?.sendCommandResult(cmd.id, false, result.error || "Withdrawal failed");
+            }
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.relay?.sendCommandResult(cmd.id, false, `Withdrawal failed: ${msg}`);
+          }
+          this.sendRelayStatus();
+          break;
+        }
         case "start_paper_trading":
           if (this.mode === "paper") {
             this.relay?.sendCommandResult(cmd.id, true, "Already paper trading");
@@ -7029,7 +9300,7 @@ var AgentRuntime = class {
     try {
       const onChain = await this.client.registry.getConfigHash(BigInt(this.config.agentId));
       if (onChain === this.pendingConfigHash) {
-        this.configHash = this.pendingConfigHash;
+        this.updateConfigHashEverywhere(this.pendingConfigHash);
         this.pendingConfigHash = null;
         console.log("Config verified on-chain! Your agent will now appear on the leaderboard.");
         this.relay?.sendMessage(
@@ -7042,6 +9313,34 @@ var AgentRuntime = class {
     } catch {
     }
   }
+  /**
+   * Periodically sync config hash from on-chain to detect external changes.
+   * This catches cases where the config was changed via the website or another
+   * session while this agent is running. Without this, all trades and recordings
+   * fail with ConfigMismatch until the agent is restarted.
+   *
+   * Called from sendRelayStatus at most every 5 minutes (timestamp-throttled).
+   */
+  lastConfigSyncAt = 0;
+  async syncConfigHashFromChain() {
+    try {
+      const onChain = await this.client.registry.getConfigHash(BigInt(this.config.agentId));
+      if (onChain && onChain !== this.configHash && onChain !== "0x0000000000000000000000000000000000000000000000000000000000000000") {
+        console.log(`Config hash changed on-chain (external update detected): ${this.configHash} \u2192 ${onChain}`);
+        this.updateConfigHashEverywhere(onChain);
+      }
+    } catch {
+    }
+  }
+  /**
+   * Propagate a config hash update to runtime + all consumers (recorders).
+   * Ensures executor, perp recorder, and prediction recorder all stay in sync.
+   */
+  updateConfigHashEverywhere(newHash) {
+    this.configHash = newHash;
+    this.perpRecorder?.updateConfigHash(newHash);
+    this.predictionRecorder?.updateConfigHash(newHash);
+  }
   /**
    * Send current status to the relay
    */
@@ -7052,6 +9351,11 @@ var AgentRuntime = class {
       this.lastConfigCheckAt = Date.now();
       this.checkPendingConfigApproval();
     }
+    const CONFIG_SYNC_INTERVAL_MS = 3e5;
+    if (!this.pendingConfigHash && Date.now() - this.lastConfigSyncAt >= CONFIG_SYNC_INTERVAL_MS) {
+      this.lastConfigSyncAt = Date.now();
+      this.syncConfigHashFromChain();
+    }
     const vaultConfig = this.config.vault || { policy: "disabled" };
     const status = {
       mode: this.mode,
@@ -7089,6 +9393,19 @@ var AgentRuntime = class {
         effectiveLeverage: this.cachedPerpLeverage,
         pendingRecords: this.perpRecorder?.pendingRetries ?? 0
       } : void 0,
+      prediction: this.predictionConnected ? {
+        enabled: true,
+        trading: this.predictionTradingActive,
+        polygonUSDC: this.cachedPredictionPolygonUSDC,
+        baseUSDC: this.cachedPredictionBaseUSDC,
+        totalExposure: this.cachedPredictionExposure,
+        openMarkets: this.cachedPredictionOpenMarkets,
+        openPositions: this.cachedPredictionOpenPositions,
+        unrealizedPnl: this.cachedPredictionUnrealizedPnl,
+        pendingFees: this.predictionRecorder?.pendingFeesUSD ?? 0,
+        pendingRecords: this.predictionRecorder?.pendingRetries ?? 0,
+        vault: this.cachedPredictionVaultStatus
+      } : void 0,
       positions: this.positionTracker ? this.positionTracker.getPositionSummary(this.lastPrices) : void 0,
       paper: this.mode === "paper" && this.paperPortfolio ? (() => {
         const summary = this.paperPortfolio.getSummary(this.lastPrices);
@@ -7131,6 +9448,39 @@ var AgentRuntime = class {
       }).catch(() => {
       });
     }
+    if (this.predictionConnected && this.predictionPositions && this.predictionFunding) {
+      this.predictionPositions.getAccountSummary().then((summary) => {
+        this.cachedPredictionExposure = summary.totalExposure;
+        this.cachedPredictionOpenMarkets = summary.openMarketCount;
+        this.cachedPredictionOpenPositions = summary.openPositionCount;
+        this.cachedPredictionUnrealizedPnl = summary.totalUnrealizedPnl;
+      }).catch(() => {
+      });
+      this.predictionFunding.getPolygonUSDCBalance().then((bal) => {
+        this.cachedPredictionPolygonUSDC = Number(bal) / 1e6;
+      }).catch(() => {
+      });
+      this.predictionFunding.getBaseUSDCBalance().then((bal) => {
+        this.cachedPredictionBaseUSDC = Number(bal) / 1e6;
+      }).catch(() => {
+      });
+      if (this.predictionVaultManager?.hasVault) {
+        this.predictionVaultManager.getVaultStatus().then((vs) => {
+          if (vs.hasVault) {
+            this.cachedPredictionVaultStatus = {
+              address: vs.vaultAddress,
+              totalAssets: Number(vs.totalAssets) / 1e6,
+              sharePrice: vs.sharePrice,
+              cachedCtfValue: Number(vs.cachedCtfValue) / 1e6,
+              currentExposureBps: vs.currentExposureBps,
+              circuitBreakerActive: vs.circuitBreakerActive,
+              isPaused: vs.isPaused
+            };
+          }
+        }).catch(() => {
+        });
+      }
+    }
   }
   /**
    * Run a single trading cycle
@@ -7328,6 +9678,15 @@ var AgentRuntime = class {
         this.relay?.sendMessage("system", "error", "Perp Cycle Error", message);
       }
     }
+    if (!isPaper && this.predictionConnected && this.predictionTradingActive) {
+      try {
+        await this.runPredictionCycle();
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error("Error in prediction cycle:", message);
+        this.relay?.sendMessage("system", "error", "Prediction Cycle Error", message);
+      }
+    }
     this.sendRelayStatus();
   }
   /**
@@ -7388,6 +9747,101 @@ var AgentRuntime = class {
       }
     }
   }
+  /**
+   * Run a single prediction market trading cycle.
+   * Fetches active markets, positions, calls prediction strategy, executes signals.
+   * Fills are recorded on Base via Router.recordPerpTrade() with POLY: prefix.
+   */
+  async runPredictionCycle() {
+    if (!this.predictionClient || !this.predictionOrders || !this.predictionPositions || !this.predictionRecorder || !this.predictionBrowser || !this.predictionConnected) return;
+    const predictionConfig = this.config.prediction;
+    if (!predictionConfig?.enabled) return;
+    console.log("  [POLY] Running prediction cycle...");
+    try {
+      const newFills = await this.predictionOrders.pollNewFills();
+      if (newFills.length > 0) {
+        console.log(`  [POLY] ${newFills.length} new fill(s) detected`);
+        for (const fill of newFills) {
+          this.predictionPositions.processFill(fill);
+          const result = await this.predictionRecorder.recordFill(fill);
+          if (result.success) {
+            this.relay?.sendMessage(
+              "prediction_fill",
+              "success",
+              "Prediction Fill",
+              `${fill.side} ${fill.size} @ $${parseFloat(fill.price).toFixed(2)} \u2014 market ${fill.marketConditionId.slice(0, 12)}...`,
+              { tradeId: fill.tradeId, side: fill.side, size: fill.size, price: fill.price, txHash: result.txHash }
+            );
+          }
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn("  [POLY] Fill polling failed:", message);
+    }
+    const account = await this.predictionPositions.getAccountSummary();
+    const positions = await this.predictionPositions.getPositions();
+    console.log(`  [POLY] Polygon USDC: $${account.polygonUSDC.toFixed(2)}, Positions: ${positions.length}, Exposure: $${account.totalExposure.toFixed(2)}`);
+    if (!this.predictionStrategy) {
+      return;
+    }
+    let markets;
+    try {
+      const category = predictionConfig.allowedCategories?.[0];
+      markets = await this.predictionBrowser.getActiveMarkets({
+        limit: 50,
+        category
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("  [POLY] Market fetch error:", message);
+      return;
+    }
+    let signals;
+    try {
+      signals = await this.predictionStrategy(
+        markets,
+        positions,
+        account,
+        this.llm,
+        this.config
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("  [POLY] Strategy error:", message);
+      return;
+    }
+    console.log(`  [POLY] Strategy generated ${signals.length} signals`);
+    for (const signal of signals) {
+      if (signal.action === "hold") continue;
+      const result = await this.predictionOrders.executeSignal(signal);
+      if (result.success) {
+        console.log(`  [POLY] Order placed: ${signal.action} "${signal.marketQuestion.slice(0, 50)}..." \u2014 ${result.status}`);
+      } else {
+        console.warn(`  [POLY] Order failed: ${signal.action} \u2014 ${result.error}`);
+      }
+    }
+    const pendingFees = this.predictionRecorder.pendingFeesUSD;
+    const threshold = predictionConfig.feeBridgeThresholdUSD ?? 10;
+    if (pendingFees >= threshold && this.predictionFunding) {
+      console.log(`  [POLY] Bridging $${pendingFees.toFixed(2)} in accumulated fees to Base...`);
+      const feeAmount = BigInt(Math.floor(pendingFees * 1e6));
+      try {
+        const bridgeResult = await this.predictionFunding.withdrawToBase(feeAmount, (step) => {
+          console.log(`  [POLY] Fee bridge: ${step}`);
+        });
+        if (bridgeResult.success) {
+          this.predictionRecorder.resetAccumulatedFees();
+          console.log(`  [POLY] Fee bridge complete: $${pendingFees.toFixed(2)} \u2192 Base`);
+        } else {
+          console.warn(`  [POLY] Fee bridge failed: ${bridgeResult.error}`);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`  [POLY] Fee bridge error: ${message}`);
+      }
+    }
+  }
   /**
    * Check if ETH balance is below threshold and notify.
    * Returns true if trading should continue, false if ETH is critically low.
@@ -7439,6 +9893,14 @@ var AgentRuntime = class {
     if (this.perpRecorder) {
       this.perpRecorder.stop();
     }
+    this.predictionConnected = false;
+    this.predictionTradingActive = false;
+    if (this.predictionVaultManager) {
+      this.predictionVaultManager.stop();
+    }
+    if (this.predictionRecorder) {
+      this.predictionRecorder.stop();
+    }
     if (this.relay) {
       this.relay.disconnect();
     }
@@ -7456,8 +9918,8 @@ var AgentRuntime = class {
    * for Frontier agents trading outside the whitelist) stay visible.
    */
   getTokensToTrack() {
-    const base6 = this.config.allowedTokens || this.getDefaultTokens();
-    const baseSet = new Set(base6.map((t) => t.toLowerCase()));
+    const base8 = this.config.allowedTokens || this.getDefaultTokens();
+    const baseSet = new Set(base8.map((t) => t.toLowerCase()));
     const trackedPositions = this.positionTracker.getPositions();
     const extras = [];
     for (const pos of trackedPositions) {
@@ -7480,7 +9942,7 @@ var AgentRuntime = class {
       console.log(`Auto-tracking ${extras.length} additional token(s) from position history`);
     }
     const resolver = this.marketData.getResolver();
-    const allTokens = [...base6, ...extras];
+    const allTokens = [...base8, ...extras];
     const filtered = allTokens.filter((t) => !resolver.isUnresolvable(t.toLowerCase()));
     const dropped = allTokens.length - filtered.length;
     if (dropped > 0) {
@@ -7633,7 +10095,7 @@ var AgentRuntime = class {
 };
 
 // src/cli.ts
-var import_accounts6 = require("viem/accounts");
+var import_accounts9 = require("viem/accounts");
 (0, import_dotenv2.config)();
 var program = new import_commander.Command();
 program.name("exagent").description("Exagent autonomous trading agent").version("0.1.0");
@@ -7741,8 +10203,8 @@ async function checkFirstRunSetup(configPath) {
     console.log("");
     console.log("[WALLET] Generating a new wallet for your agent...");
     console.log("");
-    const generatedKey = (0, import_accounts6.generatePrivateKey)();
-    const account = (0, import_accounts6.privateKeyToAccount)(generatedKey);
+    const generatedKey = (0, import_accounts9.generatePrivateKey)();
+    const account = (0, import_accounts9.privateKeyToAccount)(generatedKey);
     privateKey = generatedKey;
     walletAddress = account.address;
     console.log("  New wallet created!");
@@ -7773,7 +10235,7 @@ async function checkFirstRunSetup(configPath) {
       process.exit(1);
     }
     try {
-      const account = (0, import_accounts6.privateKeyToAccount)(privateKey);
+      const account = (0, import_accounts9.privateKeyToAccount)(privateKey);
       walletAddress = account.address;
       console.log("");
       console.log(`  Wallet address: ${walletAddress}`);
@@ -8268,8 +10730,8 @@ program.command("export-key").description("Display your trading wallet private k
       console.error("");
       process.exit(1);
     }
-    const { privateKeyToAccount: privateKeyToAccount7 } = await import("viem/accounts");
-    const account = privateKeyToAccount7(privateKey);
+    const { privateKeyToAccount: privateKeyToAccount10 } = await import("viem/accounts");
+    const account = privateKeyToAccount10(privateKey);
     console.log("");
     console.log("=".repeat(60));
     console.log("  WALLET PRIVATE KEY EXPORT");