@general-liquidity/gordon-cli 0.75.4 → 0.75.6

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
   };
 }
@@ -195777,6 +195785,9 @@ var init_hyperliquid3 = __esm(() => {
 });
 
 // src/infra/uniswap/types.ts
+function isUniswapXRouting(routing) {
+  return ["DUTCH_V2", "DUTCH_V3", "DUTCH_LIMIT", "PRIORITY"].includes(routing);
+}
 var NATIVE_TOKEN = "0x0000000000000000000000000000000000000000", GAS_BUFFER_PERCENT = 0.15, WRAPPED_NATIVE, USDC_ADDRESSES, SUPPORTED_CHAIN_IDS, CHAIN_NAMES;
 var init_types10 = __esm(() => {
   WRAPPED_NATIVE = {
@@ -195797,13 +195808,14 @@ var init_types10 = __esm(() => {
     42161: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
     43114: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E"
   };
-  SUPPORTED_CHAIN_IDS = [1, 10, 56, 130, 137, 196, 324, 480, 1868, 8453, 42161, 42220, 43114, 81457, 7777777];
+  SUPPORTED_CHAIN_IDS = [1, 10, 56, 130, 137, 143, 196, 324, 480, 1868, 8453, 42161, 42220, 43114, 81457, 7777777];
   CHAIN_NAMES = {
     1: "Ethereum",
     10: "Optimism",
     56: "BNB Chain",
     130: "Unichain",
     137: "Polygon",
+    143: "Monad",
     196: "X Layer",
     324: "zkSync",
     480: "World Chain",
@@ -196193,23 +196205,779 @@ var init_client9 = __esm(() => {
   };
 });
 
+// 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) {
+  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();
@@ -196241,16 +197009,40 @@ class UniswapAdapter {
       throw new Error("No output amount in quote");
     return Number(outputAmount) / 10 ** tokenOutDecimals;
   }
-  async getCandles(_symbol2, _interval, _limit) {
-    return [];
+  async getCandles(symbol16, interval, limit) {
+    if (!this.subgraph?.isAvailable())
+      return [];
+    try {
+      return await this.subgraph.getCandles(symbol16, interval, limit ?? 50);
+    } catch {
+      return [];
+    }
   }
   async get24hrTickers() {
-    return [];
+    if (!this.subgraph?.isAvailable())
+      return [];
+    try {
+      return await this.subgraph.get24hrTickers();
+    } catch {
+      return [];
+    }
   }
-  async getTopSymbols(_n) {
-    return ["ETHUSDC", "WBTCUSDC", "ARBUSDC", "LINKUSDC", "UNIUSDC"];
+  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 {
@@ -196260,6 +197052,11 @@ class UniswapAdapter {
     };
   }
   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 {
@@ -196271,6 +197068,11 @@ class UniswapAdapter {
     };
   }
   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 {
@@ -196281,6 +197083,11 @@ class UniswapAdapter {
     };
   }
   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 };
   }
@@ -196345,11 +197152,16 @@ class UniswapAdapter {
     this.localOrders.set(orderId, order);
     const meta3 = {
       _unsignedTx: swapTx.swap,
-      _quoteTimestamp: quoteTimestamp
+      _quoteTimestamp: quoteTimestamp,
+      _routing: quote.routing
     };
     if (approvalResult.approval) {
       meta3._approvalTx = approvalResult.approval;
     }
+    if (isUniswapXRouting(quote.routing) && quote.permitData) {
+      meta3._permitData = quote.permitData;
+      meta3._isUniswapX = true;
+    }
     if (swapTx.txFailureReasons?.length) {
       meta3._txFailureReasons = swapTx.txFailureReasons;
     }
@@ -196395,8 +197207,18 @@ class UniswapAdapter {
       return false;
     }
   }
-  async getTradeHistory(symbol16, _limit) {
-    return this.localTrades.get(symbol16) || [];
+  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);
@@ -196430,6 +197252,7 @@ class UniswapAdapter {
 }
 var init_uniswap2 = __esm(() => {
   init_uniswap();
+  init_subgraph();
   init_types10();
 });
 
@@ -196498,7 +197321,7 @@ var init_factory = __esm(() => {
           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);
+          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}`);
@@ -286303,26 +287126,52 @@ async function dexScreenerFetch(path6) {
   }
   return await res.json();
 }
-async function getBasePairs(tokenAddress) {
-  const data = await dexScreenerFetch(`/token-pairs/v1/base/${tokenAddress}`);
-  return (data.pairs ?? []).filter((p) => p.chainId === "base");
+async function getDexPairs(chain, tokenAddress) {
+  const data = await dexScreenerFetch(`/token-pairs/v1/${chain}/${tokenAddress}`);
+  return (data.pairs ?? []).filter((p) => p.chainId === chain);
 }
-async function searchBasePairs(query) {
+async function searchDexPairs(query, chain, dex) {
   const data = await dexScreenerFetch(`/latest/dex/search?q=${encodeURIComponent(query)}`);
-  return (data.pairs ?? []).filter((p) => p.chainId === "base");
-}
-async function getBaseTokensBatch(addresses) {
+  let pairs = data.pairs ?? [];
+  if (chain)
+    pairs = pairs.filter((p) => p.chainId === chain);
+  if (dex)
+    pairs = pairs.filter((p) => p.dexId === dex);
+  return pairs;
+}
+async function getDexTokensBatch(chain, addresses) {
   if (addresses.length === 0)
     return [];
   const batch = addresses.slice(0, 30).join(",");
-  const data = await dexScreenerFetch(`/tokens/v1/base/${batch}`);
-  return (data.pairs ?? []).filter((p) => p.chainId === "base");
+  const data = await dexScreenerFetch(`/tokens/v1/${chain}/${batch}`);
+  return (data.pairs ?? []).filter((p) => p.chainId === chain);
 }
-async function getNewBaseTokens() {
+async function getNewTokens(chain) {
   const data = await dexScreenerFetch(`/token-profiles/latest/v1`);
-  return (data ?? []).filter((t2) => t2.chainId === "base");
+  if (!chain)
+    return data ?? [];
+  return (data ?? []).filter((t2) => t2.chainId === chain);
+}
+async function getBoostedTokens(chain) {
+  const data = await dexScreenerFetch(`/token-boosts/top/v1`);
+  if (!chain)
+    return data ?? [];
+  return (data ?? []).filter((t2) => t2.chainId === chain);
+}
+async function getBasePairs(tokenAddress) {
+  return getDexPairs("base", tokenAddress);
+}
+async function searchBasePairs(query) {
+  return searchDexPairs(query, "base");
+}
+async function getBaseTokensBatch(addresses) {
+  return getDexTokensBatch("base", addresses);
+}
+async function getNewBaseTokens() {
+  return getNewTokens("base");
 }
 var DEXSCREENER_BASE = "https://api.dexscreener.com";
+var init_dexscreener = () => {};
 
 // src/infra/base/signals.ts
 async function detectWhaleTransfers(opts = {}) {
@@ -286433,6 +287282,7 @@ async function detectNewListings(opts = {}) {
   return signals;
 }
 var init_signals = __esm(() => {
+  init_dexscreener();
   init_types14();
 });
 
@@ -286440,6 +287290,7 @@ var init_signals = __esm(() => {
 var init_base4 = __esm(() => {
   init_registry4();
   init_chain2();
+  init_dexscreener();
   init_signals();
   init_types14();
 });
@@ -1120270,6 +1121121,7 @@ var init_base_signals = __esm(() => {
   init_tools();
   init_zod();
   init_signals();
+  init_dexscreener();
   scanBaseWhaleTransfersTool = createTool({
     id: "scan_base_whale_transfers",
     description: "Scan for large token transfers (whale movements) on Base L2. " + "Detects big USDC, WETH, and other major token movements. " + "Requires BASESCAN_API_KEY. " + "Use when user asks 'any whale activity on Base', 'large transfers', 'who is moving big money on Base'.",
@@ -1120715,6 +1121567,624 @@ ${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/dex-search.ts
+var searchDexPairsTool, getBoostedTokensTool, dexSearchTools;
+var init_dex_search = __esm(() => {
+  init_tools();
+  init_zod();
+  init_dexscreener();
+  searchDexPairsTool = createTool({
+    id: "search_dex_pairs",
+    description: "Search for DEX trading pairs across any chain using DexScreener. " + "Works on Ethereum, Base, Arbitrum, Optimism, Polygon, BSC, Avalanche, and more. " + "Filter by chain and/or DEX. No API key needed. " + "Use when user asks about DEX pairs on chains other than Base, or wants to compare " + "pairs across chains. For Base-only queries, prefer get_base_dex_pairs.",
+    inputSchema: exports_external.object({
+      query: exports_external.string().describe("Search term: token symbol (e.g., 'UNI'), pair (e.g., 'WETH/USDC'), or token address (0x...)"),
+      chain: exports_external.string().optional().describe("DexScreener chain ID: 'ethereum', 'base', 'arbitrum', 'optimism', 'polygon', 'bsc', 'avalanche', 'unichain'. Omit for all chains."),
+      dex: exports_external.string().optional().describe("DEX filter: 'uniswap', 'sushiswap', 'aerodrome', 'curve', etc. Omit for all DEXs.")
+    }),
+    outputSchema: exports_external.object({
+      pairs: exports_external.array(exports_external.object({
+        chain: exports_external.string(),
+        pairAddress: exports_external.string(),
+        dex: exports_external.string(),
+        baseToken: exports_external.string(),
+        quoteToken: exports_external.string(),
+        priceUsd: exports_external.string(),
+        volumeH24: exports_external.number(),
+        liquidityUsd: exports_external.number(),
+        priceChangeH24: exports_external.number(),
+        marketCap: exports_external.number().nullable(),
+        url: exports_external.string()
+      })).optional(),
+      count: exports_external.number().optional(),
+      error: exports_external.string().optional()
+    }),
+    execute: async ({ query, chain, dex }) => {
+      try {
+        const isAddress4 = /^0x[a-fA-F0-9]{40}$/.test(query);
+        let pairs;
+        if (isAddress4 && chain) {
+          pairs = await getDexPairs(chain, query);
+          if (dex)
+            pairs = pairs.filter((p) => p.dexId === dex);
+        } else {
+          pairs = await searchDexPairs(query, chain, dex);
+        }
+        return {
+          count: pairs.length,
+          pairs: pairs.slice(0, 25).map((p) => ({
+            chain: p.chainId,
+            pairAddress: p.pairAddress,
+            dex: p.dexId,
+            baseToken: `${p.baseToken.symbol} (${p.baseToken.address})`,
+            quoteToken: `${p.quoteToken.symbol} (${p.quoteToken.address})`,
+            priceUsd: p.priceUsd,
+            volumeH24: p.volume?.h24 ?? 0,
+            liquidityUsd: p.liquidity?.usd ?? 0,
+            priceChangeH24: p.priceChange?.h24 ?? 0,
+            marketCap: p.marketCap ?? null,
+            url: p.url
+          }))
+        };
+      } catch (error48) {
+        return { error: `Failed to search DEX pairs: ${error48.message}` };
+      }
+    }
+  });
+  getBoostedTokensTool = createTool({
+    id: "get_boosted_tokens",
+    description: "Get currently promoted/boosted tokens from DexScreener across all chains. " + "Shows tokens with active promotions \u2014 can indicate marketing spend or community interest. " + "Optionally filter by chain. No API key needed.",
+    inputSchema: exports_external.object({
+      chain: exports_external.string().optional().describe("Filter to a specific chain: 'ethereum', 'base', 'arbitrum', etc. Omit for all chains.")
+    }),
+    outputSchema: exports_external.object({
+      tokens: exports_external.array(exports_external.object({
+        chain: exports_external.string(),
+        tokenAddress: exports_external.string(),
+        url: exports_external.string(),
+        description: exports_external.string().optional()
+      })).optional(),
+      count: exports_external.number().optional(),
+      error: exports_external.string().optional()
+    }),
+    execute: async ({ chain }) => {
+      try {
+        const tokens = await getBoostedTokens(chain);
+        return {
+          count: tokens.length,
+          tokens: tokens.slice(0, 30).map((t3) => ({
+            chain: t3.chainId,
+            tokenAddress: t3.tokenAddress,
+            url: t3.url,
+            description: t3.description
+          }))
+        };
+      } catch (error48) {
+        return { error: `Failed to get boosted tokens: ${error48.message}` };
+      }
+    }
+  });
+  dexSearchTools = {
+    search_dex_pairs: searchDexPairsTool,
+    get_boosted_tokens: getBoostedTokensTool
+  };
+});
+
+// src/infra/defillama/client.ts
+async function llamaFetch(base4, path6) {
+  const url2 = `${base4}${path6}`;
+  const res = await fetch(url2, { signal: AbortSignal.timeout(15000) });
+  if (!res.ok) {
+    throw new Error(`DefiLlama API error: ${res.status} ${res.statusText}`);
+  }
+  return await res.json();
+}
+async function getAllPools() {
+  const cached2 = poolsCache.get("all");
+  if (cached2)
+    return cached2;
+  const resp = await llamaFetch(YIELDS_BASE, "/pools");
+  const pools = resp.data ?? [];
+  poolsCache.set("all", pools);
+  return pools;
+}
+async function getUniswapPoolYields(chain, symbol16) {
+  const allPools = await getAllPools();
+  let pools = allPools.filter((p) => p.project === "uniswap-v3" || p.project === "uniswap-v4");
+  if (chain) {
+    const defillamaChain = DEFILLAMA_CHAINS[chain.toLowerCase()] ?? chain;
+    pools = pools.filter((p) => p.chain === defillamaChain);
+  }
+  if (symbol16) {
+    const sym = symbol16.toUpperCase();
+    pools = pools.filter((p) => p.symbol.toUpperCase().includes(sym));
+  }
+  pools.sort((a2, b) => b.tvlUsd - a2.tvlUsd);
+  return pools;
+}
+async function getTopYieldPools(chain, limit = 20, minTvl = 1e5) {
+  const allPools = await getAllPools();
+  let pools = allPools.filter((p) => p.tvlUsd >= minTvl && p.apy > 0);
+  if (chain) {
+    const defillamaChain = DEFILLAMA_CHAINS[chain.toLowerCase()] ?? chain;
+    pools = pools.filter((p) => p.chain === defillamaChain);
+  }
+  pools.sort((a2, b) => b.apy - a2.apy);
+  return pools.slice(0, limit);
+}
+var YIELDS_BASE = "https://yields.llama.fi", DEFILLAMA_CHAINS, poolsCache, priceCache;
+var init_client11 = __esm(() => {
+  DEFILLAMA_CHAINS = {
+    ethereum: "Ethereum",
+    base: "Base",
+    arbitrum: "Arbitrum",
+    optimism: "Optimism",
+    polygon: "Polygon",
+    bsc: "BSC",
+    avalanche: "Avalanche",
+    celo: "Celo",
+    blast: "Blast",
+    unichain: "Unichain"
+  };
+  poolsCache = new Cache({ defaultTtl: 5 * 60 * 1000 });
+  priceCache = new Cache({ defaultTtl: 2 * 60 * 1000 });
+});
+
+// src/infra/agents/tools/defillama-yields.ts
+var getUniswapYieldsTool, getTopYieldsTool, defillamaYieldTools;
+var init_defillama_yields = __esm(() => {
+  init_tools();
+  init_zod();
+  init_client11();
+  getUniswapYieldsTool = createTool({
+    id: "get_uniswap_pool_yields",
+    description: "Get current APY, TVL, and volume data for Uniswap V3/V4 pools from DefiLlama. " + "Shows base APY (fees), reward APY, 7d/30d trends, impermanent loss risk, and pool TVL. " + "Use for yield farming analysis, comparing fee tiers, and LP profitability assessment. " + "Supports all chains: Ethereum, Base, Arbitrum, Optimism, Polygon, etc.",
+    inputSchema: exports_external.object({
+      chain: exports_external.string().optional().describe("Chain name (e.g., 'ethereum', 'base', 'arbitrum'). Omit for all chains."),
+      symbol: exports_external.string().optional().describe("Token pair filter (e.g., 'WETH-USDC', 'USDC'). Partial match."),
+      limit: exports_external.number().min(1).max(50).default(15).describe("Max pools to return")
+    }),
+    outputSchema: exports_external.object({
+      pools: exports_external.array(exports_external.object({
+        pool: exports_external.string(),
+        symbol: exports_external.string(),
+        chain: exports_external.string(),
+        tvlUsd: exports_external.number(),
+        apy: exports_external.number(),
+        apyBase: exports_external.number().nullable(),
+        apyReward: exports_external.number().nullable(),
+        apyPct7D: exports_external.number().nullable(),
+        apyPct30D: exports_external.number().nullable(),
+        volumeUsd1d: exports_external.number().nullable(),
+        volumeUsd7d: exports_external.number().nullable(),
+        ilRisk: exports_external.string(),
+        stablecoin: exports_external.boolean(),
+        poolMeta: exports_external.string().nullable()
+      })).optional(),
+      count: exports_external.number().optional(),
+      error: exports_external.string().optional()
+    }),
+    execute: async ({ chain, symbol: symbol16, limit }) => {
+      try {
+        const pools = await getUniswapPoolYields(chain, symbol16);
+        return {
+          count: Math.min(pools.length, limit),
+          pools: pools.slice(0, limit).map((p) => ({
+            pool: p.pool,
+            symbol: p.symbol,
+            chain: p.chain,
+            tvlUsd: Math.round(p.tvlUsd),
+            apy: Math.round(p.apy * 100) / 100,
+            apyBase: p.apyBase !== null ? Math.round(p.apyBase * 100) / 100 : null,
+            apyReward: p.apyReward !== null ? Math.round(p.apyReward * 100) / 100 : null,
+            apyPct7D: p.apyPct7D !== null ? Math.round(p.apyPct7D * 100) / 100 : null,
+            apyPct30D: p.apyPct30D !== null ? Math.round(p.apyPct30D * 100) / 100 : null,
+            volumeUsd1d: p.volumeUsd1d !== null ? Math.round(p.volumeUsd1d) : null,
+            volumeUsd7d: p.volumeUsd7d !== null ? Math.round(p.volumeUsd7d) : null,
+            ilRisk: p.ilRisk,
+            stablecoin: p.stablecoin,
+            poolMeta: p.poolMeta
+          }))
+        };
+      } catch (error48) {
+        return { error: `Failed to get Uniswap yields: ${error48.message}` };
+      }
+    }
+  });
+  getTopYieldsTool = createTool({
+    id: "get_top_defi_yields",
+    description: "Get the highest-yielding DeFi pools across all protocols from DefiLlama. " + "Includes Uniswap, Aave, Compound, Aerodrome, Curve, and all tracked protocols. " + "Use for finding the best yield opportunities, comparing protocols, and yield farming research.",
+    inputSchema: exports_external.object({
+      chain: exports_external.string().optional().describe("Chain name (e.g., 'ethereum', 'base', 'arbitrum'). Omit for all chains."),
+      limit: exports_external.number().min(1).max(50).default(20).describe("Max pools to return"),
+      minTvl: exports_external.number().default(1e5).describe("Minimum TVL in USD (default: 100000)")
+    }),
+    outputSchema: exports_external.object({
+      pools: exports_external.array(exports_external.object({
+        pool: exports_external.string(),
+        project: exports_external.string(),
+        symbol: exports_external.string(),
+        chain: exports_external.string(),
+        tvlUsd: exports_external.number(),
+        apy: exports_external.number(),
+        apyBase: exports_external.number().nullable(),
+        apyReward: exports_external.number().nullable(),
+        stablecoin: exports_external.boolean(),
+        ilRisk: exports_external.string()
+      })).optional(),
+      count: exports_external.number().optional(),
+      error: exports_external.string().optional()
+    }),
+    execute: async ({ chain, limit, minTvl }) => {
+      try {
+        const pools = await getTopYieldPools(chain, limit, minTvl);
+        return {
+          count: pools.length,
+          pools: pools.map((p) => ({
+            pool: p.pool,
+            project: p.project,
+            symbol: p.symbol,
+            chain: p.chain,
+            tvlUsd: Math.round(p.tvlUsd),
+            apy: Math.round(p.apy * 100) / 100,
+            apyBase: p.apyBase !== null ? Math.round(p.apyBase * 100) / 100 : null,
+            apyReward: p.apyReward !== null ? Math.round(p.apyReward * 100) / 100 : null,
+            stablecoin: p.stablecoin,
+            ilRisk: p.ilRisk
+          }))
+        };
+      } catch (error48) {
+        return { error: `Failed to get top yields: ${error48.message}` };
+      }
+    }
+  });
+  defillamaYieldTools = {
+    get_uniswap_pool_yields: getUniswapYieldsTool,
+    get_top_defi_yields: getTopYieldsTool
+  };
+});
+
 // src/infra/agents/tools/position-tracking.ts
 async function getManager() {
   return getPositionManager(getEventBus());
@@ -1127074,6 +1128544,9 @@ var init_tools3 = __esm(async () => {
   init_agentkit_defi();
   init_base_signals();
   init_base_indexers();
+  init_uniswap_data();
+  init_dex_search();
+  init_defillama_yields();
   init_position_tracking();
   init_risk_gate();
   init_memory_tools();
@@ -1127125,6 +1128598,9 @@ var init_tools3 = __esm(async () => {
   init_agentkit_defi();
   init_base_signals();
   init_base_indexers();
+  init_uniswap_data();
+  init_dex_search();
+  init_defillama_yields();
   init_position_tracking();
   init_risk_gate();
   init_memory_tools();
@@ -1127180,6 +1128656,9 @@ var init_tools3 = __esm(async () => {
     ...agentKitDefiTools,
     ...baseSignalTools,
     ...baseIndexerTools,
+    ...uniswapDataTools,
+    ...dexSearchTools,
+    ...defillamaYieldTools,
     ...multiModalChartTools,
     ...evalTools,
     ...positionTrackingTools,
@@ -1127226,6 +1128705,9 @@ 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,
+    dexSearch: Object.keys(dexSearchTools).length,
+    defillamaYields: Object.keys(defillamaYieldTools).length,
     multiModalCharts: Object.keys(multiModalChartTools).length,
     evals: Object.keys(evalTools).length,
     positionTracking: Object.keys(positionTrackingTools).length,
@@ -1140867,7 +1142349,7 @@ class ExperimentalClientTasks {
     return this._client.requestStream(request, resultSchema, options);
   }
 }
-var init_client11 = __esm(() => {
+var init_client12 = __esm(() => {
   init_types19();
 });
 
@@ -1140949,12 +1142431,12 @@ function getSupportedElicitationModes(capabilities) {
   return { supportsFormMode, supportsUrlMode };
 }
 var Client2;
-var init_client12 = __esm(() => {
+var init_client13 = __esm(() => {
   init_protocol3();
   init_types19();
   init_ajv_provider();
   init_zod_compat();
-  init_client11();
+  init_client12();
   Client2 = class Client2 extends Protocol {
     constructor(_clientInfo, options) {
       super(options);
@@ -1148833,7 +1150315,7 @@ var init_dist18 = __esm(() => {
   init_error();
   init_tools();
   init_utils();
-  init_client12();
+  init_client13();
   init_sse();
   init_stdio2();
   init_streamableHttp();
@@ -1150405,7 +1151887,7 @@ function disableMCPHotReload() {
   }
 }
 var _mcpClient = null, _mcpTools = null, _initPromise = null, _hotReloadTimer = null, _lastPluginFingerprint = null;
-var init_client13 = __esm(() => {
+var init_client14 = __esm(() => {
   init_dist18();
   init_installer();
   init_credentials();
@@ -1150499,6 +1151981,10 @@ function getScannerAgent() {
         defillama_search_protocols: instrumentedAgentKitDefiTools.defillama_search_protocols,
         indexer_top_pools: instrumentedBaseIndexerTools.indexer_top_pools,
         indexer_aerodrome_pools: instrumentedBaseIndexerTools.indexer_aerodrome_pools,
+        search_dex_pairs: instrumentedDexSearchTools.search_dex_pairs,
+        get_boosted_tokens: instrumentedDexSearchTools.get_boosted_tokens,
+        get_uniswap_protocol_overview: instrumentedUniswapDataTools.get_uniswap_protocol_overview,
+        get_liquidity_events: instrumentedUniswapDataTools.get_liquidity_events,
         report_setup: instrumentedPositionTrackingTools.report_setup,
         ...instrumentedMemoryTools,
         ...instrumentedPlaybookTools,
@@ -1150542,6 +1152028,14 @@ 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,
+        get_uniswap_pool_yields: instrumentedDefillamaYieldTools.get_uniswap_pool_yields,
+        get_top_defi_yields: instrumentedDefillamaYieldTools.get_top_defi_yields,
+        search_dex_pairs: instrumentedDexSearchTools.search_dex_pairs,
         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,
@@ -1150684,6 +1152178,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,
@@ -1150796,7 +1152292,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, instrumentedDexSearchTools, instrumentedDefillamaYieldTools, instrumentedEvalTools, instrumentedPositionTrackingTools, instrumentedMemoryTools, instrumentedPlaybookTools, instrumentedPlaybookBacktestTools, instrumentedAuditTools, instrumentedProtocolTools, instrumentedRegimeTools, instrumentedRuntimeTools, instrumentedAdvancedTools, instrumentedCheckRiskTool, WORKING_MEMORY_TEMPLATE = `
 # Trader Profile
 
 ## Personal Info
@@ -1151402,7 +1152898,7 @@ var init_agents = __esm(async () => {
   init_registry2();
   init_shared_context();
   init_evals2();
-  init_client13();
+  init_client14();
   await init_tools3();
   DEFAULT_MEMORY_CONFIG = {
     lastMessages: 20,
@@ -1151443,6 +1152939,9 @@ var init_agents = __esm(async () => {
   instrumentedAgentKitDefiTools = withToolsMetrics(agentKitDefiTools);
   instrumentedBaseSignalTools = withToolsMetrics(baseSignalTools);
   instrumentedBaseIndexerTools = withToolsMetrics(baseIndexerTools);
+  instrumentedUniswapDataTools = withToolsMetrics(uniswapDataTools);
+  instrumentedDexSearchTools = withToolsMetrics(dexSearchTools);
+  instrumentedDefillamaYieldTools = withToolsMetrics(defillamaYieldTools);
   instrumentedEvalTools = withToolsMetrics(evalTools);
   instrumentedPositionTrackingTools = withToolsMetrics(positionTrackingTools);
   instrumentedMemoryTools = withToolsMetrics(memoryTools);
@@ -1153279,6 +1154778,16 @@ 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",
+    search_dex_pairs: "Scanner",
+    get_boosted_tokens: "Scanner",
+    get_uniswap_pool_yields: "Analyst",
+    get_top_defi_yields: "Analyst",
     scan_base_whale_transfers: "Scanner",
     scan_base_volume_spikes: "Scanner",
     scan_base_new_tokens: "Scanner",
@@ -1155427,7 +1156936,7 @@ async function checkOrphanedOrders(exchange, activeTrades, result) {
 }
 
 // src/gateway/runtime/gateway-runtime.ts
-init_client13();
+init_client14();
 
 // src/gateway/scheduler/local-cron.ts
 init_logger2();
@@ -1156281,7 +1157790,7 @@ class ReconciliationLoop {
   }
 }
 // src/gateway/daemon/process.ts
-init_client13();
+init_client14();
 init_engine();
 var logger116 = createModuleLogger("gateway-daemon");
 async function startGatewayDaemonProcess() {
@@ -1162414,7 +1163923,7 @@ var import_react64 = __toESM(require_react(), 1);
 // package.json
 var package_default2 = {
   name: "@general-liquidity/gordon-cli",
-  version: "0.75.4",
+  version: "0.75.6",
   description: "The Frontier Trading Agent",
   author: "General Liquidity, Inc.",
   license: "MIT",
@@ -1164542,7 +1166051,7 @@ async function ensureThreadRegistered() {
 
 // src/infra/agents/index.ts
 init_memory3();
-init_client13();
+init_client14();
 init_reflection();
 
 // src/app/SetupWizard.tsx
@@ -1166459,7 +1167968,7 @@ function useTheme() {
 }
 
 // src/app/App.tsx
-init_client13();
+init_client14();
 init_llm();
 init_binance2();
 init_exchange();
@@ -1172691,7 +1174200,7 @@ async function checkForUpdates() {
 
 // src/index.tsx
 init_telemetry2();
-init_client13();
+init_client14();
 var jsx_dev_runtime26 = __toESM(require_jsx_dev_runtime(), 1);
 var flags = parseFlags();
 var command = parseCommand();