@continuumdao/ctm-mpc-defi 0.2.20 → 0.2.24

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

@@ -68,8 +68,18 @@ var UNIVERSAL_ROUTER_SPENDER = {
   143: "0x0d97dc33264bfc1c226207428a79b26757fb9dc3",
   59144: "0x661e93cca42afacb172121ef892830ca3b70f08d",
   4217: "0x1febb76be10aaf3a1402f04e8e835f2c382f7914",
-  196: "0x5507749f2c558bb3e162c6e90c314c092e7372ff"
+  196: "0x5507749f2c558bb3e162c6e90c314c092e7372ff",
+  /** Robinhood Chain mainnet — Universal Router v2.1.1 (Trade API / interface) */
+  4663: "0x8876789976decbfcbbbe364623c63652db8c0904"
 };
+var UNIVERSAL_ROUTER_VERSION_BY_CHAIN = {
+  /** Robinhood has UR 2.1.1 only in the supported-chains table (no 2.0 Trade API column). */
+  4663: "2.1.1"
+};
+function getUniswapUniversalRouterVersion(chainId) {
+  const v = UNIVERSAL_ROUTER_VERSION_BY_CHAIN[chainId];
+  return typeof v === "string" && v.trim() ? v.trim() : UNISWAP_UNIVERSAL_ROUTER_VERSION_DEFAULT;
+}
 function isUniswapV4ChainSupported(chainId) {
   if (chainId == null) return false;
   const n = parseEvmChainIdToNumber(chainId);
@@ -106,8 +116,12 @@ var POSITION_MANAGER_BY_CHAIN = {
   11155111: "0x4B2C77d209D3405F41a037Ec6c77F7F5b8e2ca80",
   130: "0x0d97dc33264bfc1c226207428a79b26757fb9dc3",
   1868: "0x0e2850543f69f678257266e0907ff9a58b3f13de",
-  59144: "0x661e93cca42afacb172121ef892830ca3b70f08d"
+  59144: "0x661e93cca42afacb172121ef892830ca3b70f08d",
+  /** Robinhood Chain mainnet */
+  4663: "0x58daec3116aae6D93017bAAea7749052E8a04fA7"
 };
+var ROBINHOOD_CHAIN_ID = 4663;
+var ROBINHOOD_WETH_ADDRESS = "0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73";
 function getUniswapV4PositionManagerOrThrow(chainId) {
   const raw = POSITION_MANAGER_BY_CHAIN[chainId];
   if (!raw || !raw.startsWith("0x") || raw.length !== 42) {
@@ -160,8 +174,8 @@ function parseUniswapChainId(value) {
 function trimAddr(a) {
   return a.trim();
 }
-function isUniswapTokenInAddressNative(tokenIn) {
-  const t = (tokenIn ?? "").toString().trim();
+function isUniswapNativeTokenAddress(token) {
+  const t = (token ?? "").toString().trim();
   if (!t) return false;
   try {
     return viem.getAddress(t) === viem.zeroAddress;
@@ -169,6 +183,9 @@ function isUniswapTokenInAddressNative(tokenIn) {
     return t.toLowerCase() === "0x0000000000000000000000000000000000000000";
   }
 }
+function isUniswapTokenInAddressNative(tokenIn) {
+  return isUniswapNativeTokenAddress(tokenIn);
+}
 function isUniswapFullQuoteResponseNativeIn(stored) {
   if (!stored) return false;
   const q = stored.quote;
@@ -176,7 +193,16 @@ function isUniswapFullQuoteResponseNativeIn(stored) {
   const input = q.input;
   if (!input) return false;
   const raw = (input.address ?? input.token ?? "").toString().trim();
-  return isUniswapTokenInAddressNative(raw);
+  return isUniswapNativeTokenAddress(raw);
+}
+function isUniswapFullQuoteResponseNativeOut(stored) {
+  if (!stored) return false;
+  const q = stored.quote;
+  if (!q || typeof q !== "object" || Array.isArray(q)) return false;
+  const output = q.output;
+  if (!output) return false;
+  const raw = (output.address ?? output.token ?? "").toString().trim();
+  return isUniswapNativeTokenAddress(raw);
 }
 async function fetchEthereumAddressForKeyGen(managementNodeUrl, keyGenId, readAuth = { bearerOnGet: true, jwt: null }, init) {
   const base = managementNodeUrl.trim().replace(/\/$/, "");
@@ -238,6 +264,31 @@ function buildUniswapQuoteRequestBody(args) {
   }
   return body;
 }
+function resolveChainIdFromStoredUniswapQuote(stored) {
+  if (!stored) return 0;
+  const top = stored;
+  for (const key of ["tokenInChainId", "chainId"]) {
+    const raw = top[key];
+    if (raw != null && String(raw).trim() !== "") {
+      try {
+        return parseUniswapChainId(raw);
+      } catch {
+      }
+    }
+  }
+  const q = top.quote;
+  if (q && typeof q === "object" && !Array.isArray(q)) {
+    const input = q.input;
+    const chain = input?.chainId;
+    if (chain != null && String(chain).trim() !== "") {
+      try {
+        return parseUniswapChainId(chain);
+      } catch {
+      }
+    }
+  }
+  return 0;
+}
 function errorMessageFromUniswapJsonBody(value) {
   if (value == null) return null;
   if (typeof value === "string") {
@@ -350,16 +401,18 @@ async function uniswapTradeQuote(args) {
   }
   const base = args.baseUrl && args.baseUrl.trim() ? args.baseUrl.trim().replace(/\/$/, "") : DEFAULT_TRADE_BASE;
   const quoteUrl = `${base}/quote`;
-  const urv = args.universalRouterVersion && args.universalRouterVersion.trim() || "2.0";
+  const chainIdForRouter = parseUniswapChainId(resolveInputChainId(args));
+  const urv = args.universalRouterVersion && args.universalRouterVersion.trim() || getUniswapUniversalRouterVersion(chainIdForRouter);
   const body = buildUniswapQuoteRequestBody({ ...args, swapper });
-  const nativeIn = isUniswapTokenInAddressNative(args.tokenIn);
+  const nativeIn = isUniswapNativeTokenAddress(args.tokenIn);
+  const nativeOut = isUniswapNativeTokenAddress(args.tokenOut);
   const headers = {
     ...UNISWAP_QUOTE_HEADERS_BASE,
     "x-api-key": apiKey,
     "x-universal-router-version": urv,
     "x-permit2-disabled": args.permit2Disabled === true ? "true" : "false",
-    /** Native (0x0) as token in: Trade API needs this for classic routes and payable /swap. */
-    "x-erc20eth-enabled": nativeIn ? "true" : "false"
+    /** Native (0x0) in or out: enables ERC20↔ETH routes (incl. UniswapX on Robinhood). */
+    "x-erc20eth-enabled": nativeIn || nativeOut ? "true" : "false"
   };
   const fetchFn = args.fetchImpl ?? globalThis.fetch;
   const res = await fetchFn(quoteUrl, {
@@ -370,7 +423,11 @@ async function uniswapTradeQuote(args) {
   });
   const text = await res.text();
   if (!res.ok) {
-    throw new Error(messageFromUniswapHttpResponseBody(text, res.status, res.statusText));
+    let msg = messageFromUniswapHttpResponseBody(text, res.status, res.statusText);
+    if (res.status === 404 && chainIdForRouter === 4663) {
+      msg += " On Robinhood Chain, confirm USDG is 0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168, use Native ETH or WETH (0x0Bd7\u2026) as output, and try at least ~$300 notional (UniswapX minimum).";
+    }
+    throw new Error(msg);
   }
   const forParse = text.replace(/^\uFEFF/, "");
   try {
@@ -598,6 +655,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 +821,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) {
@@ -930,16 +991,17 @@ async function uniswapCreateSwap(args) {
     quote: classic,
     deadline
   };
-  const urv = (args.universalRouterVersion ?? UNISWAP_UNIVERSAL_ROUTER_VERSION_DEFAULT).trim() || "2.0";
+  const urv = (args.universalRouterVersion ?? "").trim() || getUniswapUniversalRouterVersion(resolveChainIdFromStoredUniswapQuote(args.fullQuoteFromPermit));
   const fn = args.fetchImpl ?? globalThis.fetch;
   const nativeIn = isUniswapFullQuoteResponseNativeIn(args.fullQuoteFromPermit);
+  const nativeOut = isUniswapFullQuoteResponseNativeOut(args.fullQuoteFromPermit);
   const res = await fn(url, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
       "x-api-key": args.uniswapApiKey.trim(),
       "x-universal-router-version": urv,
-      "x-erc20eth-enabled": nativeIn ? "true" : "false",
+      "x-erc20eth-enabled": nativeIn || nativeOut ? "true" : "false",
       "x-permit2-disabled": "true"
     },
     body: JSON.stringify(body)
@@ -2578,6 +2640,1271 @@ 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 uniswapV4OhlcvSupportedChainIds() {
+  const ids = new Set(uniswapV4SubgraphSupportedChainIds());
+  ids.add(4663);
+  return [...ids].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/bitqueryApiKey.ts
+var BITQUERY_API_KEY_ENV = "BITQUERY_API_KEY";
+var BITQUERY_API_KEY_SIGNUP_URL = "https://account.bitquery.io/";
+var BITQUERY_API_KEY_DOCS_URL = "https://bitquery.io/blockchains/robinhood-chain-api";
+var BITQUERY_GRAPHQL_URL = "https://graphql.bitquery.io";
+function resolveBitqueryApiKey(override) {
+  const fromOverride = override?.trim();
+  if (fromOverride) return fromOverride;
+  const raw = process.env[BITQUERY_API_KEY_ENV]?.trim();
+  return raw || void 0;
+}
+function isBitqueryAuthOrRateLimitError(message) {
+  const m = message.toLowerCase();
+  const mentionsBitquery = m.includes("bitquery") || m.includes("bitquery_api_key") || m.includes("robinhood chain ohlcv");
+  if (!mentionsBitquery) return false;
+  return m.includes("429") || m.includes("rate limit") || m.includes("too many requests") || m.includes("auth") || m.includes("unauthorized") || m.includes("forbidden") || m.includes("api key") || m.includes("access token") || m.includes("required");
+}
+function bitqueryApiKeyVariablesHint() {
+  return [
+    `Set \`${BITQUERY_API_KEY_ENV}\` in Node \u2192 AI Agent \u2192 Variables (+ Add: paste the key as the value).`,
+    `Get an API key at ${BITQUERY_API_KEY_SIGNUP_URL}`
+  ].join(" ");
+}
+function bitqueryAuthErrorMessage(baseError) {
+  return `${baseError}
+
+Bitquery auth or rate limit \u2014 ${bitqueryApiKeyVariablesHint()}`;
+}
+function requireBitqueryApiKey(override) {
+  const key = resolveBitqueryApiKey(override);
+  if (!key) {
+    throw new Error(
+      `Bitquery API key is required for Robinhood Chain OHLCV. ${bitqueryApiKeyVariablesHint()}`
+    );
+  }
+  return key;
+}
+
+// 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/bitqueryOhlcv.ts
+function intervalToBitquerySpec(interval) {
+  const bucketSec = uniswapV4OhlcvIntervalToBucketSec(interval);
+  if (bucketSec < 3600) {
+    return { count: Math.max(1, Math.floor(bucketSec / 60)), in: "minutes" };
+  }
+  if (bucketSec < 86400) {
+    return { count: Math.max(1, Math.floor(bucketSec / 3600)), in: "hours" };
+  }
+  return { count: Math.max(1, Math.floor(bucketSec / 86400)), in: "days" };
+}
+function parseIsoOrUnixToMs(raw) {
+  if (raw == null) return null;
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return raw > 1e12 ? raw : raw * 1e3;
+  }
+  const s = String(raw).trim();
+  if (!s) return null;
+  if (/^\d+$/.test(s)) {
+    const n = Number(s);
+    return n > 1e12 ? n : n * 1e3;
+  }
+  const ms = Date.parse(s);
+  return Number.isFinite(ms) ? ms : null;
+}
+function numToString(raw) {
+  if (raw == null) return null;
+  const n = typeof raw === "number" ? raw : Number(String(raw).trim());
+  if (!Number.isFinite(n)) return null;
+  return String(n);
+}
+function mapBitqueryOhlcvRowsToCandles(rows) {
+  const out = [];
+  for (const row of rows) {
+    const timestampMs = parseIsoOrUnixToMs(row.Block?.Time);
+    if (timestampMs == null) continue;
+    const open = numToString(row.Trade?.open);
+    const high = numToString(row.Trade?.high);
+    const low = numToString(row.Trade?.low);
+    const close = numToString(row.Trade?.close);
+    if (open == null || high == null || low == null || close == null) continue;
+    const volume = numToString(row.volumeUsd) ?? numToString(row.volume) ?? void 0;
+    out.push({
+      timestampMs,
+      open,
+      high,
+      low,
+      close,
+      ...volume != null ? { volume } : {}
+    });
+  }
+  return out.sort((a, b) => a.timestampMs - b.timestampMs);
+}
+function buildCurrencyWhere(filter) {
+  if (filter.kind === "symbol") {
+    const symbol = filter.symbol.trim().replace(/"/g, "");
+    return `Currency: { Symbol: { is: "${symbol}" } }`;
+  }
+  const address = viem.getAddress(filter.address).toLowerCase();
+  return `Currency: { SmartContract: { is: "${address}" } }`;
+}
+function buildBitqueryOhlcvQuery(args) {
+  const spec = intervalToBitquerySpec(args.interval);
+  const currencyWhere = buildCurrencyWhere(args.filter);
+  return `query RobinhoodUniswapOhlcv {
+  EVM(network: robinhood) {
+    DEXTradeByTokens(
+      limit: { count: ${args.limit} }
+      orderBy: { ascendingByField: "Block_Time" }
+      where: {
+        TransactionStatus: { Success: true }
+        Trade: {
+          Dex: { ProtocolName: { is: "uniswap_v4" } }
+          ${currencyWhere}
+        }
+        Block: { Time: { since: "${args.sinceIso}", till: "${args.tillIso}" } }
+      }
+    ) {
+      Block { Time(interval: { count: ${spec.count}, in: ${spec.in} }) }
+      Trade {
+        open: PriceInUSD(minimum: Block_Number)
+        high: PriceInUSD(maximum: Trade_PriceInUSD)
+        low: PriceInUSD(minimum: Trade_PriceInUSD)
+        close: PriceInUSD(maximum: Block_Number)
+      }
+      volumeUsd: sum(of: Trade_Side_AmountInUSD)
+    }
+  }
+}`;
+}
+function isRobinhoodOhlcvChain(chainId) {
+  return chainId === ROBINHOOD_CHAIN_ID;
+}
+function resolveRobinhoodChartCurrency(args) {
+  const symbol = args.currencySymbol?.trim();
+  if (symbol) return { kind: "symbol", symbol };
+  const direct = args.currencyAddress?.trim();
+  if (direct && direct.startsWith("0x")) {
+    return { kind: "address", address: viem.getAddress(direct) };
+  }
+  const weth = ROBINHOOD_WETH_ADDRESS.toLowerCase();
+  const zero = viem.zeroAddress.toLowerCase();
+  const candidates = [args.tokenOut, args.tokenIn].map((a) => a?.trim()).filter((a) => Boolean(a && a.startsWith("0x"))).map((a) => viem.getAddress(a));
+  const nonWeth = candidates.find((a) => {
+    const lower = a.toLowerCase();
+    return lower !== weth && lower !== zero;
+  });
+  if (nonWeth) return { kind: "address", address: nonWeth };
+  if (candidates[0]) return { kind: "address", address: candidates[0] };
+  throw new Error(
+    "Robinhood OHLCV requires currencyAddress, currencySymbol, or tokenIn/tokenOut (existingPool)."
+  );
+}
+function currencyFilterLabel(filter) {
+  if (filter.kind === "symbol") return filter.symbol.toUpperCase();
+  return `${filter.address.slice(0, 6)}\u2026${filter.address.slice(-4)}`;
+}
+async function fetchRobinhoodBitqueryOhlcv(args) {
+  const interval = assertUniswapV4OhlcvInterval(args.interval);
+  const apiKey = requireBitqueryApiKey(args.apiKey);
+  const limit = Math.max(1, Math.min(1e3, Math.floor(args.limit ?? 500)));
+  const sinceIso = new Date(args.startTimeMs).toISOString();
+  const tillIso = new Date(args.endTimeMs).toISOString();
+  const query = buildBitqueryOhlcvQuery({
+    filter: args.filter,
+    interval,
+    sinceIso,
+    tillIso,
+    limit
+  });
+  let json;
+  try {
+    const res = await fetch(BITQUERY_GRAPHQL_URL, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({ query })
+    });
+    const text = await res.text();
+    if (!res.ok) {
+      const msg = text ? `Bitquery HTTP ${res.status}: ${text.slice(0, 300)}` : `Bitquery HTTP ${res.status}`;
+      throw new Error(
+        isBitqueryAuthOrRateLimitError(msg) ? bitqueryAuthErrorMessage(msg) : msg
+      );
+    }
+    json = JSON.parse(text);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (isBitqueryAuthOrRateLimitError(msg) && !msg.includes(BITQUERY_GRAPHQL_URL)) {
+      throw new Error(bitqueryAuthErrorMessage(msg));
+    }
+    throw e instanceof Error ? e : new Error(msg);
+  }
+  if (json.errors?.length) {
+    const msg = json.errors.map((e) => e.message ?? "GraphQL error").join("; ");
+    throw new Error(
+      isBitqueryAuthOrRateLimitError(msg) ? bitqueryAuthErrorMessage(msg) : `Bitquery GraphQL: ${msg}`
+    );
+  }
+  const rows = json.data?.EVM?.DEXTradeByTokens ?? [];
+  const candles = mapBitqueryOhlcvRowsToCandles(rows);
+  const warnings = [];
+  if (candles.length === 0) {
+    warnings.push("No Bitquery Uniswap v4 candles for this token and window on Robinhood Chain.");
+  }
+  if (rows.length >= limit) {
+    warnings.push("Bitquery row limit reached; history may be truncated. Shorten lookback or coarsen interval.");
+  }
+  return { candles, warnings };
+}
+
+// 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 { startTimeMs, endTimeMs } = windowFromArgs(args);
+  const fromSec = Math.floor(startTimeMs / 1e3);
+  const toSec = Math.ceil(endTimeMs / 1e3);
+  if (isRobinhoodOhlcvChain(chainId)) {
+    const filter = resolveRobinhoodChartCurrency({
+      currencyAddress: args.currencyAddress,
+      currencySymbol: args.currencySymbol,
+      tokenIn: args.existingPool?.token0Address,
+      tokenOut: args.existingPool?.token1Address
+    });
+    const { candles: candles2, warnings: warnings2 } = await fetchRobinhoodBitqueryOhlcv({
+      filter,
+      interval,
+      startTimeMs,
+      endTimeMs
+    });
+    const label = currencyFilterLabel(filter);
+    const window2 = candleWindowFromRows(candles2);
+    return {
+      symbol: label,
+      timeframe: interval,
+      chainId,
+      poolReference: filter.kind === "address" ? filter.address.toLowerCase() : `symbol:${filter.symbol}`,
+      dataSource: "bitquery",
+      priceQuote: "token0PerToken1",
+      ...window2,
+      candleCount: candles2.length,
+      candles: candles2,
+      fetchedAtMs: Date.now(),
+      ...warnings2.length > 0 ? { warnings: warnings2 } : {}
+    };
+  }
+  const tier = resolveUniswapV4OhlcvDataTier(interval);
+  const pool = await resolveUniswapV4OhlcvPool(args);
+  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/limitOrder.ts
+function trimAddr3(a) {
+  return a.trim();
+}
+var UNISWAP_LIMIT_ORDER_CHAIN_ID = 1;
+var DEFAULT_UNISWAPX_ORDER_BASE = "https://api.uniswap.org/v2";
+var DEFAULT_LIMIT_ORDER_QUOTE_PATH = "/limit_order_quote";
+var DEFAULT_ORDER_SUBMIT_PATH = "/order";
+var UNISWAP_QUOTE_HEADERS_BASE2 = {
+  "Content-Type": "application/json",
+  "User-Agent": "ctm-mpc-defi uniswapLimitOrderQuote/1.0 (TS)"
+};
+function isUniswapLimitOrderChainSupported(chainId) {
+  return parseUniswapChainId(chainId) === UNISWAP_LIMIT_ORDER_CHAIN_ID;
+}
+function assertUniswapLimitOrderChain(chainId) {
+  if (!isUniswapLimitOrderChainSupported(chainId)) {
+    throw new Error(
+      `UniswapX limit orders are only supported on Ethereum mainnet (chainId ${UNISWAP_LIMIT_ORDER_CHAIN_ID}). Got ${chainId}. Use market swap on this chain or wait for UniswapX limit support.`
+    );
+  }
+}
+function inferPrimaryTypeFromPermitTypes(types) {
+  for (const key of Object.keys(types)) {
+    if (key !== "EIP712Domain") {
+      return key;
+    }
+  }
+  throw new Error("permitData.types missing primaryType (no non-EIP712Domain entry)");
+}
+function permitDataToEip712Payload(permitData) {
+  const domain = permitData.domain;
+  const types = permitData.types;
+  const message = permitData.values ?? permitData.message;
+  if (domain == null || typeof domain !== "object" || Array.isArray(domain)) {
+    throw new Error("limit order quote: permitData.domain missing");
+  }
+  if (types == null || typeof types !== "object" || Array.isArray(types)) {
+    throw new Error("limit order quote: permitData.types missing");
+  }
+  if (message == null || typeof message !== "object" || Array.isArray(message)) {
+    throw new Error("limit order quote: permitData.values (message) missing");
+  }
+  const primaryType = typeof permitData.primaryType === "string" && permitData.primaryType.trim() ? permitData.primaryType.trim() : inferPrimaryTypeFromPermitTypes(
+    types
+  );
+  return {
+    domain,
+    types,
+    primaryType,
+    message
+  };
+}
+function extractPermitDataFromLimitQuote(quoteResponse) {
+  const permitData = quoteResponse.permitData;
+  if (permitData == null) return null;
+  if (typeof permitData !== "object" || Array.isArray(permitData)) {
+    throw new Error("limit order quote: permitData is not an object");
+  }
+  return permitData;
+}
+function buildLimitOrderQuoteRequestBody(args) {
+  const base = buildUniswapQuoteRequestBody({
+    type: args.type,
+    amount: args.amount,
+    tokenIn: args.tokenIn,
+    tokenOut: args.tokenOut,
+    chainId: args.chainId,
+    tokenInChainId: args.tokenInChainId,
+    tokenOutChainId: args.tokenOutChainId,
+    swapper: args.swapper
+  });
+  assertUniswapLimitOrderChain(base.tokenInChainId);
+  return {
+    ...base,
+    limitPrice: String(args.limitPrice).trim(),
+    orderDeadline: args.orderDeadline
+  };
+}
+async function uniswapLimitOrderQuote(args) {
+  const apiKey = (args.uniswapApiKey || "").trim();
+  if (!apiKey) {
+    throw new Error("uniswapApiKey (x-api-key) is required");
+  }
+  let swapper;
+  if ((args.swapper || "").trim()) {
+    swapper = trimAddr3(args.swapper);
+  } else {
+    const keyGen = (args.keyGen || "").trim();
+    if (!keyGen) {
+      throw new Error("keyGen is required when swapper is not provided");
+    }
+    const mpc = (args.managementNodeUrl || "").trim();
+    if (!mpc) {
+      throw new Error("managementNodeUrl is required when swapper is not provided (to resolve keyGen)");
+    }
+    swapper = await fetchEthereumAddressForKeyGen(
+      mpc,
+      keyGen,
+      args.nodeReadAuth ?? { bearerOnGet: true, jwt: null }
+    );
+  }
+  const chainIdForGuard = parseUniswapChainId(resolveInputChainId(args));
+  assertUniswapLimitOrderChain(chainIdForGuard);
+  const base = args.baseUrl && args.baseUrl.trim() ? args.baseUrl.trim().replace(/\/$/, "") : "https://trade-api.gateway.uniswap.org/v1";
+  const quoteUrl = `${base}${DEFAULT_LIMIT_ORDER_QUOTE_PATH}`;
+  const body = buildLimitOrderQuoteRequestBody({ ...args, swapper });
+  const headers = {
+    ...UNISWAP_QUOTE_HEADERS_BASE2,
+    "x-api-key": apiKey
+  };
+  const fetchFn = args.fetchImpl ?? globalThis.fetch;
+  const res = await fetchFn(quoteUrl, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+    signal: args.signal
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(messageFromUniswapHttpResponseBody(text, res.status, res.statusText));
+  }
+  const forParse = text.replace(/^\uFEFF/, "");
+  try {
+    return JSON.parse(forParse);
+  } catch {
+    throw new Error(
+      `Limit order quote: ${messageFromUniswapHttpResponseBody(text, res.status, res.statusText)}`
+    );
+  }
+}
+function buildUniswapXLimitOrderSubmitBody(args) {
+  const quote = args.quoteResponse.quote;
+  if (quote == null || typeof quote !== "object" || Array.isArray(quote)) {
+    throw new Error("limit order submit: quoteResponse.quote missing");
+  }
+  const routing = typeof args.quoteResponse.routing === "string" && args.quoteResponse.routing.trim() ? args.quoteResponse.routing.trim() : "LIMIT_ORDER";
+  const chainId = args.quoteResponse.chainId ?? quote.chainId ?? UNISWAP_LIMIT_ORDER_CHAIN_ID;
+  const quoteId = typeof args.quoteResponse.quoteId === "string" ? args.quoteResponse.quoteId : void 0;
+  const requestId = typeof args.quoteResponse.requestId === "string" ? args.quoteResponse.requestId : void 0;
+  return {
+    signature: args.signatureHex.startsWith("0x") ? args.signatureHex : `0x${args.signatureHex}`,
+    quote,
+    chainId: parseUniswapChainId(chainId),
+    orderType: "Limit",
+    routing,
+    ...quoteId ? { quoteId } : {},
+    ...requestId ? { requestId } : {}
+  };
+}
+async function submitUniswapXLimitOrder(args) {
+  const apiKey = (args.uniswapApiKey || "").trim();
+  if (!apiKey) {
+    throw new Error("uniswapApiKey (x-api-key) is required");
+  }
+  const base = args.baseUrl && args.baseUrl.trim() ? args.baseUrl.trim().replace(/\/$/, "") : "https://trade-api.gateway.uniswap.org/v1";
+  const orderUrl = `${base}${DEFAULT_ORDER_SUBMIT_PATH}`;
+  const fetchFn = args.fetchImpl ?? globalThis.fetch;
+  const res = await fetchFn(orderUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey,
+      "User-Agent": "ctm-mpc-defi uniswapLimitOrderSubmit/1.0 (TS)"
+    },
+    body: JSON.stringify(args.submitBody)
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(messageFromUniswapHttpResponseBody(text, res.status, res.statusText));
+  }
+  const forParse = text.replace(/^\uFEFF/, "");
+  try {
+    return JSON.parse(forParse);
+  } catch {
+    throw new Error(
+      `Limit order submit: ${messageFromUniswapHttpResponseBody(text, res.status, res.statusText)}`
+    );
+  }
+}
+async function fetchUniswapXLimitOrders(args) {
+  const chainId = args.chainId ?? UNISWAP_LIMIT_ORDER_CHAIN_ID;
+  assertUniswapLimitOrderChain(chainId);
+  const base = args.baseUrl && args.baseUrl.trim() ? args.baseUrl.trim().replace(/\/$/, "") : DEFAULT_UNISWAPX_ORDER_BASE;
+  const params = new URLSearchParams({
+    chainId: String(chainId),
+    swapper: trimAddr3(args.swapper)
+  });
+  if (args.limit != null && args.limit > 0) {
+    params.set("limit", String(Math.floor(args.limit)));
+  }
+  const url = `${base}/limit-orders?${params.toString()}`;
+  const headers = {
+    Accept: "application/json",
+    "User-Agent": "ctm-mpc-defi uniswapLimitOrdersList/1.0 (TS)"
+  };
+  const apiKey = (args.uniswapApiKey || "").trim();
+  if (apiKey) {
+    headers["x-api-key"] = apiKey;
+  }
+  const fetchFn = args.fetchImpl ?? globalThis.fetch;
+  const res = await fetchFn(url, { method: "GET", headers });
+  const text = await res.text();
+  if (!res.ok) {
+    const parsed = (() => {
+      try {
+        return JSON.parse(text);
+      } catch {
+        return null;
+      }
+    })();
+    const msg = errorMessageFromUniswapJsonBody(parsed) ?? (text.trim() || res.statusText);
+    throw new Error(`List limit orders HTTP ${res.status}: ${msg}`);
+  }
+  return JSON.parse(text.replace(/^\uFEFF/, ""));
+}
+async function uniswapFetchLimitOrdersMcp(args) {
+  let swapper;
+  if ((args.swapper || "").trim()) {
+    swapper = trimAddr3(args.swapper);
+  } else {
+    const keyGen = (args.keyGen || "").trim();
+    if (!keyGen) {
+      throw new Error("swapper or keyGen is required");
+    }
+    const mpc = (args.managementNodeUrl || "").trim();
+    if (!mpc) {
+      throw new Error("managementNodeUrl is required when swapper is not provided");
+    }
+    swapper = await fetchEthereumAddressForKeyGen(
+      mpc,
+      keyGen,
+      args.nodeReadAuth ?? { bearerOnGet: true, jwt: null }
+    );
+  }
+  return fetchUniswapXLimitOrders({
+    swapper,
+    chainId: args.chainId,
+    uniswapApiKey: args.uniswapApiKey,
+    limit: args.limit,
+    baseUrl: args.baseUrl,
+    fetchImpl: args.fetchImpl
+  });
+}
+var EIP712_SIGN_REQUEST_KIND = "eip712";
+function msgHashNo0x(digest) {
+  return digest.startsWith("0x") ? digest.slice(2) : digest;
+}
+function eip712SignatureText(domain, primaryType) {
+  return JSON.stringify({
+    kind: "EIP-712",
+    ...typeof domain.name === "string" ? { name: domain.name } : {},
+    primaryType
+  });
+}
+function jsonStringifyForAudit(value) {
+  return JSON.stringify(value, (_, v) => typeof v === "bigint" ? v.toString() : v);
+}
+function eip712MsgRawHex(typedData, delivery) {
+  const envelope = {
+    version: 1,
+    ...typedData,
+    delivery
+  };
+  return viem.stringToHex(jsonStringifyForAudit(envelope));
+}
+function buildEip712MultisignBody(args) {
+  const { typedData, delivery } = args;
+  const digest = viem.hashTypedData({
+    domain: typedData.domain,
+    types: typedData.types,
+    primaryType: typedData.primaryType,
+    message: typedData.message
+  });
+  const extraJSON = {
+    signRequestKind: EIP712_SIGN_REQUEST_KIND,
+    eip712: {
+      version: 1,
+      digest,
+      domain: typedData.domain,
+      types: typedData.types,
+      primaryType: typedData.primaryType,
+      message: typedData.message
+    },
+    delivery
+  };
+  return finalizeMultisign({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    purposeSuffix: args.purposeSuffix,
+    destinationChainID: args.destinationChainID,
+    destinationAddress: args.destinationAddress,
+    extraJSON,
+    expiryDate: args.expiryDate,
+    legs: [
+      {
+        msgHash: msgHashNo0x(digest),
+        msgRaw: eip712MsgRawHex(typedData, delivery),
+        destinationAddress: args.destinationAddress,
+        signatureText: eip712SignatureText(typedData.domain, typedData.primaryType),
+        audit: {
+          kind: "EIP712",
+          primaryType: typedData.primaryType,
+          deliveryKind: delivery.kind,
+          ...args.audit ?? {}
+        },
+        feeSnapshot: {}
+      }
+    ]
+  });
+}
+
+// src/protocols/evm/uniswap-v4/limitOrderMultisign.ts
+async function buildEvmMultisignBodyUniswapV4LimitOrderBatch(args) {
+  assertUniswapLimitOrderChain(args.chainId);
+  const permitRaw = extractPermitDataFromLimitQuote(args.fullLimitQuote);
+  if (!permitRaw) {
+    throw new Error(
+      "Limit order quote has no permitData \u2014 cannot build EIP-712 sign request. Re-quote or confirm mainnet limit order support for this pair."
+    );
+  }
+  const typedData = permitDataToEip712Payload(permitRaw);
+  const submitTemplate = buildUniswapXLimitOrderSubmitBody({
+    quoteResponse: args.fullLimitQuote,
+    signatureHex: "0x"
+  });
+  return buildEip712MultisignBody({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    destinationChainID: String(UNISWAP_LIMIT_ORDER_CHAIN_ID),
+    destinationAddress: PERMIT2_ADDRESS,
+    typedData,
+    delivery: {
+      kind: "uniswapx_limit_order",
+      chainId: UNISWAP_LIMIT_ORDER_CHAIN_ID,
+      swapper: viem.getAddress(args.swapper),
+      submitBodyTemplate: submitTemplate,
+      quoteResponse: args.fullLimitQuote,
+      uniswapApiKey: args.uniswapApiKey,
+      tradeApiBaseUrl: args.tradeApiBaseUrl ?? "https://trade-api.gateway.uniswap.org/v1"
+    },
+    audit: {
+      protocol: "uniswap-v4",
+      action: "limitOrder",
+      routing: args.fullLimitQuote.routing ?? "LIMIT_ORDER",
+      orderType: "Limit",
+      primaryType: typedData.primaryType
+    },
+    expiryDate: args.expiryDate
+  });
+}
+async function buildEvmMultisignBodyUniswapV4LimitOrderBatchFromMcp(args) {
+  return buildEvmMultisignBodyUniswapV4LimitOrderBatch({
+    keyGen: args.keyGen,
+    chainId: args.chainId,
+    purposeText: args.purposeText,
+    fullLimitQuote: args.fullLimitQuote,
+    swapper: viem.getAddress(args.executorAddress),
+    uniswapApiKey: args.uniswapApiKey,
+    tradeApiBaseUrl: args.tradeApiBaseUrl,
+    expiryDate: args.expiryDate
+  });
+}
+
 // src/protocols/evm/uniswap-v4/index.ts
 var UNISWAP_V4_PROTOCOL_ID = "uniswap-v4";
 var uniswapV4ProtocolModule = {
@@ -2624,6 +3951,17 @@ var uniswapV4ProtocolModule = {
         type: { type: "EXACT_INPUT | EXACT_OUTPUT", required: true, description: "Trade type" }
       }
     },
+    {
+      id: "uniswap-v4.limit-order",
+      protocolId: UNISWAP_V4_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Place UniswapX limit order via EIP-712 sign + POST /order (Ethereum mainnet only)",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        fullLimitQuote: { type: "object", required: true, description: "Full limit order quote from Trade API" },
+        uniswapApiKey: { type: "string", required: true, description: "Uniswap Trade API key" }
+      }
+    },
     {
       id: "uniswap-v4.mint-liquidity",
       protocolId: UNISWAP_V4_PROTOCOL_ID,
@@ -2679,6 +4017,10 @@ var uniswapV4 = {
   swapExactInput,
   swapFromQuote,
   buildSwapMultisignBody: buildEvmMultisignBodyUniswapV4SkipPermit2Batch,
+  limitOrderQuote: uniswapLimitOrderQuote,
+  buildLimitOrderMultisignBody: buildEvmMultisignBodyUniswapV4LimitOrderBatchFromMcp,
+  fetchLimitOrders: fetchUniswapXLimitOrders,
+  fetchLimitOrdersMcp: uniswapFetchLimitOrdersMcp,
   quote: uniswapTradeQuote,
   createLiquidityPosition: uniswapLpCreatePosition,
   increaseLiquidityPosition: uniswapLpIncreasePosition,
@@ -2692,9 +4034,22 @@ var uniswapV4 = {
   isChainSupported: isUniswapV4ChainSupported
 };
 
+exports.BITQUERY_API_KEY_DOCS_URL = BITQUERY_API_KEY_DOCS_URL;
+exports.BITQUERY_API_KEY_ENV = BITQUERY_API_KEY_ENV;
+exports.BITQUERY_API_KEY_SIGNUP_URL = BITQUERY_API_KEY_SIGNUP_URL;
+exports.BITQUERY_GRAPHQL_URL = BITQUERY_GRAPHQL_URL;
+exports.DEFAULT_LIMIT_ORDER_QUOTE_PATH = DEFAULT_LIMIT_ORDER_QUOTE_PATH;
+exports.DEFAULT_ORDER_SUBMIT_PATH = DEFAULT_ORDER_SUBMIT_PATH;
+exports.DEFAULT_UNISWAPX_ORDER_BASE = DEFAULT_UNISWAPX_ORDER_BASE;
 exports.MAX_UINT160 = MAX_UINT160;
 exports.MAX_UINT48 = MAX_UINT48;
 exports.PERMIT2_ADDRESS = PERMIT2_ADDRESS;
+exports.ROBINHOOD_CHAIN_ID = ROBINHOOD_CHAIN_ID;
+exports.ROBINHOOD_WETH_ADDRESS = ROBINHOOD_WETH_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_LIMIT_ORDER_CHAIN_ID = UNISWAP_LIMIT_ORDER_CHAIN_ID;
 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,22 +4069,41 @@ 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.assertUniswapLimitOrderChain = assertUniswapLimitOrderChain;
+exports.assertUniswapV4OhlcvInterval = assertUniswapV4OhlcvInterval;
+exports.bitqueryApiKeyVariablesHint = bitqueryApiKeyVariablesHint;
+exports.bitqueryAuthErrorMessage = bitqueryAuthErrorMessage;
 exports.buildEvmMultisignBodyUniswapV4CollectFeesBatch = buildEvmMultisignBodyUniswapV4CollectFeesBatch;
 exports.buildEvmMultisignBodyUniswapV4DecreaseLiquidityBatch = buildEvmMultisignBodyUniswapV4DecreaseLiquidityBatch;
 exports.buildEvmMultisignBodyUniswapV4IncreaseLiquidityBatch = buildEvmMultisignBodyUniswapV4IncreaseLiquidityBatch;
+exports.buildEvmMultisignBodyUniswapV4LimitOrderBatch = buildEvmMultisignBodyUniswapV4LimitOrderBatch;
+exports.buildEvmMultisignBodyUniswapV4LimitOrderBatchFromMcp = buildEvmMultisignBodyUniswapV4LimitOrderBatchFromMcp;
 exports.buildEvmMultisignBodyUniswapV4MintLiquidityBatch = buildEvmMultisignBodyUniswapV4MintLiquidityBatch;
 exports.buildEvmMultisignBodyUniswapV4SkipPermit2Batch = buildEvmMultisignBodyUniswapV4SkipPermit2Batch;
+exports.buildLimitOrderQuoteRequestBody = buildLimitOrderQuoteRequestBody;
 exports.buildUniswapQuoteRequestBody = buildUniswapQuoteRequestBody;
 exports.buildUniswapV4PurposePrefill = buildUniswapV4PurposePrefill;
+exports.buildUniswapXLimitOrderSubmitBody = buildUniswapXLimitOrderSubmitBody;
 exports.computeUniswapV4PoolReference = computeUniswapV4PoolReference;
 exports.computeUniswapV4Session = computeUniswapV4Session;
 exports.createSwap = createSwap;
+exports.currencyFilterLabel = currencyFilterLabel;
 exports.errorMessageFromUniswapJsonBody = errorMessageFromUniswapJsonBody;
+exports.extractPermitDataFromLimitQuote = extractPermitDataFromLimitQuote;
 exports.extractUniswapLpTokenAmounts = extractUniswapLpTokenAmounts;
 exports.extractUniswapLpTransaction = extractUniswapLpTransaction;
 exports.fetchEthereumAddressForKeyGen = fetchEthereumAddressForKeyGen;
+exports.fetchRobinhoodBitqueryOhlcv = fetchRobinhoodBitqueryOhlcv;
+exports.fetchUniswapV4PoolDayDatas = fetchUniswapV4PoolDayDatas;
+exports.fetchUniswapV4PoolHourDatas = fetchUniswapV4PoolHourDatas;
+exports.fetchUniswapV4PoolMeta = fetchUniswapV4PoolMeta;
+exports.fetchUniswapV4Swaps = fetchUniswapV4Swaps;
+exports.fetchUniswapXLimitOrders = fetchUniswapXLimitOrders;
 exports.formatUniswapAmountFieldFromWei = formatUniswapAmountFieldFromWei;
 exports.formatUniswapLpAmountHuman = formatUniswapLpAmountHuman;
 exports.formatUniswapPercentForUi = formatUniswapPercentForUi;
@@ -2737,36 +4111,58 @@ exports.formatUniswapQuoteForDisplay = formatUniswapQuoteForDisplay;
 exports.formatUniswapV4PositionNotFoundError = formatUniswapV4PositionNotFoundError;
 exports.getClassicQuoteFromStoredUniswapResponse = getClassicQuoteFromStoredUniswapResponse;
 exports.getUniswapUniversalRouterSpenderOrThrow = getUniswapUniversalRouterSpenderOrThrow;
+exports.getUniswapUniversalRouterVersion = getUniswapUniversalRouterVersion;
 exports.getUniswapV4PositionManagerDeployBlock = getUniswapV4PositionManagerDeployBlock;
 exports.getUniswapV4PositionManagerOrThrow = getUniswapV4PositionManagerOrThrow;
+exports.isBitqueryAuthOrRateLimitError = isBitqueryAuthOrRateLimitError;
 exports.isEthGetLogsBlockRangeTooLargeError = isEthGetLogsBlockRangeTooLargeError;
 exports.isNativeUniswapLpTokenAddress = isNativeUniswapLpTokenAddress;
+exports.isRobinhoodOhlcvChain = isRobinhoodOhlcvChain;
+exports.isTheGraphRateLimitOrAuthError = isTheGraphRateLimitOrAuthError;
 exports.isUniswapFullQuoteResponseNativeIn = isUniswapFullQuoteResponseNativeIn;
+exports.isUniswapFullQuoteResponseNativeOut = isUniswapFullQuoteResponseNativeOut;
+exports.isUniswapLimitOrderChainSupported = isUniswapLimitOrderChainSupported;
+exports.isUniswapNativeTokenAddress = isUniswapNativeTokenAddress;
 exports.isUniswapTokenInAddressNative = isUniswapTokenInAddressNative;
 exports.isUniswapV4ChainSupported = isUniswapV4ChainSupported;
 exports.isUniswapV4LiquidityEvmSignRequest = isUniswapV4LiquidityEvmSignRequest;
 exports.isUniswapV4SwapEvmSignRequest = isUniswapV4SwapEvmSignRequest;
 exports.listUniswapV4PositionsForWallet = listUniswapV4PositionsForWallet;
 exports.listUniswapV4StandardLpPools = listUniswapV4StandardLpPools;
+exports.mapBitqueryOhlcvRowsToCandles = mapBitqueryOhlcvRowsToCandles;
 exports.messageFromUniswapHttpResponseBody = messageFromUniswapHttpResponseBody;
 exports.parseUniswapChainId = parseUniswapChainId;
 exports.parseUniswapLpApiSnapshot = parseUniswapLpApiSnapshot;
 exports.parseUniswapQuoteClassicInOut = parseUniswapQuoteClassicInOut;
 exports.parseUniswapQuoteSlippageInfo = parseUniswapQuoteSlippageInfo;
 exports.parseUniswapV4ScanFromDateYmd = parseUniswapV4ScanFromDateYmd;
+exports.permitDataToEip712Payload = permitDataToEip712Payload;
 exports.quoteSwap = quoteSwap;
 exports.readUniswapV4PositionInfoRaw = readUniswapV4PositionInfoRaw;
+exports.requireBitqueryApiKey = requireBitqueryApiKey;
+exports.resolveBitqueryApiKey = resolveBitqueryApiKey;
 exports.resolveBlockAtOrAfterUnixTime = resolveBlockAtOrAfterUnixTime;
+exports.resolveChainIdFromStoredUniswapQuote = resolveChainIdFromStoredUniswapQuote;
+exports.resolveInputChainId = resolveInputChainId;
+exports.resolveRobinhoodChartCurrency = resolveRobinhoodChartCurrency;
 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.submitUniswapXLimitOrder = submitUniswapXLimitOrder;
 exports.swapExactInput = swapExactInput;
 exports.swapFromQuote = swapFromQuote;
 exports.swapTransactionDeadlineUnixFromExpiryMinutes = swapTransactionDeadlineUnixFromExpiryMinutes;
+exports.theGraphApiKeyVariablesHint = theGraphApiKeyVariablesHint;
+exports.theGraphRateLimitErrorMessage = theGraphRateLimitErrorMessage;
 exports.tryGetUniswapV4PositionManager = tryGetUniswapV4PositionManager;
 exports.uniswapCreateSwap = uniswapCreateSwap;
+exports.uniswapFetchLimitOrdersMcp = uniswapFetchLimitOrdersMcp;
+exports.uniswapLimitOrderQuote = uniswapLimitOrderQuote;
 exports.uniswapLpClaimFees = uniswapLpClaimFees;
 exports.uniswapLpCreatePosition = uniswapLpCreatePosition;
 exports.uniswapLpDecreasePosition = uniswapLpDecreasePosition;
@@ -2775,13 +4171,19 @@ 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.uniswapV4OhlcvSupportedChainIds = uniswapV4OhlcvSupportedChainIds;
 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