@exagent/agent 0.1.32 → 0.1.33

package/dist/index.js

@@ -85,13 +85,296 @@ module.exports = __toCommonJS(index_exports);
 
 // src/runtime.ts
 var import_sdk = require("@exagent/sdk");
-var import_viem6 = require("viem");
+var import_viem7 = require("viem");
 var import_chains4 = require("viem/chains");
 var import_accounts5 = require("viem/accounts");
 
 // src/trading/market.ts
+var import_viem2 = require("viem");
+
+// src/trading/token-resolver.ts
 var import_viem = require("viem");
+var STORE_KEY = "__token_metadata";
+var UNRESOLVABLE_KEY = "__unresolvable_tokens";
+var HARDCODED = {
+  "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee": { decimals: 18, symbol: "ETH" },
+  // Core (0)
+  "0x4200000000000000000000000000000000000006": { decimals: 18, symbol: "WETH" },
+  "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913": { decimals: 6, symbol: "USDC" },
+  "0x2ae3f1ec7f1f5012cfeab0185bfc7aa3cf0dec22": { decimals: 18, symbol: "cbETH" },
+  "0xcbb7c0000ab88b473b1f5afd9ef808440eed33bf": { decimals: 8, symbol: "cbBTC" },
+  "0xc1cba3fcea344f92d9239c08c0568f6f2f0ee452": { decimals: 18, symbol: "wstETH" },
+  "0x50c5725949a6f0c72e6c4a641f24049a917db0cb": { decimals: 18, symbol: "DAI" },
+  "0xfde4c96c8593536e31f229ea8f37b2ada2699bb2": { decimals: 6, symbol: "USDT" },
+  "0xd9aaec86b65d86f6a7b5b1b0c42ffa531710b6ca": { decimals: 6, symbol: "USDbC" },
+  "0x60a3e35cc302bfa44cb288bc5a4f316fdb1adb42": { decimals: 6, symbol: "EURC" },
+  "0xb6fe221fe9eef5aba221c348ba20a1bf5e73624c": { decimals: 18, symbol: "rETH" },
+  "0x0555e30da8f98308edb960aa94c0db47230d2b9c": { decimals: 8, symbol: "WBTC" },
+  // Established (1)
+  "0x940181a94a35a4569e4529a3cdfb74e38fd98631": { decimals: 18, symbol: "AERO" },
+  "0x04c0599ae5a44757c0af6f9ec3b93da8976c150a": { decimals: 18, symbol: "weETH" },
+  "0x2416092f143378750bb29b79ed961ab195cceea5": { decimals: 18, symbol: "ezETH" },
+  "0xa88594d404727625a9437c3f886c7643872296ae": { decimals: 18, symbol: "WELL" },
+  "0xbaa5cc21fd487b8fcc2f632f3f4e8d37262a0842": { decimals: 18, symbol: "MORPHO" },
+  "0x88fb150bdc53a65fe94dea0c9ba0a6daf8c6e196": { decimals: 18, symbol: "LINK" },
+  "0xc3de830ea07524a0761646a6a4e4be0e114a3c83": { decimals: 18, symbol: "UNI" },
+  "0x63706e401c06ac8513145b7687a14804d17f814b": { decimals: 18, symbol: "AAVE" },
+  "0x9e1028f5f1d5ede59748ffcee5532509976840e0": { decimals: 18, symbol: "COMP" },
+  "0x4158734d47fc9692176b5085e0f52ee0da5d47f1": { decimals: 18, symbol: "BAL" },
+  "0x8ee73c484a26e0a5df2ee2a4960b789967dd0415": { decimals: 18, symbol: "CRV" },
+  "0x22e6966b799c4d5b13be962e1d117b56327fda66": { decimals: 18, symbol: "SNX" },
+  // Derivatives (2)
+  "0x0b3e328455c4059eeb9e3f84b5543f74e24e7e1b": { decimals: 18, symbol: "VIRTUAL" },
+  "0x4f9fd6be4a90f2620860d680c0d4d5fb53d1a825": { decimals: 18, symbol: "AIXBT" },
+  "0x4ed4e862860bed51a9570b96d89af5e1b0efefed": { decimals: 18, symbol: "DEGEN" },
+  "0x0578d8a44db98b23bf096a382e016e29a5ce0ffe": { decimals: 18, symbol: "HIGHER" },
+  "0x1bc0c42215582d5a085795f4badbaac3ff36d1bcb": { decimals: 18, symbol: "CLANKER" },
+  // Emerging (3)
+  "0x532f27101965dd16442e59d40670faf5ebb142e4": { decimals: 18, symbol: "BRETT" },
+  "0xac1bd2486aaf3b5c0fc3fd868558b082a531b2b4": { decimals: 18, symbol: "TOSHI" },
+  "0x6921b130d297cc43754afba22e5eac0fbf8db75b": { decimals: 18, symbol: "DOGINME" },
+  "0xb1a03eda10342529bbf8eb700a06c60441fef25d": { decimals: 18, symbol: "MIGGLES" },
+  "0x7f12d13b34f5f4f0a9449c16bcd42f0da47af200": { decimals: 9, symbol: "NORMIE" },
+  "0x27d2decb4bfc9c76f0309b8e88dec3a601fe25a8": { decimals: 18, symbol: "BALD" },
+  "0x768be13e1680b5ebe0024c42c896e3db59ec0149": { decimals: 9, symbol: "SKI" }
+};
+var TokenResolver = class {
+  client;
+  store;
+  cache = {};
+  unresolvable = /* @__PURE__ */ new Set();
+  constructor(client, store) {
+    this.client = client;
+    this.store = store || null;
+    for (const [addr, info] of Object.entries(HARDCODED)) {
+      this.cache[addr] = {
+        decimals: info.decimals,
+        symbol: info.symbol,
+        source: "hardcoded",
+        resolvedAt: 0
+      };
+    }
+    if (this.store) {
+      const saved = this.store.get(STORE_KEY);
+      if (saved) {
+        for (const [addr, meta] of Object.entries(saved)) {
+          const key = addr.toLowerCase();
+          if (!this.cache[key]) {
+            this.cache[key] = meta;
+          }
+        }
+      }
+      const savedUnresolvable = this.store.get(UNRESOLVABLE_KEY);
+      if (savedUnresolvable) {
+        for (const addr of savedUnresolvable) {
+          this.unresolvable.add(addr.toLowerCase());
+        }
+      }
+    }
+  }
+  /**
+   * Get decimals for a token (synchronous).
+   * Returns undefined if the token has never been resolved and is not hardcoded.
+   * Call resolve() first for unknown tokens.
+   */
+  getDecimals(address) {
+    const meta = this.cache[address.toLowerCase()];
+    return meta?.decimals;
+  }
+  /**
+   * Get symbol for a token (synchronous).
+   */
+  getSymbol(address) {
+    return this.cache[address.toLowerCase()]?.symbol;
+  }
+  /**
+   * Set symbol for a token (used when DexScreener returns symbol data).
+   */
+  setSymbol(address, symbol) {
+    const key = address.toLowerCase();
+    if (this.cache[key]) {
+      if (!this.cache[key].symbol) {
+        this.cache[key].symbol = symbol;
+        this.persist();
+      }
+    }
+  }
+  /**
+   * Check if a token has been marked as unresolvable by all tiers.
+   */
+  isUnresolvable(address) {
+    return this.unresolvable.has(address.toLowerCase());
+  }
+  /**
+   * Batch-resolve metadata for a list of token addresses.
+   *
+   * Skips already-resolved tokens. For unknown tokens:
+   * 1. Multicall3 on-chain batch (decimals + symbol)
+   * 2. Blockscout API for any multicall failures
+   * 3. Mark remaining as unresolvable
+   */
+  async resolve(addresses) {
+    const unknown = addresses.filter((addr) => {
+      const key = addr.toLowerCase();
+      return !this.cache[key] && !this.unresolvable.has(key);
+    });
+    if (unknown.length === 0) return;
+    const unique = [...new Set(unknown.map((a) => a.toLowerCase()))];
+    const stillUnresolved = await this.resolveViaMulticall(unique);
+    if (stillUnresolved.length > 0) {
+      const afterBlockscout = await this.resolveViaBlockscout(stillUnresolved);
+      if (afterBlockscout.length > 0) {
+        for (const addr of afterBlockscout) {
+          this.unresolvable.add(addr);
+        }
+        console.warn(
+          `TokenResolver: ${afterBlockscout.length} token(s) unresolvable after all tiers \u2014 skipping from portfolio: ${afterBlockscout.map((a) => a.slice(0, 10) + "...").join(", ")}`
+        );
+        this.persistUnresolvable();
+      }
+    }
+  }
+  /**
+   * Tier 2: Batch-fetch decimals + symbol via Multicall3.
+   * Returns addresses that failed (for next tier).
+   */
+  async resolveViaMulticall(addresses) {
+    const failed = [];
+    try {
+      const contracts = addresses.flatMap((addr) => [
+        {
+          address: addr,
+          abi: import_viem.erc20Abi,
+          functionName: "decimals"
+        },
+        {
+          address: addr,
+          abi: import_viem.erc20Abi,
+          functionName: "symbol"
+        }
+      ]);
+      const BATCH_SIZE = 100;
+      const allResults = [];
+      for (let i = 0; i < contracts.length; i += BATCH_SIZE) {
+        const batch = contracts.slice(i, i + BATCH_SIZE);
+        try {
+          const results = await this.client.multicall({
+            contracts: batch,
+            allowFailure: true
+          });
+          allResults.push(...results);
+        } catch {
+          for (let j = 0; j < batch.length; j += 2) {
+            allResults.push({ status: "failure" }, { status: "failure" });
+          }
+        }
+      }
+      for (let i = 0; i < addresses.length; i++) {
+        const decimalsResult = allResults[i * 2];
+        const symbolResult = allResults[i * 2 + 1];
+        const addr = addresses[i];
+        if (decimalsResult?.status === "success" && decimalsResult.result !== void 0) {
+          const decimals = Number(decimalsResult.result);
+          const symbol = symbolResult?.status === "success" && symbolResult.result ? String(symbolResult.result) : void 0;
+          this.cache[addr] = {
+            decimals,
+            symbol,
+            source: "onchain",
+            resolvedAt: Date.now()
+          };
+          if (symbol) {
+            console.log(`TokenResolver: ${symbol} (${addr.slice(0, 10)}...) \u2192 ${decimals} decimals [onchain]`);
+          } else {
+            console.log(`TokenResolver: ${addr.slice(0, 10)}... \u2192 ${decimals} decimals [onchain]`);
+          }
+        } else {
+          failed.push(addr);
+        }
+      }
+      this.persist();
+    } catch (error) {
+      console.warn("TokenResolver: Multicall3 failed entirely, trying Blockscout:", error instanceof Error ? error.message : error);
+      return addresses;
+    }
+    return failed;
+  }
+  /**
+   * Tier 3: Fetch token metadata from Blockscout (Base's block explorer API).
+   * Free, no API key, near-universal coverage for any token indexed by the explorer.
+   * Returns addresses that failed (truly unresolvable).
+   */
+  async resolveViaBlockscout(addresses) {
+    const failed = [];
+    const CONCURRENCY = 5;
+    for (let i = 0; i < addresses.length; i += CONCURRENCY) {
+      const batch = addresses.slice(i, i + CONCURRENCY);
+      const results = await Promise.allSettled(
+        batch.map(async (addr) => {
+          const response = await fetch(
+            `https://base.blockscout.com/api/v2/tokens/${addr}`,
+            { signal: AbortSignal.timeout(8e3) }
+          );
+          if (!response.ok) return null;
+          const data = await response.json();
+          if (data.decimals === null || data.decimals === void 0) return null;
+          const decimals = parseInt(data.decimals, 10);
+          if (isNaN(decimals)) return null;
+          return {
+            decimals,
+            symbol: data.symbol || data.name || void 0
+          };
+        })
+      );
+      for (let j = 0; j < batch.length; j++) {
+        const addr = batch[j];
+        const result = results[j];
+        if (result.status === "fulfilled" && result.value) {
+          this.cache[addr] = {
+            decimals: result.value.decimals,
+            symbol: result.value.symbol,
+            source: "blockscout",
+            resolvedAt: Date.now()
+          };
+          const sym = result.value.symbol || addr.slice(0, 10) + "...";
+          console.log(`TokenResolver: ${sym} \u2192 ${result.value.decimals} decimals [blockscout]`);
+        } else {
+          failed.push(addr);
+        }
+      }
+    }
+    if (failed.length === 0 || addresses.length > failed.length) {
+      this.persist();
+    }
+    return failed;
+  }
+  /**
+   * Persist resolved metadata to FileStore.
+   */
+  persist() {
+    if (!this.store) return;
+    const toSave = {};
+    for (const [addr, meta] of Object.entries(this.cache)) {
+      if (meta.source !== "hardcoded") {
+        toSave[addr] = meta;
+      }
+    }
+    this.store.set(STORE_KEY, toSave);
+  }
+  /**
+   * Persist unresolvable token list to FileStore.
+   */
+  persistUnresolvable() {
+    if (!this.store) return;
+    this.store.set(UNRESOLVABLE_KEY, [...this.unresolvable]);
+  }
+};
+
+// src/trading/market.ts
 var NATIVE_ETH = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+var _globalResolver = null;
