@continuumdao/ctm-mpc-defi 0.2.3 → 0.2.5

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

@@ -90,9 +90,55 @@ var MAX_UINT160 = (1n << 160n) - 1n;
 var MAX_UINT48 = (1n << 48n) - 1n;
 var UNISWAP_UNIVERSAL_ROUTER_DEFAULT_GAS_UNITS = 1500000n;
 var UNISWAP_TRADE_BASE_DEFAULT = "https://trade-api.gateway.uniswap.org/v1";
+var UNISWAP_LP_API_BASE_DEFAULT = "https://api.uniswap.org";
 var UNISWAP_UNIVERSAL_ROUTER_VERSION_DEFAULT = "2.0";
 var UNISWAP_SWAP_DEFAULT_EXPIRY_MINUTES = 30;
 var UNISWAP_SWAP_DEFAULT_DEADLINE_SEC_OFFSET = UNISWAP_SWAP_DEFAULT_EXPIRY_MINUTES * 60;
+var UNISWAP_LP_DEFAULT_EXPIRY_MINUTES = 30;
+var UNISWAP_LP_DEFAULT_DEADLINE_SEC_OFFSET = UNISWAP_LP_DEFAULT_EXPIRY_MINUTES * 60;
+var UNISWAP_LP_DEFAULT_SLIPPAGE_PERCENT = 0.5;
+var POSITION_MANAGER_BY_CHAIN = {
+  1: "0xbd216513d74c8cf14cf4747e6aaa6420ff64ee9e",
+  10: "0x3c3ea4b57a46241e54610e5f022e5c45859a1017",
+  137: "0x1ec2ebf4f37e7363fdfe3551602425af0b3ceef9",
+  42161: "0xd88f38f930b7952f2db2432cb002e7abbf3dd869",
+  8453: "0x7C5f5A4bBd8fD63184577525326123B519429bDc",
+  11155111: "0x4B2C77d209D3405F41a037Ec6c77F7F5b8e2ca80",
+  130: "0x0d97dc33264bfc1c226207428a79b26757fb9dc3",
+  1868: "0x0e2850543f69f678257266e0907ff9a58b3f13de",
+  59144: "0x661e93cca42afacb172121ef892830ca3b70f08d"
+};
+function getUniswapV4PositionManagerOrThrow(chainId) {
+  const raw = POSITION_MANAGER_BY_CHAIN[chainId];
+  if (!raw || !raw.startsWith("0x") || raw.length !== 42) {
+    throw new Error(
+      `No Uniswap V4 PositionManager is configured for chainId ${chainId}. Add this chain to uniswap-v4/constants or pass position manager from LP API response.`
+    );
+  }
+  return viem.getAddress(raw);
+}
+function tryGetUniswapV4PositionManager(chainId) {
+  try {
+    return getUniswapV4PositionManagerOrThrow(chainId);
+  } catch {
+    return null;
+  }
+}
+var POSITION_MANAGER_DEPLOY_BLOCK_BY_CHAIN = {
+  /** Ethereum mainnet — Uniswap v4 launch (Jan 2025). */
+  1: 22938741n
+};
+var UNISWAP_V4_LP_LOG_CHUNK_SIZE_DEFAULT = 200n;
+var UNISWAP_V4_LP_LOG_CHUNK_SIZE_MIN = 10n;
+function getUniswapV4PositionManagerDeployBlock(chainId) {
+  return POSITION_MANAGER_DEPLOY_BLOCK_BY_CHAIN[chainId];
+}
+var UNISWAP_V4_LP_MINT_DEFAULT_GAS_UNITS = 1800000n;
+var UNISWAP_V4_LP_INCREASE_DEFAULT_GAS_UNITS = 1500000n;
+var UNISWAP_V4_LP_DECREASE_DEFAULT_GAS_UNITS = 1200000n;
+var UNISWAP_V4_LP_COLLECT_DEFAULT_GAS_UNITS = 900000n;
+var UNISWAP_V4_LP_ERC20_APPROVE_FALLBACK = 100000n;
+var UNISWAP_V4_LP_WETH_DEPOSIT_FALLBACK = 120000n;
 var DEFAULT_TRADE_BASE = "https://trade-api.gateway.uniswap.org/v1";
 var UNISWAP_QUOTE_HEADERS_BASE = {
   "Content-Type": "application/json",
@@ -345,7 +391,16 @@ function parseUniswapQuoteClassicInOut(res) {
   const input = q.input;
   const output = q.output;
   const inAm = input?.amount;
-  const outAm = output?.amount;
+  let outAm = output?.amount;
+  if (typeof outAm !== "string" || !outAm) {
+    const agg = q.aggregatedOutputs;
+    if (Array.isArray(agg) && agg.length > 0) {
+      const first = agg[0];
+      if (typeof first?.amount === "string" && first.amount) {
+        outAm = first.amount;
+      }
+    }
+  }
   if (typeof inAm !== "string" || !inAm || typeof outAm !== "string" || !outAm) return null;
   try {
     return { inputWei: BigInt(inAm), outputWei: BigInt(outAm) };
@@ -1323,6 +1378,1075 @@ async function buildEvmMultisignBodyUniswapV4SkipPermit2Batch(args) {
     }
   });
 }
