@exagent/agent 0.1.11 → 0.1.13

package/dist/index.js

@@ -69,7 +69,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/runtime.ts
-var import_sdk = require("@exagent/sdk");
+var import_sdk2 = require("@exagent/sdk");
 var import_viem3 = require("viem");
 var import_chains2 = require("viem/chains");
 
@@ -820,7 +820,7 @@ export const generateSignals: StrategyFunction = async (marketData, llm, config)
     riskWarnings: [
       "Custom strategies have no guardrails - you are fully responsible",
       "LLMs can hallucinate or make errors - always validate outputs",
-      "Test thoroughly on testnet before using real funds",
+      "Start with small amounts before scaling up",
       "Consider edge cases: what happens if the LLM returns invalid JSON?",
       "Your prompts and strategy logic are your competitive advantage - protect them",
       "Agents may not behave exactly as expected based on your prompts"
@@ -882,9 +882,13 @@ function getAllStrategyTemplates() {
 var TradeExecutor = class {
   client;
   config;
+  allowedTokens;
   constructor(client, config) {
     this.client = client;
     this.config = config;
+    this.allowedTokens = new Set(
+      (config.allowedTokens || []).map((t) => t.toLowerCase())
+    );
   }
   /**
    * Execute a single trade signal
@@ -903,8 +907,7 @@ var TradeExecutor = class {
         tokenIn: signal.tokenIn,
         tokenOut: signal.tokenOut,
         amountIn: signal.amountIn,
-        maxSlippageBps: 100
-        // 1% default slippage
+        maxSlippageBps: this.config.trading?.maxSlippageBps ?? 100
       });
       console.log(`Trade executed: ${result.hash}`);
       return { success: true, txHash: result.hash };
@@ -930,13 +933,25 @@ var TradeExecutor = class {
     return results;
   }
   /**
-   * Validate a signal against config limits
+   * Validate a signal against config limits and token restrictions
    */
   validateSignal(signal) {
     if (signal.confidence < 0.5) {
       console.warn(`Signal confidence ${signal.confidence} below threshold (0.5)`);
       return false;
     }
+    if (this.allowedTokens.size > 0) {
+      const tokenInAllowed = this.allowedTokens.has(signal.tokenIn.toLowerCase());
+      const tokenOutAllowed = this.allowedTokens.has(signal.tokenOut.toLowerCase());
+      if (!tokenInAllowed) {
+        console.warn(`Token ${signal.tokenIn} not in allowed list for this agent's risk universe \u2014 skipping`);
+        return false;
+      }
+      if (!tokenOutAllowed) {
+        console.warn(`Token ${signal.tokenOut} not in allowed list for this agent's risk universe \u2014 skipping`);
+        return false;
+      }
+    }
     return true;
   }
   delay(ms) {
@@ -944,103 +959,99 @@ var TradeExecutor = class {
   }
 };
 
-// src/trading/risk.ts
-var RiskManager = class {
-  config;
-  dailyPnL = 0;
-  lastResetDate = "";
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Filter signals through risk checks
-   * Returns only signals that pass all guardrails
-   */
-  filterSignals(signals, marketData) {
-    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    if (today !== this.lastResetDate) {
-      this.dailyPnL = 0;
-      this.lastResetDate = today;
-    }
-    if (this.isDailyLossLimitHit(marketData.portfolioValue)) {
-      console.warn("Daily loss limit reached - no new trades");
-      return [];
-    }
-    return signals.filter((signal) => this.validateSignal(signal, marketData));
-  }
-  /**
-   * Validate individual signal against risk limits
-   */
-  validateSignal(signal, marketData) {
-    if (signal.action === "hold") {
-      return true;
-    }
-    const signalValue = this.estimateSignalValue(signal, marketData);
-    const maxPositionValue = marketData.portfolioValue * this.config.maxPositionSizeBps / 1e4;
-    if (signalValue > maxPositionValue) {
-      console.warn(
-        `Signal exceeds position limit: ${signalValue.toFixed(2)} > ${maxPositionValue.toFixed(2)}`
-      );
-      return false;
-    }
-    if (signal.confidence < 0.5) {
-      console.warn(`Signal confidence too low: ${signal.confidence}`);
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Check if daily loss limit has been hit
-   */
-  isDailyLossLimitHit(portfolioValue) {
-    const maxLoss = portfolioValue * this.config.maxDailyLossBps / 1e4;
-    return this.dailyPnL < -maxLoss;
-  }
-  /**
-   * Estimate USD value of a trade signal
-   */
-  estimateSignalValue(signal, marketData) {
-    const price = marketData.prices[signal.tokenIn] || 0;
-    const amount = Number(signal.amountIn) / 1e18;
-    return amount * price;
-  }
-  /**
-   * Update daily PnL after a trade
-   */
-  updatePnL(pnl) {
-    this.dailyPnL += pnl;
-  }
-  /**
-   * Get current risk status
-   */
-  getStatus() {
-    return {
-      dailyPnL: this.dailyPnL,
-      dailyLossLimit: this.config.maxDailyLossBps / 100,
-      // As percentage
-      isLimitHit: this.dailyPnL < -(this.config.maxDailyLossBps / 100)
-    };
-  }
-};
-
 // src/trading/market.ts
 var import_viem = require("viem");
 var NATIVE_ETH = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
-var USDC_DECIMALS = {
+var TOKEN_DECIMALS = {
+  // Base Mainnet — Core tokens
   "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913": 6,
-  // USDC on Base
-  "0xd9aaec86b65d86f6a7b5b1b0c42ffa531710b6ca": 6
-  // USDbC on Base
+  // USDC
+  "0xd9aaec86b65d86f6a7b5b1b0c42ffa531710b6ca": 6,
+  // USDbC
+  "0x4200000000000000000000000000000000000006": 18,
+  // WETH
+  "0x50c5725949a6f0c72e6c4a641f24049a917db0cb": 18,
+  // DAI
+  "0x2ae3f1ec7f1f5012cfeab0185bfc7aa3cf0dec22": 18,
+  // cbETH
+  [NATIVE_ETH.toLowerCase()]: 18,
+  // Native ETH
+  // Base Mainnet — Established tokens
+  "0x940181a94a35a4569e4529a3cdfb74e38fd98631": 18,
+  // AERO (Aerodrome)
+  "0x532f27101965dd16442e59d40670faf5ebb142e4": 18,
+  // BRETT
+  "0x4ed4e862860bed51a9570b96d89af5e1b0efefed": 18,
+  // DEGEN
+  "0x0b3e328455c4059eeb9e3f84b5543f74e24e7e1b": 18,
+  // VIRTUAL
+  "0xac1bd2486aaf3b5c0fc3fd868558b082a531b2b4": 18,
+  // TOSHI
+  "0xcbb7c0000ab88b473b1f5afd9ef808440eed33bf": 8,
+  // cbBTC
+  "0x2416092f143378750bb29b79ed961ab195cceea5": 18,
+  // ezETH (Renzo)
+  "0xc1cba3fcea344f92d9239c08c0568f6f2f0ee452": 18
+  // wstETH (Lido)
 };
+function getTokenDecimals(address) {
+  const decimals = TOKEN_DECIMALS[address.toLowerCase()];
+  if (decimals === void 0) {
+    console.warn(`Unknown token decimals for ${address}, defaulting to 18. THIS MAY BE WRONG.`);
+    return 18;
+  }
+  return decimals;
+}
+var TOKEN_TO_COINGECKO = {
+  // Core
+  "0x4200000000000000000000000000000000000006": "ethereum",
+  // WETH
+  [NATIVE_ETH.toLowerCase()]: "ethereum",
+  "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913": "usd-coin",
+  // USDC
+  "0xd9aaec86b65d86f6a7b5b1b0c42ffa531710b6ca": "usd-coin",
+  // USDbC
+  "0x2ae3f1ec7f1f5012cfeab0185bfc7aa3cf0dec22": "coinbase-wrapped-staked-eth",
+  // cbETH
+  "0x50c5725949a6f0c72e6c4a641f24049a917db0cb": "dai",
+  // DAI
+  // Established
+  "0x940181a94a35a4569e4529a3cdfb74e38fd98631": "aerodrome-finance",
+  // AERO
+  "0x532f27101965dd16442e59d40670faf5ebb142e4": "brett",
+  // BRETT
+  "0x4ed4e862860bed51a9570b96d89af5e1b0efefed": "degen-base",
+  // DEGEN
+  "0x0b3e328455c4059eeb9e3f84b5543f74e24e7e1b": "virtual-protocol",
+  // VIRTUAL
+  "0xac1bd2486aaf3b5c0fc3fd868558b082a531b2b4": "toshi",
+  // TOSHI
+  "0xcbb7c0000ab88b473b1f5afd9ef808440eed33bf": "coinbase-wrapped-btc",
+  // cbBTC
+  "0x2416092f143378750bb29b79ed961ab195cceea5": "renzo-restaked-eth",
+  // ezETH
+  "0xc1cba3fcea344f92d9239c08c0568f6f2f0ee452": "wrapped-steth"
+  // wstETH
+};
+var STABLECOIN_IDS = /* @__PURE__ */ new Set(["usd-coin", "dai"]);
+var PRICE_STALENESS_MS = 6e4;
 var MarketDataService = class {
   rpcUrl;
   client;
+  /** Cached prices from last fetch */
+  cachedPrices = {};
+  /** Timestamp of last successful price fetch */
+  lastPriceFetchAt = 0;
   constructor(rpcUrl) {
     this.rpcUrl = rpcUrl;
     this.client = (0, import_viem.createPublicClient)({
       transport: (0, import_viem.http)(rpcUrl)
     });
   }
+  /** Cached volume data */
+  cachedVolume24h = {};
+  /** Cached price change data */
+  cachedPriceChange24h = {};
   /**
    * Fetch current market data for the agent
    */
@@ -1048,31 +1059,126 @@ var MarketDataService = class {
     const prices = await this.fetchPrices(tokenAddresses);
     const balances = await this.fetchBalances(walletAddress, tokenAddresses);
     const portfolioValue = this.calculatePortfolioValue(balances, prices);
+    let gasPrice;
+    try {
+      gasPrice = await this.client.getGasPrice();
+    } catch {
+    }
     return {
       timestamp: Date.now(),
       prices,
       balances,
-      portfolioValue
+      portfolioValue,
+      volume24h: Object.keys(this.cachedVolume24h).length > 0 ? { ...this.cachedVolume24h } : void 0,
+      priceChange24h: Object.keys(this.cachedPriceChange24h).length > 0 ? { ...this.cachedPriceChange24h } : void 0,
+      gasPrice,
+      network: {
+        chainId: this.client.chain?.id ?? 8453
+      }
     };
   }
   /**
-   * Fetch token prices from price oracle
+   * Check if cached prices are still fresh
+   */
+  get pricesAreFresh() {
+    return Date.now() - this.lastPriceFetchAt < PRICE_STALENESS_MS;
+  }
+  /**
+   * Fetch token prices from CoinGecko free API
+   * Returns cached prices if still fresh (<60s old)
    */
   async fetchPrices(tokenAddresses) {
+    if (this.pricesAreFresh && Object.keys(this.cachedPrices).length > 0) {
+      const prices2 = { ...this.cachedPrices };
+      for (const addr of tokenAddresses) {
+        const cgId = TOKEN_TO_COINGECKO[addr.toLowerCase()];
+        if (cgId && STABLECOIN_IDS.has(cgId) && !prices2[addr.toLowerCase()]) {
+          prices2[addr.toLowerCase()] = 1;
+        }
+      }
+      return prices2;
+    }
     const prices = {};
-    const knownPrices = {
-      // Native ETH (sentinel address)
-      [NATIVE_ETH.toLowerCase()]: 3500,
-      // WETH
-      "0x4200000000000000000000000000000000000006": 3500,
-      // USDC
-      "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913": 1,
-      // USDbC (bridged USDC)
-      "0xd9aaec86b65d86f6a7b5b1b0c42ffa531710b6ca": 1
-    };
-    prices[NATIVE_ETH.toLowerCase()] = knownPrices[NATIVE_ETH.toLowerCase()];
-    for (const address of tokenAddresses) {
-      prices[address.toLowerCase()] = knownPrices[address.toLowerCase()] || 0;
+    const idsToFetch = /* @__PURE__ */ new Set();
+    for (const addr of tokenAddresses) {
+      const cgId = TOKEN_TO_COINGECKO[addr.toLowerCase()];
+      if (cgId && !STABLECOIN_IDS.has(cgId)) {
+        idsToFetch.add(cgId);
+      }
+    }
+    idsToFetch.add("ethereum");
+    if (idsToFetch.size > 0) {
+      try {
+        const ids = Array.from(idsToFetch).join(",");
+        const response = await fetch(
+          `https://api.coingecko.com/api/v3/simple/price?ids=${ids}&vs_currencies=usd&include_24hr_vol=true&include_24hr_change=true`,
+          { signal: AbortSignal.timeout(5e3) }
+        );
+        if (response.ok) {
+          const data = await response.json();
+          for (const [cgId, priceData] of Object.entries(data)) {
+            for (const [addr, id] of Object.entries(TOKEN_TO_COINGECKO)) {
+              if (id === cgId) {
+                const key = addr.toLowerCase();
+                prices[key] = priceData.usd;
+                if (priceData.usd_24h_vol !== void 0) {
+                  this.cachedVolume24h[key] = priceData.usd_24h_vol;
+                }
+                if (priceData.usd_24h_change !== void 0) {
+                  this.cachedPriceChange24h[key] = priceData.usd_24h_change;
+                }
+              }
+            }
+          }
+          this.lastPriceFetchAt = Date.now();
+        } else {
+          console.warn(`CoinGecko API returned ${response.status}, using cached prices`);
+        }
+      } catch (error) {
+        console.warn("Failed to fetch prices from CoinGecko:", error instanceof Error ? error.message : error);
+      }
+    }
+    for (const addr of tokenAddresses) {
+      const cgId = TOKEN_TO_COINGECKO[addr.toLowerCase()];
+      if (cgId && STABLECOIN_IDS.has(cgId)) {
+        prices[addr.toLowerCase()] = 1;
+      }
+    }
+    const missingAddrs = tokenAddresses.filter(
+      (addr) => !prices[addr.toLowerCase()] && !STABLECOIN_IDS.has(TOKEN_TO_COINGECKO[addr.toLowerCase()] || "")
+    );
+    if (missingAddrs.length > 0) {
+      try {
+        const coins = missingAddrs.map((a) => `base:${a}`).join(",");
+        const llamaResponse = await fetch(
+          `https://coins.llama.fi/prices/current/${coins}`,
+          { signal: AbortSignal.timeout(5e3) }
+        );
+        if (llamaResponse.ok) {
+          const llamaData = await llamaResponse.json();
+          for (const [key, data] of Object.entries(llamaData.coins)) {
+            const addr = key.replace("base:", "").toLowerCase();
+            if (data.price && data.confidence > 0.5) {
+              prices[addr] = data.price;
+            }
+          }
+          if (!this.lastPriceFetchAt) this.lastPriceFetchAt = Date.now();
+        }
+      } catch {
+      }
+    }
+    if (Object.keys(prices).length > 0) {
+      this.cachedPrices = prices;
+    }
+    if (Object.keys(prices).length === 0 && Object.keys(this.cachedPrices).length > 0) {
+      console.warn("Using cached prices (last successful fetch was stale)");
+      return { ...this.cachedPrices };
+    }
+    for (const addr of tokenAddresses) {
+      if (!prices[addr.toLowerCase()]) {
+        console.warn(`No price available for ${addr}, using 0`);
+        prices[addr.toLowerCase()] = 0;
+      }
     }
     return prices;
   }
@@ -1118,7 +1224,7 @@ var MarketDataService = class {
     let total = 0;
     for (const [address, balance] of Object.entries(balances)) {
       const price = prices[address.toLowerCase()] || 0;
-      const decimals = USDC_DECIMALS[address.toLowerCase()] || 18;
+      const decimals = getTokenDecimals(address);
       const amount = Number(balance) / Math.pow(10, decimals);
       total += amount * price;
     }
@@ -1126,22 +1232,138 @@ var MarketDataService = class {
   }
 };
 
+// src/trading/risk.ts
+var RiskManager = class {
+  config;
+  dailyPnL = 0;
+  dailyFees = 0;
+  lastResetDate = "";
+  /** Minimum trade value in USD — trades below this are rejected as dust */
+  minTradeValueUSD;
+  constructor(config) {
+    this.config = config;
+    this.minTradeValueUSD = config.minTradeValueUSD ?? 1;
+  }
+  /**
+   * Filter signals through risk checks
+   * Returns only signals that pass all guardrails
+   */
+  filterSignals(signals, marketData) {
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    if (today !== this.lastResetDate) {
+      this.dailyPnL = 0;
+      this.dailyFees = 0;
+      this.lastResetDate = today;
+    }
+    if (this.isDailyLossLimitHit(marketData.portfolioValue)) {
+      console.warn("Daily loss limit reached - no new trades");
+      return [];
+    }
+    return signals.filter((signal) => this.validateSignal(signal, marketData));
+  }
+  /**
+   * Validate individual signal against risk limits
+   */
+  validateSignal(signal, marketData) {
+    if (signal.action === "hold") {
+      return true;
+    }
+    const signalValue = this.estimateSignalValue(signal, marketData);
+    const maxPositionValue = marketData.portfolioValue * this.config.maxPositionSizeBps / 1e4;
+    if (signalValue > maxPositionValue) {
+      console.warn(
+        `Signal exceeds position limit: ${signalValue.toFixed(2)} > ${maxPositionValue.toFixed(2)}`
+      );
+      return false;
+    }
+    if (signal.confidence < 0.5) {
+      console.warn(`Signal confidence too low: ${signal.confidence}`);
+      return false;
+    }
+    if (signal.action === "buy" && this.config.maxConcurrentPositions) {
+      const activePositions = this.countActivePositions(marketData);
+      if (activePositions >= this.config.maxConcurrentPositions) {
+        console.warn(
+          `Max concurrent positions reached: ${activePositions}/${this.config.maxConcurrentPositions} \u2014 blocking new buy`
+        );
+        return false;
+      }
+    }
+    if (signalValue < this.minTradeValueUSD) {
+      console.warn(`Trade value $${signalValue.toFixed(2)} below minimum $${this.minTradeValueUSD} \u2014 skipping`);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Count non-zero token positions (excluding native ETH and stablecoins used as base currency)
+   */
+  countActivePositions(marketData) {
+    const NATIVE_ETH_KEY = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+    let count = 0;
+    for (const [address, balance] of Object.entries(marketData.balances)) {
+      if (address.toLowerCase() === NATIVE_ETH_KEY) continue;
+      if (balance > 0n) count++;
+    }
+    return count;
+  }
+  /**
+   * Check if daily loss limit has been hit
+   */
+  isDailyLossLimitHit(portfolioValue) {
+    const maxLoss = portfolioValue * this.config.maxDailyLossBps / 1e4;
+    return this.dailyPnL < -maxLoss;
+  }
+  /**
+   * Estimate USD value of a trade signal
+   */
+  estimateSignalValue(signal, marketData) {
+    const price = marketData.prices[signal.tokenIn.toLowerCase()] || 0;
+    const tokenDecimals = getTokenDecimals(signal.tokenIn);
+    const amount = Number(signal.amountIn) / Math.pow(10, tokenDecimals);
+    return amount * price;
+  }
+  /**
+   * Update daily PnL after a trade (market gains/losses only)
+   */
+  updatePnL(pnl) {
+    this.dailyPnL += pnl;
+  }
+  /**
+   * Update daily fees (trading fees, gas costs, etc.)
+   * Fees are tracked separately and do NOT count toward the daily loss limit.
+   * This prevents protocol fees from triggering circuit breakers.
+   */
+  updateFees(fees) {
+    this.dailyFees += fees;
+  }
+  /**
+   * Get current risk status
+   * @param portfolioValue - Current portfolio value in USD (needed for accurate loss limit)
+   */
+  getStatus(portfolioValue) {
+    const pv = portfolioValue || 0;
+    const maxLossUSD = pv * this.config.maxDailyLossBps / 1e4;
+    return {
+      dailyPnL: this.dailyPnL,
+      dailyFees: this.dailyFees,
+      dailyNetPnL: this.dailyPnL - this.dailyFees,
+      dailyLossLimit: maxLossUSD,
+      // Only market PnL triggers the limit — fees are excluded
+      isLimitHit: pv > 0 ? this.dailyPnL < -maxLossUSD : false
+    };
+  }
+};
+
 // src/vault/manager.ts
 var import_viem2 = require("viem");
 var import_accounts = require("viem/accounts");
 var import_chains = require("viem/chains");
 var ADDRESSES = {
-  testnet: {
-    vaultFactory: "0x5c099daaE33801a907Bb57011c6749655b55dc75",
-    registry: "0xCF48C341e3FebeCA5ECB7eb2535f61A2Ba855d9C",
-    usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
-  },
   mainnet: {
-    vaultFactory: "0x0000000000000000000000000000000000000000",
-    // TODO: Deploy
-    registry: "0x0000000000000000000000000000000000000000",
+    vaultFactory: process.env.EXAGENT_VAULT_FACTORY_ADDRESS || "0x0000000000000000000000000000000000000000",
+    registry: process.env.EXAGENT_REGISTRY_ADDRESS || "0x0000000000000000000000000000000000000000",
     usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
-    // Base mainnet USDC
   }
 };
 var VAULT_FACTORY_ABI = [
@@ -1165,6 +1387,7 @@ var VAULT_FACTORY_ABI = [
     inputs: [
       { name: "agentId", type: "uint256" },
       { name: "asset", type: "address" },
+      { name: "seedAmount", type: "uint256" },
       { name: "name", type: "string" },
       { name: "symbol", type: "string" },
       { name: "feeRecipient", type: "address" }
@@ -1178,13 +1401,6 @@ var VAULT_FACTORY_ABI = [
     inputs: [],
     outputs: [{ type: "uint256" }],
     stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "eXABurnFee",
-    inputs: [],
-    outputs: [{ type: "uint256" }],
-    stateMutability: "view"
   }
 ];
 var VAULT_ABI = [
@@ -1224,12 +1440,13 @@ var VaultManager = class {
   lastVaultCheck = 0;
   VAULT_CACHE_TTL = 6e4;
   // 1 minute
+  enabled = true;
   constructor(config) {
     this.config = config;
     this.addresses = ADDRESSES[config.network];
     this.account = (0, import_accounts.privateKeyToAccount)(config.walletKey);
-    this.chain = config.network === "mainnet" ? import_chains.base : import_chains.baseSepolia;
-    const rpcUrl = config.network === "mainnet" ? "https://mainnet.base.org" : "https://sepolia.base.org";
+    this.chain = import_chains.base;
+    const rpcUrl = "https://mainnet.base.org";
     this.publicClient = (0, import_viem2.createPublicClient)({
       chain: this.chain,
       transport: (0, import_viem2.http)(rpcUrl)
@@ -1239,6 +1456,10 @@ var VaultManager = class {
       chain: this.chain,
       transport: (0, import_viem2.http)(rpcUrl)
     });
+    if (this.addresses.vaultFactory === "0x0000000000000000000000000000000000000000") {
+      console.warn("VaultFactory address is zero \u2014 vault operations will be disabled");
+      this.enabled = false;
+    }
   }
   /**
    * Get the agent's vault policy
@@ -1256,6 +1477,17 @@ var VaultManager = class {
    * Get comprehensive vault status
    */
   async getVaultStatus() {
+    if (!this.enabled) {
+      return {
+        hasVault: false,
+        vaultAddress: null,
+        totalAssets: BigInt(0),
+        canCreateVault: false,
+        cannotCreateReason: "Vault operations disabled (contract address not set)",
+        requirementsMet: false,
+        requirements: { veXARequired: BigInt(0), isBypassed: false }
+      };
+    }
     const vaultAddress = await this.getVaultAddress();
     const hasVault = vaultAddress !== null;
     let totalAssets = BigInt(0);
@@ -1290,22 +1522,16 @@ var VaultManager = class {
   }
   /**
    * Get vault creation requirements
+   * Note: No burnFee on mainnet — vault creation requires USDC seed instead
    */
   async getRequirements() {
-    const [veXARequired, burnFee] = await Promise.all([
-      this.publicClient.readContract({
-        address: this.addresses.vaultFactory,
-        abi: VAULT_FACTORY_ABI,
-        functionName: "minimumVeEXARequired"
-      }),
-      this.publicClient.readContract({
-        address: this.addresses.vaultFactory,
-        abi: VAULT_FACTORY_ABI,
-        functionName: "eXABurnFee"
-      })
-    ]);
-    const isBypassed = veXARequired === BigInt(0) && burnFee === BigInt(0);
-    return { veXARequired, burnFee, isBypassed };
+    const veXARequired = await this.publicClient.readContract({
+      address: this.addresses.vaultFactory,
+      abi: VAULT_FACTORY_ABI,
+      functionName: "minimumVeEXARequired"
+    });
+    const isBypassed = veXARequired === BigInt(0);
+    return { veXARequired, isBypassed };
   }
   /**
    * Get the agent's vault address (cached)
@@ -1329,30 +1555,15 @@ var VaultManager = class {
     this.cachedVaultAddress = vaultAddress;
     return vaultAddress;
   }
-  /**
-   * Check if the agent should create a vault based on policy and qualification
-   */
-  async shouldCreateVault() {
-    if (this.policy === "disabled") {
-      return { should: false, reason: "Vault creation disabled by policy" };
-    }
-    if (this.policy === "manual") {
-      return { should: false, reason: "Vault creation set to manual - waiting for owner instruction" };
-    }
-    const status = await this.getVaultStatus();
-    if (status.hasVault) {
-      return { should: false, reason: "Vault already exists" };
-    }
-    if (!status.canCreateVault) {
-      return { should: false, reason: status.cannotCreateReason || "Requirements not met" };
-    }
-    return { should: true, reason: "Agent is qualified and auto-creation is enabled" };
-  }
   /**
    * Create a vault for the agent
+   * @param seedAmount - USDC seed amount in raw units (default: 100e6 = 100 USDC)
    * @returns Vault address if successful
    */
-  async createVault() {
+  async createVault(seedAmount) {
+    if (!this.enabled) {
+      return { success: false, error: "Vault operations disabled (contract address not set)" };
+    }
     if (this.policy === "disabled") {
       return { success: false, error: "Vault creation disabled by policy" };
     }
@@ -1364,6 +1575,7 @@ var VaultManager = class {
     if (!status.canCreateVault) {
       return { success: false, error: status.cannotCreateReason || "Requirements not met" };
     }
+    const seed = seedAmount || BigInt(1e8);
     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;
@@ -1375,6 +1587,7 @@ var VaultManager = class {
         args: [
           this.config.agentId,
           this.addresses.usdc,
+          seed,
           vaultName,
           vaultSymbol,
           feeRecipient
@@ -1438,37 +1651,12 @@ var VaultManager = class {
       };
     }
   }
-  /**
-   * Run the auto-creation check (call this periodically in the agent loop)
-   * Only creates vault if policy is 'auto_when_qualified'
-   */
-  async checkAndAutoCreateVault() {
-    const shouldCreate = await this.shouldCreateVault();
-    if (!shouldCreate.should) {
-      const status = await this.getVaultStatus();
-      if (status.hasVault) {
-        return { action: "already_exists", vaultAddress: status.vaultAddress, reason: "Vault already exists" };
-      }
-      if (this.policy !== "auto_when_qualified") {
-        return { action: "skipped", reason: shouldCreate.reason };
-      }
-      return { action: "not_qualified", reason: shouldCreate.reason };
-    }
-    const result = await this.createVault();
-    if (result.success) {
-      return {
-        action: "created",
-        vaultAddress: result.vaultAddress,
-        reason: "Vault created automatically"
-      };
-    }
-    return { action: "not_qualified", reason: result.error || "Creation failed" };
-  }
 };
 
 // src/relay.ts
 var import_ws = __toESM(require("ws"));
 var import_accounts2 = require("viem/accounts");
+var import_sdk = require("@exagent/sdk");
 var RelayClient = class {
   config;
   ws = null;
@@ -1571,7 +1759,8 @@ var RelayClient = class {
       agentId: this.config.agentId,
       wallet: account.address,
       timestamp,
-      signature
+      signature,
+      sdkVersion: import_sdk.SDK_VERSION
     });
   }
   /**
@@ -1733,6 +1922,7 @@ function openBrowser(url) {
 
 // src/runtime.ts
 var FUNDS_LOW_THRESHOLD = 5e-3;
+var FUNDS_CRITICAL_THRESHOLD = 1e-3;
 var AgentRuntime = class {
   config;
   client;
@@ -1746,14 +1936,13 @@ var AgentRuntime = class {
   isRunning = false;
   mode = "idle";
   configHash;
-  lastVaultCheck = 0;
   cycleCount = 0;
   lastCycleAt = 0;
   lastPortfolioValue = 0;
   lastEthBalance = "0";
   processAlive = true;
-  VAULT_CHECK_INTERVAL = 3e5;
-  // Check vault status every 5 minutes
+  riskUniverse = 0;
+  allowedTokens = /* @__PURE__ */ new Set();
   constructor(config) {
     this.config = config;
   }
@@ -1762,7 +1951,7 @@ var AgentRuntime = class {
    */
   async initialize() {
     console.log(`Initializing agent: ${this.config.name} (ID: ${this.config.agentId})`);
-    this.client = new import_sdk.ExagentClient({
+    this.client = new import_sdk2.ExagentClient({
       privateKey: this.config.privateKey,
       network: this.config.network
     });
@@ -1773,6 +1962,7 @@ var AgentRuntime = class {
     }
     console.log(`Agent verified: ${agent.name}`);
     await this.ensureWalletLinked();
+    await this.loadTradingRestrictions();
     console.log(`Initializing LLM: ${this.config.llm.provider}`);
     this.llm = await createLLMAdapter(this.config.llm);
     const llmMeta = this.llm.getMetadata();
@@ -1840,12 +2030,8 @@ var AgentRuntime = class {
       console.log(`Vault TVL: ${Number(status.totalAssets) / 1e6} USDC`);
     } else {
       console.log("No vault exists for this agent");
-      if (vaultConfig.policy === "auto_when_qualified") {
-        if (status.canCreateVault) {
-          console.log("Agent is qualified to create vault - will attempt on next check");
-        } else {
-          console.log(`Cannot create vault yet: ${status.cannotCreateReason}`);
-        }
+      if (vaultConfig.policy === "manual") {
+        console.log("Vault creation is manual \u2014 use the command center to create one");
       }
     }
   }
@@ -1864,7 +2050,7 @@ var AgentRuntime = class {
       if (agent?.owner.toLowerCase() !== address.toLowerCase()) {
         const ccUrl = `https://exagent.io/agents/${encodeURIComponent(this.config.name)}/command-center`;
         const nonce = await this.client.registry.getNonce(address);
-        const linkMessage = import_sdk.ExagentRegistry.generateLinkMessage(
+        const linkMessage = import_sdk2.ExagentRegistry.generateLinkMessage(
           address,
           agentId,
           nonce
@@ -1904,6 +2090,49 @@ var AgentRuntime = class {
       console.log("Wallet already linked");
     }
   }
+  /**
+   * Load risk universe and allowed tokens from on-chain registry.
+   * This prevents the agent from wasting gas on trades that will revert.
+   */
+  async loadTradingRestrictions() {
+    const agentId = BigInt(this.config.agentId);
+    const RISK_UNIVERSE_NAMES = ["Core", "Established", "Derivatives", "Emerging", "Frontier"];
+    try {
+      this.riskUniverse = await this.client.registry.getRiskUniverse(agentId);
+      console.log(`Risk universe: ${RISK_UNIVERSE_NAMES[this.riskUniverse] || this.riskUniverse}`);
+      const configTokens = this.config.allowedTokens || this.getDefaultTokens();
+      const verified = [];
+      for (const token of configTokens) {
+        try {
+          const allowed = await this.client.registry.isTradeAllowed(
+            agentId,
+            token,
+            "0x0000000000000000000000000000000000000000"
+            // zero = check token only
+          );
+          if (allowed) {
+            this.allowedTokens.add(token.toLowerCase());
+            verified.push(token);
+          } else {
+            console.warn(`Token ${token} not allowed for this agent's risk universe \u2014 excluded`);
+          }
+        } catch {
+          this.allowedTokens.add(token.toLowerCase());
+          verified.push(token);
+        }
+      }
+      this.config.allowedTokens = verified;
+      console.log(`Allowed tokens loaded: ${verified.length} tokens verified`);
+      if (this.riskUniverse === 4) {
+        console.warn("Frontier risk universe: vault creation is disabled");
+      }
+    } catch (error) {
+      console.warn(
+        "Could not load trading restrictions from registry (using defaults):",
+        error instanceof Error ? error.message : error
+      );
+    }
+  }
   /**
    * Sync the LLM config hash to chain for epoch tracking.
    * If the wallet has insufficient gas, enters a recovery loop
@@ -1912,7 +2141,7 @@ var AgentRuntime = class {
   async syncConfigHash() {
     const agentId = BigInt(this.config.agentId);
     const llmMeta = this.llm.getMetadata();
-    this.configHash = import_sdk.ExagentRegistry.calculateConfigHash(llmMeta.provider, llmMeta.model);
+    this.configHash = import_sdk2.ExagentRegistry.calculateConfigHash(llmMeta.provider, llmMeta.model);
     console.log(`Config hash: ${this.configHash}`);
     const onChainHash = await this.client.registry.getConfigHash(agentId);
     if (onChainHash !== this.configHash) {
@@ -1925,7 +2154,7 @@ var AgentRuntime = class {
         const message = error instanceof Error ? error.message : String(error);
         if (message.includes("insufficient funds") || message.includes("gas") || message.includes("intrinsic gas too low") || message.includes("exceeds the balance")) {
           const ccUrl = `https://exagent.io/agents/${encodeURIComponent(this.config.name)}/command-center`;
-          const chain = this.config.network === "mainnet" ? import_chains2.base : import_chains2.baseSepolia;
+          const chain = import_chains2.base;
           const publicClientInstance = (0, import_viem3.createPublicClient)({
             chain,
             transport: (0, import_viem3.http)(this.getRpcUrl())
@@ -2076,21 +2305,38 @@ var AgentRuntime = class {
           break;
         case "update_risk_params": {
           const params = cmd.params || {};
+          let updated = false;
           if (params.maxPositionSizeBps !== void 0) {
-            this.config.trading.maxPositionSizeBps = Number(params.maxPositionSizeBps);
+            const value = Number(params.maxPositionSizeBps);
+            if (isNaN(value) || value < 100 || value > 1e4) {
+              this.relay?.sendCommandResult(cmd.id, false, "maxPositionSizeBps must be 100-10000");
+              break;
+            }
+            this.config.trading.maxPositionSizeBps = value;
+            updated = true;
           }
           if (params.maxDailyLossBps !== void 0) {
-            this.config.trading.maxDailyLossBps = Number(params.maxDailyLossBps);
+            const value = Number(params.maxDailyLossBps);
+            if (isNaN(value) || value < 50 || value > 5e3) {
+              this.relay?.sendCommandResult(cmd.id, false, "maxDailyLossBps must be 50-5000");
+              break;
+            }
+            this.config.trading.maxDailyLossBps = value;
+            updated = true;
+          }
+          if (updated) {
+            this.riskManager = new RiskManager(this.config.trading);
+            console.log("Risk params updated via command center");
+            this.relay?.sendCommandResult(cmd.id, true, "Risk parameters updated");
+            this.relay?.sendMessage(
+              "config_updated",
+              "info",
+              "Risk Parameters Updated",
+              `Max position: ${this.config.trading.maxPositionSizeBps / 100}%, Max daily loss: ${this.config.trading.maxDailyLossBps / 100}%`
+            );
+          } else {
+            this.relay?.sendCommandResult(cmd.id, false, "No valid parameters provided");
           }
-          this.riskManager = new RiskManager(this.config.trading);
-          console.log("Risk params updated via command center");
-          this.relay?.sendCommandResult(cmd.id, true, "Risk params updated");
-          this.relay?.sendMessage(
-            "config_updated",
-            "info",
-            "Risk Parameters Updated",
-            `Max position: ${this.config.trading.maxPositionSizeBps / 100}%, Max daily loss: ${this.config.trading.maxDailyLossBps / 100}%`
-          );
           break;
         }
         case "update_trading_interval": {
@@ -2167,7 +2413,7 @@ var AgentRuntime = class {
         provider: this.config.llm.provider,
         model: this.config.llm.model || "default"
       },
-      risk: this.riskManager?.getStatus() || {
+      risk: this.riskManager?.getStatus(this.lastPortfolioValue) || {
         dailyPnL: 0,
         dailyLossLimit: 0,
         isLimitHit: false
@@ -2188,14 +2434,18 @@ var AgentRuntime = class {
 --- Trading Cycle: ${(/* @__PURE__ */ new Date()).toISOString()} ---`);
     this.cycleCount++;
     this.lastCycleAt = Date.now();
-    await this.checkVaultAutoCreation();
     const tokens = this.config.allowedTokens || this.getDefaultTokens();
     const marketData = await this.marketData.fetchMarketData(this.client.address, tokens);
     console.log(`Portfolio value: $${marketData.portfolioValue.toFixed(2)}`);
     this.lastPortfolioValue = marketData.portfolioValue;
     const nativeEthBal = marketData.balances[NATIVE_ETH.toLowerCase()] || BigInt(0);
     this.lastEthBalance = (Number(nativeEthBal) / 1e18).toFixed(6);
-    this.checkFundsLow(marketData);
+    const fundsOk = this.checkFundsLow(marketData);
+    if (!fundsOk) {
+      console.warn("Skipping trading cycle \u2014 ETH balance critically low");
+      this.sendRelayStatus();
+      return;
+    }
     let signals;
     try {
       signals = await this.strategy(marketData, this.llm, this.config);
@@ -2213,19 +2463,31 @@ var AgentRuntime = class {
     console.log(`Strategy generated ${signals.length} signals`);
     const filteredSignals = this.riskManager.filterSignals(signals, marketData);
     console.log(`${filteredSignals.length} signals passed risk checks`);
-    if (this.riskManager.getStatus().isLimitHit) {
+    if (this.riskManager.getStatus(marketData.portfolioValue).isLimitHit) {
       this.relay?.sendMessage(
         "risk_limit_hit",
         "warning",
         "Risk Limit Hit",
-        `Daily loss limit reached: ${this.riskManager.getStatus().dailyPnL.toFixed(2)}`
+        `Daily loss limit reached: $${this.riskManager.getStatus(marketData.portfolioValue).dailyPnL.toFixed(2)}`
       );
     }
     if (filteredSignals.length > 0) {
+      const vaultStatus = await this.vaultManager?.getVaultStatus();
+      if (vaultStatus?.hasVault && this.vaultManager?.preferVaultTrading) {
+        console.log(`Trading through vault: ${vaultStatus.vaultAddress}`);
+      }
+      const preTradePortfolioValue = marketData.portfolioValue;
       const results = await this.executor.executeAll(filteredSignals);
+      let totalFeesUSD = 0;
       for (const result of results) {
         if (result.success) {
           console.log(`Trade executed: ${result.signal.action} - ${result.txHash}`);
+          const feeCostBps = 20;
+          const signalPrice = marketData.prices[result.signal.tokenIn.toLowerCase()] || 0;
+          const amountUSD = Number(result.signal.amountIn) / Math.pow(10, getTokenDecimals(result.signal.tokenIn)) * signalPrice;
+          const feeCostUSD = amountUSD * feeCostBps / 1e4;
+          totalFeesUSD += feeCostUSD;
+          this.riskManager.updateFees(feeCostUSD);
           this.relay?.sendMessage(
             "trade_executed",
             "success",
@@ -2249,18 +2511,43 @@ var AgentRuntime = class {
           );
         }
       }
+      const postTokens = this.config.allowedTokens || this.getDefaultTokens();
+      const postTradeData = await this.marketData.fetchMarketData(this.client.address, postTokens);
+      const marketPnL = postTradeData.portfolioValue - preTradePortfolioValue + totalFeesUSD;
+      this.riskManager.updatePnL(marketPnL);
+      if (marketPnL !== 0) {
+        console.log(`Cycle PnL: $${marketPnL.toFixed(2)} (market), -$${totalFeesUSD.toFixed(2)} (fees)`);
+      }
+      this.lastPortfolioValue = postTradeData.portfolioValue;
+      const postNativeEthBal = postTradeData.balances[NATIVE_ETH.toLowerCase()] || BigInt(0);
+      this.lastEthBalance = (Number(postNativeEthBal) / 1e18).toFixed(6);
     }
     this.sendRelayStatus();
   }
   /**
-   * Check if ETH balance is below threshold and notify
+   * Check if ETH balance is below threshold and notify.
+   * Returns true if trading should continue, false if ETH is critically low.
    */
   checkFundsLow(marketData) {
-    if (!this.relay) return;
     const ethBalance = marketData.balances[NATIVE_ETH.toLowerCase()] || BigInt(0);
     const ethAmount = Number(ethBalance) / 1e18;
+    if (ethAmount < FUNDS_CRITICAL_THRESHOLD) {
+      console.error(`ETH balance critically low: ${ethAmount.toFixed(6)} ETH \u2014 halting trading`);
+      this.relay?.sendMessage(
+        "funds_low",
+        "error",
+        "Funds Critical",
+        `ETH balance is ${ethAmount.toFixed(6)} ETH (below ${FUNDS_CRITICAL_THRESHOLD} ETH minimum). Trading halted \u2014 fund your wallet.`,
+        {
+          ethBalance: ethAmount.toFixed(6),
+          wallet: this.client.address,
+          threshold: FUNDS_CRITICAL_THRESHOLD
+        }
+      );
+      return false;
+    }
     if (ethAmount < FUNDS_LOW_THRESHOLD) {
-      this.relay.sendMessage(
+      this.relay?.sendMessage(
         "funds_low",
         "warning",
         "Low Funds",
@@ -2272,36 +2559,7 @@ var AgentRuntime = class {
         }
       );
     }
-  }
-  /**
-   * Check for vault auto-creation based on policy
-   */
-  async checkVaultAutoCreation() {
-    const now = Date.now();
-    if (now - this.lastVaultCheck < this.VAULT_CHECK_INTERVAL) {
-      return;
-    }
-    this.lastVaultCheck = now;
-    const result = await this.vaultManager.checkAndAutoCreateVault();
-    switch (result.action) {
-      case "created":
-        console.log(`Vault created automatically: ${result.vaultAddress}`);
-        this.relay?.sendMessage(
-          "vault_created",
-          "success",
-          "Vault Auto-Created",
-          `Vault deployed at ${result.vaultAddress}`,
-          { vaultAddress: result.vaultAddress }
-        );
-        break;
-      case "already_exists":
-        break;
-      case "skipped":
-        break;
-      case "not_qualified":
-        console.log(`Vault auto-creation pending: ${result.reason}`);
-        break;
-    }
+    return true;
   }
   /**
    * Stop the agent process completely
@@ -2319,26 +2577,44 @@ var AgentRuntime = class {
    * Get RPC URL based on network
    */
   getRpcUrl() {
-    if (this.config.network === "mainnet") {
-      return "https://mainnet.base.org";
-    }
-    return "https://sepolia.base.org";
+    return "https://mainnet.base.org";
   }
   /**
-   * Default tokens to track
+   * Default tokens to track.
+   * These are validated against the on-chain registry's isTradeAllowed() during init —
+   * agents in restricted risk universes will have ineligible tokens filtered out.
    */
   getDefaultTokens() {
-    if (this.config.network === "mainnet") {
-      return [
-        "0x4200000000000000000000000000000000000006",
-        // WETH
-        "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
-        // USDC
-      ];
-    }
     return [
-      "0x4200000000000000000000000000000000000006"
+      // Core
+      "0x4200000000000000000000000000000000000006",
       // WETH
+      "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+      // USDC
+      "0x2Ae3F1Ec7F1F5012CFEab0185bFC7aa3cf0DEC22",
+      // cbETH
+      "0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA",
+      // USDbC
+      "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
+      // DAI
+      // Established
+      "0x940181a94A35A4569E4529A3CDfB74e38FD98631",
+      // AERO
+      "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+      // cbBTC
+      "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452",
+      // wstETH
+      "0x2416092f143378750bb29b79eD961ab195CcEea5",
+      // ezETH
+      // Emerging (filtered by risk universe at init)
+      "0x532f27101965dd16442E59d40670FaF5eBB142E4",
+      // BRETT
+      "0x4ed4E862860beD51a9570b96d89aF5E1B0Efefed",
+      // DEGEN
+      "0x0b3e328455c4059EEb9e3f84b5543F74E24e7E1b",
+      // VIRTUAL
+      "0xAC1Bd2486Aaf3B5C0fc3Fd868558b082a531B2B4"
+      // TOSHI
     ];
   }
   sleep(ms) {
@@ -2359,7 +2635,7 @@ var AgentRuntime = class {
         model: this.config.llm.model || "default"
       },
       configHash: this.configHash || "not initialized",
-      risk: this.riskManager?.getStatus() || { dailyPnL: 0, dailyLossLimit: 0, isLimitHit: false },
+      risk: this.riskManager?.getStatus(this.lastPortfolioValue) || { dailyPnL: 0, dailyLossLimit: 0, isLimitHit: false },
       vault: {
         policy: vaultConfig.policy,
         hasVault: false,
@@ -2421,16 +2697,18 @@ var TradingConfigSchema = import_zod.z.object({
   maxDailyLossBps: import_zod.z.number().min(0).max(1e4).default(500),
   // 0-100%
   maxConcurrentPositions: import_zod.z.number().min(1).max(100).default(5),
-  tradingIntervalMs: import_zod.z.number().min(1e3).default(6e4)
+  tradingIntervalMs: import_zod.z.number().min(1e3).default(6e4),
   // minimum 1 second
+  maxSlippageBps: import_zod.z.number().min(10).max(1e3).default(100),
+  // 0.1-10%, default 1%
+  minTradeValueUSD: import_zod.z.number().min(0).default(1)
+  // minimum trade value in USD
 });
 var VaultPolicySchema = import_zod.z.enum([
   "disabled",
   // Never create a vault - trade with agent's own capital only
-  "manual",
+  "manual"
   // Only create vault when explicitly directed by owner
-  "auto_when_qualified"
-  // Automatically create vault when requirements are met
 ]);
 var VaultConfigSchema = import_zod.z.object({
   // Policy for vault creation (asked during deployment)
@@ -2458,7 +2736,7 @@ var AgentConfigSchema = import_zod.z.object({
   agentId: import_zod.z.union([import_zod.z.number().positive(), import_zod.z.string()]),
   name: import_zod.z.string().min(3).max(32),
   // Network
-  network: import_zod.z.enum(["mainnet", "testnet"]).default("testnet"),
+  network: import_zod.z.literal("mainnet").default("mainnet"),
   // Wallet setup preference
   wallet: WalletConfigSchema,
   // LLM
@@ -2545,7 +2823,7 @@ function createSampleConfig(agentId, name) {
   return {
     agentId,
     name,
-    network: "testnet",
+    network: "mainnet",
     llm: {
       provider: "openai",
       model: "gpt-4.1",
@@ -2558,7 +2836,9 @@ function createSampleConfig(agentId, name) {
       maxPositionSizeBps: 1e3,
       maxDailyLossBps: 500,
       maxConcurrentPositions: 5,
-      tradingIntervalMs: 6e4
+      tradingIntervalMs: 6e4,
+      maxSlippageBps: 100,
+      minTradeValueUSD: 1
     },
     vault: {
       // Default to manual - user must explicitly enable auto-creation