@general-liquidity/gordon-cli 0.75.3 → 0.75.5

package/dist/gordon.js

@@ -14414,7 +14414,9 @@ async function checkEnvStatus() {
       KRAKEN_API_SECRET: process.env.KRAKEN_API_SECRET,
       BITFINEX_API_KEY: process.env.BITFINEX_API_KEY,
       BITFINEX_API_SECRET: process.env.BITFINEX_API_SECRET,
-      HYPERLIQUID_PRIVATE_KEY: process.env.HYPERLIQUID_PRIVATE_KEY
+      HYPERLIQUID_PRIVATE_KEY: process.env.HYPERLIQUID_PRIVATE_KEY,
+      UNISWAP_API_KEY: process.env.UNISWAP_API_KEY,
+      THEGRAPH_API_KEY: process.env.THEGRAPH_API_KEY
     };
     return {
       fileExists: false,
@@ -14425,6 +14427,8 @@ async function checkEnvStatus() {
       hasKrakenKeys: !!(keys2.KRAKEN_API_KEY && keys2.KRAKEN_API_SECRET),
       hasBitfinexKeys: !!(keys2.BITFINEX_API_KEY && keys2.BITFINEX_API_SECRET),
       hasHyperliquidKey: !!keys2.HYPERLIQUID_PRIVATE_KEY,
+      hasUniswapKey: !!keys2.UNISWAP_API_KEY,
+      hasGraphKey: !!keys2.THEGRAPH_API_KEY,
       keys: keys2
     };
   }
@@ -14445,7 +14449,9 @@ async function checkEnvStatus() {
     KRAKEN_API_SECRET: parsed.KRAKEN_API_SECRET || process.env.KRAKEN_API_SECRET,
     BITFINEX_API_KEY: parsed.BITFINEX_API_KEY || process.env.BITFINEX_API_KEY,
     BITFINEX_API_SECRET: parsed.BITFINEX_API_SECRET || process.env.BITFINEX_API_SECRET,
-    HYPERLIQUID_PRIVATE_KEY: parsed.HYPERLIQUID_PRIVATE_KEY || process.env.HYPERLIQUID_PRIVATE_KEY
+    HYPERLIQUID_PRIVATE_KEY: parsed.HYPERLIQUID_PRIVATE_KEY || process.env.HYPERLIQUID_PRIVATE_KEY,
+    UNISWAP_API_KEY: parsed.UNISWAP_API_KEY || process.env.UNISWAP_API_KEY,
+    THEGRAPH_API_KEY: parsed.THEGRAPH_API_KEY || process.env.THEGRAPH_API_KEY
   };
   return {
     fileExists: true,
@@ -14456,6 +14462,8 @@ async function checkEnvStatus() {
     hasKrakenKeys: !!(keys.KRAKEN_API_KEY && keys.KRAKEN_API_SECRET),
     hasBitfinexKeys: !!(keys.BITFINEX_API_KEY && keys.BITFINEX_API_SECRET),
     hasHyperliquidKey: !!keys.HYPERLIQUID_PRIVATE_KEY,
+    hasUniswapKey: !!keys.UNISWAP_API_KEY,
+    hasGraphKey: !!keys.THEGRAPH_API_KEY,
     keys
   };
 }
@@ -14715,7 +14723,7 @@ var init_config = __esm(() => {
     apiSecret: exports_external.string(),
     permissions: ExchangePermissionsSchema
   });