+var POOL_KEY_ABI = viem.parseAbiParameters(
+  "address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks"
+);
+var ZERO_HOOKS = "0x0000000000000000000000000000000000000000";
+function sortUniswapV4PoolCurrencies(token0Address, token1Address) {
+  const a = normalizePoolCurrency(token0Address);
+  const b = normalizePoolCurrency(token1Address);
+  if (a.toLowerCase() === b.toLowerCase()) {
+    throw new Error("Pool tokens must be distinct.");
+  }
+  return a.toLowerCase() < b.toLowerCase() ? { currency0: a, currency1: b } : { currency0: b, currency1: a };
+}
+function normalizePoolCurrency(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    throw new Error("Pool token address is required.");
+  }
+  const lower = trimmed.toLowerCase();
+  if (lower === "eth" || lower === "native" || lower === "native_eth" || lower === viem.zeroAddress.toLowerCase()) {
+    return viem.zeroAddress;
+  }
+  return viem.getAddress(trimmed);
+}
+function computeUniswapV4PoolReference(args) {
+  const { currency0, currency1 } = sortUniswapV4PoolCurrencies(
+    args.token0Address,
+    args.token1Address
+  );
+  const hooks = args.hooks?.trim() && args.hooks.trim() !== "0x" ? viem.getAddress(args.hooks.trim()) : ZERO_HOOKS;
+  return viem.keccak256(
+    viem.encodeAbiParameters(POOL_KEY_ABI, [
+      currency0,
+      currency1,
+      args.fee,
+      args.tickSpacing,
+      hooks
+    ])
+  );
+}
+
+// src/protocols/evm/uniswap-v4/knownLpPools.ts
+var ZERO_HOOKS2 = "0x0000000000000000000000000000000000000000";
+var UNISWAP_V4_LP_POOL_LOOKUP_HINT = "Pool may not be initialized on this chain. Call ctm_uniswap_v4_list_lp_pools for other presets, pass a custom existingPool.poolReference, or use newPool to initialize a pool.";
+var FEE_TIERS = [
+  { fee: 500, feeLabel: "0.05%", tickSpacing: 10 },
+  { fee: 3e3, feeLabel: "0.3%", tickSpacing: 60 },
+  { fee: 1e4, feeLabel: "1%", tickSpacing: 200 }
+];
+var CHAIN_LP_CONFIGS = [
+  {
+    chainId: 1,
+    chainLabel: "Ethereum",
+    nativeWrapped: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    tokens: {
+      eth: { symbol: "ETH", address: "0x0000000000000000000000000000000000000000", native: true },
+      usdc: { symbol: "USDC", address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" },
+      usdt: { symbol: "USDT", address: "0xdAC17F958D2ee523a2206206994597C13D831ec7" },
+      wbtc: { symbol: "WBTC", address: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599" }
+    },
+    pairs: [
+      { slug: "eth-usdc", label: "ETH/USDC", token0Key: "eth", token1Key: "usdc", tiers: [...FEE_TIERS] },
+      { slug: "eth-usdt", label: "ETH/USDT", token0Key: "eth", token1Key: "usdt", tiers: [...FEE_TIERS] },
+      { slug: "eth-wbtc", label: "ETH/WBTC", token0Key: "eth", token1Key: "wbtc", tiers: [...FEE_TIERS] }
+    ]
+  },
+  {
+    chainId: 8453,
+    chainLabel: "Base",
+    nativeWrapped: "0x4200000000000000000000000000000000000006",
+    tokens: {
+      eth: { symbol: "ETH", address: "0x0000000000000000000000000000000000000000", native: true },
+      usdc: { symbol: "USDC", address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" }
+    },
+    pairs: [
+      { slug: "eth-usdc", label: "ETH/USDC", token0Key: "eth", token1Key: "usdc", tiers: [...FEE_TIERS] }
+    ]
+  },
+  {
+    chainId: 42161,
+    chainLabel: "Arbitrum",
+    nativeWrapped: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+    tokens: {
+      eth: { symbol: "ETH", address: "0x0000000000000000000000000000000000000000", native: true },
+      usdc: { symbol: "USDC", address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831" }
+    },
+    pairs: [
+      { slug: "eth-usdc", label: "ETH/USDC", token0Key: "eth", token1Key: "usdc", tiers: [...FEE_TIERS] }
+    ]
+  },
+  {
+    chainId: 10,
+    chainLabel: "Optimism",
+    nativeWrapped: "0x4200000000000000000000000000000000000006",
+    tokens: {
+      eth: { symbol: "ETH", address: "0x0000000000000000000000000000000000000000", native: true },
+      usdc: { symbol: "USDC", address: "0x0b2C639c533813f4Aa9D7837CAa646c993D1B7926" }
+    },
+    pairs: [
+      { slug: "eth-usdc", label: "ETH/USDC", token0Key: "eth", token1Key: "usdc", tiers: [...FEE_TIERS] }
+    ]
+  },
+  {
+    chainId: 137,
+    chainLabel: "Polygon",
+    nativeWrapped: "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619",
+    tokens: {
+      eth: { symbol: "ETH", address: "0x0000000000000000000000000000000000000000", native: true },
+      usdc: { symbol: "USDC", address: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359" }
+    },
+    pairs: [
+      { slug: "eth-usdc", label: "ETH/USDC", token0Key: "eth", token1Key: "usdc", tiers: [...FEE_TIERS] }
+    ]
+  }
+];
+function buildPresetId(pairSlug, feeLabel) {
+  const feeSlug = feeLabel.replace("%", "").replace(".", "-");
+  return `${pairSlug}-${feeSlug}`;
+}
+function buildPoolRows(config) {
+  const rows = [];
+  for (const pair of config.pairs) {
+    const token0 = config.tokens[pair.token0Key];
+    const token1 = config.tokens[pair.token1Key];
+    if (!token0 || !token1) continue;
+    for (const tier of pair.tiers) {
+      const poolReference = computeUniswapV4PoolReference({
+        token0Address: token0.address,
+        token1Address: token1.address,
+        fee: tier.fee,
+        tickSpacing: tier.tickSpacing,
+        hooks: ZERO_HOOKS2
+      });
+      const usesNativeEth = Boolean(token0.native || token1.native);
+      rows.push({
+        presetId: buildPresetId(pair.slug, tier.feeLabel),
+        pairSlug: pair.slug,
+        pairLabel: pair.label,
+        fee: tier.fee,
+        feeLabel: tier.feeLabel,
+        tickSpacing: tier.tickSpacing,
+        token0Symbol: token0.symbol,
+        token1Symbol: token1.symbol,
+        token0Address: viem.getAddress(token0.address),
+        token1Address: viem.getAddress(token1.address),
+        poolReference,
+        hooks: ZERO_HOOKS2,
+        nativeWrapped: usesNativeEth ? viem.getAddress(config.nativeWrapped) : void 0,
+        usesNativeEth
+      });
+    }
+  }
+  return rows;
+}
+function chainConfigOrThrow(chainId) {
+  const config = CHAIN_LP_CONFIGS.find((row) => row.chainId === chainId);
+  if (!config) {
+    throw new Error(
+      `No standard Uniswap V4 LP pool catalog for chainId ${chainId}. Supported catalog chains: ${CHAIN_LP_CONFIGS.map((c) => c.chainId).join(", ")}.`
+    );
+  }
+  if (!isUniswapV4ChainSupported(chainId)) {
+    throw new Error(`chainId ${chainId} is not supported for Uniswap V4 MCP tools.`);
+  }
+  return config;
+}
+function listUniswapV4StandardLpPools(args) {
+  const chainId = parseUniswapChainId(args.chainId);
+  const config = chainConfigOrThrow(chainId);
+  let pools = buildPoolRows(config);
+  const pairFilter = args.pair?.trim().toLowerCase();
+  if (pairFilter) {
+    pools = pools.filter(
+      (row) => row.pairSlug.includes(pairFilter) || row.pairLabel.toLowerCase().includes(pairFilter) || row.presetId.includes(pairFilter)
+    );
+  }
+  return {
+    chainId,
+    chainLabel: config.chainLabel,
+    pools,
+    notes: "poolReference is derived from token addresses, fee, tickSpacing, and hooks (no-hook pools). Pass presetId to ctm_uniswap_v4_lp_create_position as poolPreset, or copy existingPool fields. If LP create fails, the pool may not exist on-chain \u2014 try another preset, pass poolReference manually, or use newPool."
+  };
+}
+function resolveUniswapV4LpPoolPreset(args) {
+  const chainId = parseUniswapChainId(args.chainId);
+  const preset = args.presetId.trim().toLowerCase();
+  const row = buildPoolRows(chainConfigOrThrow(chainId)).find(
+    (pool) => pool.presetId.toLowerCase() === preset
+  );
+  if (!row) {
+    throw new Error(
+      `Unknown LP pool preset "${args.presetId}" on chainId ${chainId}. Call ctm_uniswap_v4_list_lp_pools to list standard presets.`
+    );
+  }
+  return row;
+}
+function resolveUniswapV4LpExistingPoolFromKey(args) {
+  const poolReference = args.poolReference?.trim() || computeUniswapV4PoolReference({
+    token0Address: args.token0Address,
+    token1Address: args.token1Address,
+    fee: args.fee,
+    tickSpacing: args.tickSpacing,
+    hooks: args.hooks
+  });
+  const sorted = sortTokensForExistingPool(args.token0Address, args.token1Address);
+  return {
+    token0Address: sorted.token0Address,
+    token1Address: sorted.token1Address,
+    poolReference
+  };
+}
+function sortTokensForExistingPool(token0Address, token1Address) {
+  const sorted = sortUniswapV4PoolCurrencies(token0Address, token1Address);
+  return { token0Address: sorted.currency0, token1Address: sorted.currency1 };
+}
+function uniswapV4ListStandardLpPools(args) {
+  return listUniswapV4StandardLpPools(args);
+}
+
+// src/protocols/evm/uniswap-v4/liquidityApi.ts
+var LP_HEADERS_BASE = {
+  "Content-Type": "application/json",
+  Accept: "application/json",
+  "User-Agent": "ctm-mpc-defi uniswapLpApi/1.0 (TS)"
+};
+function trimAddr2(a) {
+  return a.trim();
+}
+function lpDeadlineUnix(nowSec = Math.floor(Date.now() / 1e3)) {
+  return nowSec + UNISWAP_LP_DEFAULT_DEADLINE_SEC_OFFSET;
+}
+function resolveLpBaseUrl(baseUrl) {
+  const raw = (baseUrl ?? UNISWAP_TRADE_BASE_DEFAULT).replace(/\/$/, "");
+  return raw;
+}
+function resolveLpPath(baseUrl, action) {
+  const normalized = baseUrl.replace(/\/$/, "");
+  if (normalized.includes("api.uniswap.org")) {
+    return `${normalized}/lp/${action}`;
+  }
+  return `${normalized}/lp/${action}`;
+}
+async function postUniswapLpApi(args) {
+  const useProxy = args.useServerProxy !== false && typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
+  if (useProxy && args.proxyPath) {
+    const fn2 = args.fetchImpl ?? globalThis.fetch;
+    const res2 = await fn2(args.proxyPath, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        uniswapApiKey: args.uniswapApiKey,
+        baseUrl: args.baseUrl,
+        body: args.body
+      }),
+      credentials: "same-origin"
+    });
+    const text2 = await res2.text();
+    if (!res2.ok) {
+      let errMsg = res2.statusText;
+      try {
+        const j = JSON.parse(text2);
+        if (j?.error?.trim()) errMsg = j.error.trim();
+      } catch {
+        if (text2.trim()) errMsg = text2.slice(0, 500);
+      }
+      throw new Error(`Uniswap LP proxy failed: ${errMsg}`);
+    }
+    return JSON.parse(text2);
+  }
+  const base = resolveLpBaseUrl(args.baseUrl);
+  const url = resolveLpPath(base, args.path);
+  const fn = args.fetchImpl ?? globalThis.fetch;
+  const res = await fn(url, {
+    method: "POST",
+    headers: {
+      ...LP_HEADERS_BASE,
+      "x-api-key": args.uniswapApiKey.trim()
+    },
+    body: JSON.stringify(args.body)
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    const base2 = messageFromUniswapHttpResponseBody(text, res.status, res.statusText);
+    const hint = args.path === "create" && args.body.existingPool ? ` ${UNISWAP_V4_LP_POOL_LOOKUP_HINT}` : "";
+    throw new Error(`Uniswap LP POST /${args.path} failed: ${base2}${hint}`);
+  }
+  return JSON.parse(text);
+}
+function extractUniswapLpTransaction(response, field) {
+  const tx = response[field];
+  if (!tx || typeof tx !== "object" || Array.isArray(tx)) {
+    throw new Error(`Uniswap LP response missing \`${field}\` transaction object.`);
+  }
+  const o = tx;
+  const to = String(o.to ?? "").trim();
+  const data = String(o.data ?? "").trim();
+  if (!to.startsWith("0x") || !data.startsWith("0x") || data === "0x") {
+    throw new Error(`Uniswap LP \`${field}\` transaction has invalid to/data.`);
+  }
+  return {
+    to,
+    from: o.from != null ? String(o.from) : void 0,
+    data,
+    value: String(o.value ?? "0"),
+    chainId: typeof o.chainId === "number" ? o.chainId : void 0,
+    gasLimit: o.gasLimit != null ? String(o.gasLimit) : void 0,
+    gasPrice: o.gasPrice != null ? String(o.gasPrice) : void 0,
+    maxFeePerGas: o.maxFeePerGas != null ? String(o.maxFeePerGas) : void 0,
+    maxPriorityFeePerGas: o.maxPriorityFeePerGas != null ? String(o.maxPriorityFeePerGas) : void 0
+  };
+}
+function extractUniswapLpTokenAmounts(response) {
+  const read = (key) => {
+    const raw = response[key];
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+    const o = raw;
+    const tokenAddress = String(o.tokenAddress ?? o.token ?? "").trim();
+    const amount = String(o.amount ?? "").trim();
+    if (!tokenAddress.startsWith("0x") || !amount) return void 0;
+    return { tokenAddress, amount };
+  };
+  return { token0: read("token0"), token1: read("token1") };
+}
+async function uniswapLpCreatePosition(args) {
+  const body = {
+    protocol: "V4",
+    walletAddress: trimAddr2(args.walletAddress),
+    chainId: args.chainId,
+    independentToken: {
+      tokenAddress: trimAddr2(args.independentToken.tokenAddress),
+      amount: String(args.independentToken.amount).trim()
+    },
+    slippageTolerance: args.slippageTolerance ?? UNISWAP_LP_DEFAULT_SLIPPAGE_PERCENT,
+    deadline: args.deadline ?? lpDeadlineUnix(),
+    simulateTransaction: args.simulateTransaction ?? false
+  };
+  if (args.existingPool) {
+    body.existingPool = {
+      token0Address: trimAddr2(args.existingPool.token0Address),
+      token1Address: trimAddr2(args.existingPool.token1Address),
+      poolReference: trimAddr2(args.existingPool.poolReference)
+    };
+  }
+  if (args.newPool) {
+    body.newPool = {
+      token0Address: trimAddr2(args.newPool.token0Address),
+      token1Address: trimAddr2(args.newPool.token1Address),
+      fee: args.newPool.fee,
+      tickSpacing: args.newPool.tickSpacing,
+      initialPrice: String(args.newPool.initialPrice).trim(),
+      ...args.newPool.hooks ? { hooks: trimAddr2(args.newPool.hooks) } : {}
+    };
+  }
+  if (!args.existingPool && !args.newPool) {
+    throw new Error("Provide existingPool or newPool for LP create.");
+  }
+  if (args.priceBounds) {
+    body.priceBounds = {
+      minPrice: String(args.priceBounds.minPrice).trim(),
+      maxPrice: String(args.priceBounds.maxPrice).trim()
+    };
+  }
+  if (args.tickBounds) {
+    body.tickBounds = {
+      tickLower: args.tickBounds.tickLower,
+      tickUpper: args.tickBounds.tickUpper
+    };
+  }
+  if (!args.priceBounds && !args.tickBounds) {
+    throw new Error("Provide priceBounds or tickBounds for LP create.");
+  }
+  if (args.batchPermitData) body.batchPermitData = args.batchPermitData;
+  if (args.signature) body.signature = args.signature;
+  return postUniswapLpApi({
+    uniswapApiKey: args.uniswapApiKey,
+    path: "create",
+    body,
+    baseUrl: args.baseUrl,
+    fetchImpl: args.fetchImpl,
+    useServerProxy: args.useServerProxy,
+    proxyPath: "/api/uniswap/liquidity/create"
+  });
+}
+async function uniswapLpIncreasePosition(args) {
+  const body = {
+    protocol: "V4",
+    walletAddress: trimAddr2(args.walletAddress),
+    chainId: args.chainId,
+    token0Address: trimAddr2(args.token0Address),
+    token1Address: trimAddr2(args.token1Address),
+    nftTokenId: String(args.nftTokenId),
+    independentToken: {
+      tokenAddress: trimAddr2(args.independentToken.tokenAddress),
+      amount: String(args.independentToken.amount).trim()
+    },
+    slippageTolerance: args.slippageTolerance ?? UNISWAP_LP_DEFAULT_SLIPPAGE_PERCENT,
+    deadline: args.deadline ?? lpDeadlineUnix(),
+    simulateTransaction: args.simulateTransaction ?? false
+  };
+  if (args.v4BatchPermitData) body.v4BatchPermitData = args.v4BatchPermitData;
+  if (args.signature) body.signature = args.signature;
+  return postUniswapLpApi({
+    uniswapApiKey: args.uniswapApiKey,
+    path: "increase",
+    body,
+    baseUrl: args.baseUrl,
+    fetchImpl: args.fetchImpl,
+    useServerProxy: args.useServerProxy,
+    proxyPath: "/api/uniswap/liquidity/increase"
+  });
+}
+async function uniswapLpDecreasePosition(args) {
+  const pct = Math.trunc(args.liquidityPercentageToDecrease);
+  if (!Number.isFinite(pct) || pct < 1 || pct > 100) {
+    throw new Error("liquidityPercentageToDecrease must be an integer from 1 to 100.");
+  }
+  const body = {
+    protocol: "V4",
+    walletAddress: trimAddr2(args.walletAddress),
+    chainId: args.chainId,
+    token0Address: trimAddr2(args.token0Address),
+    token1Address: trimAddr2(args.token1Address),
+    nftTokenId: String(args.nftTokenId),
+    liquidityPercentageToDecrease: pct,
+    slippageTolerance: args.slippageTolerance ?? UNISWAP_LP_DEFAULT_SLIPPAGE_PERCENT,
+    deadline: args.deadline ?? lpDeadlineUnix(),
+    simulateTransaction: args.simulateTransaction ?? false
+  };
+  return postUniswapLpApi({
+    uniswapApiKey: args.uniswapApiKey,
+    path: "decrease",
+    body,
+    baseUrl: args.baseUrl,
+    fetchImpl: args.fetchImpl,
+    useServerProxy: args.useServerProxy,
+    proxyPath: "/api/uniswap/liquidity/decrease"
+  });
+}
+async function uniswapLpClaimFees(args) {
+  const body = {
+    protocol: "V4",
+    walletAddress: trimAddr2(args.walletAddress),
+    chainId: args.chainId,
+    tokenId: String(args.tokenId),
+    simulateTransaction: args.simulateTransaction ?? false
+  };
+  return postUniswapLpApi({
+    uniswapApiKey: args.uniswapApiKey,
+    path: "claim",
+    body,
+    baseUrl: args.baseUrl,
+    fetchImpl: args.fetchImpl,
+    useServerProxy: args.useServerProxy,
+    proxyPath: "/api/uniswap/liquidity/claim"
+  });
+}
+var TX_FIELD_BY_ACTION = {
+  mint: "create",
+  increase: "increase",
+  decrease: "decrease",
+  collect: "claim"
+};
+function uniswapLpTxFieldForAction(action) {
+  return TX_FIELD_BY_ACTION[action];
+}
+function parseUniswapLpApiSnapshot(args) {
+  const field = TX_FIELD_BY_ACTION[args.action];
+  const transaction = extractUniswapLpTransaction(args.lpResponse, field);
+  const amounts = extractUniswapLpTokenAmounts(args.lpResponse);
+  const tickLower = typeof args.lpResponse.tickLower === "number" ? args.lpResponse.tickLower : void 0;
+  const tickUpper = typeof args.lpResponse.tickUpper === "number" ? args.lpResponse.tickUpper : void 0;
+  const minPrice = typeof args.lpResponse.minPrice === "string" ? args.lpResponse.minPrice : void 0;
+  const maxPrice = typeof args.lpResponse.maxPrice === "string" ? args.lpResponse.maxPrice : void 0;
+  return {
+    transaction,
+    token0: amounts.token0,
+    token1: amounts.token1,
+    tickLower,
+    tickUpper,
+    minPrice,
+    maxPrice
+  };
+}
+function formatUniswapLpAmountHuman(amountWei, decimals) {
+  try {
+    return viem.formatUnits(BigInt(amountWei), decimals);
+  } catch {
+    return amountWei;
+  }
+}
+var erc721BalanceAbi = viem.parseAbi([
+  "function balanceOf(address owner) view returns (uint256)",
+  "function ownerOf(uint256 tokenId) view returns (address)"
+]);
+var positionInfoAbi = viem.parseAbi([
+  "function positionInfo(uint256 tokenId) view returns (uint256 info)"
+]);
+var UNISWAP_V4_LP_POSITION_REGISTRY_HINT = "Add the position NFT to the node token registry (tokenType ERC721: Uniswap V4 Position Manager contract + tokenId). MCP: call ctm_uniswap_v4_register_position_nft (by tokenId) or ctm_uniswap_v4_register_position_from_mint_tx (after mint execute). Or use add_to_token_registry. In the Continuum app: Add Token (ERC721), or Manage liquidity \u2192 Refresh positions (blockchain scan).";
+function formatUniswapV4PositionNotFoundError(args) {
+  return `Uniswap V4 position #${args.tokenId} is not in the node token registry for chain ${args.chainId}. ` + UNISWAP_V4_LP_POSITION_REGISTRY_HINT;
+}
+var positionManagerTransferEvent = viem.parseAbiItem(
+  "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)"
+);
+function uniswapV4PositionMintedTokenIdsFromReceipt(receipt, positionManager, owner) {
+  const pm = viem.getAddress(positionManager);
+  const wallet = viem.getAddress(owner);
+  const ids = [];
+  for (const log of receipt.logs) {
+    try {
+      if (viem.getAddress(log.address) !== pm) continue;
+      const decoded = viem.decodeEventLog({
+        abi: [positionManagerTransferEvent],
+        data: log.data,
+        topics: log.topics
+      });
+      if (decoded.eventName !== "Transfer") continue;
+      const from = decoded.args.from;
+      const to = decoded.args.to;
+      const tokenId = decoded.args.tokenId;
+      if (from === viem.zeroAddress && viem.getAddress(to) === wallet) {
+        ids.push(tokenId);
+      }
+    } catch {
+    }
+  }
+  return ids;
+}
+function uniswapV4ListPositionsFromRegistryForMcp(args) {
+  const chainId = typeof args.chainId === "number" ? args.chainId : Number.parseInt(String(args.chainId), 10);
+  if (!Number.isFinite(chainId) || chainId <= 0) {
+    throw new Error("chainId must be a positive integer");
+  }
+  const wallet = viem.getAddress(args.walletAddress);
+  const pm = viem.getAddress(
+    args.positionManagerAddress ? String(args.positionManagerAddress) : getUniswapV4PositionManagerOrThrow(chainId)
+  );
+  const pmLower = pm.toLowerCase();
+  const positions = [];
+  for (const row of args.erc721Tokens) {
+    const addr = (row.contractAddress ?? "").trim();
+    const tokenId = (row.tokenId ?? "").trim();
+    if (!addr || !tokenId) continue;
+    try {
+      if (viem.getAddress(addr).toLowerCase() !== pmLower) continue;
+    } catch {
+      continue;
+    }
+    positions.push({
+      tokenId,
+      positionManager: pm,
+      owner: wallet,
+      name: row.name,
+      symbol: row.symbol
+    });
+  }
+  positions.sort((a, b) => BigInt(a.tokenId) < BigInt(b.tokenId) ? -1 : 1);
+  return { positions, source: "token_registry" };
+}
+function throwIfScanAborted(signal) {
+  if (signal?.aborted) {
+    throw new DOMException("Position scan aborted.", "AbortError");
+  }
+}
+var TRANSFER_EVENT = {
+  type: "event",
+  name: "Transfer",
+  inputs: [
+    { indexed: true, name: "from", type: "address" },
+    { indexed: true, name: "to", type: "address" },
+    { indexed: true, name: "tokenId", type: "uint256" }
+  ]
+};
+function isEthGetLogsBlockRangeTooLargeError(err) {
+  const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
+  return msg.includes("block range too large") || msg.includes("maximum allowed") || msg.includes("query returned more than") || msg.includes("exceed maximum block range") || msg.includes("block range is too large");
+}
+async function getTransferLogsForWalletInRange(args) {
+  const { client, positionManager, wallet, fromBlock, toBlock } = args;
+  let chunkSize = args.chunkSize < UNISWAP_V4_LP_LOG_CHUNK_SIZE_MIN ? UNISWAP_V4_LP_LOG_CHUNK_SIZE_MIN : args.chunkSize;
+  const out = [];
+  let from = fromBlock;
+  while (from <= toBlock) {
+    let to = from + chunkSize - 1n > toBlock ? toBlock : from + chunkSize - 1n;
+    for (; ; ) {
+      try {
+        const [toLogs, fromLogs] = await Promise.all([
+          client.getLogs({
+            address: positionManager,
+            event: TRANSFER_EVENT,
+            args: { to: wallet },
+            fromBlock: from,
+            toBlock: to
+          }),
+          client.getLogs({
+            address: positionManager,
+            event: TRANSFER_EVENT,
+            args: { from: wallet },
+            fromBlock: from,
+            toBlock: to
+          })
+        ]);
+        out.push(...toLogs, ...fromLogs);
+        from = to + 1n;
+        break;
+      } catch (err) {
+        if (!isEthGetLogsBlockRangeTooLargeError(err) || chunkSize <= UNISWAP_V4_LP_LOG_CHUNK_SIZE_MIN) {
+          throw err;
+        }
+        chunkSize = chunkSize / 2n;
+        if (chunkSize < UNISWAP_V4_LP_LOG_CHUNK_SIZE_MIN) {
+          chunkSize = UNISWAP_V4_LP_LOG_CHUNK_SIZE_MIN;
+        }
+        to = from + chunkSize - 1n > toBlock ? toBlock : from + chunkSize - 1n;
+      }
+    }
+  }
+  return out;
+}
+function parseUniswapV4ScanFromDateYmd(fromDate) {
+  const trimmed = fromDate.trim();
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+    throw new Error("fromDate must be YYYY-MM-DD");
+  }
+  const ms = Date.parse(`${trimmed}T00:00:00.000Z`);
+  if (!Number.isFinite(ms)) {
+    throw new Error(`Invalid fromDate: ${fromDate}`);
+  }
+  return Math.floor(ms / 1e3);
+}
+async function resolveBlockAtOrAfterUnixTime(client, unixTime, bounds) {
+  let lo = bounds.minBlock;
+  let hi = bounds.maxBlock;
+  let ans = hi;
+  while (lo <= hi) {
+    const mid = (lo + hi) / 2n;
+    const block = await client.getBlock({ blockNumber: mid });
+    const ts = Number(block.timestamp);
+    if (ts >= unixTime) {
+      ans = mid;
+      if (mid === 0n) break;
+      hi = mid - 1n;
+    } else {
+      lo = mid + 1n;
+    }
+  }
+  return ans;
+}
+async function resolveUniswapV4PositionScanFromDate(args) {
+  const unixTime = parseUniswapV4ScanFromDateYmd(args.fromDate);
+  const chain = viem.defineChain({
+    id: args.chainId,
+    name: `uniswap-v4-${args.chainId}`,
+    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const client = viem.createPublicClient({ chain, transport: viem.http(args.rpcUrl) });
+  const latest = await client.getBlockNumber();
+  const deploy = getUniswapV4PositionManagerDeployBlock(args.chainId) ?? 0n;
+  const resolved = await resolveBlockAtOrAfterUnixTime(client, unixTime, {
+    minBlock: deploy,
+    maxBlock: latest
+  });
+  return resolved < deploy ? deploy : resolved;
+}
+function defaultScanFromBlock(args) {
+  if (args.fromBlock != null) return args.fromBlock;
+  const deploy = getUniswapV4PositionManagerDeployBlock(args.chainId);
+  if (deploy != null) return deploy;
+  return args.latest > args.maxBlocksToScan ? args.latest - args.maxBlocksToScan : 0n;
+}
+async function listUniswapV4PositionsForWallet(args) {
+  throwIfScanAborted(args.signal);
+  const wallet = viem.getAddress(args.walletAddress);
+  const pm = viem.getAddress(
+    args.positionManagerAddress ? String(args.positionManagerAddress) : getUniswapV4PositionManagerOrThrow(args.chainId)
+  );
+  const chain = viem.defineChain({
+    id: args.chainId,
+    name: `uniswap-v4-${args.chainId}`,
+    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const client = viem.createPublicClient({ chain, transport: viem.http(args.rpcUrl) });
+  const latest = await client.getBlockNumber();
+  const maxScan = args.maxBlocksToScan ?? 500000n;
+  const chunkSize = args.chunkSize ?? UNISWAP_V4_LP_LOG_CHUNK_SIZE_DEFAULT;
+  const scanFrom = defaultScanFromBlock({
+    chainId: args.chainId,
+    latest,
+    fromBlock: args.fromBlock,
+    maxBlocksToScan: maxScan
+  });
+  const balance = await client.readContract({
+    address: pm,
+    abi: erc721BalanceAbi,
+    functionName: "balanceOf",
+    args: [wallet]
+  });
+  const targetCount = Number(balance);
+  const emitProgress = (scanningFromBlock, scanningToBlock, foundCount) => {
+    args.onProgress?.({
+      latestBlock: latest.toString(),
+      scanFromBlock: scanFrom.toString(),
+      scanningFromBlock: scanningFromBlock.toString(),
+      scanningToBlock: scanningToBlock.toString(),
+      foundCount,
+      targetCount
+    });
+  };
+  if (balance === 0n) {
+    emitProgress(latest, latest, 0);
+    return [];
+  }
+  const candidates = /* @__PURE__ */ new Set();
+  const verified = /* @__PURE__ */ new Map();
+  let toBlock = latest;
+  while (toBlock >= scanFrom && verified.size < targetCount) {
+    throwIfScanAborted(args.signal);
+    let fromBlock = toBlock >= chunkSize - 1n ? toBlock - chunkSize + 1n : 0n;
+    if (fromBlock < scanFrom) fromBlock = scanFrom;
+    emitProgress(fromBlock, toBlock, verified.size);
+    const logs = await getTransferLogsForWalletInRange({
+      client,
+      positionManager: pm,
+      wallet,
+      fromBlock,
+      toBlock,
+      chunkSize
+    });
+    for (const log of logs) {
+      const tokenId = log.args.tokenId?.toString();
+      if (!tokenId) continue;
+      const to = log.args.to != null ? viem.getAddress(log.args.to) : null;
+      const from = log.args.from != null ? viem.getAddress(log.args.from) : null;
+      if (to === wallet) candidates.add(tokenId);
+      if (from === wallet) candidates.delete(tokenId);
+    }
+    for (const tokenId of candidates) {
+      if (verified.has(tokenId)) continue;
+      try {
+        const owner = await client.readContract({
+          address: pm,
+          abi: erc721BalanceAbi,
+          functionName: "ownerOf",
+          args: [BigInt(tokenId)]
+        });
+        if (viem.getAddress(owner) !== wallet) continue;
+        verified.set(tokenId, { tokenId, positionManager: pm, owner: wallet });
+        if (verified.size >= targetCount) break;
+      } catch {
+      }
+    }
+    if (verified.size >= targetCount) break;
+    if (fromBlock <= scanFrom) break;
+    toBlock = fromBlock - 1n;
+  }
+  const out = [...verified.values()];
+  out.sort((a, b) => BigInt(a.tokenId) < BigInt(b.tokenId) ? -1 : 1);
+  return out;
+}
+async function readUniswapV4PositionInfoRaw(args) {
+  const pm = viem.getAddress(
+    args.positionManagerAddress ? String(args.positionManagerAddress) : getUniswapV4PositionManagerOrThrow(args.chainId)
+  );
+  const chain = viem.defineChain({
+    id: args.chainId,
+    name: `uniswap-v4-${args.chainId}`,
+    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const client = viem.createPublicClient({ chain, transport: viem.http(args.rpcUrl) });
+  const info = await client.readContract({
+    address: pm,
+    abi: positionInfoAbi,
+    functionName: "positionInfo",
+    args: [BigInt(args.tokenId)]
+  });
+  return { info, positionManager: pm };
+}
+async function uniswapV4ListPositionsForMcp(args) {
+  const chainId = typeof args.chainId === "number" ? args.chainId : Number.parseInt(String(args.chainId), 10);
+  if (!Number.isFinite(chainId) || chainId <= 0) {
+    throw new Error("chainId must be a positive integer");
+  }
+  const fromBlock = args.fromBlock != null && String(args.fromBlock).trim() !== "" ? BigInt(String(args.fromBlock).trim()) : void 0;
+  const positions = await listUniswapV4PositionsForWallet({
+    chainId,
+    rpcUrl: args.rpcUrl,
+    walletAddress: args.walletAddress,
+    positionManagerAddress: args.positionManagerAddress,
+    fromBlock,
+    onProgress: args.onProgress,
+    signal: args.signal
+  });
+  return { positions };
+}
+function uniswapV4ListPositionsRegistryMcpPlaceholder() {
+  throw new Error(
+    "ctm_uniswap_v4_lp_list_positions must run via continuum-node-sdk MCP (token registry, no RPC scan)."
+  );
+}
+function uniswapV4RegisterPositionNftPlaceholder() {
+  throw new Error(
+    "ctm_uniswap_v4_register_position_nft must run via continuum-node-sdk MCP (management-signed addToken)."
+  );
+}
+function uniswapV4RegisterPositionFromMintTxPlaceholder() {
+  throw new Error(
+    "ctm_uniswap_v4_register_position_from_mint_tx must run via continuum-node-sdk MCP (management-signed addToken)."
+  );
+}
+function isNativeUniswapLpTokenAddress(token) {
+  try {
+    return viem.getAddress(token) === viem.zeroAddress;
+  } catch {
+    return token.toLowerCase() === viem.zeroAddress.toLowerCase();
+  }
+}
+
+// src/protocols/evm/uniswap-v4/liquidityMultisign.ts
+var wethDepositAbi = viem.parseAbi(["function deposit() payable"]);
+var erc20AllowanceAbi = viem.parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function decimals() view returns (uint8)"
+]);
+function parseOptionalGasLimitString2(raw) {
+  if (raw == null) return null;
+  const s = String(raw).trim();
+  if (!s) return null;
+  try {
+    if (/^0x[0-9a-fA-F]+$/.test(s)) return BigInt(s);
+    return BigInt(s);
+  } catch {
+    return null;
+  }
+}
+function parseTxValueWei(tx) {
+  const raw = tx.value ?? "0";
+  try {
+    if (typeof raw === "string" && /^0x[0-9a-fA-F]+$/.test(raw.trim())) return BigInt(raw.trim());
+    return BigInt(String(raw).trim() || "0");
+  } catch {
+    return 0n;
+  }
+}
+function dataHexFromTx(tx) {
+  const d = (tx.data ?? "0x").toString().trim();
+  return d.startsWith("0x") ? d : `0x${d}`;
+}
+function parseExtraJsonObject2(detail) {
+  if (!detail) return null;
+  const raw = detail.ExtraJSON ?? detail.extraJSON;
+  if (raw == null) return null;
+  if (typeof raw === "object" && !Array.isArray(raw)) return raw;
+  if (typeof raw === "string" && raw.trim()) {
+    try {
+      const p = JSON.parse(raw);
+      if (p && typeof p === "object" && !Array.isArray(p)) return p;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function uniswapV4LiquidityEvmTypeFromBatchMeta(ex, batchIndex) {
+  if (!ex) return false;
+  const bm = ex.batchMeta;
+  if (!Array.isArray(bm) || !bm[batchIndex] || typeof bm[batchIndex] !== "object" || Array.isArray(bm[batchIndex])) {
+    return false;
+  }
+  const evm0 = bm[batchIndex].evm;
+  if (!evm0 || typeof evm0 !== "object" || Array.isArray(evm0)) return false;
+  return String(evm0.type ?? "") === "uniswap_v4_liquidity_tx";
+}
+function isUniswapV4LiquidityEvmSignRequest(detail, batchIndex) {
+  const ex = parseExtraJsonObject2(detail);
+  if (batchIndex != null && batchIndex >= 0) {
+    if (uniswapV4LiquidityEvmTypeFromBatchMeta(ex, batchIndex)) return true;
+  } else if (uniswapV4LiquidityEvmTypeFromBatchMeta(ex, 0)) {
+    return true;
+  }
+  const evm = ex?.evm;
+  if (!evm || typeof evm !== "object" || Array.isArray(evm)) return false;
+  return String(evm.type ?? "") === "uniswap_v4_liquidity_tx";
+}
+function defaultGasForAction(action) {
+  switch (action) {
+    case "mint":
+      return UNISWAP_V4_LP_MINT_DEFAULT_GAS_UNITS;
+    case "increase":
+      return UNISWAP_V4_LP_INCREASE_DEFAULT_GAS_UNITS;
+    case "decrease":
+      return UNISWAP_V4_LP_DECREASE_DEFAULT_GAS_UNITS;
+    case "collect":
+      return UNISWAP_V4_LP_COLLECT_DEFAULT_GAS_UNITS;
+    default:
+      return UNISWAP_V4_LP_MINT_DEFAULT_GAS_UNITS;
+  }
+}
+async function resolveApproveTargets(args) {
+  const out = [];
+  const pairs = [args.token0, args.token1].filter(Boolean);
+  for (const row of pairs) {
+    const amt = BigInt(row.amount);
+    if (amt <= 0n) continue;
+    if (isNativeUniswapLpTokenAddress(row.tokenAddress)) {
+      if (!args.nativeWrapped) {
+        throw new Error("nativeWrapped is required when LP uses native ETH (0x0) token.");
+      }
+      out.push({ token: viem.getAddress(args.nativeWrapped), amount: amt, kind: "weth_deposit" });
+      continue;
+    }
+    out.push({ token: viem.getAddress(row.tokenAddress), amount: amt, kind: "approve" });
+  }
+  const deduped = [];
+  for (const row of out) {
+    const existing = deduped.find((d) => d.token === row.token && d.kind === row.kind);
+    if (existing) {
+      if (row.amount > existing.amount) existing.amount = row.amount;
+    } else {
+      deduped.push({ ...row });
+    }
+  }
+  const steps = [];
+  for (const row of deduped) {
+    if (row.kind === "weth_deposit") {
+      steps.push(row);
+      continue;
+    }
+    const allowance = await args.publicClient.readContract({
+      address: row.token,
+      abi: erc20AllowanceAbi,
+      functionName: "allowance",
+      args: [args.executor, args.spender]
+    });
+    if (allowance < row.amount) {
+      steps.push(row);
+    }
+  }
+  return steps;
+}
+async function buildEvmMultisignBodyUniswapV4LiquidityBatchInternal(args) {
+  const parsed = parseUniswapLpApiSnapshot({ action: args.action, lpResponse: args.lpResponse });
+  const tx = parsed.transaction;
+  const to = viem.getAddress(tx.to);
+  const dataHex = dataHexFromTx(tx);
+  const valueWei = parseTxValueWei(tx);
+  const executor = viem.getAddress(args.executorAddress);
+  const spender = to;
+  const chain = viem.defineChain({
+    id: args.chainId,
+    name: `uniswap-v4-lp-${args.chainId}`,
+    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain, transport: viem.http(args.rpcUrl) });
+  const approveTargets = await resolveApproveTargets({
+    publicClient,
+    executor,
+    spender,
+    token0: parsed.token0,
+    token1: parsed.token1,
+    nativeWrapped: args.nativeWrapped
+  });
+  const steps = [];
+  for (const target of approveTargets) {
+    if (target.kind === "weth_deposit") {
+      steps.push({
+        to: target.token,
+        data: viem.encodeFunctionData({ abi: wethDepositAbi, functionName: "deposit" }),
+        value: target.amount,
+        fallbackGas: UNISWAP_V4_LP_WETH_DEPOSIT_FALLBACK
+      });
+      steps.push({
+        to: target.token,
+        data: viem.encodeFunctionData({
+          abi: viem.erc20Abi,
+          functionName: "approve",
+          args: [spender, target.amount]
+        }),
+        value: 0n,
+        fallbackGas: UNISWAP_V4_LP_ERC20_APPROVE_FALLBACK
+      });
+    } else {
+      steps.push({
+        to: target.token,
+        data: viem.encodeFunctionData({
+          abi: viem.erc20Abi,
+          functionName: "approve",
+          args: [spender, target.amount]
+        }),
+        value: 0n,
+        fallbackGas: UNISWAP_V4_LP_ERC20_APPROVE_FALLBACK
+      });
+    }
+  }
+  const lpFallbackGas = defaultGasForAction(args.action);
+  const fromTradeApi = parseOptionalGasLimitString2(tx.gasLimit) ?? parseOptionalGasLimitString2(tx.gas);
+  steps.push({
+    to,
+    data: dataHex,
+    value: valueWei,
+    fallbackGas: fromTradeApi != null && fromTradeApi > 0n ? fromTradeApi : lpFallbackGas
+  });
+  const actionLabel = args.action === "mint" ? "mint liquidity" : args.action === "increase" ? "increase liquidity" : args.action === "decrease" ? "decrease liquidity" : "collect fees";
+  const dataNo0x = dataHex.startsWith("0x") ? dataHex.slice(2) : dataHex;
+  const lpIndex = steps.length - 1;
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: args.keyGen,
+      purposeText: args.purposeText,
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl,
+      executorAddress: args.executorAddress,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails
+    },
+    steps,
+    purposeSuffix: `Uniswap V4: ${steps.length}-tx batch \u2014 ${actionLabel} (classic ERC-20 approve + Position Manager).`,
+    firstMsgRawNo0x: dataNo0x,
+    destinationAddress: to,
+    buildBatchMeta: ({ index }) => {
+      const isLpStep = index === lpIndex;
+      return {
+        signatureText: JSON.stringify({
+          kind: "UniswapV4Liquidity",
+          action: args.action,
+          step: index,
+          lpTx: isLpStep
+        }),
+        ...isLpStep ? {
+          evm: { type: "uniswap_v4_liquidity_tx", version: 1, chainId: String(args.chainId) },
+          uniswapV4Liquidity: {
+            action: args.action,
+            skipPermit2Batch: true,
+            nftTokenId: args.nftTokenId != null ? String(args.nftTokenId) : void 0,
+            poolReference: args.poolReference,
+            lpResponseSnapshot: args.lpResponse,
+            token0: parsed.token0,
+            token1: parsed.token1,
+            tickLower: parsed.tickLower,
+            tickUpper: parsed.tickUpper,
+            transaction: {
+              to: tx.to,
+              value: tx.value,
+              dataNibbles: dataNo0x.length,
+              gasLimit: tx.gasLimit
+            },
+            originalPurpose: args.purposeText
+          }
+        } : {}
+      };
+    }
+  });
+}
+async function buildEvmMultisignBodyUniswapV4MintLiquidityBatch(args) {
+  return buildEvmMultisignBodyUniswapV4LiquidityBatchInternal({ ...args, action: "mint" });
+}
+async function buildEvmMultisignBodyUniswapV4IncreaseLiquidityBatch(args) {
+  return buildEvmMultisignBodyUniswapV4LiquidityBatchInternal({ ...args, action: "increase" });
+}
+async function buildEvmMultisignBodyUniswapV4DecreaseLiquidityBatch(args) {
+  return buildEvmMultisignBodyUniswapV4LiquidityBatchInternal({ ...args, action: "decrease" });
+}
+async function buildEvmMultisignBodyUniswapV4CollectFeesBatch(args) {
+  return buildEvmMultisignBodyUniswapV4LiquidityBatchInternal({ ...args, action: "collect" });
+}
 
 // src/protocols/evm/uniswap-v4/support.ts
 function computeUniswapV4Session(args) {
@@ -1427,6 +2551,52 @@ var uniswapV4ProtocolModule = {
         amount: { type: "string", required: true, description: "Amount for quote" },
         type: { type: "EXACT_INPUT | EXACT_OUTPUT", required: true, description: "Trade type" }
       }
+    },
+    {
+      id: "uniswap-v4.mint-liquidity",
+      protocolId: UNISWAP_V4_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Mint a new Uniswap V4 concentrated liquidity position (Position Manager NFT)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        lpResponse: { type: "object", required: true, description: "Full LP API create response" },
+        nativeWrapped: { type: "address", required: false, description: "WETH when pool uses native ETH" },
+        poolReference: { type: "string", required: false, description: "V4 pool id" },
+        uniswapApiKey: { type: "string", required: true, description: "Uniswap API key" }
+      }
+    },
+    {
+      id: "uniswap-v4.increase-liquidity",
+      protocolId: UNISWAP_V4_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Increase liquidity on an existing Uniswap V4 position NFT",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        nftTokenId: { type: "string", required: true, description: "Position NFT token id" },
+        lpResponse: { type: "object", required: true, description: "Full LP API increase response" }
+      }
+    },
+    {
+      id: "uniswap-v4.decrease-liquidity",
+      protocolId: UNISWAP_V4_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Decrease liquidity on an existing Uniswap V4 position NFT",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        nftTokenId: { type: "string", required: true, description: "Position NFT token id" },
+        lpResponse: { type: "object", required: true, description: "Full LP API decrease response" }
+      }
+    },
+    {
+      id: "uniswap-v4.collect-fees",
+      protocolId: UNISWAP_V4_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Collect accrued fees from a Uniswap V4 position NFT",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        nftTokenId: { type: "string", required: true, description: "Position NFT token id" },
+        lpResponse: { type: "object", required: true, description: "Full LP API claim response" }
+      }
     }
   ]
 };
