@general-liquidity/gordon-cli 0.75.4 → 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
   };
 }
@@ -196193,23 +196201,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 +197005,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 +197048,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 +197064,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 +197079,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 };
   }
@@ -196395,8 +197198,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 +197243,7 @@ class UniswapAdapter {
 }
 var init_uniswap2 = __esm(() => {
   init_uniswap();
+  init_subgraph();
   init_types10();
 });
 
@@ -196498,7 +197312,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}`);
@@ -1120715,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());
@@ -1127074,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();
@@ -1127125,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();
@@ -1127180,6 +1128338,7 @@ var init_tools3 = __esm(async () => {
     ...agentKitDefiTools,
     ...baseSignalTools,
     ...baseIndexerTools,
+    ...uniswapDataTools,
     ...multiModalChartTools,
     ...evalTools,
     ...positionTrackingTools,
@@ -1127226,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,
@@ -1150499,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,
@@ -1150542,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,
@@ -1150684,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,
@@ -1150796,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
@@ -1151443,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);
@@ -1153279,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",
@@ -1162414,7 +1163590,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.5",
   description: "The Frontier Trading Agent",
   author: "General Liquidity, Inc.",
   license: "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@general-liquidity/gordon-cli",
-  "version": "0.75.4",
+  "version": "0.75.5",
   "description": "The Frontier Trading Agent",
   "author": "General Liquidity, Inc.",
   "license": "MIT",