+function setGlobalResolver(resolver) {
+  _globalResolver = resolver;
+}
 var TOKEN_DECIMALS = {
   [NATIVE_ETH.toLowerCase()]: 18,
   // Native ETH
@@ -170,54 +453,19 @@ var TOKEN_DECIMALS = {
   "0x768be13e1680b5ebe0024c42c896e3db59ec0149": 9
   // SKI
 };
-var decimalsCache = {};
-var symbolCache = {};
 function getTokenDecimals(address) {
   const key = address.toLowerCase();
+  if (_globalResolver) {
+    const d = _globalResolver.getDecimals(key);
+    if (d !== void 0) return d;
+    if (_globalResolver.isUnresolvable(key)) return 18;
+  }
   const known = TOKEN_DECIMALS[key];
   if (known !== void 0) return known;
-  const cached = decimalsCache[key];
-  if (cached !== void 0) return cached;
-  console.warn(`Unknown token decimals for ${address}, defaulting to 18. Call fetchTokenDecimals() first for accuracy.`);
   return 18;
 }
 function getTokenSymbol(address) {
-  return symbolCache[address.toLowerCase()];
-}
-async function fetchTokenDecimals(client, address) {
-  const key = address.toLowerCase();
-  const known = TOKEN_DECIMALS[key];
-  if (known !== void 0) return known;
-  const cached = decimalsCache[key];
-  if (cached !== void 0) return cached;
-  for (let attempt = 0; attempt < 2; attempt++) {
-    try {
-      const [decimals, symbol] = await Promise.all([
-        client.readContract({
-          address,
-          abi: import_viem.erc20Abi,
-          functionName: "decimals"
-        }),
-        client.readContract({
-          address,
-          abi: import_viem.erc20Abi,
-          functionName: "symbol"
-        }).catch(() => void 0)
-        // symbol is optional — some tokens don't have it
-      ]);
-      const result = Number(decimals);
-      decimalsCache[key] = result;
-      if (symbol) symbolCache[key] = String(symbol);
-      return result;
-    } catch {
-      if (attempt === 0) {
-        await new Promise((r) => setTimeout(r, 2e3));
-      }
-    }
-  }
-  console.warn(`Failed to fetch decimals for ${address} after 2 attempts, defaulting to 18`);
-  decimalsCache[key] = 18;
-  return 18;
+  return _globalResolver?.getSymbol(address.toLowerCase());
 }
 var TOKEN_TO_COINGECKO = {
   [NATIVE_ETH.toLowerCase()]: "ethereum",
@@ -301,24 +549,31 @@ var PRICE_STALENESS_MS = 6e4;
 var MarketDataService = class {
   rpcUrl;
   client;
+  resolver;
   /** 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, { timeout: 6e4 })
-    });
-  }
   /** Cached volume data */
   cachedVolume24h = {};
   /** Cached price change data */
   cachedPriceChange24h = {};
+  constructor(rpcUrl, store) {
+    this.rpcUrl = rpcUrl;
+    this.client = (0, import_viem2.createPublicClient)({
+      transport: (0, import_viem2.http)(rpcUrl, { timeout: 6e4 })
+    });
+    this.resolver = new TokenResolver(this.client, store);
+  }
+  /** Get the underlying TokenResolver for direct access */
+  getResolver() {
+    return this.resolver;
+  }
   /**
    * Fetch current market data for the agent
    */
   async fetchMarketData(walletAddress, tokenAddresses) {
+    await this.resolver.resolve(tokenAddresses);
     const prices = await this.fetchPrices(tokenAddresses);
     const balances = await this.fetchBalances(walletAddress, tokenAddresses);
     const portfolioValue = this.calculatePortfolioValue(balances, prices);
@@ -455,14 +710,14 @@ var MarketDataService = class {
               const liq = pair.liquidity?.usd || 0;
               if (price > 0 && (!bestPrices[addr] || liq > bestPrices[addr].liquidity)) {
                 bestPrices[addr] = { price, liquidity: liq };
-                if (pair.baseToken.symbol && !symbolCache[addr]) {
-                  symbolCache[addr] = pair.baseToken.symbol;
+                if (pair.baseToken.symbol) {
+                  this.resolver.setSymbol(addr, pair.baseToken.symbol);
                 }
               }
             }
             for (const [addr, { price }] of Object.entries(bestPrices)) {
               prices[addr] = price;
-              const sym = symbolCache[addr] || addr.slice(0, 10);
+              const sym = this.resolver.getSymbol(addr) || addr.slice(0, 10);
               console.log(`DexScreener price for ${sym}: $${price}`);
             }
           }
@@ -479,7 +734,7 @@ var MarketDataService = class {
     }
     for (const addr of tokenAddresses) {
       if (!prices[addr.toLowerCase()]) {
-        const sym = symbolCache[addr.toLowerCase()];
+        const sym = this.resolver.getSymbol(addr.toLowerCase());
         console.warn(`No price available for ${sym ? `${sym} (${addr})` : addr} \u2014 CoinGecko, DeFi Llama, and DexScreener all returned nothing`);
         prices[addr.toLowerCase()] = 0;
       }
@@ -487,36 +742,35 @@ var MarketDataService = class {
     return prices;
   }
   /**
-   * Fetch real on-chain balances: native ETH + ERC-20 tokens
+   * Fetch real on-chain balances: native ETH + ERC-20 tokens.
+   * Uses Multicall3 to batch all balanceOf calls into a single RPC request.
    */
   async fetchBalances(walletAddress, tokenAddresses) {
     const balances = {};
     const wallet = walletAddress;
     try {
-      const unknownTokens = tokenAddresses.filter(
-        (addr) => TOKEN_DECIMALS[addr.toLowerCase()] === void 0 && !decimalsCache[addr.toLowerCase()]
-      );
-      if (unknownTokens.length > 0) {
-        await Promise.all(unknownTokens.map((addr) => fetchTokenDecimals(this.client, addr)));
-      }
       const nativeBalance = await this.client.getBalance({ address: wallet });
       balances[NATIVE_ETH.toLowerCase()] = nativeBalance;
-      const erc20Promises = tokenAddresses.map(async (tokenAddress) => {
+      if (tokenAddresses.length > 0) {
         try {
-          const balance = await this.client.readContract({
-            address: tokenAddress,
-            abi: import_viem.erc20Abi,
-            functionName: "balanceOf",
-            args: [wallet]
+          const results = await this.client.multicall({
+            contracts: tokenAddresses.map((addr) => ({
+              address: addr,
+              abi: import_viem2.erc20Abi,
+              functionName: "balanceOf",
+              args: [wallet]
+            })),
+            allowFailure: true
           });
-          return { address: tokenAddress.toLowerCase(), balance };
-        } catch (error) {
-          return { address: tokenAddress.toLowerCase(), balance: 0n };
+          for (let i = 0; i < tokenAddresses.length; i++) {
+            const addr = tokenAddresses[i].toLowerCase();
+            const r = results[i];
+            balances[addr] = r.status === "success" ? r.result : 0n;
+          }
+        } catch {
+          console.warn("Multicall3 balanceOf failed, falling back to individual queries");
+          await this.fetchBalancesIndividual(wallet, tokenAddresses, balances);
         }
-      });
-      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);
@@ -528,13 +782,42 @@ var MarketDataService = class {
     return balances;
   }
   /**
-   * Calculate total portfolio value in USD
+   * Fallback: fetch ERC-20 balances individually (if multicall fails).
+   */
+  async fetchBalancesIndividual(wallet, tokenAddresses, balances) {
+    const promises = tokenAddresses.map(async (tokenAddress) => {
+      try {
+        const balance = await this.client.readContract({
+          address: tokenAddress,
+          abi: import_viem2.erc20Abi,
+          functionName: "balanceOf",
+          args: [wallet]
+        });
+        return { address: tokenAddress.toLowerCase(), balance };
+      } catch {
+        return { address: tokenAddress.toLowerCase(), balance: 0n };
+      }
+    });
+    const results = await Promise.all(promises);
+    for (const { address, balance } of results) {
+      balances[address] = balance;
+    }
+  }
+  /**
+   * Calculate total portfolio value in USD.
+   * Skips tokens with unresolvable decimals to avoid corrupted calculations.
    */
   calculatePortfolioValue(balances, prices) {
     let total = 0;
     for (const [address, balance] of Object.entries(balances)) {
       const price = prices[address.toLowerCase()] || 0;
-      const decimals = getTokenDecimals(address);
+      if (price === 0) continue;
+      const key = address.toLowerCase();
+      const resolverDecimals = _globalResolver?.getDecimals(key);
+      if (resolverDecimals === void 0 && _globalResolver?.isUnresolvable(key)) {
+        continue;
+      }
+      const decimals = resolverDecimals ?? getTokenDecimals(address);
       const amount = Number(balance) / Math.pow(10, decimals);
       total += amount * price;
     }
@@ -2254,7 +2537,7 @@ var FileStore = class {
 };
 
 // src/vault/manager.ts
-var import_viem2 = require("viem");
+var import_viem3 = require("viem");
 var import_accounts = require("viem/accounts");
 var import_chains = require("viem/chains");
 var ADDRESSES = {
@@ -2345,12 +2628,12 @@ var VaultManager = class {
     this.account = (0, import_accounts.privateKeyToAccount)(config.walletKey);
     this.chain = import_chains.base;
     const rpcUrl = getRpcUrl();
-    const transport = (0, import_viem2.http)(rpcUrl, { timeout: 6e4 });
-    this.publicClient = (0, import_viem2.createPublicClient)({
+    const transport = (0, import_viem3.http)(rpcUrl, { timeout: 6e4 });
+    this.publicClient = (0, import_viem3.createPublicClient)({
       chain: this.chain,
       transport
     });
-    this.walletClient = (0, import_viem2.createWalletClient)({
+    this.walletClient = (0, import_viem3.createWalletClient)({
       account: this.account,
       chain: this.chain,
       transport
@@ -2998,7 +3281,7 @@ var HyperliquidClient = class {
 };
 
 // src/perp/signer.ts
-var import_viem3 = require("viem");
+var import_viem4 = require("viem");
 var HYPERLIQUID_DOMAIN = {
   name: "HyperliquidSignTransaction",
   version: "1",
@@ -3072,10 +3355,10 @@ function fillHashToBytes32(fillHash) {
   if (fillHash.startsWith("0x") && fillHash.length === 66) {
     return fillHash;
   }
-  return (0, import_viem3.keccak256)((0, import_viem3.encodePacked)(["string"], [fillHash]));
+  return (0, import_viem4.keccak256)((0, import_viem4.encodePacked)(["string"], [fillHash]));
 }
 function fillOidToBytes32(oid) {
-  return (0, import_viem3.keccak256)((0, import_viem3.encodePacked)(["uint256"], [BigInt(oid)]));
+  return (0, import_viem4.keccak256)((0, import_viem4.encodePacked)(["uint256"], [BigInt(oid)]));
 }
 
 // src/perp/orders.ts
@@ -3677,7 +3960,7 @@ var HyperliquidWebSocket = class {
 };
 
 // src/perp/recorder.ts
-var import_viem4 = require("viem");
+var import_viem5 = require("viem");
 var import_chains2 = require("viem/chains");
 var import_accounts3 = require("viem/accounts");
 var ROUTER_ADDRESS = "0x1BCFa13f677fDCf697D8b7d5120f544817F1de1A";
@@ -3720,12 +4003,12 @@ var PerpTradeRecorder = class {
     this.configHash = opts.configHash;
     this.account = (0, import_accounts3.privateKeyToAccount)(opts.privateKey);
     const rpcUrl = opts.rpcUrl || "https://mainnet.base.org";
-    const transport = (0, import_viem4.http)(rpcUrl, { timeout: 6e4 });
-    this.publicClient = (0, import_viem4.createPublicClient)({
+    const transport = (0, import_viem5.http)(rpcUrl, { timeout: 6e4 });
+    this.publicClient = (0, import_viem5.createPublicClient)({
       chain: import_chains2.base,
       transport
     });
-    this.walletClient = (0, import_viem4.createWalletClient)({
+    this.walletClient = (0, import_viem5.createWalletClient)({
       chain: import_chains2.base,
       transport,
       account: this.account
@@ -4033,23 +4316,23 @@ var PerpOnboarding = class {
 };
 
 // src/perp/funding.ts
-var import_viem5 = require("viem");
+var import_viem6 = require("viem");
 var import_chains3 = require("viem/chains");
 var import_accounts4 = require("viem/accounts");
-var ERC20_ABI = (0, import_viem5.parseAbi)([
+var ERC20_ABI = (0, import_viem6.parseAbi)([
   "function approve(address spender, uint256 amount) external returns (bool)",
   "function balanceOf(address account) external view returns (uint256)",
   "function allowance(address owner, address spender) external view returns (uint256)"
 ]);
-var TOKEN_MESSENGER_V2_ABI = (0, import_viem5.parseAbi)([
+var TOKEN_MESSENGER_V2_ABI = (0, import_viem6.parseAbi)([
   "function depositForBurn(uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken) external returns (uint64 nonce)",
   "event DepositForBurn(uint64 indexed nonce, address indexed burnToken, uint256 amount, address indexed depositor, bytes32 mintRecipient, uint32 destinationDomain, bytes32 destinationTokenMessenger, bytes32 destinationCaller)"
 ]);
-var MESSAGE_TRANSMITTER_V2_ABI = (0, import_viem5.parseAbi)([
+var MESSAGE_TRANSMITTER_V2_ABI = (0, import_viem6.parseAbi)([
   "function receiveMessage(bytes message, bytes attestation) external returns (bool success)",
   "event MessageSent(bytes message)"
 ]);
-var CORE_DEPOSIT_WALLET_ABI = (0, import_viem5.parseAbi)([
+var CORE_DEPOSIT_WALLET_ABI = (0, import_viem6.parseAbi)([
   "function deposit(uint256 amount, uint32 destinationDex) external"
 ]);
 
@@ -4139,7 +4422,8 @@ var AgentRuntime = class {
     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());
+    this.marketData = new MarketDataService(this.getRpcUrl(), store);
+    setGlobalResolver(this.marketData.getResolver());
     const savedRisk = this.positionTracker.getRiskState();
     if (savedRisk.lastResetDate) {
       this.riskManager.restoreState(savedRisk);
@@ -4236,9 +4520,9 @@ var AgentRuntime = class {
       this.perpClient = new HyperliquidClient(config);
       const perpKey = perpConfig.perpRelayerKey || this.config.privateKey;
       const account = (0, import_accounts5.privateKeyToAccount)(perpKey);
-      const walletClient = (0, import_viem6.createWalletClient)({
+      const walletClient = (0, import_viem7.createWalletClient)({
         chain: { id: 42161, name: "Arbitrum", nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 }, rpcUrls: { default: { http: ["https://arb1.arbitrum.io/rpc"] } } },
-        transport: (0, import_viem6.http)("https://arb1.arbitrum.io/rpc", { timeout: 6e4 }),
+        transport: (0, import_viem7.http)("https://arb1.arbitrum.io/rpc", { timeout: 6e4 }),
         account
       });
       this.perpSigner = new HyperliquidSigner(walletClient);
@@ -4478,9 +4762,9 @@ var AgentRuntime = class {
       const message = error instanceof Error ? error.message : String(error);
       if (message.includes("insufficient funds") || message.includes("intrinsic gas too low") || message.includes("exceeds the balance")) {
         const ccUrl = `https://exagent.io/agents/${encodeURIComponent(this.config.name)}/command-center`;
-        const publicClientInstance = (0, import_viem6.createPublicClient)({
+        const publicClientInstance = (0, import_viem7.createPublicClient)({
           chain: import_chains4.base,
-          transport: (0, import_viem6.http)(this.getRpcUrl(), { timeout: 6e4 })
+          transport: (0, import_viem7.http)(this.getRpcUrl(), { timeout: 6e4 })
         });
         console.log("");
         console.log("=== ETH NEEDED FOR GAS ===");
@@ -5232,7 +5516,14 @@ var AgentRuntime = class {
     if (extras.length > 0) {
       console.log(`Auto-tracking ${extras.length} additional token(s) from position history`);
     }
-    return [...base5, ...extras];
+    const resolver = this.marketData.getResolver();
+    const allTokens = [...base5, ...extras];
+    const filtered = allTokens.filter((t) => !resolver.isUnresolvable(t.toLowerCase()));
+    const dropped = allTokens.length - filtered.length;
+    if (dropped > 0) {
+      console.log(`Skipping ${dropped} unresolvable token(s)`);
+    }
+    return filtered;
   }
   /**
    * Default tokens to track.

package/dist/index.mjs

@@ -49,7 +49,7 @@ import {
   loadStrategy,
   validateConfig,
   validateStrategy
-} from "./chunk-BAOLHULW.mjs";
+} from "./chunk-Q23UPFHO.mjs";
 export {
   AGENT_VERSION,
   AgentConfigSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exagent/agent",
-  "version": "0.1.32",
+  "version": "0.1.33",
   "description": "Autonomous trading agent runtime for Exagent",
   "main": "dist/index.js",
   "module": "dist/index.mjs",