@@ -1438,48 +2608,108 @@ var uniswapV4 = {
   swapFromQuote,
   buildSwapMultisignBody: buildEvmMultisignBodyUniswapV4SkipPermit2Batch,
   quote: uniswapTradeQuote,
+  createLiquidityPosition: uniswapLpCreatePosition,
+  increaseLiquidityPosition: uniswapLpIncreasePosition,
+  decreaseLiquidityPosition: uniswapLpDecreasePosition,
+  claimLiquidityFees: uniswapLpClaimFees,
+  buildMintLiquidityMultisignBody: buildEvmMultisignBodyUniswapV4MintLiquidityBatch,
+  buildIncreaseLiquidityMultisignBody: buildEvmMultisignBodyUniswapV4IncreaseLiquidityBatch,
+  buildDecreaseLiquidityMultisignBody: buildEvmMultisignBodyUniswapV4DecreaseLiquidityBatch,
+  buildCollectFeesMultisignBody: buildEvmMultisignBodyUniswapV4CollectFeesBatch,
+  listPositions: listUniswapV4PositionsForWallet,
   isChainSupported: isUniswapV4ChainSupported
 };
 
 exports.MAX_UINT160 = MAX_UINT160;
 exports.MAX_UINT48 = MAX_UINT48;
 exports.PERMIT2_ADDRESS = PERMIT2_ADDRESS;
