@continuumdao/ctm-mpc-defi 0.2.19 → 0.2.22

package/dist/protocols/evm/uniswap-v4/index.cjs

@@ -573,7 +573,7 @@ function finalizeMultisign(input) {
     batchMeta,
     ...input.extraJSON ?? {}
   };
-  const extraJSON = JSON.stringify(extraPayload);
+  const extraJSON = JSON.stringify(extraPayload, (_, v) => typeof v === "bigint" ? v.toString() : v);
   const bodyForSign = {
     keyList,
     pubKey: ph,
@@ -598,6 +598,9 @@ function finalizeMultisign(input) {
     bodyForSign.value = valueWei.toString();
   }
   if (clientId) bodyForSign.clientId = clientId;
+  if (input.expiryDate != null && input.expiryDate > 0) {
+    bodyForSign.expiryDate = Math.floor(input.expiryDate);
+  }
   return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
 }
 function routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimit) {
@@ -761,7 +764,8 @@ async function buildEvmMultisignBatch(args) {
     destinationChainID: String(chainId),
     destinationAddress: args.destinationAddress ?? steps[0].to,
     legs,
-    extraJSON: Object.keys(extraJSON).length > 0 ? extraJSON : void 0
+    extraJSON: Object.keys(extraJSON).length > 0 ? extraJSON : void 0,
+    expiryDate: context.expiryDate
   });
   const pv = args.payableValueWei;
   if (pv != null && pv > 0n) {
@@ -2578,6 +2582,662 @@ async function swapExactInput(args) {
   return swapFromQuote({ ...args, swap });
 }
 
+// src/core/defiProxy.ts
+async function postJsonViaOptionalProxy(args) {
+  const proxy = args.proxyUrl?.trim();
+  if (proxy) {
+    const r2 = await fetch(proxy, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(args.proxyEnvelope ?? args.body)
+    });
+    if (!r2.ok) {
+      const t = await r2.text().catch(() => "");
+      throw new Error(t ? `Proxy HTTP ${r2.status}: ${t.slice(0, 200)}` : `Proxy HTTP ${r2.status}`);
+    }
+    return await r2.json();
+  }
+  const r = await fetch(args.directUrl, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(args.body)
+  });
+  if (!r.ok) {
+    const t = await r.text().catch(() => "");
+    throw new Error(t ? `HTTP ${r.status}: ${t.slice(0, 200)}` : `HTTP ${r.status}`);
+  }
+  return await r.json();
+}
+
+// src/protocols/evm/uniswap-v4/theGraphApiKey.ts
+var THE_GRAPH_API_KEY_ENV = "THE_GRAPH_API_KEY";
+var THE_GRAPH_API_KEY_SIGNUP_URL = "https://thegraph.com/studio/apikeys/";
+var THE_GRAPH_API_KEY_DOCS_URL = "https://thegraph.com/docs/en/subgraphs/querying/managing-api-keys/";
+function isTheGraphRateLimitOrAuthError(message) {
+  const m = message.toLowerCase();
+  return m.includes("429") || m.includes("rate limit") || m.includes("too many requests") || m.includes("auth error") || m.includes("missing authorization") || m.includes("unauthorized");
+}
+function theGraphApiKeyVariablesHint() {
+  return [
+    `Set \`${THE_GRAPH_API_KEY_ENV}\` in Node \u2192 AI Agent \u2192 Variables (+ Add: paste the key as the value).`,
+    `Get a free API key at ${THE_GRAPH_API_KEY_SIGNUP_URL}`
+  ].join(" ");
+}
+function theGraphRateLimitErrorMessage(baseError) {
+  return `${baseError}
+
+The Graph rate limit or auth issue \u2014 ${theGraphApiKeyVariablesHint()}`;
+}
+
+// src/protocols/evm/uniswap-v4/subgraph.ts
+var UNISWAP_V4_SUBGRAPH_ID_BY_CHAIN_ID = {
+  1: "DiYPVdygkfjDWhbxGSqAQxwBKmfKnkWQojqeM2rkLb3G",
+  // Ethereum
+  10: "3Tn7Y1NJAr4ySKm7KFu1dwvH2WM3mHJnXzXAxQsdBDvW",
+  // Optimism
+  56: "2qQpC8inZPZL4tYfRQPFGZhsE8mYzE67n5z3Yf5uuKMu",
+  // BSC
+  130: "EoCvJ5tyMLMJcTnLQwWpjAtPdn74PcrZgzfcT5bYxNBH",
+  // Unichain
+  137: "CwpebM66AH5uqS5sreKij8yEkkPcHvmyEs7EwFtdM5ND",
+  // Polygon
+  8453: "HNCFA9TyBqpo5qpe6QreQABAA1kV8g46mhkCcicu6v2R",
+  // Base
+  81457: "FCHYK3Ab6bBnkfeCKRhFbs1Q8rX4yt6rKJibpDTC74ns",
+  // Blast
+  42161: "G5TsTKNi8yhPSV7kycaE23oWbqv9zzNqR49FoEQjzq1r",
+  // Arbitrum
+  43114: "49JxRo9FGxWpSf5Y5GKQPj5NUpX2HhpoZHpGzNEWQZjq"
+  // Avalanche
+};
+var SUBGRAPH_PAGE_SIZE = 1e3;
+function uniswapV4SubgraphIdForChain(chainId) {
+  return UNISWAP_V4_SUBGRAPH_ID_BY_CHAIN_ID[chainId];
+}
+function uniswapV4SubgraphSupportedChainIds() {
+  return Object.keys(UNISWAP_V4_SUBGRAPH_ID_BY_CHAIN_ID).map(Number).sort((a, b) => a - b);
+}
+function uniswapV4SubgraphUrlForChain(chainId, apiKey) {
+  const id = uniswapV4SubgraphIdForChain(chainId);
+  if (!id) {
+    throw new Error(
+      `Uniswap V4 subgraph is not configured for chainId ${chainId}. Supported: ${uniswapV4SubgraphSupportedChainIds().join(", ")}`
+    );
+  }
+  const key = apiKey?.trim();
+  if (key) {
+    return `https://gateway.thegraph.com/api/${key}/subgraphs/id/${id}`;
+  }
+  return `https://gateway.thegraph.com/api/subgraphs/id/${id}`;
+}
+function resolveTheGraphApiKey(override) {
+  const fromOverride = override?.trim();
+  if (fromOverride) return fromOverride;
+  const raw = process.env[THE_GRAPH_API_KEY_ENV]?.trim();
+  return raw || void 0;
+}
+async function postUniswapV4SubgraphGql(chainId, query, variables, theGraphApiKey) {
+  const url = uniswapV4SubgraphUrlForChain(chainId, resolveTheGraphApiKey(theGraphApiKey));
+  const body = { query, variables: variables ?? {} };
+  let j;
+  try {
+    j = await postJsonViaOptionalProxy({ directUrl: url, body });
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (isTheGraphRateLimitOrAuthError(msg)) {
+      throw new Error(theGraphRateLimitErrorMessage(msg));
+    }
+    throw e;
+  }
+  if (j.errors?.length) {
+    const msg = j.errors.map((e) => e.message ?? "GraphQL error").join("; ");
+    if (isTheGraphRateLimitOrAuthError(msg)) {
+      throw new Error(theGraphRateLimitErrorMessage(msg));
+    }
+    throw new Error(msg);
+  }
+  if (j.data == null) {
+    throw new Error("Uniswap V4 subgraph: empty response");
+  }
+  return j.data;
+}
+var POOL_HOUR_PAGE_GQL = `
+query UniswapV4PoolHourDatas($pool: String!, $from: Int!, $to: Int!, $first: Int!, $skip: Int!) {
+  poolHourDatas(
+    where: { pool: $pool, periodStartUnix_gte: $from, periodStartUnix_lt: $to }
+    orderBy: periodStartUnix
+    orderDirection: asc
+    first: $first
+    skip: $skip
+  ) {
+    periodStartUnix
+    open
+    high
+    low
+    close
+    volumeUSD
+  }
+}`;
+var POOL_DAY_PAGE_GQL = `
+query UniswapV4PoolDayDatas($pool: String!, $from: Int!, $to: Int!, $first: Int!, $skip: Int!) {
+  poolDayDatas(
+    where: { pool: $pool, date_gte: $from, date_lt: $to }
+    orderBy: date
+    orderDirection: asc
+    first: $first
+    skip: $skip
+  ) {
+    date
+    open
+    high
+    low
+    close
+    volumeUSD
+  }
+}`;
+var SWAPS_PAGE_GQL = `
+query UniswapV4Swaps($pool: String!, $from: BigInt!, $to: BigInt!, $first: Int!, $skip: Int!) {
+  swaps(
+    where: { pool: $pool, timestamp_gte: $from, timestamp_lt: $to }
+    orderBy: timestamp
+    orderDirection: asc
+    first: $first
+    skip: $skip
+  ) {
+    timestamp
+    amountUSD
+    token0Price
+    sqrtPriceX96
+  }
+}`;
+var POOL_META_GQL = `
+query UniswapV4PoolMeta($id: ID!) {
+  pool(id: $id) {
+    id
+    token0 { symbol }
+    token1 { symbol }
+  }
+}`;
+async function paginateSubgraphRows(fetchPage, maxPages) {
+  const rows = [];
+  for (let page = 0; page < maxPages; page++) {
+    const batch = await fetchPage(page * SUBGRAPH_PAGE_SIZE);
+    rows.push(...batch);
+    if (batch.length < SUBGRAPH_PAGE_SIZE) {
+      return { rows, truncated: false };
+    }
+  }
+  return { rows, truncated: true };
+}
+function normalizePoolId(poolReference) {
+  return poolReference.trim().toLowerCase();
+}
+async function fetchUniswapV4PoolHourDatas(args) {
+  const pool = normalizePoolId(args.poolReference);
+  const maxPages = args.maxPages ?? 20;
+  return paginateSubgraphRows(async (skip) => {
+    const data = await postUniswapV4SubgraphGql(args.chainId, POOL_HOUR_PAGE_GQL, {
+      pool,
+      from: args.fromSec,
+      to: args.toSec,
+      first: SUBGRAPH_PAGE_SIZE,
+      skip
+    });
+    return data.poolHourDatas ?? [];
+  }, maxPages);
+}
+async function fetchUniswapV4PoolDayDatas(args) {
+  const pool = normalizePoolId(args.poolReference);
+  const maxPages = args.maxPages ?? 20;
+  return paginateSubgraphRows(async (skip) => {
+    const data = await postUniswapV4SubgraphGql(args.chainId, POOL_DAY_PAGE_GQL, {
+      pool,
+      from: args.fromSec,
+      to: args.toSec,
+      first: SUBGRAPH_PAGE_SIZE,
+      skip
+    });
+    return data.poolDayDatas ?? [];
+  }, maxPages);
+}
+async function fetchUniswapV4Swaps(args) {
+  const pool = normalizePoolId(args.poolReference);
+  const maxPages = args.maxPages ?? 50;
+  return paginateSubgraphRows(async (skip) => {
+    const data = await postUniswapV4SubgraphGql(
+      args.chainId,
+      SWAPS_PAGE_GQL,
+      {
+        pool,
+        from: String(args.fromSec),
+        to: String(args.toSec),
+        first: SUBGRAPH_PAGE_SIZE,
+        skip
+      }
+    );
+    return data.swaps ?? [];
+  }, maxPages);
+}
+async function fetchUniswapV4PoolMeta(args) {
+  const id = normalizePoolId(args.poolReference);
+  const data = await postUniswapV4SubgraphGql(
+    args.chainId,
+    POOL_META_GQL,
+    { id }
+  );
+  return data.pool ?? null;
+}
+
+// src/protocols/evm/uniswap-v4/ohlcvInterval.ts
+var UNISWAP_V4_OHLCV_INTERVALS = [
+  "1m",
+  "5m",
+  "15m",
+  "30m",
+  "1h",
+  "2h",
+  "4h",
+  "6h",
+  "8h",
+  "12h",
+  "1d",
+  "2d",
+  "3d",
+  "1w",
+  "1M"
+];
+var INTERVAL_SECONDS = {
+  "1m": 60,
+  "5m": 300,
+  "15m": 900,
+  "30m": 1800,
+  "1h": 3600,
+  "2h": 7200,
+  "4h": 14400,
+  "6h": 21600,
+  "8h": 28800,
+  "12h": 43200,
+  "1d": 86400,
+  "2d": 172800,
+  "3d": 259200,
+  "1w": 604800,
+  "1M": 2592e3
+};
+function assertUniswapV4OhlcvInterval(interval) {
+  const normalized = interval.trim();
+  if (!UNISWAP_V4_OHLCV_INTERVALS.includes(normalized)) {
+    throw new Error(
+      `Invalid interval "${interval}". Valid: ${UNISWAP_V4_OHLCV_INTERVALS.join(", ")}`
+    );
+  }
+  return normalized;
+}
+function uniswapV4OhlcvIntervalToBucketSec(interval) {
+  return INTERVAL_SECONDS[interval];
+}
+function resolveUniswapV4OhlcvDataTier(intervalRaw) {
+  const interval = assertUniswapV4OhlcvInterval(intervalRaw);
+  const bucketSec = uniswapV4OhlcvIntervalToBucketSec(interval);
+  if (bucketSec === 3600) {
+    return { kind: "subgraph_native", entity: "hourly", bucketSec, interval };
+  }
+  if (bucketSec === 86400) {
+    return { kind: "subgraph_native", entity: "daily", bucketSec, interval };
+  }
+  if (bucketSec < 3600) {
+    return { kind: "swaps", bucketSec, interval };
+  }
+  if (bucketSec < 86400 && bucketSec % 3600 === 0) {
+    return { kind: "subgraph_aggregate", baseEntity: "hourly", bucketSec, interval };
+  }
+  if (bucketSec > 86400 && bucketSec % 86400 === 0) {
+    return { kind: "subgraph_aggregate", baseEntity: "daily", bucketSec, interval };
+  }
+  throw new Error(
+    `Interval "${interval}" is not supported for Uniswap V4 OHLCV routing. Valid: ${UNISWAP_V4_OHLCV_INTERVALS.join(", ")}`
+  );
+}
+
+// src/protocols/evm/uniswap-v4/swapCandles.ts
+function parseDecimal(raw) {
+  if (raw == null) return null;
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+function priceFromSwapRow(row) {
+  const fromToken0 = parseDecimal(row.token0Price);
+  if (fromToken0 != null) return fromToken0;
+  const sqrt = row.sqrtPriceX96?.trim();
+  if (!sqrt) return null;
+  try {
+    const sqrtPrice = BigInt(sqrt);
+    if (sqrtPrice <= 0n) return null;
+    const ratio = Number(sqrtPrice) / 2 ** 96;
+    const price = ratio * ratio;
+    return Number.isFinite(price) && price > 0 ? price : null;
+  } catch {
+    return null;
+  }
+}
+function bucketStartSec(timestampSec, bucketSec) {
+  return Math.floor(timestampSec / bucketSec) * bucketSec;
+}
+function bucketUniswapV4SwapsIntoCandles(args) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const swap of args.swaps) {
+    const ts = Number(swap.timestamp);
+    const price = priceFromSwapRow(swap);
+    if (!Number.isFinite(ts) || price == null) continue;
+    const bucket = bucketStartSec(Math.floor(ts), args.bucketSec);
+    const vol = parseDecimal(swap.amountUSD) ?? 0;
+    const existing = buckets.get(bucket);
+    if (!existing) {
+      buckets.set(bucket, { open: price, high: price, low: price, close: price, volume: vol });
+      continue;
+    }
+    existing.close = price;
+    if (price > existing.high) existing.high = price;
+    if (price < existing.low) existing.low = price;
+    existing.volume += vol;
+  }
+  return [...buckets.entries()].sort(([a], [b]) => a - b).map(([bucketSec, bar]) => ({
+    timestampMs: bucketSec * 1e3,
+    open: String(bar.open),
+    high: String(bar.high),
+    low: String(bar.low),
+    close: String(bar.close),
+    volume: bar.volume > 0 ? String(bar.volume) : void 0
+  }));
+}
+
+// src/protocols/evm/uniswap-v4/ohlcv.ts
+var MAX_CANDLES = 2e3;
+function invertCandleRow(row) {
+  const inv = (raw) => {
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n <= 0) return raw;
+    return String(1 / n);
+  };
+  const open = inv(row.open);
+  const close = inv(row.close);
+  const highRaw = Number(row.high);
+  const lowRaw = Number(row.low);
+  const high = Number.isFinite(highRaw) && Number.isFinite(lowRaw) && highRaw > 0 && lowRaw > 0 ? String(1 / Math.min(highRaw, lowRaw)) : inv(row.high);
+  const low = Number.isFinite(highRaw) && Number.isFinite(lowRaw) && highRaw > 0 && lowRaw > 0 ? String(1 / Math.max(highRaw, lowRaw)) : inv(row.low);
+  return {
+    timestampMs: row.timestampMs,
+    open,
+    high,
+    low,
+    close,
+    ...row.volume != null ? { volume: row.volume } : {}
+  };
+}
+function mapSubgraphHourRow(row) {
+  return {
+    timestampMs: row.periodStartUnix * 1e3,
+    open: row.open,
+    high: row.high,
+    low: row.low,
+    close: row.close,
+    volume: row.volumeUSD
+  };
+}
+function mapSubgraphDayRow(row) {
+  return {
+    timestampMs: row.date * 1e3,
+    open: row.open,
+    high: row.high,
+    low: row.low,
+    close: row.close,
+    volume: row.volumeUSD
+  };
+}
+function aggregateOhlcvCandles(bars, bucketSec) {
+  if (bars.length === 0) return [];
+  const buckets = /* @__PURE__ */ new Map();
+  for (const bar of bars) {
+    const bucketStart = Math.floor(bar.timestampMs / 1e3 / bucketSec) * bucketSec;
+    const list = buckets.get(bucketStart) ?? [];
+    list.push(bar);
+    buckets.set(bucketStart, list);
+  }
+  return [...buckets.entries()].sort(([a], [b]) => a - b).map(([bucketStartSec2, group]) => {
+    const sorted = [...group].sort((a, b) => a.timestampMs - b.timestampMs);
+    const first = sorted[0];
+    const last = sorted[sorted.length - 1];
+    let high = Number(first.high);
+    let low = Number(first.low);
+    let volume = 0;
+    for (const row of sorted) {
+      const h = Number(row.high);
+      const l = Number(row.low);
+      if (Number.isFinite(h) && h > high) high = h;
+      if (Number.isFinite(l) && l < low) low = l;
+      const v = row.volume != null ? Number(row.volume) : 0;
+      if (Number.isFinite(v)) volume += v;
+    }
+    return {
+      timestampMs: bucketStartSec2 * 1e3,
+      open: first.open,
+      high: String(high),
+      low: String(low),
+      close: last.close,
+      volume: volume > 0 ? String(volume) : void 0
+    };
+  });
+}
+function windowFromArgs(args) {
+  const nowMs = Date.now();
+  if (args.startTimeMs != null || args.endTimeMs != null) {
+    const endTimeMs = args.endTimeMs ?? nowMs;
+    const startTimeMs = args.startTimeMs ?? endTimeMs - 7 * 864e5;
+    if (startTimeMs >= endTimeMs) {
+      throw new Error("startTimeMs must be before endTimeMs.");
+    }
+    return { startTimeMs, endTimeMs };
+  }
+  if (args.lookbackHours != null) {
+    const hours = Math.max(1, Math.floor(args.lookbackHours));
+    return { startTimeMs: nowMs - hours * 36e5, endTimeMs: nowMs };
+  }
+  const days = args.lookbackDays ?? 7;
+  const lookbackDays = Math.max(1, Math.floor(days));
+  return { startTimeMs: nowMs - lookbackDays * 864e5, endTimeMs: nowMs };
+}
+function candleWindowFromRows(candles) {
+  if (candles.length === 0) return {};
+  let startTimeMs = candles[0].timestampMs;
+  let endTimeMs = candles[0].timestampMs;
+  for (const c of candles) {
+    if (c.timestampMs < startTimeMs) startTimeMs = c.timestampMs;
+    if (c.timestampMs > endTimeMs) endTimeMs = c.timestampMs;
+  }
+  return { startTimeMs, endTimeMs };
+}
+async function resolveUniswapV4OhlcvPool(args) {
+  const chainId = parseUniswapChainId(args.chainId);
+  if (args.poolPreset?.trim()) {
+    const preset = resolveUniswapV4LpPoolPreset({ chainId, presetId: args.poolPreset });
+    return {
+      poolReference: preset.poolReference,
+      pairLabel: preset.pairLabel,
+      token0Symbol: preset.token0Symbol,
+      token1Symbol: preset.token1Symbol
+    };
+  }
+  if (args.poolReference?.trim()) {
+    const poolReference = args.poolReference.trim();
+    let pairLabel = poolReference.slice(0, 10) + "\u2026";
+    let token0Symbol;
+    let token1Symbol;
+    try {
+      const meta = await fetchUniswapV4PoolMeta({ chainId, poolReference });
+      if (meta?.token0?.symbol && meta?.token1?.symbol) {
+        token0Symbol = meta.token0.symbol;
+        token1Symbol = meta.token1.symbol;
+        pairLabel = `${meta.token0.symbol}/${meta.token1.symbol}`;
+      }
+    } catch {
+    }
+    return { poolReference, pairLabel, token0Symbol, token1Symbol };
+  }
+  const existing = args.existingPool;
+  if (existing?.token0Address && existing?.token1Address) {
+    const resolved = resolveUniswapV4LpExistingPoolFromKey({
+      token0Address: existing.token0Address,
+      token1Address: existing.token1Address,
+      fee: existing.fee ?? 0,
+      tickSpacing: existing.tickSpacing ?? 60,
+      hooks: existing.hooks,
+      poolReference: existing.poolReference
+    });
+    const t0 = existing.token0Address;
+    const t1 = existing.token1Address;
+    return {
+      poolReference: resolved.poolReference,
+      pairLabel: `${t0.slice(0, 6)}\u2026/${t1.slice(0, 6)}\u2026`
+    };
+  }
+  throw new Error(
+    "Pool is required: pass poolPreset (from ctm_uniswap_v4_list_lp_pools), poolReference, or existingPool."
+  );
+}
+async function fetchFromSubgraphTier(args) {
+  const warnings = [];
+  if (args.tier.kind === "subgraph_native") {
+    if (args.tier.entity === "hourly") {
+      const { rows: rows2, truncated: truncated2 } = await fetchUniswapV4PoolHourDatas({
+        chainId: args.chainId,
+        poolReference: args.poolReference,
+        fromSec: args.fromSec,
+        toSec: args.toSec
+      });
+      if (truncated2) warnings.push("Hourly subgraph page limit reached; history may be truncated.");
+      return { candles: rows2.map(mapSubgraphHourRow), warnings };
+    }
+    const { rows, truncated } = await fetchUniswapV4PoolDayDatas({
+      chainId: args.chainId,
+      poolReference: args.poolReference,
+      fromSec: args.fromSec,
+      toSec: args.toSec
+    });
+    if (truncated) warnings.push("Daily subgraph page limit reached; history may be truncated.");
+    return { candles: rows.map(mapSubgraphDayRow), warnings };
+  }
+  if (args.tier.kind === "subgraph_aggregate") {
+    if (args.tier.baseEntity === "hourly") {
+      const { rows: rows2, truncated: truncated2 } = await fetchUniswapV4PoolHourDatas({
+        chainId: args.chainId,
+        poolReference: args.poolReference,
+        fromSec: args.fromSec,
+        toSec: args.toSec
+      });
+      if (truncated2) warnings.push("Hourly subgraph page limit reached before aggregation.");
+      const base2 = rows2.map(mapSubgraphHourRow);
+      return { candles: aggregateOhlcvCandles(base2, args.tier.bucketSec), warnings };
+    }
+    const { rows, truncated } = await fetchUniswapV4PoolDayDatas({
+      chainId: args.chainId,
+      poolReference: args.poolReference,
+      fromSec: args.fromSec,
+      toSec: args.toSec
+    });
+    if (truncated) warnings.push("Daily subgraph page limit reached before aggregation.");
+    const base = rows.map(mapSubgraphDayRow);
+    return { candles: aggregateOhlcvCandles(base, args.tier.bucketSec), warnings };
+  }
+  return { candles: [], warnings };
+}
+async function fetchFromSwapsTier(args) {
+  const warnings = [];
+  const { rows, truncated } = await fetchUniswapV4Swaps({
+    chainId: args.chainId,
+    poolReference: args.poolReference,
+    fromSec: args.fromSec,
+    toSec: args.toSec
+  });
+  if (truncated) {
+    warnings.push(
+      "Swap pagination limit reached; sub-hour candles may be incomplete. Try a shorter lookback or a coarser interval (1h+)."
+    );
+  }
+  if (rows.length === 0) {
+    warnings.push("No swaps found in the requested window for this pool.");
+  }
+  return {
+    candles: bucketUniswapV4SwapsIntoCandles({ swaps: rows, bucketSec: args.bucketSec }),
+    warnings
+  };
+}
+async function uniswapV4FetchOhlcv(args) {
+  const chainId = parseUniswapChainId(args.chainId);
+  const interval = assertUniswapV4OhlcvInterval(args.interval ?? "1h");
+  const tier = resolveUniswapV4OhlcvDataTier(interval);
+  const pool = await resolveUniswapV4OhlcvPool(args);
+  const { startTimeMs, endTimeMs } = windowFromArgs(args);
+  const fromSec = Math.floor(startTimeMs / 1e3);
+  const toSec = Math.ceil(endTimeMs / 1e3);
+  const expectedBars = Math.ceil((toSec - fromSec) / tier.bucketSec);
+  if (expectedBars > MAX_CANDLES) {
+    throw new Error(
+      `Requested window would produce ~${expectedBars} bars (max ${MAX_CANDLES}). Use a coarser interval or shorter lookback.`
+    );
+  }
+  let candles;
+  let warnings = [];
+  let dataSource;
+  let baseSubgraphEntity;
+  if (tier.kind === "swaps") {
+    const result = await fetchFromSwapsTier({
+      chainId,
+      poolReference: pool.poolReference,
+      bucketSec: tier.bucketSec,
+      fromSec,
+      toSec
+    });
+    candles = result.candles;
+    warnings = result.warnings;
+    dataSource = "swaps";
+  } else {
+    const result = await fetchFromSubgraphTier({
+      chainId,
+      poolReference: pool.poolReference,
+      tier,
+      fromSec,
+      toSec
+    });
+    candles = result.candles;
+    warnings = result.warnings;
+    dataSource = tier.kind;
+    if (tier.kind === "subgraph_aggregate") {
+      baseSubgraphEntity = tier.baseEntity;
+    }
+  }
+  const quoteToken = args.quoteToken ?? "token0";
+  if (quoteToken === "token1") {
+    candles = candles.map(invertCandleRow);
+  }
+  if (candles.length === 0 && warnings.length === 0) {
+    warnings.push("No candles returned for this pool and window.");
+  }
+  const window = candleWindowFromRows(candles);
+  return {
+    symbol: pool.pairLabel,
+    timeframe: interval,
+    chainId,
+    poolReference: pool.poolReference,
+    dataSource,
+    ...baseSubgraphEntity ? { baseSubgraphEntity } : {},
+    priceQuote: quoteToken === "token1" ? "token1PerToken0" : "token0PerToken1",
+    ...window,
+    candleCount: candles.length,
+    candles,
+    fetchedAtMs: Date.now(),
+    ...warnings.length > 0 ? { warnings } : {}
+  };
+}
+
 // src/protocols/evm/uniswap-v4/index.ts
 var UNISWAP_V4_PROTOCOL_ID = "uniswap-v4";
 var uniswapV4ProtocolModule = {
@@ -2695,6 +3355,9 @@ var uniswapV4 = {
 exports.MAX_UINT160 = MAX_UINT160;
 exports.MAX_UINT48 = MAX_UINT48;
 exports.PERMIT2_ADDRESS = PERMIT2_ADDRESS;
+exports.THE_GRAPH_API_KEY_DOCS_URL = THE_GRAPH_API_KEY_DOCS_URL;
+exports.THE_GRAPH_API_KEY_ENV = THE_GRAPH_API_KEY_ENV;
+exports.THE_GRAPH_API_KEY_SIGNUP_URL = THE_GRAPH_API_KEY_SIGNUP_URL;
 exports.UNISWAP_LP_API_BASE_DEFAULT = UNISWAP_LP_API_BASE_DEFAULT;
 exports.UNISWAP_LP_DEFAULT_DEADLINE_SEC_OFFSET = UNISWAP_LP_DEFAULT_DEADLINE_SEC_OFFSET;
 exports.UNISWAP_LP_DEFAULT_EXPIRY_MINUTES = UNISWAP_LP_DEFAULT_EXPIRY_MINUTES;
@@ -2714,8 +3377,13 @@ exports.UNISWAP_V4_LP_MINT_DEFAULT_GAS_UNITS = UNISWAP_V4_LP_MINT_DEFAULT_GAS_UN
 exports.UNISWAP_V4_LP_POOL_LOOKUP_HINT = UNISWAP_V4_LP_POOL_LOOKUP_HINT;
 exports.UNISWAP_V4_LP_POSITION_REGISTRY_HINT = UNISWAP_V4_LP_POSITION_REGISTRY_HINT;
 exports.UNISWAP_V4_LP_WETH_DEPOSIT_FALLBACK = UNISWAP_V4_LP_WETH_DEPOSIT_FALLBACK;
+exports.UNISWAP_V4_OHLCV_INTERVALS = UNISWAP_V4_OHLCV_INTERVALS;
 exports.UNISWAP_V4_PROTOCOL_ID = UNISWAP_V4_PROTOCOL_ID;
+exports.UNISWAP_V4_SUBGRAPH_ID_BY_CHAIN_ID = UNISWAP_V4_SUBGRAPH_ID_BY_CHAIN_ID;
+exports.aggregateOhlcvCandles = aggregateOhlcvCandles;
 exports.applySlippagePercentToApproveWei = applySlippagePercentToApproveWei;
+exports.assertUniswapV4OhlcvInterval = assertUniswapV4OhlcvInterval;
+exports.bucketUniswapV4SwapsIntoCandles = bucketUniswapV4SwapsIntoCandles;
 exports.buildEvmMultisignBodyUniswapV4CollectFeesBatch = buildEvmMultisignBodyUniswapV4CollectFeesBatch;
 exports.buildEvmMultisignBodyUniswapV4DecreaseLiquidityBatch = buildEvmMultisignBodyUniswapV4DecreaseLiquidityBatch;
 exports.buildEvmMultisignBodyUniswapV4IncreaseLiquidityBatch = buildEvmMultisignBodyUniswapV4IncreaseLiquidityBatch;
@@ -2730,6 +3398,10 @@ exports.errorMessageFromUniswapJsonBody = errorMessageFromUniswapJsonBody;
 exports.extractUniswapLpTokenAmounts = extractUniswapLpTokenAmounts;
 exports.extractUniswapLpTransaction = extractUniswapLpTransaction;
 exports.fetchEthereumAddressForKeyGen = fetchEthereumAddressForKeyGen;
+exports.fetchUniswapV4PoolDayDatas = fetchUniswapV4PoolDayDatas;
+exports.fetchUniswapV4PoolHourDatas = fetchUniswapV4PoolHourDatas;
+exports.fetchUniswapV4PoolMeta = fetchUniswapV4PoolMeta;
+exports.fetchUniswapV4Swaps = fetchUniswapV4Swaps;
 exports.formatUniswapAmountFieldFromWei = formatUniswapAmountFieldFromWei;
 exports.formatUniswapLpAmountHuman = formatUniswapLpAmountHuman;
 exports.formatUniswapPercentForUi = formatUniswapPercentForUi;
@@ -2741,6 +3413,7 @@ exports.getUniswapV4PositionManagerDeployBlock = getUniswapV4PositionManagerDepl
 exports.getUniswapV4PositionManagerOrThrow = getUniswapV4PositionManagerOrThrow;
 exports.isEthGetLogsBlockRangeTooLargeError = isEthGetLogsBlockRangeTooLargeError;
 exports.isNativeUniswapLpTokenAddress = isNativeUniswapLpTokenAddress;
+exports.isTheGraphRateLimitOrAuthError = isTheGraphRateLimitOrAuthError;
 exports.isUniswapFullQuoteResponseNativeIn = isUniswapFullQuoteResponseNativeIn;
 exports.isUniswapTokenInAddressNative = isUniswapTokenInAddressNative;
 exports.isUniswapV4ChainSupported = isUniswapV4ChainSupported;
@@ -2758,13 +3431,18 @@ exports.quoteSwap = quoteSwap;
 exports.readUniswapV4PositionInfoRaw = readUniswapV4PositionInfoRaw;
 exports.resolveBlockAtOrAfterUnixTime = resolveBlockAtOrAfterUnixTime;
 exports.resolveRouterSwapGasUnitsFromSignRequest = resolveRouterSwapGasUnitsFromSignRequest;
+exports.resolveTheGraphApiKey = resolveTheGraphApiKey;
 exports.resolveUniswapV4LpExistingPoolFromKey = resolveUniswapV4LpExistingPoolFromKey;
 exports.resolveUniswapV4LpPoolPreset = resolveUniswapV4LpPoolPreset;
+exports.resolveUniswapV4OhlcvDataTier = resolveUniswapV4OhlcvDataTier;
+exports.resolveUniswapV4OhlcvPool = resolveUniswapV4OhlcvPool;
 exports.resolveUniswapV4PositionScanFromDate = resolveUniswapV4PositionScanFromDate;
 exports.sortUniswapV4PoolCurrencies = sortUniswapV4PoolCurrencies;
 exports.swapExactInput = swapExactInput;
 exports.swapFromQuote = swapFromQuote;
 exports.swapTransactionDeadlineUnixFromExpiryMinutes = swapTransactionDeadlineUnixFromExpiryMinutes;
+exports.theGraphApiKeyVariablesHint = theGraphApiKeyVariablesHint;
+exports.theGraphRateLimitErrorMessage = theGraphRateLimitErrorMessage;
 exports.tryGetUniswapV4PositionManager = tryGetUniswapV4PositionManager;
 exports.uniswapCreateSwap = uniswapCreateSwap;
 exports.uniswapLpClaimFees = uniswapLpClaimFees;
@@ -2775,13 +3453,18 @@ exports.uniswapLpTxFieldForAction = uniswapLpTxFieldForAction;
 exports.uniswapQuoteToJsonQuoteOneLine = uniswapQuoteToJsonQuoteOneLine;
 exports.uniswapTradeQuote = uniswapTradeQuote;
 exports.uniswapV4 = uniswapV4;
+exports.uniswapV4FetchOhlcv = uniswapV4FetchOhlcv;
 exports.uniswapV4ListPositionsForMcp = uniswapV4ListPositionsForMcp;
 exports.uniswapV4ListPositionsFromRegistryForMcp = uniswapV4ListPositionsFromRegistryForMcp;
 exports.uniswapV4ListPositionsRegistryMcpPlaceholder = uniswapV4ListPositionsRegistryMcpPlaceholder;
 exports.uniswapV4ListStandardLpPools = uniswapV4ListStandardLpPools;
+exports.uniswapV4OhlcvIntervalToBucketSec = uniswapV4OhlcvIntervalToBucketSec;
 exports.uniswapV4PositionMintedTokenIdsFromReceipt = uniswapV4PositionMintedTokenIdsFromReceipt;
 exports.uniswapV4ProtocolModule = uniswapV4ProtocolModule;
 exports.uniswapV4RegisterPositionFromMintTxPlaceholder = uniswapV4RegisterPositionFromMintTxPlaceholder;
 exports.uniswapV4RegisterPositionNftPlaceholder = uniswapV4RegisterPositionNftPlaceholder;
+exports.uniswapV4SubgraphIdForChain = uniswapV4SubgraphIdForChain;
+exports.uniswapV4SubgraphSupportedChainIds = uniswapV4SubgraphSupportedChainIds;
+exports.uniswapV4SubgraphUrlForChain = uniswapV4SubgraphUrlForChain;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map