@exagent/agent 0.1.20 → 0.1.22

package/dist/index.js

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AGENT_VERSION: () => AGENT_VERSION,
   AgentConfigSchema: () => AgentConfigSchema,
   AgentRuntime: () => AgentRuntime,
   AnthropicAdapter: () => AnthropicAdapter,
@@ -53,6 +54,7 @@ __export(index_exports, {
   PerpOnboarding: () => PerpOnboarding,
   PerpTradeRecorder: () => PerpTradeRecorder,
   PositionManager: () => PositionManager,
+  PositionTracker: () => PositionTracker,
   RelayClient: () => RelayClient,
   RelayConfigSchema: () => RelayConfigSchema,
   RiskManager: () => RiskManager,
@@ -82,105 +84,641 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/runtime.ts
-var import_sdk2 = require("@exagent/sdk");
+var import_sdk = require("@exagent/sdk");
 var import_viem6 = require("viem");
 var import_chains4 = require("viem/chains");
 var import_accounts5 = require("viem/accounts");
 
-// src/llm/openai.ts
-var import_openai = __toESM(require("openai"));
-
-// src/llm/base.ts
-var BaseLLMAdapter = class {
-  config;
-  constructor(config) {
-    this.config = config;
+// src/trading/market.ts
+var import_viem = require("viem");
+var NATIVE_ETH = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+var TOKEN_DECIMALS = {
+  // Base Mainnet — Core tokens
+  "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913": 6,
+  // 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;
   }
-  getMetadata() {
+  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
+   */
+  async fetchMarketData(walletAddress, tokenAddresses) {
+    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 {
-      provider: this.config.provider,
-      model: this.config.model || "unknown",
-      isLocal: this.config.provider === "ollama"
+      timestamp: Date.now(),
+      prices,
+      balances,
+      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
+      }
     };
   }
   /**
-   * Format model name for display
+   * Check if cached prices are still fresh
    */
-  getDisplayModel() {
-    if (this.config.provider === "ollama") {
-      return `Local (${this.config.model || "ollama"})`;
-    }
-    return this.config.model || this.config.provider;
+  get pricesAreFresh() {
+    return Date.now() - this.lastPriceFetchAt < PRICE_STALENESS_MS;
   }
-};
-
-// src/llm/openai.ts
-var OpenAIAdapter = class extends BaseLLMAdapter {
-  client;
-  constructor(config) {
-    super(config);
-    if (!config.apiKey && !config.endpoint) {
-      throw new Error("OpenAI API key or custom endpoint required");
+  /**
+   * 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;
     }
-    this.client = new import_openai.default({
-      apiKey: config.apiKey || "not-needed-for-custom",
-      baseURL: config.endpoint
-    });
-  }
-  async chat(messages) {
-    try {
-      const response = await this.client.chat.completions.create({
-        model: this.config.model || "gpt-4.1",
-        messages: messages.map((m) => ({
-          role: m.role,
-          content: m.content
-        })),
-        temperature: this.config.temperature,
-        max_tokens: this.config.maxTokens
-      });
-      const choice = response.choices[0];
-      if (!choice || !choice.message) {
-        throw new Error("No response from OpenAI");
+    const prices = {};
+    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);
       }
-      return {
-        content: choice.message.content || "",
-        usage: response.usage ? {
-          promptTokens: response.usage.prompt_tokens,
-          completionTokens: response.usage.completion_tokens,
-          totalTokens: response.usage.total_tokens
-        } : void 0
-      };
-    } catch (error) {
-      if (error instanceof import_openai.default.APIError) {
-        throw new Error(`OpenAI API error: ${error.message}`);
+    }
+    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);
       }
-      throw error;
     }
-  }
-};
-
-// src/llm/anthropic.ts
-var AnthropicAdapter = class extends BaseLLMAdapter {
-  apiKey;
-  baseUrl;
-  constructor(config) {
-    super(config);
-    if (!config.apiKey) {
-      throw new Error("Anthropic API key required");
+    for (const addr of tokenAddresses) {
+      const cgId = TOKEN_TO_COINGECKO[addr.toLowerCase()];
+      if (cgId && STABLECOIN_IDS.has(cgId)) {
+        prices[addr.toLowerCase()] = 1;
+      }
     }
-    this.apiKey = config.apiKey;
-    this.baseUrl = config.endpoint || "https://api.anthropic.com";
-  }
-  async chat(messages) {
-    const systemMessage = messages.find((m) => m.role === "system");
-    const chatMessages = messages.filter((m) => m.role !== "system");
-    const body = {
-      model: this.config.model || "claude-opus-4-5-20251101",
-      max_tokens: this.config.maxTokens || 4096,
-      temperature: this.config.temperature,
-      system: systemMessage?.content,
-      messages: chatMessages.map((m) => ({
-        role: m.role,
+    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;
+  }
+  /**
+   * Fetch real on-chain balances: native ETH + ERC-20 tokens
+   */
+  async fetchBalances(walletAddress, tokenAddresses) {
+    const balances = {};
+    const wallet = walletAddress;
+    try {
+      const nativeBalance = await this.client.getBalance({ address: wallet });
+      balances[NATIVE_ETH.toLowerCase()] = nativeBalance;
+      const erc20Promises = tokenAddresses.map(async (tokenAddress) => {
+        try {
+          const balance = await this.client.readContract({
+            address: tokenAddress,
+            abi: import_viem.erc20Abi,
+            functionName: "balanceOf",
+            args: [wallet]
+          });
+          return { address: tokenAddress.toLowerCase(), balance };
+        } catch (error) {
+          return { address: tokenAddress.toLowerCase(), balance: 0n };
+        }
+      });
+      const results = await Promise.all(erc20Promises);
+      for (const { address, balance } of results) {
+        balances[address] = balance;
+      }
+    } catch (error) {
+      console.error("MarketData: Failed to fetch balances:", error instanceof Error ? error.message : error);
+      balances[NATIVE_ETH.toLowerCase()] = 0n;
+      for (const address of tokenAddresses) {
+        balances[address.toLowerCase()] = 0n;
+      }
+    }
+    return balances;
+  }
+  /**
+   * Calculate total portfolio value in USD
+   */
+  calculatePortfolioValue(balances, prices) {
+    let total = 0;
+    for (const [address, balance] of Object.entries(balances)) {
+      const price = prices[address.toLowerCase()] || 0;
+      const decimals = getTokenDecimals(address);
+      const amount = Number(balance) / Math.pow(10, decimals);
+      total += amount * price;
+    }
+    return total;
+  }
+};
+
+// src/position-tracker.ts
+var BASE_ASSETS = /* @__PURE__ */ new Set([
+  NATIVE_ETH.toLowerCase(),
+  // Native ETH
+  "0x4200000000000000000000000000000000000006",
+  // WETH
+  "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+  // USDC
+  "0xd9aaec86b65d86f6a7b5b1b0c42ffa531710b6ca",
+  // USDbC
+  "0x50c5725949a6f0c72e6c4a641f24049a917db0cb",
+  // DAI
+  "0xfde4c96c8593536e31f229ea8f37b2ada2699bb2",
+  // USDT
+  "0x60a3e35cc302bfa44cb36dc100b2587cd09b9c83"
+  // EURC
+]);
+var TOKEN_SYMBOLS = {
+  "0x940181a94a35a4569e4529a3cdfb74e38fd98631": "AERO",
+  "0x532f27101965dd16442e59d40670faf5ebb142e4": "BRETT",
+  "0x4ed4e862860bed51a9570b96d89af5e1b0efefed": "DEGEN",
+  "0x0b3e328455c4059eeb9e3f84b5543f74e24e7e1b": "VIRTUAL",
+  "0xac1bd2486aaf3b5c0fc3fd868558b082a531b2b4": "TOSHI",
+  "0xcbb7c0000ab88b473b1f5afd9ef808440eed33bf": "cbBTC",
+  "0x2416092f143378750bb29b79ed961ab195cceea5": "ezETH",
+  "0xc1cba3fcea344f92d9239c08c0568f6f2f0ee452": "wstETH",
+  "0x2ae3f1ec7f1f5012cfeab0185bfc7aa3cf0dec22": "cbETH",
+  "0x13403fb738c97cf7564f279288468c140aaed05c": "EXA"
+};
+var KEY_POSITIONS = "__positions";
+var KEY_TRADE_HISTORY = "__trade_history";
+var KEY_RISK_STATE = "__risk_state";
+var PositionTracker = class {
+  store;
+  positions;
+  tradeHistory;
+  maxTradeHistory;
+  constructor(store, options) {
+    this.store = store;
+    this.maxTradeHistory = options?.maxTradeHistory ?? 50;
+    this.positions = store.get(KEY_POSITIONS) || {};
+    this.tradeHistory = store.get(KEY_TRADE_HISTORY) || [];
+    const posCount = Object.keys(this.positions).length;
+    if (posCount > 0 || this.tradeHistory.length > 0) {
+      console.log(`Position tracker loaded: ${posCount} positions, ${this.tradeHistory.length} trade records`);
+    }
+  }
+  // ============================================================
+  // TRADE RECORDING (called by runtime after execution)
+  // ============================================================
+  /**
+   * Record a trade result. On buy: creates/updates position with cost-basis
+   * weighted average. On sell: calculates realized PnL and removes if fully sold.
+   */
+  recordTrade(params) {
+    const { action, tokenIn, tokenOut, amountIn, priceIn, priceOut, txHash, reasoning, success } = params;
+    const decimalsIn = getTokenDecimals(tokenIn);
+    const amountInUnits = Number(amountIn) / Math.pow(10, decimalsIn);
+    const tradeValueUSD = amountInUnits * priceIn;
+    const record = {
+      timestamp: Date.now(),
+      action,
+      tokenIn: tokenIn.toLowerCase(),
+      tokenOut: tokenOut.toLowerCase(),
+      amountIn: amountIn.toString(),
+      priceUSD: tradeValueUSD,
+      txHash,
+      reasoning,
+      success
+    };
+    if (success) {
+      if (action === "buy") {
+        this.handleBuy(tokenOut.toLowerCase(), tradeValueUSD, priceOut, txHash);
+      } else if (action === "sell") {
+        const realizedPnL = this.handleSell(tokenIn.toLowerCase(), tradeValueUSD);
+        record.realizedPnL = realizedPnL;
+      }
+    }
+    this.tradeHistory.unshift(record);
+    if (this.tradeHistory.length > this.maxTradeHistory) {
+      this.tradeHistory = this.tradeHistory.slice(0, this.maxTradeHistory);
+    }
+    this.persist();
+  }
+  /**
+   * Handle a buy: create or update position with cost-basis weighted average.
+   */
+  handleBuy(token, costUSD, priceUSD, txHash) {
+    if (BASE_ASSETS.has(token) || priceUSD <= 0 || costUSD <= 0) return;
+    const existing = this.positions[token];
+    const acquiredAmount = costUSD / priceUSD;
+    if (existing) {
+      const newTotalCost = existing.totalCostBasis + costUSD;
+      const newTotalAmount = existing.totalAmountAcquired + acquiredAmount;
+      existing.averageEntryPrice = newTotalAmount > 0 ? newTotalCost / newTotalAmount : priceUSD;
+      existing.totalCostBasis = newTotalCost;
+      existing.totalAmountAcquired = newTotalAmount;
+      existing.lastUpdateTimestamp = Date.now();
+      if (txHash) {
+        existing.txHashes.push(txHash);
+        if (existing.txHashes.length > 10) existing.txHashes.shift();
+      }
+    } else {
+      this.positions[token] = {
+        token,
+        symbol: TOKEN_SYMBOLS[token],
+        entryPrice: priceUSD,
+        averageEntryPrice: priceUSD,
+        totalCostBasis: costUSD,
+        totalAmountAcquired: acquiredAmount,
+        currentAmount: acquiredAmount,
+        entryTimestamp: Date.now(),
+        lastUpdateTimestamp: Date.now(),
+        txHashes: txHash ? [txHash] : []
+      };
+    }
+  }
+  /**
+   * Handle a sell: calculate realized PnL and remove position if fully sold.
+   * Returns the realized PnL in USD.
+   */
+  handleSell(token, saleValueUSD) {
+    if (BASE_ASSETS.has(token)) return 0;
+    const position = this.positions[token];
+    if (!position || position.averageEntryPrice <= 0) return 0;
+    const estimatedUnitsSold = position.currentAmount > 0 ? Math.min(position.currentAmount, saleValueUSD / position.averageEntryPrice) : saleValueUSD / position.averageEntryPrice;
+    const costBasisOfSold = estimatedUnitsSold * position.averageEntryPrice;
+    const realizedPnL = saleValueUSD - costBasisOfSold;
+    position.totalAmountAcquired = Math.max(0, position.totalAmountAcquired - estimatedUnitsSold);
+    position.totalCostBasis = Math.max(0, position.totalCostBasis - costBasisOfSold);
+    position.lastUpdateTimestamp = Date.now();
+    return realizedPnL;
+  }
+  // ============================================================
+  // BALANCE SYNC (called by runtime each cycle)
+  // ============================================================
+  /**
+   * Sync tracked positions with on-chain balances.
+   * Updates currentAmount, detects new tokens (airdrops), removes zeroed positions.
+   */
+  syncBalances(balances, prices) {
+    let changed = false;
+    for (const [address, balance] of Object.entries(balances)) {
+      const token = address.toLowerCase();
+      if (BASE_ASSETS.has(token)) continue;
+      const decimals = getTokenDecimals(token);
+      const amount = Number(balance) / Math.pow(10, decimals);
+      if (amount > 0) {
+        if (this.positions[token]) {
+          if (this.positions[token].currentAmount !== amount) {
+            this.positions[token].currentAmount = amount;
+            this.positions[token].lastUpdateTimestamp = Date.now();
+            changed = true;
+          }
+        } else {
+          const price = prices[token] || 0;
+          this.positions[token] = {
+            token,
+            symbol: TOKEN_SYMBOLS[token],
+            entryPrice: price,
+            averageEntryPrice: price,
+            totalCostBasis: amount * price,
+            totalAmountAcquired: amount,
+            currentAmount: amount,
+            entryTimestamp: Date.now(),
+            lastUpdateTimestamp: Date.now(),
+            txHashes: []
+          };
+          if (price > 0) {
+            console.log(`Position tracker: detected new holding ${TOKEN_SYMBOLS[token] || token.slice(0, 10)} (${amount.toFixed(4)} units @ $${price.toFixed(4)})`);
+          }
+          changed = true;
+        }
+      } else if (this.positions[token]) {
+        delete this.positions[token];
+        changed = true;
+      }
+    }
+    if (changed) {
+      this.persist();
+    }
+  }
+  // ============================================================
+  // QUERY METHODS (for strategies)
+  // ============================================================
+  /** Get all tracked positions */
+  getPositions() {
+    return Object.values(this.positions);
+  }
+  /** Get a single position by token address */
+  getPosition(token) {
+    return this.positions[token.toLowerCase()];
+  }
+  /** Get trade history (newest first) */
+  getTradeHistory(limit) {
+    return limit ? this.tradeHistory.slice(0, limit) : [...this.tradeHistory];
+  }
+  /** Get unrealized PnL per position given current prices */
+  getUnrealizedPnL(prices) {
+    const pnl = {};
+    for (const pos of Object.values(this.positions)) {
+      const currentPrice = prices[pos.token] || 0;
+      if (currentPrice > 0 && pos.averageEntryPrice > 0 && pos.currentAmount > 0) {
+        const currentValue = pos.currentAmount * currentPrice;
+        const costBasis = pos.currentAmount * pos.averageEntryPrice;
+        pnl[pos.token] = currentValue - costBasis;
+      }
+    }
+    return pnl;
+  }
+  /** Get total unrealized PnL across all positions */
+  getTotalUnrealizedPnL(prices) {
+    const pnl = this.getUnrealizedPnL(prices);
+    return Object.values(pnl).reduce((sum, v) => sum + v, 0);
+  }
+  // ============================================================
+  // RISK STATE PERSISTENCE
+  // ============================================================
+  /** Load persisted risk state */
+  getRiskState() {
+    return this.store.get(KEY_RISK_STATE) || {
+      dailyPnL: 0,
+      dailyFees: 0,
+      lastResetDate: ""
+    };
+  }
+  /** Save risk state to persistent store */
+  saveRiskState(state) {
+    this.store.set(KEY_RISK_STATE, state);
+  }
+  // ============================================================
+  // RELAY SUMMARY
+  // ============================================================
+  /** Get a compact summary for relay heartbeats */
+  getPositionSummary(prices) {
+    const unrealizedPnL = this.getUnrealizedPnL(prices);
+    const now = Date.now();
+    const topPositions = Object.values(this.positions).map((pos) => ({
+      token: pos.token,
+      symbol: pos.symbol,
+      unrealizedPnL: unrealizedPnL[pos.token] || 0,
+      holdingDuration: now - pos.entryTimestamp
+    })).sort((a, b) => Math.abs(b.unrealizedPnL) - Math.abs(a.unrealizedPnL)).slice(0, 5);
+    const oneDayAgo = now - 24 * 60 * 60 * 1e3;
+    const recentTrades = this.tradeHistory.filter((t) => t.timestamp > oneDayAgo).length;
+    const totalRealizedPnL = this.tradeHistory.filter((t) => t.realizedPnL !== void 0).reduce((sum, t) => sum + (t.realizedPnL || 0), 0);
+    return {
+      openPositions: Object.keys(this.positions).length,
+      totalUnrealizedPnL: Object.values(unrealizedPnL).reduce((s, v) => s + v, 0),
+      topPositions,
+      recentTrades,
+      totalRealizedPnL
+    };
+  }
+  // ============================================================
+  // INTERNAL
+  // ============================================================
+  persist() {
+    this.store.set(KEY_POSITIONS, this.positions);
+    this.store.set(KEY_TRADE_HISTORY, this.tradeHistory);
+  }
+};
+
+// src/llm/openai.ts
+var import_openai = __toESM(require("openai"));
+
+// src/llm/base.ts
+var BaseLLMAdapter = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  getMetadata() {
+    return {
+      provider: this.config.provider,
+      model: this.config.model || "unknown",
+      isLocal: this.config.provider === "ollama"
+    };
+  }
+  /**
+   * Format model name for display
+   */
+  getDisplayModel() {
+    if (this.config.provider === "ollama") {
+      return `Local (${this.config.model || "ollama"})`;
+    }
+    return this.config.model || this.config.provider;
+  }
+};
+
+// src/llm/openai.ts
+var OpenAIAdapter = class extends BaseLLMAdapter {
+  client;
+  constructor(config) {
+    super(config);
+    if (!config.apiKey && !config.endpoint) {
+      throw new Error("OpenAI API key or custom endpoint required");
+    }
+    this.client = new import_openai.default({
+      apiKey: config.apiKey || "not-needed-for-custom",
+      baseURL: config.endpoint
+    });
+  }
+  async chat(messages) {
+    try {
+      const response = await this.client.chat.completions.create({
+        model: this.config.model || "gpt-4.1",
+        messages: messages.map((m) => ({
+          role: m.role,
+          content: m.content
+        })),
+        temperature: this.config.temperature,
+        max_tokens: this.config.maxTokens
+      });
+      const choice = response.choices[0];
+      if (!choice || !choice.message) {
+        throw new Error("No response from OpenAI");
+      }
+      return {
+        content: choice.message.content || "",
+        usage: response.usage ? {
+          promptTokens: response.usage.prompt_tokens,
+          completionTokens: response.usage.completion_tokens,
+          totalTokens: response.usage.total_tokens
+        } : void 0
+      };
+    } catch (error) {
+      if (error instanceof import_openai.default.APIError) {
+        throw new Error(`OpenAI API error: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+};
+
+// src/llm/anthropic.ts
+var AnthropicAdapter = class extends BaseLLMAdapter {
+  apiKey;
+  baseUrl;
+  constructor(config) {
+    super(config);
+    if (!config.apiKey) {
+      throw new Error("Anthropic API key required");
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.endpoint || "https://api.anthropic.com";
+  }
+  async chat(messages) {
+    const systemMessage = messages.find((m) => m.role === "system");
+    const chatMessages = messages.filter((m) => m.role !== "system");
+    const body = {
+      model: this.config.model || "claude-opus-4-5-20251101",
+      max_tokens: this.config.maxTokens || 4096,
+      temperature: this.config.temperature,
+      system: systemMessage?.content,
+      messages: chatMessages.map((m) => ({
+        role: m.role,
         content: m.content
       }))
     };
@@ -1073,441 +1611,168 @@ function createSampleConfig(agentId, name) {
     llm: {
       provider: "openai",
       model: "gpt-4.1",
-      temperature: 0.7,
-      maxTokens: 4096
-    },
-    riskUniverse: "established",
-    trading: {
-      timeHorizon: "swing",
-      maxPositionSizeBps: 1e3,
-      maxDailyLossBps: 500,
-      maxConcurrentPositions: 5,
-      tradingIntervalMs: 6e4,
-      maxSlippageBps: 100,
-      minTradeValueUSD: 1
-    },
-    vault: {
-      // Default to manual - user must explicitly enable auto-creation
-      policy: "manual",
-      // Will use agent name for vault name if not set
-      preferVaultTrading: true
-    }
-  };
-}
-
-// src/trading/executor.ts
-var TradeExecutor = class {
-  client;
-  config;
-  allowedTokens;
-  configHashFn;
-  constructor(client, config, configHashFn) {
-    this.client = client;
-    this.config = config;
-    this.configHashFn = configHashFn;
-    this.allowedTokens = new Set(
-      (config.allowedTokens || []).map((t) => t.toLowerCase())
-    );
-  }
-  /**
-   * Execute a single trade signal
-   */
-  async execute(signal) {
-    if (signal.action === "hold") {
-      return { success: true };
-    }
-    try {
-      console.log(`Executing ${signal.action}: ${signal.tokenIn} -> ${signal.tokenOut}`);
-      console.log(`Amount: ${signal.amountIn.toString()}, Confidence: ${signal.confidence}`);
-      if (!this.validateSignal(signal)) {
-        return { success: false, error: "Signal exceeds position limits" };
-      }
-      const configHash = this.configHashFn?.();
-      const result = await this.client.trade({
-        tokenIn: signal.tokenIn,
-        tokenOut: signal.tokenOut,
-        amountIn: signal.amountIn,
-        maxSlippageBps: this.config.trading?.maxSlippageBps ?? 100,
-        ...configHash && { configHash }
-      });
-      console.log(`Trade executed: ${result.hash}`);
-      return { success: true, txHash: result.hash };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      const classified = classifyTradeError(message);
-      console.error(`Trade failed (${classified.category}): ${classified.userMessage}`);
-      return { success: false, error: classified.userMessage };
-    }
-  }
-  /**
-   * Execute multiple trade signals
-   * Returns results for each signal
-   */
-  async executeAll(signals) {
-    const results = [];
-    for (const signal of signals) {
-      const result = await this.execute(signal);
-      results.push({ signal, ...result });
-      if (signals.indexOf(signal) < signals.length - 1) {
-        await this.delay(1e3);
-      }
-    }
-    return results;
-  }
-  /**
-   * 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) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-};
-function classifyTradeError(message) {
-  const lower = message.toLowerCase();
-  if (lower.includes("configmismatch") || lower.includes("config mismatch")) {
-    return {
-      category: "config_mismatch",
-      userMessage: "Config hash mismatch \u2014 on-chain config does not match. Restart the agent to re-sync."
-    };
-  }
-  if (lower.includes("insufficient funds") || lower.includes("exceeds the balance")) {
-    return {
-      category: "insufficient_funds",
-      userMessage: "Insufficient ETH for gas \u2014 fund your trading wallet."
-    };
-  }
-  if (lower.includes("out of gas") || lower.includes("intrinsic gas too low")) {
-    return {
-      category: "out_of_gas",
-      userMessage: "Transaction ran out of gas during execution. This is usually transient \u2014 retrying with more gas."
-    };
-  }
-  if (lower.includes("minamountnotmet") || lower.includes("min amount") || lower.includes("slippage")) {
-    return {
-      category: "slippage",
-      userMessage: "Swap failed due to slippage \u2014 price moved beyond tolerance. Will retry next cycle."
-    };
-  }
-  if (lower.includes("notauthorizedforagent") || lower.includes("not authorized")) {
-    return {
-      category: "not_authorized",
-      userMessage: "Wallet not authorized for this agent. Ensure your wallet is linked via the registry."
-    };
-  }
-  if (lower.includes("aggregatornotwhitelisted")) {
-    return {
-      category: "aggregator_error",
-      userMessage: "DEX aggregator not whitelisted on the router. Contact support."
-    };
-  }
-  if (lower.includes("reverted") || lower.includes("execution reverted")) {
-    return {
-      category: "reverted",
-      userMessage: `Transaction reverted: ${message.slice(0, 200)}`
-    };
-  }
-  if (lower.includes("timeout") || lower.includes("econnrefused") || lower.includes("network")) {
-    return {
-      category: "network",
-      userMessage: "Network error \u2014 RPC node may be down. Will retry next cycle."
-    };
-  }
-  return {
-    category: "unknown",
-    userMessage: message.slice(0, 300)
-  };
-}
-
-// src/trading/market.ts
-var import_viem = require("viem");
-var NATIVE_ETH = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
-var TOKEN_DECIMALS = {
-  // Base Mainnet — Core tokens
-  "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913": 6,
-  // 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
-   */
-  async fetchMarketData(walletAddress, tokenAddresses) {
-    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,
-      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
-      }
-    };
-  }
-  /**
-   * 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 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;
-      }
+      temperature: 0.7,
+      maxTokens: 4096
+    },
+    riskUniverse: "established",
+    trading: {
+      timeHorizon: "swing",
+      maxPositionSizeBps: 1e3,
+      maxDailyLossBps: 500,
+      maxConcurrentPositions: 5,
+      tradingIntervalMs: 6e4,
+      maxSlippageBps: 100,
+      minTradeValueUSD: 1
+    },
+    vault: {
+      // Default to manual - user must explicitly enable auto-creation
+      policy: "manual",
+      // Will use agent name for vault name if not set
+      preferVaultTrading: true
     }
-    return prices;
+  };
+}
+
+// src/trading/executor.ts
+var TradeExecutor = class {
+  client;
+  config;
+  allowedTokens;
+  configHashFn;
+  constructor(client, config, configHashFn) {
+    this.client = client;
+    this.config = config;
+    this.configHashFn = configHashFn;
+    this.allowedTokens = new Set(
+      (config.allowedTokens || []).map((t) => t.toLowerCase())
+    );
   }
   /**
-   * Fetch real on-chain balances: native ETH + ERC-20 tokens
+   * Execute a single trade signal
    */
-  async fetchBalances(walletAddress, tokenAddresses) {
-    const balances = {};
-    const wallet = walletAddress;
+  async execute(signal) {
+    if (signal.action === "hold") {
+      return { success: true };
+    }
     try {
-      const nativeBalance = await this.client.getBalance({ address: wallet });
-      balances[NATIVE_ETH.toLowerCase()] = nativeBalance;
-      const erc20Promises = tokenAddresses.map(async (tokenAddress) => {
-        try {
-          const balance = await this.client.readContract({
-            address: tokenAddress,
-            abi: import_viem.erc20Abi,
-            functionName: "balanceOf",
-            args: [wallet]
-          });
-          return { address: tokenAddress.toLowerCase(), balance };
-        } catch (error) {
-          return { address: tokenAddress.toLowerCase(), balance: 0n };
-        }
-      });
-      const results = await Promise.all(erc20Promises);
-      for (const { address, balance } of results) {
-        balances[address] = balance;
+      console.log(`Executing ${signal.action}: ${signal.tokenIn} -> ${signal.tokenOut}`);
+      console.log(`Amount: ${signal.amountIn.toString()}, Confidence: ${signal.confidence}`);
+      if (!this.validateSignal(signal)) {
+        return { success: false, error: "Signal exceeds position limits" };
       }
+      const configHash = this.configHashFn?.();
+      const result = await this.client.trade({
+        tokenIn: signal.tokenIn,
+        tokenOut: signal.tokenOut,
+        amountIn: signal.amountIn,
+        maxSlippageBps: this.config.trading?.maxSlippageBps ?? 100,
+        ...configHash && { configHash }
+      });
+      console.log(`Trade executed: ${result.hash}`);
+      return { success: true, txHash: result.hash };
     } catch (error) {
-      console.error("MarketData: Failed to fetch balances:", error instanceof Error ? error.message : error);
-      balances[NATIVE_ETH.toLowerCase()] = 0n;
-      for (const address of tokenAddresses) {
-        balances[address.toLowerCase()] = 0n;
+      const message = error instanceof Error ? error.message : "Unknown error";
+      const classified = classifyTradeError(message);
+      console.error(`Trade failed (${classified.category}): ${classified.userMessage}`);
+      return { success: false, error: classified.userMessage };
+    }
+  }
+  /**
+   * Execute multiple trade signals
+   * Returns results for each signal
+   */
+  async executeAll(signals) {
+    const results = [];
+    for (const signal of signals) {
+      const result = await this.execute(signal);
+      results.push({ signal, ...result });
+      if (signals.indexOf(signal) < signals.length - 1) {
+        await this.delay(1e3);
       }
     }
-    return balances;
+    return results;
   }
   /**
-   * Calculate total portfolio value in USD
+   * Validate a signal against config limits and token restrictions
    */
-  calculatePortfolioValue(balances, prices) {
-    let total = 0;
-    for (const [address, balance] of Object.entries(balances)) {
-      const price = prices[address.toLowerCase()] || 0;
-      const decimals = getTokenDecimals(address);
-      const amount = Number(balance) / Math.pow(10, decimals);
-      total += amount * price;
+  validateSignal(signal) {
+    if (signal.confidence < 0.5) {
+      console.warn(`Signal confidence ${signal.confidence} below threshold (0.5)`);
+      return false;
     }
-    return total;
+    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) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
   }
 };
+function classifyTradeError(message) {
+  const lower = message.toLowerCase();
+  if (lower.includes("configmismatch") || lower.includes("config mismatch")) {
+    return {
+      category: "config_mismatch",
+      userMessage: "Config hash mismatch \u2014 on-chain config does not match. Restart the agent to re-sync."
+    };
+  }
+  if (lower.includes("insufficient funds") || lower.includes("exceeds the balance")) {
+    return {
+      category: "insufficient_funds",
+      userMessage: "Insufficient ETH for gas \u2014 fund your trading wallet."
+    };
+  }
+  if (lower.includes("out of gas") || lower.includes("intrinsic gas too low")) {
+    return {
+      category: "out_of_gas",
+      userMessage: "Transaction ran out of gas during execution. This is usually transient \u2014 retrying with more gas."
+    };
+  }
+  if (lower.includes("minamountnotmet") || lower.includes("min amount") || lower.includes("slippage")) {
+    return {
+      category: "slippage",
+      userMessage: "Swap failed due to slippage \u2014 price moved beyond tolerance. Will retry next cycle."
+    };
+  }
+  if (lower.includes("notauthorizedforagent") || lower.includes("not authorized")) {
+    return {
+      category: "not_authorized",
+      userMessage: "Wallet not authorized for this agent. Ensure your wallet is linked via the registry."
+    };
+  }
+  if (lower.includes("aggregatornotwhitelisted")) {
+    return {
+      category: "aggregator_error",
+      userMessage: "DEX aggregator not whitelisted on the router. Contact support."
+    };
+  }
+  if (lower.includes("reverted") || lower.includes("execution reverted")) {
+    return {
+      category: "reverted",
+      userMessage: `Transaction reverted: ${message.slice(0, 200)}`
+    };
+  }
+  if (lower.includes("timeout") || lower.includes("econnrefused") || lower.includes("network")) {
+    return {
+      category: "network",
+      userMessage: "Network error \u2014 RPC node may be down. Will retry next cycle."
+    };
+  }
+  return {
+    category: "unknown",
+    userMessage: message.slice(0, 300)
+  };
+}
 
 // src/trading/risk.ts
 var RiskManager = class {
@@ -1619,6 +1884,31 @@ var RiskManager = class {
   updateFees(fees) {
     this.dailyFees += fees;
   }
+  /**
+   * Export current risk state for persistence across restarts.
+   */
+  exportState() {
+    return {
+      dailyPnL: this.dailyPnL,
+      dailyFees: this.dailyFees,
+      lastResetDate: this.lastResetDate
+    };
+  }
+  /**
+   * Restore risk state from persistence (called on startup).
+   * Only restores if the saved state is from today — expired state is ignored.
+   */
+  restoreState(state) {
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    if (state.lastResetDate === today) {
+      this.dailyPnL = state.dailyPnL;
+      this.dailyFees = state.dailyFees;
+      this.lastResetDate = state.lastResetDate;
+      console.log(`Risk state restored: PnL=$${this.dailyPnL.toFixed(2)}, Fees=$${this.dailyFees.toFixed(2)}`);
+    } else {
+      console.log("Risk state expired (different day), starting fresh");
+    }
+  }
   /**
    * Get current risk status
    * @param portfolioValue - Current portfolio value in USD (needed for accurate loss limit)
@@ -2082,7 +2372,6 @@ var VaultManager = class {
 // 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;
@@ -2186,7 +2475,7 @@ var RelayClient = class {
       wallet: account.address,
       timestamp,
       signature,
-      sdkVersion: import_sdk.SDK_VERSION
+      sdkVersion: AGENT_VERSION
     });
   }
   /**
@@ -3597,14 +3886,19 @@ var AgentRuntime = class {
   isRunning = false;
   mode = "idle";
   configHash;
+  pendingConfigHash = null;
+  lastConfigCheckAt = 0;
+  // Timestamp of last pending config RPC check
   cycleCount = 0;
   lastCycleAt = 0;
   lastPortfolioValue = 0;
   lastEthBalance = "0";
+  lastPrices = {};
   processAlive = true;
   riskUniverse = 0;
   allowedTokens = /* @__PURE__ */ new Set();
   strategyContext;
+  positionTracker;
   // Perp trading components (null if perp not enabled)
   perpClient = null;
   perpSigner = null;
@@ -3621,6 +3915,12 @@ var AgentRuntime = class {
   // When perpConnected && perpTradingActive: dedicated runPerpCycle() runs every interval
   perpConnected = false;
   perpTradingActive = false;
+  // Cached perp account data for synchronous heartbeat inclusion (refreshed async)
+  cachedPerpEquity = 0;
+  cachedPerpUnrealizedPnl = 0;
+  cachedPerpMarginUsed = 0;
+  cachedPerpLeverage = 0;
+  cachedPerpOpenPositions = 0;
   constructor(config) {
     this.config = config;
   }
@@ -3629,7 +3929,7 @@ var AgentRuntime = class {
    */
   async initialize() {
     console.log(`Initializing agent: ${this.config.name} (ID: ${this.config.agentId})`);
-    this.client = new import_sdk2.ExagentClient({
+    this.client = new import_sdk.ExagentClient({
       privateKey: this.config.privateKey,
       network: this.config.network
     });
@@ -3647,14 +3947,20 @@ var AgentRuntime = class {
     console.log(`LLM ready: ${llmMeta.provider} (${llmMeta.model})`);
     await this.syncConfigHash();
     this.strategy = await loadStrategy();
+    const store = new FileStore();
     this.strategyContext = {
-      store: new FileStore(),
+      store,
       agentId: Number(this.config.agentId),
       walletAddress: this.client.address
     };
+    this.positionTracker = new PositionTracker(store, { maxTradeHistory: 50 });
     this.executor = new TradeExecutor(this.client, this.config, () => this.getConfigHash());
     this.riskManager = new RiskManager(this.config.trading);
     this.marketData = new MarketDataService(this.getRpcUrl());
+    const savedRisk = this.positionTracker.getRiskState();
+    if (savedRisk.lastResetDate) {
+      this.riskManager.restoreState(savedRisk);
+    }
     await this.initializeVaultManager();
     await this.initializePerp();
     await this.initializeRelay();
@@ -3840,7 +4146,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_sdk2.ExagentRegistry.generateLinkMessage(
+        const linkMessage = import_sdk.ExagentRegistry.generateLinkMessage(
           address,
           agentId,
           nonce
@@ -3925,65 +4231,104 @@ var AgentRuntime = class {
   }
   /**
    * Sync the LLM config hash to chain for epoch tracking.
-   * If the wallet has insufficient gas, enters a recovery loop
-   * that waits for the user to fund the wallet.
+   *
+   * If the trading wallet is NOT the agent owner, the on-chain setConfig
+   * call would revert with AgentNotOwner. Instead, we set a pending state
+   * and send a message to the command center so the owner can approve it
+   * from the website with one click.
+   *
+   * Until the config is verified on-chain, the agent won't appear on the
+   * leaderboard (trades still execute normally).
    */
   async syncConfigHash() {
     const agentId = BigInt(this.config.agentId);
     const llmMeta = this.llm.getMetadata();
-    this.configHash = import_sdk2.ExagentRegistry.calculateConfigHash(llmMeta.provider, llmMeta.model);
+    this.configHash = import_sdk.ExagentRegistry.calculateConfigHash(llmMeta.provider, llmMeta.model);
     console.log(`Config hash: ${this.configHash}`);
     const onChainHash = await this.client.registry.getConfigHash(agentId);
-    if (onChainHash !== this.configHash) {
-      console.log("Config changed, updating on-chain...");
-      try {
-        await this.client.registry.updateConfig(agentId, this.configHash);
-        const newEpoch = await this.client.registry.getCurrentEpoch(agentId);
-        console.log(`Config updated, new epoch started: ${newEpoch}`);
-      } catch (error) {
-        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 chain = import_chains4.base;
-          const publicClientInstance = (0, import_viem6.createPublicClient)({
-            chain,
-            transport: (0, import_viem6.http)(this.getRpcUrl())
+    if (onChainHash === this.configHash) {
+      console.log("Config hash matches on-chain");
+      this.pendingConfigHash = null;
+      return;
+    }
+    console.log("Config changed, updating on-chain...");
+    const agent = await this.client.registry.getAgent(agentId);
+    const isOwner = agent?.owner.toLowerCase() === this.client.address.toLowerCase();
+    if (!isOwner) {
+      this.pendingConfigHash = this.configHash;
+      this.configHash = onChainHash;
+      console.log("");
+      console.log("=== CONFIG VERIFICATION NEEDED ===");
+      console.log("");
+      console.log("  Your trading wallet cannot update the LLM config on-chain.");
+      console.log("  The owner must approve this from the command center.");
+      console.log("");
+      console.log(`  LLM:  ${llmMeta.provider} / ${llmMeta.model}`);
+      console.log(`  Hash: ${this.pendingConfigHash}`);
+      console.log("");
+      console.log("  Until approved:");
+      console.log("    - New agents will not appear on the leaderboard");
+      console.log("    - Trades will still execute normally");
+      console.log("");
+      this.relay?.sendMessage(
+        "system",
+        "warning",
+        "Config Verification Needed",
+        `Your agent is using ${llmMeta.provider}/${llmMeta.model} but this hasn't been recorded on-chain. Open the command center and click "Approve Config" to verify. Until then, your agent won't appear on the leaderboard.`,
+        { configHash: this.pendingConfigHash, provider: llmMeta.provider, model: llmMeta.model }
+      );
+      return;
+    }
+    try {
+      await this.client.registry.updateConfig(agentId, this.configHash);
+      console.log(`Config updated on-chain`);
+      this.pendingConfigHash = null;
+    } catch (error) {
+      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_viem6.createPublicClient)({
+          chain: import_chains4.base,
+          transport: (0, import_viem6.http)(this.getRpcUrl())
+        });
+        console.log("");
+        console.log("=== ETH NEEDED FOR GAS ===");
+        console.log("");
+        console.log(`  Wallet: ${this.client.address}`);
+        console.log("  Your wallet needs ETH to pay for transaction gas.");
+        console.log("  Opening the command center to fund your wallet...");
+        console.log(`  ${ccUrl}`);
+        console.log("");
+        openBrowser(ccUrl);
+        console.log("  Waiting for ETH... (checking every 15s)");
+        console.log("  Press Ctrl+C to exit.");
+        console.log("");
+        while (true) {
+          await this.sleep(15e3);
+          const balance = await publicClientInstance.getBalance({
+            address: this.client.address
           });
-          console.log("");
-          console.log("=== ETH NEEDED FOR GAS ===");
-          console.log("");
-          console.log(`  Wallet: ${this.client.address}`);
-          console.log("  Your wallet needs ETH to pay for transaction gas.");
-          console.log("  Opening the command center to fund your wallet...");
-          console.log(`  ${ccUrl}`);
-          console.log("");
-          openBrowser(ccUrl);
-          console.log("  Waiting for ETH... (checking every 15s)");
-          console.log("  Press Ctrl+C to exit.");
-          console.log("");
-          while (true) {
-            await this.sleep(15e3);
-            const balance = await publicClientInstance.getBalance({
-              address: this.client.address
-            });
-            if (balance > BigInt(0)) {
-              console.log("  ETH detected! Retrying config update...");
-              console.log("");
+          if (balance > BigInt(0)) {
+            console.log("  ETH detected! Retrying config update...");
+            console.log("");
+            try {
               await this.client.registry.updateConfig(agentId, this.configHash);
-              const newEpoch = await this.client.registry.getCurrentEpoch(agentId);
-              console.log(`Config updated, new epoch started: ${newEpoch}`);
-              return;
+              console.log(`Config updated on-chain`);
+              this.pendingConfigHash = null;
+            } catch (retryError) {
+              const retryMsg = retryError instanceof Error ? retryError.message : String(retryError);
+              console.warn(`Config update failed after funding: ${retryMsg}`);
+              console.warn("Continuing with on-chain config.");
+              this.configHash = onChainHash;
             }
-            process.stdout.write(".");
+            return;
           }
-        } else {
-          console.warn(`Config update skipped (continuing with on-chain config): ${message}`);
-          this.configHash = onChainHash;
+          process.stdout.write(".");
         }
+      } else {
+        console.warn(`Config update skipped (continuing with on-chain config): ${message}`);
+        this.configHash = onChainHash;
       }
-    } else {
-      const currentEpoch = await this.client.registry.getCurrentEpoch(agentId);
-      console.log(`Config hash matches on-chain (epoch ${currentEpoch})`);
     }
   }
   /**
@@ -4117,6 +4462,10 @@ var AgentRuntime = class {
           }
           if (updated) {
             this.riskManager = new RiskManager(this.config.trading);
+            const savedRiskState = this.positionTracker.getRiskState();
+            if (savedRiskState.lastResetDate) {
+              this.riskManager.restoreState(savedRiskState);
+            }
             console.log("Risk params updated via command center");
             this.relay?.sendCommandResult(cmd.id, true, "Risk parameters updated");
             this.relay?.sendMessage(
@@ -4310,16 +4659,44 @@ var AgentRuntime = class {
       this.relay?.sendCommandResult(cmd.id, false, message);
     }
   }
+  /**
+   * Periodically check if the owner has approved the pending config hash.
+   * Called from sendRelayStatus at most every 2.5 minutes (timestamp-throttled).
+   */
+  async checkPendingConfigApproval() {
+    if (!this.pendingConfigHash) return;
+    try {
+      const onChain = await this.client.registry.getConfigHash(BigInt(this.config.agentId));
+      if (onChain === this.pendingConfigHash) {
+        this.configHash = this.pendingConfigHash;
+        this.pendingConfigHash = null;
+        console.log("Config verified on-chain! Your agent will now appear on the leaderboard.");
+        this.relay?.sendMessage(
+          "config_updated",
+          "success",
+          "Config Verified",
+          "Your LLM config has been verified on-chain. Your agent will now appear on the leaderboard."
+        );
+      }
+    } catch {
+    }
+  }
   /**
    * Send current status to the relay
    */
   sendRelayStatus() {
     if (!this.relay) return;
+    const CONFIG_CHECK_INTERVAL_MS = 15e4;
+    if (this.pendingConfigHash && Date.now() - this.lastConfigCheckAt >= CONFIG_CHECK_INTERVAL_MS) {
+      this.lastConfigCheckAt = Date.now();
+      this.checkPendingConfigApproval();
+    }
     const vaultConfig = this.config.vault || { policy: "disabled" };
     const status = {
       mode: this.mode,
       agentId: String(this.config.agentId),
       wallet: this.client?.address,
+      sdkVersion: AGENT_VERSION,
       cycleCount: this.cycleCount,
       lastCycleAt: this.lastCycleAt,
       tradingIntervalMs: this.config.trading.tradingIntervalMs,
@@ -4342,30 +4719,32 @@ var AgentRuntime = class {
       perp: this.perpConnected ? {
         enabled: true,
         trading: this.perpTradingActive,
-        equity: 0,
-        unrealizedPnl: 0,
-        marginUsed: 0,
-        openPositions: 0,
-        effectiveLeverage: 0,
+        equity: this.cachedPerpEquity,
+        unrealizedPnl: this.cachedPerpUnrealizedPnl,
+        marginUsed: this.cachedPerpMarginUsed,
+        openPositions: this.cachedPerpOpenPositions,
+        effectiveLeverage: this.cachedPerpLeverage,
         pendingRecords: this.perpRecorder?.pendingRetries ?? 0
-      } : void 0
+      } : void 0,
+      positions: this.positionTracker ? this.positionTracker.getPositionSummary(this.lastPrices) : void 0,
+      configHash: this.configHash || void 0,
+      pendingConfigHash: this.pendingConfigHash
+      // null preserved by JSON.stringify for clearing
     };
-    if (this.perpConnected && this.perpPositions && status.perp) {
+    this.relay.sendHeartbeat(status);
+    if (this.perpConnected && this.perpPositions) {
       this.perpPositions.getAccountSummary().then((account) => {
-        if (status.perp) {
-          status.perp.equity = account.totalEquity;
-          status.perp.unrealizedPnl = account.totalUnrealizedPnl;
-          status.perp.marginUsed = account.totalMarginUsed;
-          status.perp.effectiveLeverage = account.effectiveLeverage;
-        }
+        this.cachedPerpEquity = account.totalEquity;
+        this.cachedPerpUnrealizedPnl = account.totalUnrealizedPnl;
+        this.cachedPerpMarginUsed = account.totalMarginUsed;
+        this.cachedPerpLeverage = account.effectiveLeverage;
       }).catch(() => {
       });
       this.perpPositions.getPositionCount().then((count) => {
-        if (status.perp) status.perp.openPositions = count;
+        this.cachedPerpOpenPositions = count;
       }).catch(() => {
       });
     }
-    this.relay.sendHeartbeat(status);
   }
   /**
    * Run a single trading cycle
@@ -4379,14 +4758,19 @@ var AgentRuntime = class {
     const marketData = await this.marketData.fetchMarketData(this.client.address, tokens);
     console.log(`Portfolio value: $${marketData.portfolioValue.toFixed(2)}`);
     this.lastPortfolioValue = marketData.portfolioValue;
+    this.lastPrices = marketData.prices;
     const nativeEthBal = marketData.balances[NATIVE_ETH.toLowerCase()] || BigInt(0);
     this.lastEthBalance = (Number(nativeEthBal) / 1e18).toFixed(6);
+    this.positionTracker.syncBalances(marketData.balances, marketData.prices);
     const fundsOk = this.checkFundsLow(marketData);
     if (!fundsOk) {
       console.warn("Skipping trading cycle \u2014 ETH balance critically low");
       this.sendRelayStatus();
       return;
     }
+    this.strategyContext.positions = this.positionTracker.getPositions();
+    this.strategyContext.tradeHistory = this.positionTracker.getTradeHistory(20);
+    this.strategyContext.positionTracker = this.positionTracker;
     let signals;
     try {
       signals = await this.strategy(marketData, this.llm, this.config, this.strategyContext);
@@ -4452,13 +4836,30 @@ var AgentRuntime = class {
           );
         }
       }
+      for (const result of results) {
+        const tokenIn = result.signal.tokenIn.toLowerCase();
+        const tokenOut = result.signal.tokenOut.toLowerCase();
+        this.positionTracker.recordTrade({
+          action: result.signal.action,
+          tokenIn,
+          tokenOut,
+          amountIn: result.signal.amountIn,
+          priceIn: marketData.prices[tokenIn] || 0,
+          priceOut: marketData.prices[tokenOut] || 0,
+          txHash: result.txHash,
+          reasoning: result.signal.reasoning,
+          success: result.success
+        });
+      }
       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);
+      this.positionTracker.saveRiskState(this.riskManager.exportState());
       if (marketPnL !== 0) {
         console.log(`Cycle PnL: $${marketPnL.toFixed(2)} (market), -$${totalFeesUSD.toFixed(2)} (fees)`);
       }
+      this.positionTracker.syncBalances(postTradeData.balances, postTradeData.prices);
       this.lastPortfolioValue = postTradeData.portfolioValue;
       const postNativeEthBal = postTradeData.balances[NATIVE_ETH.toLowerCase()] || BigInt(0);
       this.lastEthBalance = (Number(postNativeEthBal) / 1e18).toFixed(6);
@@ -4914,8 +5315,12 @@ function loadSecureEnv(basePath, passphrase) {
   }
   return false;
 }
+
+// src/index.ts
+var AGENT_VERSION = "0.1.22";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AGENT_VERSION,
   AgentConfigSchema,
   AgentRuntime,
   AnthropicAdapter,
@@ -4939,6 +5344,7 @@ function loadSecureEnv(basePath, passphrase) {
   PerpOnboarding,
   PerpTradeRecorder,
   PositionManager,
+  PositionTracker,
   RelayClient,
   RelayConfigSchema,
   RiskManager,