+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;
+exports.UNISWAP_LP_DEFAULT_SLIPPAGE_PERCENT = UNISWAP_LP_DEFAULT_SLIPPAGE_PERCENT;
 exports.UNISWAP_SWAP_DEFAULT_DEADLINE_SEC_OFFSET = UNISWAP_SWAP_DEFAULT_DEADLINE_SEC_OFFSET;
 exports.UNISWAP_SWAP_DEFAULT_EXPIRY_MINUTES = UNISWAP_SWAP_DEFAULT_EXPIRY_MINUTES;
 exports.UNISWAP_TRADE_BASE_DEFAULT = UNISWAP_TRADE_BASE_DEFAULT;
 exports.UNISWAP_UNIVERSAL_ROUTER_DEFAULT_GAS_UNITS = UNISWAP_UNIVERSAL_ROUTER_DEFAULT_GAS_UNITS;
 exports.UNISWAP_UNIVERSAL_ROUTER_VERSION_DEFAULT = UNISWAP_UNIVERSAL_ROUTER_VERSION_DEFAULT;
+exports.UNISWAP_V4_LP_COLLECT_DEFAULT_GAS_UNITS = UNISWAP_V4_LP_COLLECT_DEFAULT_GAS_UNITS;
+exports.UNISWAP_V4_LP_DECREASE_DEFAULT_GAS_UNITS = UNISWAP_V4_LP_DECREASE_DEFAULT_GAS_UNITS;
+exports.UNISWAP_V4_LP_ERC20_APPROVE_FALLBACK = UNISWAP_V4_LP_ERC20_APPROVE_FALLBACK;
+exports.UNISWAP_V4_LP_INCREASE_DEFAULT_GAS_UNITS = UNISWAP_V4_LP_INCREASE_DEFAULT_GAS_UNITS;
+exports.UNISWAP_V4_LP_LOG_CHUNK_SIZE_DEFAULT = UNISWAP_V4_LP_LOG_CHUNK_SIZE_DEFAULT;
+exports.UNISWAP_V4_LP_LOG_CHUNK_SIZE_MIN = UNISWAP_V4_LP_LOG_CHUNK_SIZE_MIN;
+exports.UNISWAP_V4_LP_MINT_DEFAULT_GAS_UNITS = UNISWAP_V4_LP_MINT_DEFAULT_GAS_UNITS;
+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_PROTOCOL_ID = UNISWAP_V4_PROTOCOL_ID;
 exports.applySlippagePercentToApproveWei = applySlippagePercentToApproveWei;