-  ExchangeTypeSchema = exports_external.enum(["binance", "binance_us", "coinbase", "kraken", "bitfinex", "hyperliquid"]);
+  ExchangeTypeSchema = exports_external.enum(["binance", "binance_us", "coinbase", "kraken", "bitfinex", "hyperliquid", "uniswap"]);
   MultiExchangeConfigSchema = exports_external.object({
     id: exports_external.string(),
     type: ExchangeTypeSchema,
@@ -195776,9 +195784,1472 @@ var init_hyperliquid3 = __esm(() => {
   init_errors3();
 });
 
+// src/infra/uniswap/types.ts
+var NATIVE_TOKEN = "0x0000000000000000000000000000000000000000", GAS_BUFFER_PERCENT = 0.15, WRAPPED_NATIVE, USDC_ADDRESSES, SUPPORTED_CHAIN_IDS, CHAIN_NAMES;
+var init_types10 = __esm(() => {
+  WRAPPED_NATIVE = {
+    1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    10: "0x4200000000000000000000000000000000000006",
+    56: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+    137: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
+    8453: "0x4200000000000000000000000000000000000006",
+    42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+    43114: "0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7"
+  };
+  USDC_ADDRESSES = {
+    1: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    10: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+    56: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
+    137: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+    8453: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    42161: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    43114: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E"
+  };
+  SUPPORTED_CHAIN_IDS = [1, 10, 56, 130, 137, 196, 324, 480, 1868, 8453, 42161, 42220, 43114, 81457, 7777777];
+  CHAIN_NAMES = {
+    1: "Ethereum",
+    10: "Optimism",
+    56: "BNB Chain",
+    130: "Unichain",
+    137: "Polygon",
+    196: "X Layer",
+    324: "zkSync",
+    480: "World Chain",
+    1868: "Soneium",
+    8453: "Base",
+    42161: "Arbitrum",
+    42220: "Celo",
+    43114: "Avalanche",
+    81457: "Blast",
+    7777777: "Zora"
+  };
+});
+
+// src/infra/uniswap/token-list.ts
+class UniswapTokenList {
+  bySymbol = new Map;
+  byAddress = new Map;
+  cache = new Cache({ defaultTtl: CACHE_TTL_MS2, maxEntries: 1 });
+  fetchPromise = null;
+  isLoaded() {
+    return this.cache.has("loaded");
+  }
+  async ensureLoaded() {
+    if (this.isLoaded())
+      return;
+    if (this.fetchPromise)
+      return this.fetchPromise;
+    this.fetchPromise = this.fetchList();
+    try {
+      await this.fetchPromise;
+    } finally {
+      this.fetchPromise = null;
+    }
+  }
+  async fetchList() {
+    try {
+      const res = await fetch(TOKEN_LIST_URL);
+      if (!res.ok)
+        throw new Error(`Token list fetch failed: ${res.status}`);
+      const data = await res.json();
+      this.buildMaps(data.tokens);
+      this.cache.set("loaded", true, CACHE_TTL_MS2);
+    } catch {
+      if (this.bySymbol.size === 0) {
+        this.buildHardcodedFallback();
+      }
+    }
+  }
+  buildMaps(tokens) {
+    this.bySymbol.clear();
+    this.byAddress.clear();
+    const supportedChains = new Set(SUPPORTED_CHAIN_IDS);
+    for (const raw of tokens) {
+      if (supportedChains.has(raw.chainId)) {
+        this.addToken({
+          chainId: raw.chainId,
+          address: raw.address,
+          symbol: raw.symbol,
+          name: raw.name,
+          decimals: raw.decimals,
+          logoURI: raw.logoURI
+        });
+      }
+      if (raw.extensions?.bridgeInfo) {
+        for (const [chainIdStr, bridge] of Object.entries(raw.extensions.bridgeInfo)) {
+          const bridgeChainId = Number(chainIdStr);
+          if (supportedChains.has(bridgeChainId)) {
+            this.addToken({
+              chainId: bridgeChainId,
+              address: bridge.tokenAddress,
+              symbol: raw.symbol,
+              name: raw.name,
+              decimals: raw.decimals,
+              logoURI: raw.logoURI
+            });
+          }
+        }
+      }
+    }
+  }
+  buildHardcodedFallback() {
+    for (const [chainIdStr, address] of Object.entries(WRAPPED_NATIVE)) {
+      const chainId = Number(chainIdStr);
+      const symbol16 = chainId === 56 ? "WBNB" : chainId === 137 ? "WMATIC" : chainId === 43114 ? "WAVAX" : "WETH";
+      this.addToken({ chainId, address, symbol: symbol16, name: `Wrapped Native (${symbol16})`, decimals: 18 });
+    }
+    for (const [chainIdStr, address] of Object.entries(USDC_ADDRESSES)) {
+      const chainId = Number(chainIdStr);
+      this.addToken({ chainId, address, symbol: "USDC", name: "USD Coin", decimals: 6 });
+    }
+    this.cache.set("loaded", true, CACHE_TTL_MS2);
+  }
+  addToken(token) {
+    const key = `${token.symbol.toUpperCase()}:${token.chainId}`;
+    const existing = this.bySymbol.get(key) || [];
+    if (!existing.some((t2) => t2.address.toLowerCase() === token.address.toLowerCase())) {
+      existing.push(token);
+      this.bySymbol.set(key, existing);
+    }
+    this.byAddress.set(token.address.toLowerCase(), token);
+  }
+  async resolve(symbol16, chainId) {
+    await this.ensureLoaded();
+    const sym = symbol16.toUpperCase();
+    const exact = this.bySymbol.get(`${sym}:${chainId}`);
+    if (exact && exact.length > 0)
+      return exact[0].address;
+    const mainnet = this.bySymbol.get(`${sym}:1`);
+    if (mainnet && mainnet.length > 0) {
+      return mainnet[0].address;
+    }
+    for (const [key, tokens] of this.bySymbol) {
+      if (key.startsWith(`${sym}:`)) {
+        return tokens[0].address;
+      }
+    }
+    return null;
+  }
+  async getToken(symbol16, chainId) {
+    await this.ensureLoaded();
+    const sym = symbol16.toUpperCase();
+    const exact = this.bySymbol.get(`${sym}:${chainId}`);
+    if (exact && exact.length > 0)
+      return exact[0];
+    const mainnet = this.bySymbol.get(`${sym}:1`);
+    if (mainnet && mainnet.length > 0)
+      return mainnet[0];
+    return null;
+  }
+  async getTokenByAddress(address) {
+    await this.ensureLoaded();
+    return this.byAddress.get(address.toLowerCase()) || null;
+  }
+}
+var TOKEN_LIST_URL = "https://tokens.uniswap.org", CACHE_TTL_MS2;
+var init_token_list = __esm(() => {
+  init_types10();
+  CACHE_TTL_MS2 = 24 * 60 * 60 * 1000;
+});
+
+// src/infra/uniswap/client.ts
+class UniswapClient {
+  apiKey;
+  walletAddress;
+  chainId;
+  rateLimitState;
+  circuitState = "closed";
+  consecutiveFailures = 0;
+  tokenList = new UniswapTokenList;
+  constructor(apiKey, walletAddress, chainId = 1) {
+    this.apiKey = apiKey;
+    this.walletAddress = walletAddress;
+    this.chainId = chainId;
+    this.rateLimitState = {
+      requestCount: 0,
+      lastReset: Date.now(),
+      throttledCount: 0
+    };
+  }
+  get address() {
+    return this.walletAddress;
+  }
+  get chain() {
+    return this.chainId;
+  }
+  checkRateLimit() {
+    const now2 = Date.now();
+    if (now2 - this.rateLimitState.lastReset > 60000) {
+      this.rateLimitState.requestCount = 0;
+      this.rateLimitState.lastReset = now2;
+      this.rateLimitState.throttledCount = 0;
+    }
+  }
+  shouldThrottle() {
+    this.checkRateLimit();
+    return this.circuitState === "open" || this.rateLimitState.requestCount > RATE_LIMIT_CONFIG6.throttleThreshold;
+  }
+  getRateLimitStatus() {
+    this.checkRateLimit();
+    const usagePercent = this.rateLimitState.requestCount / RATE_LIMIT_CONFIG6.maxRequestsPerMinute * 100;
+    return {
+      currentRequests: this.rateLimitState.requestCount,
+      maxRequests: RATE_LIMIT_CONFIG6.maxRequestsPerMinute,
+      usagePercent: Math.round(usagePercent),
+      isThrottling: this.shouldThrottle(),
+      throttledCount: this.rateLimitState.throttledCount,
+      timeUntilReset: Math.max(0, 60000 - (Date.now() - this.rateLimitState.lastReset))
+    };
+  }
+  getCircuitBreakerState() {
+    return this.circuitState;
+  }
+  resetCircuitBreaker() {
+    this.circuitState = "closed";
+    this.consecutiveFailures = 0;
+  }
+  getUsdcAddress() {
+    return USDC_ADDRESSES[this.chainId] || USDC_ADDRESSES[1];
+  }
+  getWrappedNative() {
+    return WRAPPED_NATIVE[this.chainId] || WRAPPED_NATIVE[1];
+  }
+  isNativeToken(token) {
+    return token.toLowerCase() === NATIVE_TOKEN.toLowerCase();
+  }
+  async resolveSymbol(symbol16) {
+    const s = symbol16.toUpperCase().replace(/[_\-/]/g, "");
+    if (s.startsWith("0X") && s.includes("0X", 3)) {
+      const parts = symbol16.split(/[_\-/]/);
+      if (parts.length === 2) {
+        const inToken = await this.tokenList.getTokenByAddress(parts[0]);
+        const outToken = await this.tokenList.getTokenByAddress(parts[1]);
+        return {
+          tokenIn: parts[0],
+          tokenOut: parts[1],
+          tokenInDecimals: inToken?.decimals ?? 18,
+          tokenOutDecimals: outToken?.decimals ?? 18
+        };
+      }
+    }
+    const quotePatterns = [
+      [/USDC$/, "USDC", () => this.getUsdcAddress(), 6],
+      [/USDT$/, "USDT", () => this.getUsdcAddress(), 6],
+      [/ETH$/, "ETH", () => this.getWrappedNative(), 18],
+      [/WETH$/, "WETH", () => this.getWrappedNative(), 18]
+    ];
+    for (const [pattern2, _quoteName, getQuoteAddress, quoteDecimals] of quotePatterns) {
+      if (pattern2.test(s)) {
+        const base2 = s.replace(pattern2, "");
+        if (!base2)
+          continue;
+        if (base2 === "ETH" || base2 === "WETH") {
+          return {
+            tokenIn: this.getWrappedNative(),
+            tokenOut: getQuoteAddress(),
+            tokenInDecimals: 18,
+            tokenOutDecimals: quoteDecimals
+          };
+        }
+        const baseToken = await this.tokenList.getToken(base2, this.chainId);
+        if (baseToken) {
+          return {
+            tokenIn: baseToken.address,
+            tokenOut: getQuoteAddress(),
+            tokenInDecimals: baseToken.decimals,
+            tokenOutDecimals: quoteDecimals
+          };
+        }
+        throw new Error(`Unknown token "${base2}" \u2014 not found in Uniswap token list for chain ${this.chainId}. ` + `Use a token address directly (e.g., "0x1234.../0xABCD...").`);
+      }
+    }
+    throw new Error(`Cannot resolve symbol "${symbol16}" to token addresses. ` + `Use a supported pair like "UNIUSDC", "LINKETH", or raw addresses "0xABC.../0xDEF...".`);
+  }
+  async request(path5, body, extraHeaders) {
+    this.checkRateLimit();
+    this.rateLimitState.requestCount++;
+    const url2 = `${BASE_URL4}${path5}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "x-api-key": this.apiKey,
+      "x-universal-router-version": "2.0",
+      ...extraHeaders
+    };
+    let lastError = null;
+    for (let attempt = 0;attempt <= MAX_RETRIES2; attempt++) {
+      if (attempt > 0) {
+        const delay5 = BASE_DELAY_MS * 2 ** (attempt - 1);
+        await new Promise((r) => setTimeout(r, delay5));
+      }
+      try {
+        const res = await fetch(url2, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body)
+        });
+        if (res.ok) {
+          this.consecutiveFailures = 0;
+          if (this.circuitState === "half-open")
+            this.circuitState = "closed";
+          return res.json();
+        }
+        const errorBody = await res.text().catch(() => "");
+        if ([429, 500, 503].includes(res.status) && attempt < MAX_RETRIES2) {
+          if (res.status === 429)
+            this.rateLimitState.throttledCount++;
+          lastError = new Error(`Uniswap API error ${res.status}: ${errorBody}`);
+          continue;
+        }
+        this.consecutiveFailures++;
+        if (this.consecutiveFailures >= 5)
+          this.circuitState = "open";
+        throw new Error(`Uniswap API error ${res.status}: ${errorBody}`);
+      } catch (err) {
+        if (err instanceof Error && err.message.startsWith("Uniswap API error")) {
+          throw err;
+        }
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt >= MAX_RETRIES2) {
+          this.consecutiveFailures++;
+          if (this.consecutiveFailures >= 5)
+            this.circuitState = "open";
+          throw lastError;
+        }
+      }
+    }
+    throw lastError || new Error("Uniswap request failed");
+  }
+  async testConnection() {
+    try {
+      const weth = this.getWrappedNative();
+      const usdc = this.getUsdcAddress();
+      await this.getQuote(weth, usdc, "1000000000000000");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getQuote(tokenIn, tokenOut, amount, options = {}) {
+    const tokenOutChainId = options.tokenOutChainId ?? this.chainId;
+    const isCrossChain = tokenOutChainId !== this.chainId;
+    const body = {
+      type: options.type ?? "EXACT_INPUT",
+      amount,
+      tokenInChainId: this.chainId,
+      tokenOutChainId,
+      tokenIn,
+      tokenOut,
+      swapper: this.walletAddress,
+      routingPreference: options.routingPreference ?? "BEST_PRICE"
+    };
+    if (options.slippageTolerance) {
+      body.slippageTolerance = options.slippageTolerance;
+    } else {
+      body.autoSlippage = "DEFAULT";
+    }
+    if (options.permitAmount) {
+      body.permitAmount = options.permitAmount;
+    }
+    const extraHeaders = isCrossChain ? { "x-chained-actions-enabled": "true" } : undefined;
+    return this.request("/quote", body, extraHeaders);
+  }
+  async getSwapTransaction(quote, permit, deadline) {
+    const body = {
+      quote: quote.quote,
+      refreshGasPrice: true,
+      deadline: deadline ?? Math.floor(Date.now() / 1000) + 120
+    };
+    if (permit) {
+      body.signature = permit.signature;
+      body.permitData = permit.permitData;
+    }
+    const resp = await this.request("/swap", body);
+    if (resp.swap.gasLimit) {
+      const buffered = Math.ceil(Number(resp.swap.gasLimit) * (1 + GAS_BUFFER_PERCENT));
+      resp.swap.gasLimit = buffered.toString();
+    }
+    return resp;
+  }
+  async checkApproval(token, amount) {
+    if (this.isNativeToken(token)) {
+      return { approval: null };
+    }
+    return this.request("/check_approval", {
+      walletAddress: this.walletAddress,
+      token,
+      amount,
+      chainId: this.chainId,
+      includeGasInfo: true
+    });
+  }
+  static validateSwapTransaction(data) {
+    if (!data || data === "" || data === "0x")
+      return false;
+    return /^0x[0-9a-fA-F]+$/.test(data);
+  }
+  static isQuoteFresh(quoteTimestamp) {
+    return Date.now() - quoteTimestamp < QUOTE_MAX_AGE_MS;
+  }
+}
+var BASE_URL4 = "https://trade-api.gateway.uniswap.org/v1", MAX_RETRIES2 = 3, BASE_DELAY_MS = 500, QUOTE_MAX_AGE_MS = 30000, RATE_LIMIT_CONFIG6;
+var init_client9 = __esm(() => {
+  init_types10();
+  init_token_list();
+  RATE_LIMIT_CONFIG6 = {
+    maxRequestsPerMinute: 60,
+    throttleThreshold: 50
+  };
+});
+
+// src/infra/uniswap/subgraph-types.ts
+var V3_SUBGRAPH_IDS;
+var init_subgraph_types = __esm(() => {
+  V3_SUBGRAPH_IDS = {
+    1: "5zvR82QoaXYFyDEKLZ9t6v9adgnptxYpKpSbxtgVENFV",
+    10: "Cghf4LfVqPiFw6fp6Y5X5Ubc8UpmUhSfJL82zwiBFLaj",
+    56: "F85MNzUGYqgSHSHRGgeVMNsdnW1KtZSVgFULumXRZTw2",
+    137: "3hCPRGf4z88VC5rsBKU5AA9FBBq5nF3jbKJG7VZCbhjm",
+    8453: "43Hwfi3dJSoGpyas9VwNoDAv55yjgGrPpNSmbQZArzMG",
+    42161: "FbCGRftH4a3yZugY7TnbYgPJVEv2LvMT6oF1fxPe9aJM",
+    42220: "ESdrTJ3twMwWVoQ1hUE2u7PugEHX3QkenudD6aXCkDQ4",
+    43114: "GVH9h9KZ9CqheUEL93qMbq7QwgoBu32QXQDPR6bev4Eo",
+    81457: "2LHovKznvo8YmKC9ZprPjsYAZDCc4K5q4AYz8s3cnQn1"
+  };
+});
+
+// src/infra/uniswap/subgraph.ts
+class UniswapSubgraph {
+  apiKey;
+  chainId;
+  client;
+  endpointUrl;
+  poolCache = new Cache({ defaultTtl: CACHE_TTL.pool, maxEntries: 100 });
+  dataCache = new Cache({ defaultTtl: CACHE_TTL.candles, maxEntries: 500 });
+  requestCount = 0;
+  lastResetTime = Date.now();
+  throttledCount = 0;
+  circuitState = "closed";
+  consecutiveFailures = 0;
+  circuitOpenedAt = 0;
+  constructor(apiKey, chainId, client) {
+    this.apiKey = apiKey;
+    this.chainId = chainId;
+    this.client = client;
+    const subgraphId = V3_SUBGRAPH_IDS[chainId];
+    this.endpointUrl = subgraphId ? `${GRAPH_GATEWAY}/subgraphs/id/${subgraphId}` : null;
+  }
+  isAvailable() {
+    if (!this.endpointUrl)
+      return false;
+    if (this.circuitState === "open") {
+      if (Date.now() - this.circuitOpenedAt > CIRCUIT_RESET_MS) {
+        this.circuitState = "half-open";
+        return true;
+      }
+      return false;
+    }
+    return true;
+  }
+  async checkRateLimit() {
+    const now2 = Date.now();
+    if (now2 - this.lastResetTime > 60000) {
+      this.requestCount = 0;
+      this.lastResetTime = now2;
+      this.throttledCount = 0;
+    }
+    if (this.requestCount >= RATE_LIMIT.maxPerMinute) {
+      const waitMs = 60000 - (now2 - this.lastResetTime);
+      throw new Error(`Subgraph rate limit reached (${RATE_LIMIT.maxPerMinute}/min). Retry in ${Math.ceil(waitMs / 1000)}s.`);
+    }
+    if (this.requestCount >= RATE_LIMIT.throttleAt) {
+      const delayMs = 500 * (this.requestCount - RATE_LIMIT.throttleAt + 1);
+      await new Promise((r) => setTimeout(r, delayMs));
+      this.throttledCount++;
+    }
+  }
+  async query(graphql, variables = {}) {
+    if (!this.endpointUrl) {
+      throw new Error(`No V3 subgraph available for chain ${this.chainId}`);
+    }
+    if (this.circuitState === "open" && !this.isAvailable()) {
+      throw new Error("Subgraph circuit breaker is open");
+    }
+    await this.checkRateLimit();
+    this.requestCount++;
+    let lastError = null;
+    for (let attempt = 0;attempt <= MAX_RETRIES3; attempt++) {
+      if (attempt > 0) {
+        const delay5 = BASE_DELAY_MS2 * 2 ** (attempt - 1);
+        await new Promise((r) => setTimeout(r, delay5));
+      }
+      try {
+        const url2 = `${GRAPH_GATEWAY}/${this.apiKey}${this.endpointUrl}`;
+        const res = await fetch(url2, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ query: graphql, variables })
+        });
+        if (res.ok) {
+          const json3 = await res.json();
+          if (json3.errors?.length) {
+            throw new Error(`Subgraph error: ${json3.errors.map((e2) => e2.message).join("; ")}`);
+          }
+          this.consecutiveFailures = 0;
+          if (this.circuitState === "half-open")
+            this.circuitState = "closed";
+          return json3.data;
+        }
+        const errBody = await res.text().catch(() => "");
+        if ([429, 500, 503].includes(res.status) && attempt < MAX_RETRIES3) {
+          if (res.status === 429)
+            this.throttledCount++;
+          lastError = new Error(`Subgraph HTTP ${res.status}: ${errBody}`);
+          continue;
+        }
+        this.onFailure();
+        throw new Error(`Subgraph HTTP ${res.status}: ${errBody}`);
+      } catch (err) {
+        if (err instanceof Error && err.message.startsWith("Subgraph"))
+          throw err;
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt >= MAX_RETRIES3) {
+          this.onFailure();
+          throw lastError;
+        }
+      }
+    }
+    throw lastError || new Error("Subgraph request failed");
+  }
+  onFailure() {
+    this.consecutiveFailures++;
+    if (this.consecutiveFailures >= CIRCUIT_FAILURE_THRESHOLD) {
+      this.circuitState = "open";
+      this.circuitOpenedAt = Date.now();
+    }
+  }
+  async resolvePool(symbol16) {
+    const cacheKey = `pool:${this.chainId}:${symbol16}`;
+    const cached2 = this.poolCache.get(cacheKey);
+    if (cached2)
+      return cached2;
+    const { tokenIn, tokenOut } = await this.client.resolveSymbol(symbol16);
+    const inLower = tokenIn.toLowerCase();
+    const outLower = tokenOut.toLowerCase();
+    const [t0, t1] = inLower < outLower ? [inLower, outLower] : [outLower, inLower];
+    const isInverted = inLower !== t0;
+    const data = await this.query(`query($t0: String!, $t1: String!) {
+        pools(
+          first: 1
+          where: { token0: $t0, token1: $t1 }
+          orderBy: liquidity
+          orderDirection: desc
+        ) {
+          id feeTier liquidity sqrtPrice tick
+          token0Price token1Price
+          totalValueLockedUSD volumeUSD
+          token0 { id symbol name decimals }
+          token1 { id symbol name decimals }
+        }
+      }`, { t0, t1 });
+    if (!data.pools.length) {
+      throw new Error(`No Uniswap V3 pool found for ${symbol16} on chain ${this.chainId}`);
+    }
+    const resolved = { pool: data.pools[0], isInverted };
+    this.poolCache.set(cacheKey, resolved, CACHE_TTL.pool);
+    return resolved;
+  }
+  getPoolPrice(pool, isInverted) {
+    return isInverted ? parseFloat(pool.token1Price) : parseFloat(pool.token0Price);
+  }
+  async getCandles(symbol16, interval, limit) {
+    const { pool, isInverted } = await this.resolvePool(symbol16);
+    const useHourly = ["1m", "5m", "15m", "30m", "1h", "4h"].includes(interval);
+    const intervalSeconds = useHourly ? 3600 : 86400;
+    const start = Math.floor(Date.now() / 1000) - limit * intervalSeconds;
+    const cacheKey = `candle:${this.chainId}:${pool.id}:${interval}:${limit}`;
+    const cached2 = this.dataCache.get(cacheKey);
+    if (cached2)
+      return cached2;
+    let candles;
+    if (useHourly) {
+      const data = await this.query(`query($pool: String!, $start: Int!, $first: Int!) {
+          poolHourDatas(
+            first: $first
+            where: { pool: $pool, periodStartUnix_gte: $start }
+            orderBy: periodStartUnix
+            orderDirection: asc
+          ) {
+            periodStartUnix open high low close
+            volumeUSD volumeToken0 volumeToken1 tvlUSD
+            token0Price token1Price
+          }
+        }`, { pool: pool.id, start, first: Math.min(limit, 1000) });
+      candles = data.poolHourDatas.map((d) => this.mapCandle(d.periodStartUnix, intervalSeconds, d, isInverted));
+    } else {
+      const data = await this.query(`query($pool: String!, $start: Int!, $first: Int!) {
+          poolDayDatas(
+            first: $first
+            where: { pool: $pool, date_gte: $start }
+            orderBy: date
+            orderDirection: asc
+          ) {
+            date open high low close
+            volumeUSD volumeToken0 volumeToken1 tvlUSD
+            token0Price token1Price
+          }
+        }`, { pool: pool.id, start, first: Math.min(limit, 1000) });
+      candles = data.poolDayDatas.map((d) => this.mapCandle(d.date, intervalSeconds, d, isInverted));
+    }
+    this.dataCache.set(cacheKey, candles, CACHE_TTL.candles);
+    return candles;
+  }
+  mapCandle(timestamp, intervalSec, d, isInverted) {
+    let open = parseFloat(d.open);
+    let high = parseFloat(d.high);
+    let low = parseFloat(d.low);
+    let close = parseFloat(d.close);
+    if (open === 0 && close === 0) {
+      const price = isInverted ? parseFloat(d.token1Price) : parseFloat(d.token0Price);
+      open = high = low = close = price;
+    } else if (isInverted && open !== 0 && high !== 0 && low !== 0 && close !== 0) {
+      const iOpen = 1 / open;
+      const iHigh = 1 / low;
+      const iLow = 1 / high;
+      const iClose = 1 / close;
+      open = iOpen;
+      high = iHigh;
+      low = iLow;
+      close = iClose;
+    } else if (isInverted) {
+      const price = parseFloat(d.token1Price);
+      if (price !== 0) {
+        open = high = low = close = price;
+      }
+    }
+    return {
+      openTime: timestamp * 1000,
+      open,
+      high,
+      low,
+      close,
+      volume: parseFloat(d.volumeUSD),
+      closeTime: (timestamp + intervalSec) * 1000 - 1
+    };
+  }
+  async get24hrTickers(limit = 100) {
+    const cacheKey = `tickers:${this.chainId}:${limit}`;
+    const cached2 = this.dataCache.get(cacheKey);
+    if (cached2)
+      return cached2;
+    const fetchLimit = Math.min(limit + 15, 200);
+    const data = await this.query(`query($first: Int!) {
+        tokens(
+          first: $first
+          orderBy: volumeUSD
+          orderDirection: desc
+          where: { volumeUSD_gt: "1000" }
+        ) {
+          id symbol name
+          volumeUSD totalValueLockedUSD
+          tokenDayDatas(first: 2, orderBy: date, orderDirection: desc) {
+            date priceUSD volumeUSD
+            open high low close
+          }
+        }
+      }`, { first: fetchLimit });
+    const now2 = Date.now();
+    const tickers = [];
+    for (const token of data.tokens) {
+      if (STABLECOIN_SYMBOLS.has(token.symbol.toUpperCase()))
+        continue;
+      if (token.tokenDayDatas.length === 0)
+        continue;
+      const today = token.tokenDayDatas[0];
+      const yesterday = token.tokenDayDatas[1];
+      const todayPrice = parseFloat(today.priceUSD);
+      const yesterdayPrice = yesterday ? parseFloat(yesterday.priceUSD) : todayPrice;
+      const priceChange = todayPrice - yesterdayPrice;
+      const priceChangePercent = yesterdayPrice !== 0 ? priceChange / yesterdayPrice * 100 : 0;
+      const highPrice = parseFloat(today.high) || todayPrice;
+      const lowPrice = parseFloat(today.low) || todayPrice;
+      tickers.push({
+        symbol: `${token.symbol.toUpperCase()}USDC`,
+        priceChange,
+        priceChangePercent,
+        lastPrice: todayPrice,
+        highPrice,
+        lowPrice,
+        volume: parseFloat(today.volumeUSD),
+        quoteVolume: parseFloat(today.volumeUSD),
+        openTime: today.date * 1000,
+        closeTime: now2
+      });
+      if (tickers.length >= limit)
+        break;
+    }
+    this.dataCache.set(cacheKey, tickers, CACHE_TTL.tickers);
+    return tickers;
+  }
+  async getTopSymbols(n) {
+    const cacheKey = `top:${this.chainId}:${n}`;
+    const cached2 = this.dataCache.get(cacheKey);
+    if (cached2)
+      return cached2;
+    const fetchN = Math.min(n + 10, 100);
+    const data = await this.query(`query($first: Int!) {
+        tokens(
+          first: $first
+          orderBy: volumeUSD
+          orderDirection: desc
+          where: { volumeUSD_gt: "1000" }
+        ) {
+          id symbol
+        }
+      }`, { first: fetchN });
+    const symbols = [];
+    for (const token of data.tokens) {
+      const sym = token.symbol.toUpperCase();
+      if (STABLECOIN_SYMBOLS.has(sym))
+        continue;
+      if (sym === "WETH" || sym === "WBTC") {
+        symbols.push(`${sym.slice(1)}USDC`);
+      } else {
+        symbols.push(`${sym}USDC`);
+      }
+      if (symbols.length >= n)
+        break;
+    }
+    this.dataCache.set(cacheKey, symbols, CACHE_TTL.top);
+    return symbols;
+  }
+  async getTradeHistory(symbol16, limit) {
+    const { pool, isInverted } = await this.resolvePool(symbol16);
+    const cacheKey = `trades:${this.chainId}:${pool.id}:${limit}`;
+    const cached2 = this.dataCache.get(cacheKey);
+    if (cached2)
+      return cached2;
+    const data = await this.query(`query($pool: String!, $first: Int!) {
+        swaps(
+          first: $first
+          where: { pool: $pool }
+          orderBy: timestamp
+          orderDirection: desc
+        ) {
+          id timestamp
+          amount0 amount1 amountUSD
+          sender recipient
+          sqrtPriceX96 tick
+        }
+      }`, { pool: pool.id, first: Math.min(limit, 1000) });
+    const trades = data.swaps.map((swap) => {
+      const amount0 = parseFloat(swap.amount0);
+      const amount1 = parseFloat(swap.amount1);
+      const amountUSD = parseFloat(swap.amountUSD);
+      const baseAmount = isInverted ? amount1 : amount0;
+      const side = baseAmount > 0 ? "SELL" : "BUY";
+      const quantity = Math.abs(baseAmount);
+      const price = amountUSD > 0 && quantity > 0 ? amountUSD / quantity : quantity > 0 ? this.getPoolPrice(pool, isInverted) : 0;
+      return {
+        id: swap.id,
+        orderId: swap.id,
+        symbol: symbol16,
+        side,
+        price,
+        quantity,
+        commission: 0,
+        commissionAsset: "USD",
+        time: parseInt(swap.timestamp, 10) * 1000,
+        isMaker: false
+      };
+    });
+    this.dataCache.set(cacheKey, trades, CACHE_TTL.trades);
+    return trades;
+  }
+  async getPoolData(symbol16) {
+    const { pool, isInverted } = await this.resolvePool(symbol16);
+    const cacheKey = `poolData:${this.chainId}:${pool.id}`;
+    const cached2 = this.dataCache.get(cacheKey);
+    if (cached2)
+      return cached2;
+    const data = await this.query(`query($id: ID!) {
+        pool(id: $id) {
+          id feeTier liquidity sqrtPrice tick
+          token0Price token1Price
+          totalValueLockedUSD volumeUSD
+          token0 { id symbol name decimals }
+          token1 { id symbol name decimals }
+        }
+      }`, { id: pool.id });
+    if (!data.pool)
+      throw new Error(`Pool ${pool.id} not found`);
+    const result = {
+      price: this.getPoolPrice(data.pool, isInverted),
+      feeTier: parseInt(data.pool.feeTier, 10),
+      tvlUSD: parseFloat(data.pool.totalValueLockedUSD),
+      liquidity: data.pool.liquidity
+    };
+    this.dataCache.set(cacheKey, result, CACHE_TTL.poolData);
+    return result;
+  }
+  async getOrderBook(symbol16) {
+    const { pool, isInverted } = await this.resolvePool(symbol16);
+    const { price, feeTier, tvlUSD } = await this.getPoolData(symbol16);
+    const spreadFraction = feeTier / 1e6;
+    const halfSpread = price * spreadFraction / 2;
+    try {
+      const ticks = await this.getTickLiquidity(symbol16, 10);
+      if (ticks.length > 0) {
+        const freshPool = await this.getPoolData(symbol16);
+        const bids = [];
+        const asks = [];
+        for (const tick of ticks) {
+          const tickIdx = parseInt(tick.tickIdx, 10);
+          const liqNet = parseFloat(tick.liquidityNet);
+          if (liqNet === 0)
+            continue;
+          const tickPrice = isInverted ? parseFloat(tick.price1) : parseFloat(tick.price0);
+          const liquidityScore = Math.abs(liqNet);
+          if (tickPrice <= freshPool.price) {
+            bids.push({ price: tickPrice, quantity: liquidityScore });
+          } else {
+            asks.push({ price: tickPrice, quantity: liquidityScore });
+          }
+        }
+        if (bids.length > 0 || asks.length > 0) {
+          bids.sort((a, b) => b.price - a.price);
+          asks.sort((a, b) => a.price - b.price);
+          return { lastUpdateId: Date.now(), bids, asks };
+        }
+      }
+    } catch {}
+    const depthProxy = tvlUSD / 2;
+    return {
+      lastUpdateId: Date.now(),
+      bids: [{ price: price - halfSpread, quantity: depthProxy / price }],
+      asks: [{ price: price + halfSpread, quantity: depthProxy / price }]
+    };
+  }
+  async getBookTicker(symbol16) {
+    const { price, feeTier, tvlUSD } = await this.getPoolData(symbol16);
+    const spreadFraction = feeTier / 1e6;
+    const halfSpread = price * spreadFraction / 2;
+    const depthProxy = tvlUSD / 2;
+    return {
+      symbol: symbol16,
+      bidPrice: price - halfSpread,
+      bidQty: depthProxy / price,
+      askPrice: price + halfSpread,
+      askQty: depthProxy / price
+    };
+  }
+  async getSpread(symbol16) {
+    const { price, feeTier } = await this.getPoolData(symbol16);
+    const spreadFraction = feeTier / 1e6;
+    const spread = price * spreadFraction;
+    return {
+      spread,
+      spreadPercent: spreadFraction * 100,
+      bidPrice: price - spread / 2,
+      askPrice: price + spread / 2
+    };
+  }
+  async getAvgPrice(symbol16) {
+    const { price } = await this.getPoolData(symbol16);
+    return { mins: 5, price };
+  }
+  async getEthPrice() {
+    const cacheKey = `bundle:${this.chainId}`;
+    const cached2 = this.dataCache.get(cacheKey);
+    if (cached2 !== undefined)
+      return cached2;
+    const data = await this.query(`{ bundle(id: "1") { id ethPriceUSD } }`);
+    const price = data.bundle ? parseFloat(data.bundle.ethPriceUSD) : NaN;
+    if (isNaN(price) || price <= 0) {
+      throw new Error(`Unable to fetch ETH price from bundle on chain ${this.chainId}`);
+    }
+    this.dataCache.set(cacheKey, price, CACHE_TTL.bundle);
+    return price;
+  }
+  async getFactory() {
+    const cacheKey = `factory:${this.chainId}`;
+    const cached2 = this.dataCache.get(cacheKey);
+    if (cached2 !== undefined)
+      return cached2;
+    const data = await this.query(`{ factory(id: "1") {
+        id poolCount txCount
+        totalVolumeUSD totalVolumeETH
+        totalFeesUSD totalFeesETH
+        totalValueLockedUSD totalValueLockedETH
+        owner
+      } }`);
+    this.dataCache.set(cacheKey, data.factory, CACHE_TTL.protocol);
+    return data.factory;
+  }
+  async getTokenHourCandles(tokenAddress, limit = 168) {
+    const addr = tokenAddress.toLowerCase();
+    const cacheKey = `tokenHour:${this.chainId}:${addr}:${limit}`;
+    const cached2 = this.dataCache.get(cacheKey);
+    if (cached2)
+      return cached2;
+    const start = Math.floor(Date.now() / 1000) - limit * 3600;
+    const data = await this.query(`query($token: String!, $start: Int!, $first: Int!) {
+        tokenHourDatas(
+          first: $first
+          where: { token: $token, periodStartUnix_gte: $start }
+          orderBy: periodStartUnix
+          orderDirection: asc
+        ) {
+          periodStartUnix
+          open high low close
+          priceUSD volumeUSD feesUSD
+          totalValueLockedUSD
+          token { id }
+        }
+      }`, { token: addr, start, first: Math.min(limit, 1000) });
+    const candles = data.tokenHourDatas.map((d) => {
+      const fallback = parseFloat(d.priceUSD);
+      const openVal = parseFloat(d.open);
+      const highVal = parseFloat(d.high);
+      const lowVal = parseFloat(d.low);
+      const closeVal = parseFloat(d.close);
+      return {
+        openTime: d.periodStartUnix * 1000,
+        open: openVal > 0 ? openVal : fallback,
+        high: highVal > 0 ? highVal : fallback,
+        low: lowVal > 0 ? lowVal : fallback,
+        close: closeVal > 0 ? closeVal : fallback,
+        volume: parseFloat(d.volumeUSD),
+        closeTime: (d.periodStartUnix + 3600) * 1000 - 1
+      };
+    });
+    this.dataCache.set(cacheKey, candles, CACHE_TTL.candles);
+    return candles;
+  }
+  async getTickLiquidity(symbol16, ticksPerSide = 20) {
+    const { pool } = await this.resolvePool(symbol16);
+    const freshData = await this.query(`query($id: ID!) { pool(id: $id) { tick feeTier } }`, { id: pool.id });
+    const currentTick = parseInt(freshData.pool?.tick ?? pool.tick, 10);
+    const feeTier = parseInt(freshData.pool?.feeTier ?? pool.feeTier, 10);
+    const tickSpacing = feeTier === 100 ? 1 : feeTier === 500 ? 10 : feeTier === 3000 ? 60 : feeTier === 1e4 ? 200 : 60;
+    const tickRange = ticksPerSide * tickSpacing;
+    const cacheKey = `ticks:${this.chainId}:${pool.id}:${currentTick}:${ticksPerSide}`;
+    const cached2 = this.dataCache.get(cacheKey);
+    if (cached2)
+      return cached2;
+    const minTick = currentTick - tickRange;
+    const maxTick = currentTick + tickRange;
+    const data = await this.query(`query($pool: String!, $minTick: BigInt!, $maxTick: BigInt!) {
+        ticks(
+          first: 100
+          where: { pool: $pool, tickIdx_gte: $minTick, tickIdx_lte: $maxTick }
+          orderBy: tickIdx
+          orderDirection: asc
+        ) {
+          id tickIdx poolAddress
+          liquidityGross liquidityNet
+          price0 price1
+          volumeToken0 volumeToken1 volumeUSD
+          feesUSD
+        }
+      }`, { pool: pool.id, minTick: minTick.toString(), maxTick: maxTick.toString() });
+    this.dataCache.set(cacheKey, data.ticks, CACHE_TTL.ticks);
+    return data.ticks;
+  }
+  async getMints(symbol16, limit = 50) {
+    const { pool } = await this.resolvePool(symbol16);
+    const cacheKey = `mints:${this.chainId}:${pool.id}:${limit}`;
+    const cached2 = this.dataCache.get(cacheKey);
+    if (cached2)
+      return cached2;
+    const data = await this.query(`query($pool: String!, $first: Int!) {
+        mints(
+          first: $first
+          where: { pool: $pool }
+          orderBy: timestamp
+          orderDirection: desc
+        ) {
+          id timestamp
+          transaction { id timestamp }
+          pool { id }
+          token0 { id symbol name decimals }
+          token1 { id symbol name decimals }
+          owner sender origin
+          amount amount0 amount1 amountUSD
+          tickLower tickUpper logIndex
+        }
+      }`, { pool: pool.id, first: Math.min(limit, 1000) });
+    this.dataCache.set(cacheKey, data.mints, CACHE_TTL.events);
+    return data.mints;
+  }
+  async getBurns(symbol16, limit = 50) {
+    const { pool } = await this.resolvePool(symbol16);
+    const cacheKey = `burns:${this.chainId}:${pool.id}:${limit}`;
+    const cached2 = this.dataCache.get(cacheKey);
+    if (cached2)
+      return cached2;
+    const data = await this.query(`query($pool: String!, $first: Int!) {
+        burns(
+          first: $first
+          where: { pool: $pool }
+          orderBy: timestamp
+          orderDirection: desc
+        ) {
+          id timestamp
+          transaction { id timestamp }
+          pool { id }
+          token0 { id symbol name decimals }
+          token1 { id symbol name decimals }
+          owner origin
+          amount amount0 amount1 amountUSD
+          tickLower tickUpper logIndex
+        }
+      }`, { pool: pool.id, first: Math.min(limit, 1000) });
+    this.dataCache.set(cacheKey, data.burns, CACHE_TTL.events);
+    return data.burns;
+  }
+  async getCollects(symbol16, limit = 50) {
+    const { pool } = await this.resolvePool(symbol16);
+    const cacheKey = `collects:${this.chainId}:${pool.id}:${limit}`;
+    const cached2 = this.dataCache.get(cacheKey);
+    if (cached2)
+      return cached2;
+    const data = await this.query(`query($pool: String!, $first: Int!) {
+        collects(
+          first: $first
+          where: { pool: $pool }
+          orderBy: timestamp
+          orderDirection: desc
+        ) {
+          id timestamp
+          transaction { id timestamp }
+          pool { id }
+          owner
+          amount0 amount1 amountUSD
+          tickLower tickUpper logIndex
+        }
+      }`, { pool: pool.id, first: Math.min(limit, 1000) });
+    this.dataCache.set(cacheKey, data.collects, CACHE_TTL.events);
+    return data.collects;
+  }
+  async getFlashLoans(symbol16, limit = 50) {
+    const { pool } = await this.resolvePool(symbol16);
+    const cacheKey = `flashes:${this.chainId}:${pool.id}:${limit}`;
+    const cached2 = this.dataCache.get(cacheKey);
+    if (cached2)
+      return cached2;
+    const data = await this.query(`query($pool: String!, $first: Int!) {
+        flashes(
+          first: $first
+          where: { pool: $pool }
+          orderBy: timestamp
+          orderDirection: desc
+        ) {
+          id timestamp
+          transaction { id timestamp }
+          pool { id }
+          sender recipient
+          amount0 amount1 amountUSD
+          amount0Paid amount1Paid
+          logIndex
+        }
+      }`, { pool: pool.id, first: Math.min(limit, 1000) });
+    this.dataCache.set(cacheKey, data.flashes, CACHE_TTL.events);
+    return data.flashes;
+  }
+  async getPositions(owner, limit = 50) {
+    const addr = owner.toLowerCase();
+    const cacheKey = `positions:${this.chainId}:${addr}:${limit}`;
+    const cached2 = this.dataCache.get(cacheKey);
+    if (cached2)
+      return cached2;
+    const data = await this.query(`query($owner: String!, $first: Int!) {
+        positions(
+          first: $first
+          where: { owner: $owner, liquidity_gt: "0" }
+          orderBy: liquidity
+          orderDirection: desc
+        ) {
+          id owner
+          pool { id token0 { id symbol name decimals } token1 { id symbol name decimals } }
+          token0 { id symbol name decimals }
+          token1 { id symbol name decimals }
+          tickLower { tickIdx price0 price1 }
+          tickUpper { tickIdx price0 price1 }
+          liquidity
+          depositedToken0 depositedToken1
+          withdrawnToken0 withdrawnToken1
+          collectedFeesToken0 collectedFeesToken1
+          transaction { id timestamp }
+        }
+      }`, { owner: addr, first: Math.min(limit, 1000) });
+    this.dataCache.set(cacheKey, data.positions, CACHE_TTL.positions);
+    return data.positions;
+  }
+  async getPositionSnapshots(positionId, limit = 50) {
+    const cacheKey = `snapshots:${this.chainId}:${positionId}:${limit}`;
+    const cached2 = this.dataCache.get(cacheKey);
+    if (cached2)
+      return cached2;
+    const data = await this.query(`query($position: String!, $first: Int!) {
+        positionSnapshots(
+          first: $first
+          where: { position: $position }
+          orderBy: timestamp
+          orderDirection: desc
+        ) {
+          id owner
+          pool { id }
+          position { id }
+          blockNumber timestamp
+          liquidity
+          depositedToken0 depositedToken1
+          withdrawnToken0 withdrawnToken1
+          collectedFeesToken0 collectedFeesToken1
+          transaction { id }
+        }
+      }`, { position: positionId, first: Math.min(limit, 1000) });
+    this.dataCache.set(cacheKey, data.positionSnapshots, CACHE_TTL.positions);
+    return data.positionSnapshots;
+  }
+  async getProtocolDayData(days = 30) {
+    const cacheKey = `protocol:${this.chainId}:${days}`;
+    const cached2 = this.dataCache.get(cacheKey);
+    if (cached2)
+      return cached2;
+    const start = Math.floor(Date.now() / 1000) - days * 86400;
+    const data = await this.query(`query($start: Int!, $first: Int!) {
+        uniswapDayDatas(
+          first: $first
+          where: { date_gte: $start }
+          orderBy: date
+          orderDirection: asc
+        ) {
+          id date
+          volumeETH volumeUSD
+          feesUSD txCount tvlUSD
+        }
+      }`, { start, first: Math.min(days, 1000) });
+    this.dataCache.set(cacheKey, data.uniswapDayDatas, CACHE_TTL.protocol);
+    return data.uniswapDayDatas;
+  }
+}
+var GRAPH_GATEWAY = "https://gateway.thegraph.com/api", MAX_RETRIES3 = 3, BASE_DELAY_MS2 = 500, RATE_LIMIT, CIRCUIT_FAILURE_THRESHOLD = 5, CIRCUIT_RESET_MS = 60000, CACHE_TTL, STABLECOIN_SYMBOLS;
+var init_subgraph = __esm(() => {
+  init_subgraph_types();
+  RATE_LIMIT = { maxPerMinute: 30, throttleAt: 25 };
+  CACHE_TTL = {
+    pool: 30 * 60000,
+    candles: 5 * 60000,
+    tickers: 2 * 60000,
+    top: 5 * 60000,
+    trades: 60000,
+    poolData: 60000,
+    bundle: 60000,
+    ticks: 60000,
+    events: 60000,
+    positions: 5 * 60000,
+    protocol: 5 * 60000
+  };
+  STABLECOIN_SYMBOLS = new Set(["USDC", "USDT", "DAI", "BUSD", "TUSD", "FRAX", "LUSD", "USDP", "GUSD", "PYUSD"]);
+});
+
+// src/infra/uniswap/index.ts
+var init_uniswap = __esm(() => {
+  init_client9();
+  init_token_list();
+  init_subgraph();
+  init_subgraph_types();
+  init_types10();
+});
+
+// src/infra/exchange/adapters/uniswap.ts
+class UniswapAdapter {
+  client;
+  subgraph;
+  exchangeId = "uniswap";
+  displayName = "Uniswap";
+  localOrders = new Map;
+  localTrades = new Map;
+  orderCounter = 0;
+  constructor(apiKey, walletAddress, chainId = 1, graphApiKey) {
+    this.client = new UniswapClient(apiKey, walletAddress, chainId);
+    this.subgraph = graphApiKey ? new UniswapSubgraph(graphApiKey, chainId, this.client) : null;
+  }
+  async testConnection() {
+    return this.client.testConnection();
+  }
+  async getExchangeInfo() {
+    const symbols = SUPPORTED_CHAIN_IDS.map((cid) => ({
+      symbol: `${CHAIN_NAMES[cid] || `Chain${cid}`}`,
+      status: "TRADING",
+      baseAsset: "ETH",
+      quoteAsset: "USDC",
+      baseAssetPrecision: 18,
+      quoteAssetPrecision: 6,
+      orderTypes: ["MARKET"],
+      isSpotTradingAllowed: true,
+      filters: []
+    }));
+    return {
+      timezone: "UTC",
+      serverTime: Date.now(),
+      symbols
+    };
+  }
+  async getPrice(symbol16) {
+    const { tokenIn, tokenOut, tokenInDecimals, tokenOutDecimals } = await this.client.resolveSymbol(symbol16);
+    const oneUnit = "1" + "0".repeat(tokenInDecimals);
+    const quote = await this.client.getQuote(tokenIn, tokenOut, oneUnit);
+    const outputAmount = quote.quote.output?.amount || quote.quote.amountOut;
+    if (!outputAmount)
+      throw new Error("No output amount in quote");
+    return Number(outputAmount) / 10 ** tokenOutDecimals;
+  }
+  async getCandles(symbol16, interval, limit) {
+    if (!this.subgraph?.isAvailable())
+      return [];
+    try {
+      return await this.subgraph.getCandles(symbol16, interval, limit ?? 50);
+    } catch {
+      return [];
+    }
+  }
+  async get24hrTickers() {
+    if (!this.subgraph?.isAvailable())
+      return [];
+    try {
+      return await this.subgraph.get24hrTickers();
+    } catch {
+      return [];
+    }
+  }
+  async getTopSymbols(n) {
+    if (!this.subgraph?.isAvailable()) {
+      return ["ETHUSDC", "WBTCUSDC", "ARBUSDC", "LINKUSDC", "UNIUSDC"];
+    }
+    try {
+      return await this.subgraph.getTopSymbols(n);
+    } catch {
+      return ["ETHUSDC", "WBTCUSDC", "ARBUSDC", "LINKUSDC", "UNIUSDC"];
+    }
+  }
+  async getOrderBook(symbol16, _limit) {
+    if (this.subgraph?.isAvailable()) {
+      try {
+        return await this.subgraph.getOrderBook(symbol16);
+      } catch {}
+    }
+    const price = await this.getPrice(symbol16);
+    const spread = price * 0.003;
+    return {
+      lastUpdateId: Date.now(),
+      bids: [{ price: price - spread / 2, quantity: 0 }],
+      asks: [{ price: price + spread / 2, quantity: 0 }]
+    };
+  }
+  async getBookTicker(symbol16) {
+    if (this.subgraph?.isAvailable()) {
+      try {
+        return await this.subgraph.getBookTicker(symbol16);
+      } catch {}
+    }
+    const price = await this.getPrice(symbol16);
+    const spread = price * 0.003;
+    return {
+      symbol: symbol16,
+      bidPrice: price - spread / 2,
+      bidQty: 0,
+      askPrice: price + spread / 2,
+      askQty: 0
+    };
+  }
+  async getSpread(symbol16) {
+    if (this.subgraph?.isAvailable()) {
+      try {
+        return await this.subgraph.getSpread(symbol16);
+      } catch {}
+    }
+    const price = await this.getPrice(symbol16);
+    const spread = price * 0.003;
+    return {
+      spread,
+      spreadPercent: 0.3,
+      bidPrice: price - spread / 2,
+      askPrice: price + spread / 2
+    };
+  }
+  async getAvgPrice(symbol16) {
+    if (this.subgraph?.isAvailable()) {
+      try {
+        return await this.subgraph.getAvgPrice(symbol16);
+      } catch {}
+    }
+    const price = await this.getPrice(symbol16);
+    return { mins: 5, price };
+  }
+  async getAccountInfo() {
+    return {
+      canTrade: true,
+      canWithdraw: true,
+      canDeposit: true,
+      accountType: "DEX",
+      balances: [],
+      updateTime: Date.now()
+    };
+  }
+  async getBalance(_asset) {
+    return 0;
+  }
+  async getAllBalances() {
+    return [];
+  }
+  async getFullAccountDetails() {
+    return {
+      accountInfo: await this.getAccountInfo(),
+      totalUsdtValue: 0,
+      nonZeroBalances: []
+    };
+  }
+  async placeOrder(params) {
+    const { tokenIn, tokenOut, tokenInDecimals, tokenOutDecimals } = await this.client.resolveSymbol(params.symbol);
+    const isBuy = params.side === "BUY";
+    const amount = params.quantity || params.quoteOrderQty || 0;
+    const inputDecimals = isBuy ? tokenOutDecimals : tokenInDecimals;
+    const rawAmount = Math.floor(amount * 10 ** inputDecimals).toString();
+    const swapTokenIn = isBuy ? tokenOut : tokenIn;
+    const swapTokenOut = isBuy ? tokenIn : tokenOut;
+    let quote = await this.client.getQuote(swapTokenIn, swapTokenOut, rawAmount);
+    let quoteTimestamp = Date.now();
+    const approvalResult = await this.client.checkApproval(swapTokenIn, rawAmount);
+    if (!UniswapClient.isQuoteFresh(quoteTimestamp)) {
+      quote = await this.client.getQuote(swapTokenIn, swapTokenOut, rawAmount);
+      quoteTimestamp = Date.now();
+    }
+    const deadline = Math.floor(Date.now() / 1000) + 120;
+    const swapTx = await this.client.getSwapTransaction(quote, undefined, deadline);
+    if (!UniswapClient.validateSwapTransaction(swapTx.swap.data)) {
+      throw new Error("Invalid swap transaction data \u2014 cannot execute");
+    }
+    const orderId = `uniswap-${++this.orderCounter}-${Date.now()}`;
+    const order = {
+      orderId,
+      clientOrderId: quote.requestId,
+      symbol: params.symbol,
+      side: params.side,
+      type: "MARKET",
+      status: "NEW",
+      price: await this.getPrice(params.symbol),
+      quantity: amount,
+      executedQty: 0,
+      cummulativeQuoteQty: 0,
+      time: Date.now(),
+      updateTime: Date.now()
+    };
+    this.localOrders.set(orderId, order);
+    const meta3 = {
+      _unsignedTx: swapTx.swap,
+      _quoteTimestamp: quoteTimestamp
+    };
+    if (approvalResult.approval) {
+      meta3._approvalTx = approvalResult.approval;
+    }
+    if (swapTx.txFailureReasons?.length) {
+      meta3._txFailureReasons = swapTx.txFailureReasons;
+    }
+    Object.assign(order, meta3);
+    return order;
+  }
+  async cancelOrder(_symbol2, orderId) {
+    const order = this.localOrders.get(orderId);
+    if (order && order.status === "NEW") {
+      order.status = "CANCELED";
+      order.updateTime = Date.now();
+    }
+  }
+  async cancelAllOrders(symbol16) {
+    const cancelled = [];
+    for (const order of this.localOrders.values()) {
+      if (order.symbol === symbol16 && order.status === "NEW") {
+        order.status = "CANCELED";
+        order.updateTime = Date.now();
+        cancelled.push(order);
+      }
+    }
+    return cancelled;
+  }
+  async getOpenOrders(symbol16) {
+    const orders = Array.from(this.localOrders.values());
+    return orders.filter((o) => o.status === "NEW" && (!symbol16 || o.symbol === symbol16));
+  }
+  async getOrderStatus(_symbol2, orderId) {
+    const order = this.localOrders.get(String(orderId));
+    if (!order)
+      throw new Error(`Order ${orderId} not found`);
+    return order;
+  }
+  async testOrder(params) {
+    try {
+      const { tokenIn, tokenOut, tokenInDecimals } = await this.client.resolveSymbol(params.symbol);
+      const amount = params.quantity || params.quoteOrderQty || 0;
+      const rawAmount = Math.floor(amount * 10 ** tokenInDecimals).toString();
+      await this.client.getQuote(tokenIn, tokenOut, rawAmount);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getTradeHistory(symbol16, limit) {
+    const local = this.localTrades.get(symbol16) || [];
+    if (!this.subgraph?.isAvailable())
+      return local;
+    try {
+      const onChain = await this.subgraph.getTradeHistory(symbol16, limit ?? 50);
+      const localIds = new Set(local.map((t2) => t2.id));
+      const deduped = onChain.filter((t2) => !localIds.has(t2.id));
+      return [...local, ...deduped].slice(0, limit ?? 50);
+    } catch {
+      return local;
+    }
+  }
+  async getOrderHistory(symbol16, _limit) {
+    return Array.from(this.localOrders.values()).filter((o) => o.symbol === symbol16);
+  }
+  async getDepositHistory(_limit) {
+    return [];
+  }
+  async getWithdrawalHistory(_limit) {
+    return [];
+  }
+  shouldThrottle() {
+    return this.client.shouldThrottle();
+  }
+  getRateLimitStatus() {
+    const status = this.client.getRateLimitStatus();
+    return {
+      currentWeight: status.currentRequests,
+      maxWeight: status.maxRequests,
+      usagePercent: status.usagePercent,
+      isThrottling: status.isThrottling,
+      throttledCount: status.throttledCount,
+      timeUntilReset: status.timeUntilReset
+    };
+  }
+  getCircuitBreakerState() {
+    return this.client.getCircuitBreakerState();
+  }
+  resetCircuitBreaker() {
+    this.client.resetCircuitBreaker();
+  }
+}
+var init_uniswap2 = __esm(() => {
+  init_uniswap();
+  init_subgraph();
+  init_types10();
+});
+
 // src/infra/exchange/factory.ts
 function getCacheKey(exchangeId, credentials) {
-  const key = exchangeId === "hyperliquid" ? credentials.walletPrivateKey || "" : credentials.apiKey;
+  const key = exchangeId === "hyperliquid" || exchangeId === "uniswap" ? credentials.walletPrivateKey || credentials.apiKey : credentials.apiKey;
   const keyPrefix = key.substring(0, 8);
   return `${exchangeId}:${keyPrefix}`;
 }
@@ -195790,13 +197261,15 @@ var init_factory = __esm(() => {
   init_kraken3();
   init_bitfinex3();
   init_hyperliquid3();
+  init_uniswap2();
   SUPPORTED_EXCHANGES = [
     "binance",
     "binance_us",
     "coinbase",
     "kraken",
     "bitfinex",
-    "hyperliquid"
+    "hyperliquid",
+    "uniswap"
   ];
   ExchangeFactory = class ExchangeFactory {
     static instanceCache = new Map;
@@ -195835,6 +197308,12 @@ var init_factory = __esm(() => {
           }
           exchange = new HyperliquidAdapter(credentials.walletPrivateKey);
           break;
+        case "uniswap":
+          if (!credentials.apiKey) {
+            throw new Error("Uniswap requires an API key from developers.uniswap.org");
+          }
+          exchange = new UniswapAdapter(credentials.apiKey, credentials.walletPrivateKey || credentials.apiSecret, 1, process.env.THEGRAPH_API_KEY);
+          break;
         default:
           throw new Error(`No adapter available for exchange: ${exchangeId}`);
       }
@@ -195872,6 +197351,7 @@ var init_exchange = __esm(() => {
   init_kraken3();
   init_bitfinex3();
   init_hyperliquid3();
+  init_uniswap2();
 });
 
 // src/core/validator.ts
@@ -265114,7 +266594,7 @@ var init_iceberg = __esm(() => {
 
 // src/core/execution/algorithms/types.ts
 var ExecutionAlgorithmSchema, DEFAULT_TWAP_CONFIG, DEFAULT_VWAP_CONFIG, DEFAULT_ICEBERG_CONFIG;
-var init_types10 = __esm(() => {
+var init_types11 = __esm(() => {
   init_zod();
   ExecutionAlgorithmSchema = exports_external.enum(["TWAP", "VWAP", "ICEBERG"]);
   DEFAULT_TWAP_CONFIG = {
@@ -265255,7 +266735,7 @@ var init_session_manager = __esm(() => {
   init_twap();
   init_vwap();
   init_iceberg();
-  init_types10();
+  init_types11();
   logger69 = createModuleLogger("execution-session-manager");
 });
 
@@ -265352,7 +266832,7 @@ function describeIntent(intent2) {
 }
 var DURATION_PATTERNS;
 var init_intent_parser = __esm(() => {
-  init_types10();
+  init_types11();
   DURATION_PATTERNS = [
     { pattern: /(\d+)\s*h(?:ours?)?/i, toMs: (m) => parseInt(m[1], 10) * 60 * 60 * 1000 },
     { pattern: /(\d+)\s*m(?:in(?:utes?)?)?/i, toMs: (m) => parseInt(m[1], 10) * 60 * 1000 },
@@ -267536,7 +269016,7 @@ var init_risk_management2 = __esm(() => {
 });
 
 // src/strategies/types.ts
-var init_types11 = () => {};
+var init_types12 = () => {};
 
 // src/strategies/registry.ts
 class StrategyRegistry {
@@ -275860,7 +277340,7 @@ var init_dsl = __esm(() => {
 
 // src/strategies/index.ts
 var init_strategies = __esm(() => {
-  init_types11();
+  init_types12();
   init_registry3();
   init_base_strategy();
   init_ensemble();
@@ -276380,7 +277860,7 @@ var init_strategies2 = __esm(() => {
 
 // src/backtest/types.ts
 var DEFAULT_BACKTEST_CONFIG, DEFAULT_BACKTEST_PARAMS;
-var init_types12 = __esm(() => {
+var init_types13 = __esm(() => {
   DEFAULT_BACKTEST_CONFIG = {
     timeframe: "4h",
     days: 90,
@@ -277348,7 +278828,7 @@ function runBacktest(strategy, data, params, strategyParams) {
   return engine.run(strategy, data, strategyParams);
 }
 var init_engine2 = __esm(() => {
-  init_types12();
+  init_types13();
   init_indicators();
 });
 
@@ -277356,7 +278836,7 @@ var init_engine2 = __esm(() => {
 function getCachedData(symbol16, timeframe, startTime, endTime) {
   const db = getDatabase();
   const now2 = Date.now();
-  const ttl = CACHE_TTL_MS2[timeframe] ?? CACHE_TTL_MS2["1h"];
+  const ttl = CACHE_TTL_MS3[timeframe] ?? CACHE_TTL_MS3["1h"];
   const minFetchedAt = now2 - ttl;
   const query = db.prepare(`
     SELECT timestamp, open, high, low, close, volume
@@ -277536,7 +279016,7 @@ async function fetchHistoricalDataRange(exchange, symbol16, timeframe, startTime
   `);
   const cachedRows = query.all(upperSymbol, timeframe, startTime, endTime);
   const now2 = Date.now();
-  const ttl = CACHE_TTL_MS2[timeframe] ?? CACHE_TTL_MS2["1h"];
+  const ttl = CACHE_TTL_MS3[timeframe] ?? CACHE_TTL_MS3["1h"];
   const cachedMap = new Map;
   for (const row of cachedRows) {
     cachedMap.set(row.timestamp, {
@@ -277586,7 +279066,7 @@ async function fetchHistoricalDataRange(exchange, symbol16, timeframe, startTime
   }
   return result;
 }
-var logger74, BINANCE_KLINE_LIMIT = 1000, TIMEFRAME_MS, CACHE_TTL_MS2;
+var logger74, BINANCE_KLINE_LIMIT = 1000, TIMEFRAME_MS, CACHE_TTL_MS3;
 var init_historical = __esm(() => {
   init_storage();
   init_logger2();
@@ -277608,7 +279088,7 @@ var init_historical = __esm(() => {
     "1w": 7 * 24 * 60 * 60 * 1000,
     "1M": 30 * 24 * 60 * 60 * 1000
   };
-  CACHE_TTL_MS2 = {
+  CACHE_TTL_MS3 = {
     "1m": 5 * 60 * 1000,
     "3m": 10 * 60 * 1000,
     "5m": 30 * 60 * 1000,
@@ -280361,7 +281841,7 @@ function standardDeviation(values) {
 }
 var logger77, DEFAULT_WALK_FORWARD_CONFIG;
 var init_walk_forward = __esm(() => {
-  init_types12();
+  init_types13();
   init_engine2();
   init_logger2();
   logger77 = createModuleLogger("walk-forward");
@@ -281029,7 +282509,7 @@ var init_backtest = __esm(async () => {
   init_tools();
   init_zod();
   init_strategies();
-  init_types12();
+  init_types13();
   init_engine2();
   init_historical();
   init_export();
@@ -284002,7 +285482,7 @@ var init_market_data = __esm(() => {
 // src/infra/agents/tools/liquidation-intelligence.ts
 async function fetchMarketData() {
   const now2 = Date.now();
-  if (_cache && now2 - _cache.timestamp < CACHE_TTL_MS3) {
+  if (_cache && now2 - _cache.timestamp < CACHE_TTL_MS4) {
     return { meta: _cache.meta, assetCtxs: _cache.assetCtxs };
   }
   const controller = new AbortController;
@@ -284122,7 +285602,7 @@ function analyzeCrowding(ctx) {
     implication = "Balanced positioning \u2014 no significant crowd";
   return { direction, crowdingScore, implication };
 }
-var HL_INFO_API = "https://api.hyperliquid.xyz/info", REQUEST_TIMEOUT_MS = 1e4, CACHE_TTL_MS3 = 1e4, _cache = null, getCascadeRiskTool, getLiquidationPressureTool, getCrowdingAnalysisTool, getSqueezeCandidatesTool, liquidationIntelligenceTools;
+var HL_INFO_API = "https://api.hyperliquid.xyz/info", REQUEST_TIMEOUT_MS = 1e4, CACHE_TTL_MS4 = 1e4, _cache = null, getCascadeRiskTool, getLiquidationPressureTool, getCrowdingAnalysisTool, getSqueezeCandidatesTool, liquidationIntelligenceTools;
 var init_liquidation_intelligence = __esm(() => {
   init_tools();
   init_zod();
@@ -285389,7 +286869,7 @@ var init_autonomous = __esm(() => {
 
 // src/infra/base/types.ts
 var BASE_CHAIN_CONFIG, BASE_TOKENS, REGISTRY_API_BASE = "https://base.org/api/registry";
-var init_types13 = __esm(() => {
+var init_types14 = __esm(() => {
   BASE_CHAIN_CONFIG = {
     mainnet: {
       chainId: 8453,
@@ -285475,7 +286955,7 @@ function formatRegistryEntry(entry) {
   };
 }
 var init_registry4 = __esm(() => {
-  init_types13();
+  init_types14();
 });
 
 // src/infra/base/chain.ts
@@ -285544,7 +287024,7 @@ async function getBaseTokenBalance(tokenAddress, walletAddress, decimals = 18, n
   return parseFloat(`${intPart}.${fracPart}`);
 }
 var init_chain2 = __esm(() => {
-  init_types13();
+  init_types14();
 });
 
 // src/infra/base/basescan.ts
@@ -285767,7 +287247,7 @@ async function detectNewListings(opts = {}) {
   return signals;
 }
 var init_signals = __esm(() => {
-  init_types13();
+  init_types14();
 });
 
 // src/infra/base/index.ts
@@ -285775,7 +287255,7 @@ var init_base4 = __esm(() => {
   init_registry4();
   init_chain2();
   init_signals();
-  init_types13();
+  init_types14();
 });
 
 // src/infra/agents/tools/base-onchain.ts
@@ -286010,7 +287490,7 @@ var init_base_onchain = __esm(() => {
 
 // src/infra/agentkit/types.ts
 var CDP_ENV_KEYS;
-var init_types14 = __esm(() => {
+var init_types15 = __esm(() => {
   CDP_ENV_KEYS = {
     API_KEY_ID: "CDP_API_KEY_ID",
     API_KEY_SECRET: "CDP_API_KEY_SECRET",
@@ -727995,7 +729475,7 @@ function createAcrossClient(options) {
   return AcrossClient.create(options);
 }
 var CLIENT_DEFAULTS;
-var init_client9 = __esm(() => {
+var init_client10 = __esm(() => {
   init__esm();
   init_actions();
   init_constants2();
@@ -728009,7 +729489,7 @@ var init_client9 = __esm(() => {
 });
 
 // node_modules/@across-protocol/app-sdk/dist/types/index.js
-var init_types15 = () => {};
+var init_types16 = () => {};
 
 // node_modules/@across-protocol/app-sdk/dist/index.js
 var exports_dist = {};
@@ -728076,8 +729556,8 @@ __export(exports_dist, {
   AcrossApiError: () => AcrossApiError
 });
 var init_dist15 = __esm(() => {
-  init_client9();
-  init_types15();
+  init_client10();
+  init_types16();
   init_actions();
   init_errors14();
   init_utils11();
@@ -880324,7 +881804,7 @@ var require_token_security = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.isTokenSecurityChainId = exports.TokenSecurityChainIds = undefined;
   var index_js_1 = require_chain7();
-  var SUPPORTED_CHAIN_IDS = [
+  var SUPPORTED_CHAIN_IDS2 = [
     index_js_1.EvmChainId.AVALANCHE,
     index_js_1.EvmChainId.BSC,
     index_js_1.EvmChainId.FANTOM,
@@ -880344,8 +881824,8 @@ var require_token_security = __commonJS((exports) => {
     index_js_1.EvmChainId.MANTA,
     index_js_1.EvmChainId.ZKLINK
   ];
-  exports.TokenSecurityChainIds = SUPPORTED_CHAIN_IDS;
-  var isTokenSecurityChainId = (chainId) => SUPPORTED_CHAIN_IDS.includes(chainId);
+  exports.TokenSecurityChainIds = SUPPORTED_CHAIN_IDS2;
+  var isTokenSecurityChainId = (chainId) => SUPPORTED_CHAIN_IDS2.includes(chainId);
   exports.isTokenSecurityChainId = isTokenSecurityChainId;
 });
 
@@ -1048457,11 +1049937,11 @@ var require_cjs8 = __commonJS((exports, module) => {
     wrapFetchWithPayment: () => wrapFetchWithPayment
   });
   module.exports = __toCommonJS2(src_exports);
-  var import_types47 = require_types26();
-  var import_client16 = require_client4();
+  var import_types51 = require_types26();
+  var import_client17 = require_client4();
   var import_shared = require_shared();
   var import_types210 = require_types26();
-  function wrapFetchWithPayment(fetch3, walletClient, maxValue2 = BigInt(0.1 * 10 ** 6), paymentRequirementsSelector = import_client16.selectPaymentRequirements, config4) {
+  function wrapFetchWithPayment(fetch3, walletClient, maxValue2 = BigInt(0.1 * 10 ** 6), paymentRequirementsSelector = import_client17.selectPaymentRequirements, config4) {
     return async (input, init2) => {
       var _a16;
       const response = await fetch3(input, init2);
@@ -1048469,13 +1049949,13 @@ var require_cjs8 = __commonJS((exports, module) => {
         return response;
       }
       const { x402Version, accepts } = await response.json();
-      const parsedPaymentRequirements = accepts.map((x) => import_types47.PaymentRequirementsSchema.parse(x));
-      const network = (0, import_types47.isMultiNetworkSigner)(walletClient) ? undefined : import_types47.evm.isSignerWallet(walletClient) ? import_types47.ChainIdToNetwork[(_a16 = walletClient.chain) == null ? undefined : _a16.id] : (0, import_types47.isSvmSignerWallet)(walletClient) ? ["solana", "solana-devnet"] : undefined;
+      const parsedPaymentRequirements = accepts.map((x) => import_types51.PaymentRequirementsSchema.parse(x));
+      const network = (0, import_types51.isMultiNetworkSigner)(walletClient) ? undefined : import_types51.evm.isSignerWallet(walletClient) ? import_types51.ChainIdToNetwork[(_a16 = walletClient.chain) == null ? undefined : _a16.id] : (0, import_types51.isSvmSignerWallet)(walletClient) ? ["solana", "solana-devnet"] : undefined;
       const selectedPaymentRequirements = paymentRequirementsSelector(parsedPaymentRequirements, network, "exact");
       if (BigInt(selectedPaymentRequirements.maxAmountRequired) > maxValue2) {
         throw new Error("Payment amount exceeds maximum allowed");
       }
-      const paymentHeader = await (0, import_client16.createPaymentHeader)(walletClient, x402Version, selectedPaymentRequirements, config4);
+      const paymentHeader = await (0, import_client17.createPaymentHeader)(walletClient, x402Version, selectedPaymentRequirements, config4);
       if (!init2) {
         throw new Error("Missing fetch request configuration");
       }
@@ -1050399,11 +1051879,11 @@ var require_cjs9 = __commonJS((exports, module) => {
     x402HTTPClient: () => import_client22.x402HTTPClient
   });
   module.exports = __toCommonJS2(src_exports);
-  var import_client16 = require_client6();
+  var import_client17 = require_client6();
   var import_client22 = require_client6();
   var import_http6 = require_http10();
   function wrapFetchWithPayment(fetch3, client2) {
-    const httpClient = client2 instanceof import_client16.x402HTTPClient ? client2 : new import_client16.x402HTTPClient(client2);
+    const httpClient = client2 instanceof import_client17.x402HTTPClient ? client2 : new import_client17.x402HTTPClient(client2);
     return async (input, init2) => {
       const request = new Request(input, init2);
       const clonedRequest = request.clone();
@@ -1050455,7 +1051935,7 @@ var require_cjs9 = __commonJS((exports, module) => {
     };
   }
   function wrapFetchWithPaymentFromConfig(fetch3, config4) {
-    const client2 = import_client16.x402Client.fromConfig(config4);
+    const client2 = import_client17.x402Client.fromConfig(config4);
     return wrapFetchWithPayment(fetch3, client2);
   }
 });
@@ -1094875,7 +1096355,7 @@ var require_yelayActionProvider = __commonJS((exports) => {
   var constants_1 = require_constants39();
   var viem_1 = require__cjs();
   var utils_1 = require_utils25();
-  var SUPPORTED_CHAIN_IDS = ["1", "146", "8453", "42161", "43114"];
+  var SUPPORTED_CHAIN_IDS2 = ["1", "146", "8453", "42161", "43114"];
 
   class YelayActionProvider extends actionProvider_1.ActionProvider {
     constructor() {
@@ -1095030,7 +1096510,7 @@ APY: ${vault.apy}%
       }
     }
     supportsNetwork(network) {
-      return network.protocolFamily === "evm" && (network.chainId ? SUPPORTED_CHAIN_IDS.includes(network.chainId) : false);
+      return network.protocolFamily === "evm" && (network.chainId ? SUPPORTED_CHAIN_IDS2.includes(network.chainId) : false);
     }
   }
   exports.YelayActionProvider = YelayActionProvider;
@@ -1119289,14 +1120769,14 @@ function getAvailableActionNames() {
 }
 var import_agentkit, _agentKit = null, _actions = null;
 var init_provider3 = __esm(() => {
-  init_types14();
+  init_types15();
   import_agentkit = __toESM(require_dist25(), 1);
 });
 
 // src/infra/agentkit/index.ts
 var init_agentkit = __esm(() => {
   init_provider3();
-  init_types14();
+  init_types15();
 });
 
 // src/infra/agents/tools/agentkit-onchain.ts
@@ -1120049,6 +1121529,348 @@ ${formatted.join(`
   };
 });
 
+// src/infra/agents/tools/uniswap-data.ts
+function getSubgraph(execContext) {
+  const ctx = getGordonContext(execContext);
+  if (!ctx?.exchange)
+    return { error: "Exchange client not connected." };
+  if (ctx.exchange.exchangeId !== "uniswap")
+    return { error: "This tool is only available on Uniswap." };
+  const subgraph = ctx.exchange.subgraph;
+  if (!subgraph?.isAvailable())
+    return { error: "Uniswap subgraph not available. Set THEGRAPH_API_KEY." };
+  return { subgraph };
+}
+var getPoolTickLiquidityTool, getLiquidityEventsTool, getPoolFlashEventsTool, getLpPositionsTool, getProtocolOverviewTool, getFeeCollectionsTool, uniswapDataTools;
+var init_uniswap_data = __esm(() => {
+  init_tools();
+  init_zod();
+  init_types8();
+  getPoolTickLiquidityTool = createTool({
+    id: "get_pool_tick_liquidity",
+    description: "Get real liquidity distribution around the current price for a Uniswap pool. " + "Shows actual bid/ask depth from on-chain tick data \u2014 much more accurate than TVL proxy. " + "Use for order book depth analysis, slippage estimation, and liquidity gap detection.",
+    inputSchema: exports_external.object({
+      symbol: exports_external.string().describe("Trading pair (e.g., 'ETHUSDC', 'UNIUSDC')"),
+      ticksPerSide: exports_external.number().min(1).max(50).default(20).describe("Number of tick spaces on each side of current price")
+    }),
+    outputSchema: exports_external.object({
+      symbol: exports_external.string().optional(),
+      currentTick: exports_external.number().optional(),
+      tickCount: exports_external.number().optional(),
+      ticks: exports_external.array(exports_external.object({
+        tickIdx: exports_external.number(),
+        price: exports_external.number(),
+        liquidityNet: exports_external.number(),
+        liquidityGross: exports_external.number(),
+        volumeUSD: exports_external.number()
+      })).optional(),
+      error: exports_external.string().optional()
+    }),
+    execute: async ({ symbol: symbol16, ticksPerSide }, execContext) => {
+      const result = getSubgraph(execContext);
+      if ("error" in result)
+        return result;
+      try {
+        const pool = await result.subgraph.resolvePool(symbol16);
+        const ticks = await result.subgraph.getTickLiquidity(symbol16, ticksPerSide);
+        return {
+          symbol: symbol16,
+          currentTick: parseInt(pool.pool.tick, 10),
+          tickCount: ticks.length,
+          ticks: ticks.map((t3) => ({
+            tickIdx: parseInt(t3.tickIdx, 10),
+            price: parseFloat(pool.isInverted ? t3.price1 : t3.price0),
+            liquidityNet: parseFloat(t3.liquidityNet),
+            liquidityGross: parseFloat(t3.liquidityGross),
+            volumeUSD: parseFloat(t3.volumeUSD)
+          }))
+        };
+      } catch (error48) {
+        return { error: `Failed to get tick liquidity: ${error48.message}` };
+      }
+    }
+  });
+  getLiquidityEventsTool = createTool({
+    id: "get_liquidity_events",
+    description: "Get recent liquidity additions (mints) and removals (burns) for a Uniswap pool. " + "Large mints signal confidence; large burns may signal exit. " + "Use for detecting smart money flows, liquidity rug risk, and LP sentiment.",
+    inputSchema: exports_external.object({
+      symbol: exports_external.string().describe("Trading pair (e.g., 'ETHUSDC', 'UNIUSDC')"),
+      limit: exports_external.number().min(1).max(100).default(20).describe("Number of events per type")
+    }),
+    outputSchema: exports_external.object({
+      symbol: exports_external.string().optional(),
+      mints: exports_external.array(exports_external.object({
+        timestamp: exports_external.number(),
+        amountUSD: exports_external.number(),
+        amount0: exports_external.number(),
+        amount1: exports_external.number(),
+        owner: exports_external.string(),
+        tickLower: exports_external.number(),
+        tickUpper: exports_external.number()
+      })).optional(),
+      burns: exports_external.array(exports_external.object({
+        timestamp: exports_external.number(),
+        amountUSD: exports_external.number(),
+        amount0: exports_external.number(),
+        amount1: exports_external.number(),
+        owner: exports_external.string(),
+        tickLower: exports_external.number(),
+        tickUpper: exports_external.number()
+      })).optional(),
+      netFlowUSD: exports_external.number().optional(),
+      error: exports_external.string().optional()
+    }),
+    execute: async ({ symbol: symbol16, limit }, execContext) => {
+      const result = getSubgraph(execContext);
+      if ("error" in result)
+        return result;
+      try {
+        const [mints, burns] = await Promise.all([
+          result.subgraph.getMints(symbol16, limit),
+          result.subgraph.getBurns(symbol16, limit)
+        ]);
+        const mintFlow = mints.reduce((sum, m) => sum + parseFloat(m.amountUSD), 0);
+        const burnFlow = burns.reduce((sum, b) => sum + parseFloat(b.amountUSD), 0);
+        return {
+          symbol: symbol16,
+          mints: mints.map((m) => ({
+            timestamp: parseInt(m.timestamp, 10) * 1000,
+            amountUSD: parseFloat(m.amountUSD),
+            amount0: parseFloat(m.amount0),
+            amount1: parseFloat(m.amount1),
+            owner: m.owner,
+            tickLower: parseInt(m.tickLower, 10),
+            tickUpper: parseInt(m.tickUpper, 10)
+          })),
+          burns: burns.map((b) => ({
+            timestamp: parseInt(b.timestamp, 10) * 1000,
+            amountUSD: parseFloat(b.amountUSD),
+            amount0: parseFloat(b.amount0),
+            amount1: parseFloat(b.amount1),
+            owner: b.owner,
+            tickLower: parseInt(b.tickLower, 10),
+            tickUpper: parseInt(b.tickUpper, 10)
+          })),
+          netFlowUSD: mintFlow - burnFlow
+        };
+      } catch (error48) {
+        return { error: `Failed to get liquidity events: ${error48.message}` };
+      }
+    }
+  });
+  getPoolFlashEventsTool = createTool({
+    id: "get_pool_flash_events",
+    description: "Get recent flash loan events for a Uniswap pool. " + "Flash loans can indicate arbitrage activity or potential manipulation. " + "Large or frequent flash loans around a token may signal price instability.",
+    inputSchema: exports_external.object({
+      symbol: exports_external.string().describe("Trading pair (e.g., 'ETHUSDC')"),
+      limit: exports_external.number().min(1).max(100).default(20).describe("Number of events to return")
+    }),
+    outputSchema: exports_external.object({
+      symbol: exports_external.string().optional(),
+      count: exports_external.number().optional(),
+      totalAmountUSD: exports_external.number().optional(),
+      events: exports_external.array(exports_external.object({
+        timestamp: exports_external.number(),
+        amountUSD: exports_external.number(),
+        amount0: exports_external.number(),
+        amount1: exports_external.number(),
+        amount0Paid: exports_external.number(),
+        amount1Paid: exports_external.number(),
+        sender: exports_external.string()
+      })).optional(),
+      error: exports_external.string().optional()
+    }),
+    execute: async ({ symbol: symbol16, limit }, execContext) => {
+      const result = getSubgraph(execContext);
+      if ("error" in result)
+        return result;
+      try {
+        const flashes = await result.subgraph.getFlashLoans(symbol16, limit);
+        const totalUSD = flashes.reduce((sum, f2) => sum + parseFloat(f2.amountUSD), 0);
+        return {
+          symbol: symbol16,
+          count: flashes.length,
+          totalAmountUSD: totalUSD,
+          events: flashes.map((f2) => ({
+            timestamp: parseInt(f2.timestamp, 10) * 1000,
+            amountUSD: parseFloat(f2.amountUSD),
+            amount0: parseFloat(f2.amount0),
+            amount1: parseFloat(f2.amount1),
+            amount0Paid: parseFloat(f2.amount0Paid),
+            amount1Paid: parseFloat(f2.amount1Paid),
+            sender: f2.sender
+          }))
+        };
+      } catch (error48) {
+        return { error: `Failed to get flash events: ${error48.message}` };
+      }
+    }
+  });
+  getLpPositionsTool = createTool({
+    id: "get_lp_positions",
+    description: "Get active Uniswap V3 LP positions for a wallet address. " + "Shows pools, price ranges, liquidity amounts, deposited/withdrawn tokens, and collected fees. " + "Use for portfolio monitoring of LP positions.",
+    inputSchema: exports_external.object({
+      owner: exports_external.string().describe("Wallet address (0x...)"),
+      limit: exports_external.number().min(1).max(100).default(20).describe("Max positions to return")
+    }),
+    outputSchema: exports_external.object({
+      owner: exports_external.string().optional(),
+      positionCount: exports_external.number().optional(),
+      positions: exports_external.array(exports_external.object({
+        id: exports_external.string(),
+        pool: exports_external.string(),
+        token0: exports_external.string(),
+        token1: exports_external.string(),
+        tickLower: exports_external.number(),
+        tickUpper: exports_external.number(),
+        liquidity: exports_external.string(),
+        depositedToken0: exports_external.number(),
+        depositedToken1: exports_external.number(),
+        withdrawnToken0: exports_external.number(),
+        withdrawnToken1: exports_external.number(),
+        collectedFeesToken0: exports_external.number(),
+        collectedFeesToken1: exports_external.number()
+      })).optional(),
+      error: exports_external.string().optional()
+    }),
+    execute: async ({ owner, limit }, execContext) => {
+      const result = getSubgraph(execContext);
+      if ("error" in result)
+        return result;
+      try {
+        const positions = await result.subgraph.getPositions(owner, limit);
+        return {
+          owner,
+          positionCount: positions.length,
+          positions: positions.map((p) => ({
+            id: p.id,
+            pool: p.pool.id,
+            token0: `${p.token0.symbol} (${p.token0.id.slice(0, 10)}...)`,
+            token1: `${p.token1.symbol} (${p.token1.id.slice(0, 10)}...)`,
+            tickLower: parseInt(p.tickLower.tickIdx, 10),
+            tickUpper: parseInt(p.tickUpper.tickIdx, 10),
+            liquidity: p.liquidity,
+            depositedToken0: parseFloat(p.depositedToken0),
+            depositedToken1: parseFloat(p.depositedToken1),
+            withdrawnToken0: parseFloat(p.withdrawnToken0),
+            withdrawnToken1: parseFloat(p.withdrawnToken1),
+            collectedFeesToken0: parseFloat(p.collectedFeesToken0),
+            collectedFeesToken1: parseFloat(p.collectedFeesToken1)
+          }))
+        };
+      } catch (error48) {
+        return { error: `Failed to get LP positions: ${error48.message}` };
+      }
+    }
+  });
+  getProtocolOverviewTool = createTool({
+    id: "get_uniswap_protocol_overview",
+    description: "Get Uniswap V3 protocol-wide metrics: ETH/USD price, total pools, total volume, " + "total fees, TVL, and recent daily data. Use for protocol health assessment, " + "DeFi market overview, and macro trend analysis.",
+    inputSchema: exports_external.object({
+      days: exports_external.number().min(1).max(90).default(7).describe("Number of days of daily data to include")
+    }),
+    outputSchema: exports_external.object({
+      ethPriceUSD: exports_external.number().optional(),
+      factory: exports_external.object({
+        poolCount: exports_external.number(),
+        totalVolumeUSD: exports_external.number(),
+        totalFeesUSD: exports_external.number(),
+        totalValueLockedUSD: exports_external.number()
+      }).optional(),
+      dailyData: exports_external.array(exports_external.object({
+        date: exports_external.number(),
+        volumeUSD: exports_external.number(),
+        feesUSD: exports_external.number(),
+        tvlUSD: exports_external.number(),
+        txCount: exports_external.number()
+      })).optional(),
+      error: exports_external.string().optional()
+    }),
+    execute: async ({ days }, execContext) => {
+      const result = getSubgraph(execContext);
+      if ("error" in result)
+        return result;
+      try {
+        const [ethPrice, factory6, dayData] = await Promise.all([
+          result.subgraph.getEthPrice(),
+          result.subgraph.getFactory(),
+          result.subgraph.getProtocolDayData(days)
+        ]);
+        return {
+          ethPriceUSD: ethPrice,
+          factory: factory6 ? {
+            poolCount: parseInt(factory6.poolCount, 10),
+            totalVolumeUSD: parseFloat(factory6.totalVolumeUSD),
+            totalFeesUSD: parseFloat(factory6.totalFeesUSD),
+            totalValueLockedUSD: parseFloat(factory6.totalValueLockedUSD)
+          } : undefined,
+          dailyData: dayData.map((d) => ({
+            date: d.date * 1000,
+            volumeUSD: parseFloat(d.volumeUSD),
+            feesUSD: parseFloat(d.feesUSD),
+            tvlUSD: parseFloat(d.tvlUSD),
+            txCount: parseInt(d.txCount, 10)
+          }))
+        };
+      } catch (error48) {
+        return { error: `Failed to get protocol overview: ${error48.message}` };
+      }
+    }
+  });
+  getFeeCollectionsTool = createTool({
+    id: "get_fee_collections",
+    description: "Get recent fee collection events for a Uniswap pool. " + "Shows when LPs harvest their earned fees. Useful for tracking LP profitability " + "and identifying wallets actively managing their positions.",
+    inputSchema: exports_external.object({
+      symbol: exports_external.string().describe("Trading pair (e.g., 'ETHUSDC')"),
+      limit: exports_external.number().min(1).max(100).default(20).describe("Number of events to return")
+    }),
+    outputSchema: exports_external.object({
+      symbol: exports_external.string().optional(),
+      count: exports_external.number().optional(),
+      totalFeesUSD: exports_external.number().optional(),
+      events: exports_external.array(exports_external.object({
+        timestamp: exports_external.number(),
+        amountUSD: exports_external.number(),
+        amount0: exports_external.number(),
+        amount1: exports_external.number(),
+        owner: exports_external.string()
+      })).optional(),
+      error: exports_external.string().optional()
+    }),
+    execute: async ({ symbol: symbol16, limit }, execContext) => {
+      const result = getSubgraph(execContext);
+      if ("error" in result)
+        return result;
+      try {
+        const collects = await result.subgraph.getCollects(symbol16, limit);
+        const totalUSD = collects.reduce((sum, c) => sum + parseFloat(c.amountUSD), 0);
+        return {
+          symbol: symbol16,
+          count: collects.length,
+          totalFeesUSD: totalUSD,
+          events: collects.map((c) => ({
+            timestamp: parseInt(c.timestamp, 10) * 1000,
+            amountUSD: parseFloat(c.amountUSD),
+            amount0: parseFloat(c.amount0),
+            amount1: parseFloat(c.amount1),
+            owner: c.owner
+          }))
+        };
+      } catch (error48) {
+        return { error: `Failed to get fee collections: ${error48.message}` };
+      }
+    }
+  });
+  uniswapDataTools = {
+    get_pool_tick_liquidity: getPoolTickLiquidityTool,
+    get_liquidity_events: getLiquidityEventsTool,
+    get_pool_flash_events: getPoolFlashEventsTool,
+    get_lp_positions: getLpPositionsTool,
+    get_uniswap_protocol_overview: getProtocolOverviewTool,
+    get_fee_collections: getFeeCollectionsTool
+  };
+});
+
 // src/infra/agents/tools/position-tracking.ts
 async function getManager() {
   return getPositionManager(getEventBus());
@@ -1121457,7 +1123279,7 @@ var init_runtime_tools = __esm(() => {
 
 // src/core/regime/types.ts
 var MarketRegimeSchema, RegimeMetricsSchema, RegimeSignalSchema, RegimeSpanSchema, RegimeHistorySchema, MultiTimeframeRegimeSchema;
-var init_types16 = __esm(() => {
+var init_types17 = __esm(() => {
   init_zod();
   MarketRegimeSchema = exports_external.enum([
     "trending_up",
@@ -1121685,7 +1123507,7 @@ var init_watcher = __esm(() => {
 
 // src/core/regime/index.ts
 var init_regime = __esm(() => {
-  init_types16();
+  init_types17();
   init_classifier();
   init_detector();
   init_watcher();
@@ -1121697,7 +1123519,7 @@ var init_regime_tools = __esm(() => {
   init_tools();
   init_zod();
   init_regime();
-  init_types16();
+  init_types17();
   init_types8();
   init_logger2();
   logger92 = createModuleLogger("regime-tools");
@@ -1122374,7 +1124196,7 @@ var init_advanced_tools = __esm(() => {
 
 // src/core/genome/types.ts
 var MutationSchema2, GenomeSchema, ExperimentSchema, MutationSuggestionSchema;
-var init_types17 = __esm(() => {
+var init_types18 = __esm(() => {
   init_zod();
   MutationSchema2 = exports_external.object({
     mutation_id: exports_external.string().uuid(),
@@ -1122901,7 +1124723,7 @@ __export(exports_genome, {
   EvolutionLoop: () => EvolutionLoop
 });
 var init_genome = __esm(() => {
-  init_types17();
+  init_types18();
   init_manager3();
   init_mutator();
   init_fitness();
@@ -1126408,6 +1128230,7 @@ var init_tools3 = __esm(async () => {
   init_agentkit_defi();
   init_base_signals();
   init_base_indexers();
+  init_uniswap_data();
   init_position_tracking();
   init_risk_gate();
   init_memory_tools();
@@ -1126459,6 +1128282,7 @@ var init_tools3 = __esm(async () => {
   init_agentkit_defi();
   init_base_signals();
   init_base_indexers();
+  init_uniswap_data();
   init_position_tracking();
   init_risk_gate();
   init_memory_tools();
@@ -1126514,6 +1128338,7 @@ var init_tools3 = __esm(async () => {
     ...agentKitDefiTools,
     ...baseSignalTools,
     ...baseIndexerTools,
+    ...uniswapDataTools,
     ...multiModalChartTools,
     ...evalTools,
     ...positionTrackingTools,
@@ -1126560,6 +1128385,7 @@ var init_tools3 = __esm(async () => {
     agentKitDefi: Object.keys(agentKitDefiTools).length,
     baseSignals: Object.keys(baseSignalTools).length,
     baseIndexers: Object.keys(baseIndexerTools).length,
+    uniswapData: Object.keys(uniswapDataTools).length,
     multiModalCharts: Object.keys(multiModalChartTools).length,
     evals: Object.keys(evalTools).length,
     positionTracking: Object.keys(positionTrackingTools).length,
@@ -1131950,7 +1133776,7 @@ var init_zod_compat = __esm(() => {
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
 var LATEST_PROTOCOL_VERSION = "2025-11-25", SUPPORTED_PROTOCOL_VERSIONS, RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task", JSONRPC_VERSION4 = "2.0", AssertObjectSchema, ProgressTokenSchema, CursorSchema, TaskCreationParamsSchema, TaskMetadataSchema, RelatedTaskMetadataSchema, RequestMetaSchema, BaseRequestParamsSchema, TaskAugmentedRequestParamsSchema, isTaskAugmentedRequestParams = (value) => TaskAugmentedRequestParamsSchema.safeParse(value).success, RequestSchema4, NotificationsParamsSchema, NotificationSchema, ResultSchema4, RequestIdSchema, JSONRPCRequestSchema4, isJSONRPCRequest = (value) => JSONRPCRequestSchema4.safeParse(value).success, JSONRPCNotificationSchema4, isJSONRPCNotification = (value) => JSONRPCNotificationSchema4.safeParse(value).success, JSONRPCResultResponseSchema, isJSONRPCResultResponse = (value) => JSONRPCResultResponseSchema.safeParse(value).success, ErrorCode, JSONRPCErrorResponseSchema, isJSONRPCErrorResponse = (value) => JSONRPCErrorResponseSchema.safeParse(value).success, JSONRPCMessageSchema, JSONRPCResponseSchema4, EmptyResultSchema, CancelledNotificationParamsSchema, CancelledNotificationSchema, IconSchema, IconsSchema, BaseMetadataSchema, ImplementationSchema, FormElicitationCapabilitySchema, ElicitationCapabilitySchema, ClientTasksCapabilitySchema, ServerTasksCapabilitySchema, ClientCapabilitiesSchema, InitializeRequestParamsSchema, InitializeRequestSchema, ServerCapabilitiesSchema4, InitializeResultSchema, InitializedNotificationSchema, isInitializedNotification = (value) => InitializedNotificationSchema.safeParse(value).success, PingRequestSchema, ProgressSchema, ProgressNotificationParamsSchema, ProgressNotificationSchema, PaginatedRequestParamsSchema, PaginatedRequestSchema, PaginatedResultSchema4, TaskStatusSchema, TaskSchema, CreateTaskResultSchema, TaskStatusNotificationParamsSchema, TaskStatusNotificationSchema, GetTaskRequestSchema, GetTaskResultSchema, GetTaskPayloadRequestSchema, GetTaskPayloadResultSchema, ListTasksRequestSchema, ListTasksResultSchema, CancelTaskRequestSchema, CancelTaskResultSchema, ResourceContentsSchema4, TextResourceContentsSchema4, Base64Schema, BlobResourceContentsSchema4, RoleSchema, AnnotationsSchema, ResourceSchema, ResourceTemplateSchema, ListResourcesRequestSchema, ListResourcesResultSchema, ListResourceTemplatesRequestSchema, ListResourceTemplatesResultSchema, ResourceRequestParamsSchema, ReadResourceRequestParamsSchema, ReadResourceRequestSchema, ReadResourceResultSchema, ResourceListChangedNotificationSchema, SubscribeRequestParamsSchema, SubscribeRequestSchema, UnsubscribeRequestParamsSchema, UnsubscribeRequestSchema, ResourceUpdatedNotificationParamsSchema, ResourceUpdatedNotificationSchema, PromptArgumentSchema, PromptSchema, ListPromptsRequestSchema, ListPromptsResultSchema, GetPromptRequestParamsSchema, GetPromptRequestSchema, TextContentSchema4, ImageContentSchema4, AudioContentSchema, ToolUseContentSchema, EmbeddedResourceSchema4, ResourceLinkSchema, ContentBlockSchema, PromptMessageSchema, GetPromptResultSchema, PromptListChangedNotificationSchema, ToolAnnotationsSchema, ToolExecutionSchema, ToolSchema4, ListToolsRequestSchema, ListToolsResultSchema, CallToolResultSchema, CompatibilityCallToolResultSchema, CallToolRequestParamsSchema, CallToolRequestSchema, ToolListChangedNotificationSchema, ListChangedOptionsBaseSchema, LoggingLevelSchema, SetLevelRequestParamsSchema, SetLevelRequestSchema, LoggingMessageNotificationParamsSchema, LoggingMessageNotificationSchema, ModelHintSchema, ModelPreferencesSchema, ToolChoiceSchema, ToolResultContentSchema, SamplingContentSchema, SamplingMessageContentBlockSchema, SamplingMessageSchema, CreateMessageRequestParamsSchema, CreateMessageRequestSchema, CreateMessageResultSchema, CreateMessageResultWithToolsSchema, BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema, UntitledSingleSelectEnumSchemaSchema, TitledSingleSelectEnumSchemaSchema, LegacyTitledEnumSchemaSchema, SingleSelectEnumSchemaSchema, UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema, MultiSelectEnumSchemaSchema, EnumSchemaSchema, PrimitiveSchemaDefinitionSchema, ElicitRequestFormParamsSchema, ElicitRequestURLParamsSchema, ElicitRequestParamsSchema, ElicitRequestSchema, ElicitationCompleteNotificationParamsSchema, ElicitationCompleteNotificationSchema, ElicitResultSchema, ResourceTemplateReferenceSchema, PromptReferenceSchema, CompleteRequestParamsSchema, CompleteRequestSchema, CompleteResultSchema, RootSchema, ListRootsRequestSchema, ListRootsResultSchema, RootsListChangedNotificationSchema, ClientRequestSchema, ClientNotificationSchema, ClientResultSchema, ServerRequestSchema, ServerNotificationSchema, ServerResultSchema, McpError, UrlElicitationRequiredError;
-var init_types18 = __esm(() => {
+var init_types19 = __esm(() => {
   init_v42();
   SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"];
   AssertObjectSchema = custom((v) => v !== null && (typeof v === "object" || typeof v === "function"));
@@ -1133626,7 +1135452,7 @@ function mergeCapabilities(base4, additional) {
 var DEFAULT_REQUEST_TIMEOUT_MSEC = 60000;
 var init_protocol3 = __esm(() => {
   init_zod_compat();
-  init_types18();
+  init_types19();
   init_zod_json_schema_compat();
 });
 
@@ -1140201,8 +1142027,8 @@ class ExperimentalClientTasks {
     return this._client.requestStream(request, resultSchema, options);
   }
 }
-var init_client10 = __esm(() => {
-  init_types18();
+var init_client11 = __esm(() => {
+  init_types19();
 });
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
@@ -1140283,12 +1142109,12 @@ function getSupportedElicitationModes(capabilities) {
   return { supportsFormMode, supportsUrlMode };
 }
 var Client2;
-var init_client11 = __esm(() => {
+var init_client12 = __esm(() => {
   init_protocol3();
-  init_types18();
+  init_types19();
   init_ajv_provider();
   init_zod_compat();
-  init_client10();
+  init_client11();
   Client2 = class Client2 extends Protocol {
     constructor(_clientInfo, options) {
       super(options);
@@ -1141700,7 +1143526,7 @@ async function registerClient(authorizationServerUrl, { metadata, clientMetadata
 var UnauthorizedError2, AUTHORIZATION_CODE_RESPONSE_TYPE = "code", AUTHORIZATION_CODE_CHALLENGE_METHOD = "S256";
 var init_auth2 = __esm(() => {
   init_index_node2();
-  init_types18();
+  init_types19();
   init_auth();
   init_auth();
   init_errors18();
@@ -1141893,7 +1143719,7 @@ class SSEClientTransport {
 var SseError;
 var init_sse = __esm(() => {
   init_dist16();
-  init_types18();
+  init_types19();
   init_auth2();
   SseError = class SseError extends Error {
     constructor(code, message4, event2) {
@@ -1142390,7 +1144216,7 @@ function serializeMessage2(message4) {
 `;
 }
 var init_stdio = __esm(() => {
-  init_types18();
+  init_types19();
 });
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/client/stdio.js
@@ -1142899,7 +1144725,7 @@ class StreamableHTTPClientTransport {
 }
 var DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS, StreamableHTTPError;
 var init_streamableHttp = __esm(() => {
-  init_types18();
+  init_types19();
   init_auth2();
   init_stream();
   DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS = {
@@ -1143048,7 +1144874,7 @@ var init_exit_hook = __esm(() => {
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
 var init_server = __esm(() => {
   init_protocol3();
-  init_types18();
+  init_types19();
   init_ajv_provider();
   init_zod_compat();
 });
@@ -1147801,7 +1149627,7 @@ var require_content_type = __commonJS((exports) => {
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/sse.js
 var import_raw_body, import_content_type;
 var init_sse2 = __esm(() => {
-  init_types18();
+  init_types19();
   import_raw_body = __toESM(require_raw_body(), 1);
   import_content_type = __toESM(require_content_type(), 1);
 });
@@ -1148013,7 +1149839,7 @@ var init_dist17 = __esm(() => {
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/webStandardStreamableHttp.js
 var init_webStandardStreamableHttp = __esm(() => {
-  init_types18();
+  init_types19();
 });
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/streamableHttp.js
@@ -1148167,12 +1149993,12 @@ var init_dist18 = __esm(() => {
   init_error();
   init_tools();
   init_utils();
-  init_client11();
+  init_client12();
   init_sse();
   init_stdio2();
   init_streamableHttp();
   init_protocol3();
-  init_types18();
+  init_types19();
   init_exit_hook();
   init_zod();
   init_dist6();
@@ -1149739,7 +1151565,7 @@ function disableMCPHotReload() {
   }
 }
 var _mcpClient = null, _mcpTools = null, _initPromise = null, _hotReloadTimer = null, _lastPluginFingerprint = null;
-var init_client12 = __esm(() => {
+var init_client13 = __esm(() => {
   init_dist18();
   init_installer();
   init_credentials();
@@ -1149833,6 +1151659,8 @@ function getScannerAgent() {
         defillama_search_protocols: instrumentedAgentKitDefiTools.defillama_search_protocols,
         indexer_top_pools: instrumentedBaseIndexerTools.indexer_top_pools,
         indexer_aerodrome_pools: instrumentedBaseIndexerTools.indexer_aerodrome_pools,
+        get_uniswap_protocol_overview: instrumentedUniswapDataTools.get_uniswap_protocol_overview,
+        get_liquidity_events: instrumentedUniswapDataTools.get_liquidity_events,
         report_setup: instrumentedPositionTrackingTools.report_setup,
         ...instrumentedMemoryTools,
         ...instrumentedPlaybookTools,
@@ -1149876,6 +1151704,11 @@ function getAnalystAgent() {
         defillama_get_protocol: instrumentedAgentKitDefiTools.defillama_get_protocol,
         defillama_get_token_prices: instrumentedAgentKitDefiTools.defillama_get_token_prices,
         indexer_pool_stats: instrumentedBaseIndexerTools.indexer_pool_stats,
+        get_pool_tick_liquidity: instrumentedUniswapDataTools.get_pool_tick_liquidity,
+        get_liquidity_events: instrumentedUniswapDataTools.get_liquidity_events,
+        get_pool_flash_events: instrumentedUniswapDataTools.get_pool_flash_events,
+        get_fee_collections: instrumentedUniswapDataTools.get_fee_collections,
+        get_uniswap_protocol_overview: instrumentedUniswapDataTools.get_uniswap_protocol_overview,
         track_base_wallet: instrumentedBaseSignalTools.track_base_wallet,
         get_base_token_holders: instrumentedBaseSignalTools.get_base_token_holders,
         get_base_dex_pairs: instrumentedBaseSignalTools.get_base_dex_pairs,
@@ -1150018,6 +1151851,8 @@ function getMonitorAgent() {
         agentkit_get_wallet: instrumentedAgentKitOnchainTools.agentkit_get_wallet,
         agentkit_get_balance: instrumentedAgentKitOnchainTools.agentkit_get_balance,
         agentkit_erc20_balance: instrumentedAgentKitOnchainTools.agentkit_erc20_balance,
+        get_lp_positions: instrumentedUniswapDataTools.get_lp_positions,
+        get_fee_collections: instrumentedUniswapDataTools.get_fee_collections,
         ...instrumentedSharedContextTools,
         record_trade_outcome: instrumentedEvalTools.record_trade_outcome,
         get_performance_report: instrumentedEvalTools.get_performance_report,
@@ -1150130,7 +1151965,7 @@ function resetAgents() {
   _agents = {};
   _subAgentMemory = null;
 }
-var DEFAULT_MEMORY_CONFIG, _memoryConfig, instrumentedIndicatorTools, instrumentedExplainTools, instrumentedMarketTools, instrumentedPositionTools, instrumentedSchedulerTools, instrumentedSystemTools, instrumentedEarnTools, instrumentedChartTools, instrumentedOrderbookTools, instrumentedWalletTools, instrumentedDiscoveryTools, instrumentedHistoryTools, instrumentedAccountTools, instrumentedTradingTools, instrumentedMarketAnalysisTools, instrumentedLiquidationIntelligenceTools, instrumentedRiskManagementTools, instrumentedStrategyTools, instrumentedMetricsTools, instrumentedCompositionTools, instrumentedBacktestTools, instrumentedSharedContextTools, instrumentedParallelAnalysisTools, instrumentedStrategyGenerationTools, instrumentedMultiModalChartTools, instrumentedMarketDataTools, instrumentedPairAnalysisTools, instrumentedAutonomousTools, instrumentedBaseOnchainTools, instrumentedAgentKitOnchainTools, instrumentedAgentKitDefiTools, instrumentedBaseSignalTools, instrumentedBaseIndexerTools, instrumentedEvalTools, instrumentedPositionTrackingTools, instrumentedMemoryTools, instrumentedPlaybookTools, instrumentedPlaybookBacktestTools, instrumentedAuditTools, instrumentedProtocolTools, instrumentedRegimeTools, instrumentedRuntimeTools, instrumentedAdvancedTools, instrumentedCheckRiskTool, WORKING_MEMORY_TEMPLATE = `
+var DEFAULT_MEMORY_CONFIG, _memoryConfig, instrumentedIndicatorTools, instrumentedExplainTools, instrumentedMarketTools, instrumentedPositionTools, instrumentedSchedulerTools, instrumentedSystemTools, instrumentedEarnTools, instrumentedChartTools, instrumentedOrderbookTools, instrumentedWalletTools, instrumentedDiscoveryTools, instrumentedHistoryTools, instrumentedAccountTools, instrumentedTradingTools, instrumentedMarketAnalysisTools, instrumentedLiquidationIntelligenceTools, instrumentedRiskManagementTools, instrumentedStrategyTools, instrumentedMetricsTools, instrumentedCompositionTools, instrumentedBacktestTools, instrumentedSharedContextTools, instrumentedParallelAnalysisTools, instrumentedStrategyGenerationTools, instrumentedMultiModalChartTools, instrumentedMarketDataTools, instrumentedPairAnalysisTools, instrumentedAutonomousTools, instrumentedBaseOnchainTools, instrumentedAgentKitOnchainTools, instrumentedAgentKitDefiTools, instrumentedBaseSignalTools, instrumentedBaseIndexerTools, instrumentedUniswapDataTools, instrumentedEvalTools, instrumentedPositionTrackingTools, instrumentedMemoryTools, instrumentedPlaybookTools, instrumentedPlaybookBacktestTools, instrumentedAuditTools, instrumentedProtocolTools, instrumentedRegimeTools, instrumentedRuntimeTools, instrumentedAdvancedTools, instrumentedCheckRiskTool, WORKING_MEMORY_TEMPLATE = `
 # Trader Profile
 
 ## Personal Info
@@ -1150736,7 +1152571,7 @@ var init_agents = __esm(async () => {
   init_registry2();
   init_shared_context();
   init_evals2();
-  init_client12();
+  init_client13();
   await init_tools3();
   DEFAULT_MEMORY_CONFIG = {
     lastMessages: 20,
@@ -1150777,6 +1152612,7 @@ var init_agents = __esm(async () => {
   instrumentedAgentKitDefiTools = withToolsMetrics(agentKitDefiTools);
   instrumentedBaseSignalTools = withToolsMetrics(baseSignalTools);
   instrumentedBaseIndexerTools = withToolsMetrics(baseIndexerTools);
+  instrumentedUniswapDataTools = withToolsMetrics(uniswapDataTools);
   instrumentedEvalTools = withToolsMetrics(evalTools);
   instrumentedPositionTrackingTools = withToolsMetrics(positionTrackingTools);
   instrumentedMemoryTools = withToolsMetrics(memoryTools);
@@ -1152613,6 +1154449,12 @@ var init_orchestrator = __esm(async () => {
     indexer_top_pools: "Scanner",
     indexer_pool_stats: "Analyst",
     indexer_aerodrome_pools: "Scanner",
+    get_pool_tick_liquidity: "Analyst",
+    get_liquidity_events: "Scanner",
+    get_pool_flash_events: "Analyst",
+    get_lp_positions: "Monitor",
+    get_uniswap_protocol_overview: "Scanner",
+    get_fee_collections: "Monitor",
     scan_base_whale_transfers: "Scanner",
     scan_base_volume_spikes: "Scanner",
     scan_base_new_tokens: "Scanner",
@@ -1154761,7 +1156603,7 @@ async function checkOrphanedOrders(exchange, activeTrades, result) {
 }
 
 // src/gateway/runtime/gateway-runtime.ts
-init_client12();
+init_client13();
 
 // src/gateway/scheduler/local-cron.ts
 init_logger2();
@@ -1155615,7 +1157457,7 @@ class ReconciliationLoop {
   }
 }
 // src/gateway/daemon/process.ts
-init_client12();
+init_client13();
 init_engine();
 var logger116 = createModuleLogger("gateway-daemon");
 async function startGatewayDaemonProcess() {
@@ -1161748,7 +1163590,7 @@ var import_react64 = __toESM(require_react(), 1);
 // package.json
 var package_default2 = {
   name: "@general-liquidity/gordon-cli",
-  version: "0.75.3",
+  version: "0.75.5",
   description: "The Frontier Trading Agent",
   author: "General Liquidity, Inc.",
   license: "MIT",
@@ -1163876,7 +1165718,7 @@ async function ensureThreadRegistered() {
 
 // src/infra/agents/index.ts
 init_memory3();
-init_client12();
+init_client13();
 init_reflection();
 
 // src/app/SetupWizard.tsx
@@ -1163893,7 +1165735,8 @@ var EXCHANGE_LABELS = {
   coinbase: "Coinbase",
   kraken: "Kraken",
   bitfinex: "Bitfinex",
-  hyperliquid: "Hyperliquid"
+  hyperliquid: "Hyperliquid",
+  uniswap: "Uniswap"
 };
 var EXCHANGE_PASSPHRASE_REQUIRED = {
   binance: false,
@@ -1163901,7 +1165744,8 @@ var EXCHANGE_PASSPHRASE_REQUIRED = {
   coinbase: true,
   kraken: false,
   bitfinex: false,
-  hyperliquid: false
+  hyperliquid: false,
+  uniswap: false
 };
 var EXCHANGE_WALLET_AUTH = {
   binance: false,
@@ -1163909,7 +1165753,8 @@ var EXCHANGE_WALLET_AUTH = {
   coinbase: false,
   kraken: false,
   bitfinex: false,
-  hyperliquid: true
+  hyperliquid: true,
+  uniswap: true
 };
 var EXCHANGE_INSTRUCTIONS = {
   binance: [
@@ -1163949,6 +1165794,12 @@ var EXCHANGE_INSTRUCTIONS = {
     "IMPORTANT: Use a dedicated wallet with limited funds for trading",
     "Never use your main wallet's private key",
     "Fund your Hyperliquid account by depositing USDC on Arbitrum"
+  ],
+  uniswap: [
+    "Get an API key from developers.uniswap.org",
+    "Provide your wallet address (the address that will execute swaps)",
+    "Ensure your wallet has ETH for gas and tokens to trade",
+    "Supports 15+ chains: Ethereum, Base, Arbitrum, Polygon, Optimism, etc."
   ]
 };
 function maskSecret(value) {
@@ -1165784,7 +1167635,7 @@ function useTheme() {
 }
 
 // src/app/App.tsx
-init_client12();
+init_client13();
 init_llm();
 init_binance2();
 init_exchange();
@@ -1168039,7 +1169890,7 @@ async function exchangeCompare(symbol16) {
   }
 }
 function isWalletBasedExchange(type2) {
-  return type2 === "hyperliquid";
+  return type2 === "hyperliquid" || type2 === "uniswap";
 }
 function getExchangeSetupInstructions(type2) {
   const instructions = {
@@ -1168073,7 +1169924,12 @@ function getExchangeSetupInstructions(type2) {
 2. Export the private key from your wallet (MetaMask: Account Details > Export Private Key)
 3. IMPORTANT: Use a DEDICATED trading wallet with limited funds
 4. Fund your Hyperliquid account by depositing USDC on Arbitrum
-5. Note: Hyperliquid uses wallet-based auth (no API key needed)`
+5. Note: Hyperliquid uses wallet-based auth (no API key needed)`,
+    uniswap: `
+1. Get an API key from developers.uniswap.org
+2. Provide your wallet address (the address that will execute swaps)
+3. Ensure your wallet has ETH for gas and tokens to trade
+4. Supports 15+ chains: Ethereum, Base, Arbitrum, Polygon, Optimism, etc.`
   };
   return instructions[type2] || "Follow the exchange documentation to create API keys.";
 }
@@ -1172011,7 +1173867,7 @@ async function checkForUpdates() {
 
 // src/index.tsx
 init_telemetry2();
-init_client12();
+init_client13();
 var jsx_dev_runtime26 = __toESM(require_jsx_dev_runtime(), 1);
 var flags = parseFlags();
 var command = parseCommand();