+exports.buildEvmMultisignBodyUniswapV4CollectFeesBatch = buildEvmMultisignBodyUniswapV4CollectFeesBatch;
+exports.buildEvmMultisignBodyUniswapV4DecreaseLiquidityBatch = buildEvmMultisignBodyUniswapV4DecreaseLiquidityBatch;
+exports.buildEvmMultisignBodyUniswapV4IncreaseLiquidityBatch = buildEvmMultisignBodyUniswapV4IncreaseLiquidityBatch;
+exports.buildEvmMultisignBodyUniswapV4MintLiquidityBatch = buildEvmMultisignBodyUniswapV4MintLiquidityBatch;
 exports.buildEvmMultisignBodyUniswapV4SkipPermit2Batch = buildEvmMultisignBodyUniswapV4SkipPermit2Batch;
 exports.buildUniswapQuoteRequestBody = buildUniswapQuoteRequestBody;
 exports.buildUniswapV4PurposePrefill = buildUniswapV4PurposePrefill;
+exports.computeUniswapV4PoolReference = computeUniswapV4PoolReference;
 exports.computeUniswapV4Session = computeUniswapV4Session;
 exports.createSwap = createSwap;
 exports.errorMessageFromUniswapJsonBody = errorMessageFromUniswapJsonBody;
+exports.extractUniswapLpTokenAmounts = extractUniswapLpTokenAmounts;
+exports.extractUniswapLpTransaction = extractUniswapLpTransaction;
 exports.fetchEthereumAddressForKeyGen = fetchEthereumAddressForKeyGen;
 exports.formatUniswapAmountFieldFromWei = formatUniswapAmountFieldFromWei;
+exports.formatUniswapLpAmountHuman = formatUniswapLpAmountHuman;
 exports.formatUniswapPercentForUi = formatUniswapPercentForUi;
 exports.formatUniswapQuoteForDisplay = formatUniswapQuoteForDisplay;
+exports.formatUniswapV4PositionNotFoundError = formatUniswapV4PositionNotFoundError;
 exports.getClassicQuoteFromStoredUniswapResponse = getClassicQuoteFromStoredUniswapResponse;
 exports.getUniswapUniversalRouterSpenderOrThrow = getUniswapUniversalRouterSpenderOrThrow;
+exports.getUniswapV4PositionManagerDeployBlock = getUniswapV4PositionManagerDeployBlock;
+exports.getUniswapV4PositionManagerOrThrow = getUniswapV4PositionManagerOrThrow;
+exports.isEthGetLogsBlockRangeTooLargeError = isEthGetLogsBlockRangeTooLargeError;
+exports.isNativeUniswapLpTokenAddress = isNativeUniswapLpTokenAddress;
 exports.isUniswapFullQuoteResponseNativeIn = isUniswapFullQuoteResponseNativeIn;
 exports.isUniswapTokenInAddressNative = isUniswapTokenInAddressNative;
 exports.isUniswapV4ChainSupported = isUniswapV4ChainSupported;
+exports.isUniswapV4LiquidityEvmSignRequest = isUniswapV4LiquidityEvmSignRequest;
 exports.isUniswapV4SwapEvmSignRequest = isUniswapV4SwapEvmSignRequest;
+exports.listUniswapV4PositionsForWallet = listUniswapV4PositionsForWallet;
+exports.listUniswapV4StandardLpPools = listUniswapV4StandardLpPools;
 exports.messageFromUniswapHttpResponseBody = messageFromUniswapHttpResponseBody;
 exports.parseUniswapChainId = parseUniswapChainId;
+exports.parseUniswapLpApiSnapshot = parseUniswapLpApiSnapshot;
 exports.parseUniswapQuoteClassicInOut = parseUniswapQuoteClassicInOut;
 exports.parseUniswapQuoteSlippageInfo = parseUniswapQuoteSlippageInfo;
+exports.parseUniswapV4ScanFromDateYmd = parseUniswapV4ScanFromDateYmd;
 exports.quoteSwap = quoteSwap;
+exports.readUniswapV4PositionInfoRaw = readUniswapV4PositionInfoRaw;
+exports.resolveBlockAtOrAfterUnixTime = resolveBlockAtOrAfterUnixTime;
 exports.resolveRouterSwapGasUnitsFromSignRequest = resolveRouterSwapGasUnitsFromSignRequest;
+exports.resolveUniswapV4LpExistingPoolFromKey = resolveUniswapV4LpExistingPoolFromKey;
+exports.resolveUniswapV4LpPoolPreset = resolveUniswapV4LpPoolPreset;
+exports.resolveUniswapV4PositionScanFromDate = resolveUniswapV4PositionScanFromDate;
+exports.sortUniswapV4PoolCurrencies = sortUniswapV4PoolCurrencies;
 exports.swapExactInput = swapExactInput;
 exports.swapFromQuote = swapFromQuote;
 exports.swapTransactionDeadlineUnixFromExpiryMinutes = swapTransactionDeadlineUnixFromExpiryMinutes;
+exports.tryGetUniswapV4PositionManager = tryGetUniswapV4PositionManager;
 exports.uniswapCreateSwap = uniswapCreateSwap;
+exports.uniswapLpClaimFees = uniswapLpClaimFees;
+exports.uniswapLpCreatePosition = uniswapLpCreatePosition;
+exports.uniswapLpDecreasePosition = uniswapLpDecreasePosition;
+exports.uniswapLpIncreasePosition = uniswapLpIncreasePosition;
+exports.uniswapLpTxFieldForAction = uniswapLpTxFieldForAction;
 exports.uniswapQuoteToJsonQuoteOneLine = uniswapQuoteToJsonQuoteOneLine;
 exports.uniswapTradeQuote = uniswapTradeQuote;
 exports.uniswapV4 = uniswapV4;
+exports.uniswapV4ListPositionsForMcp = uniswapV4ListPositionsForMcp;
+exports.uniswapV4ListPositionsFromRegistryForMcp = uniswapV4ListPositionsFromRegistryForMcp;
+exports.uniswapV4ListPositionsRegistryMcpPlaceholder = uniswapV4ListPositionsRegistryMcpPlaceholder;
+exports.uniswapV4ListStandardLpPools = uniswapV4ListStandardLpPools;
+exports.uniswapV4PositionMintedTokenIdsFromReceipt = uniswapV4PositionMintedTokenIdsFromReceipt;
 exports.uniswapV4ProtocolModule = uniswapV4ProtocolModule;
+exports.uniswapV4RegisterPositionFromMintTxPlaceholder = uniswapV4RegisterPositionFromMintTxPlaceholder;
+exports.uniswapV4RegisterPositionNftPlaceholder = uniswapV4RegisterPositionNftPlaceholder;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map