@continuumdao/ctm-mpc-defi 0.2.2 → 0.2.4

package/dist/index.cjs

@@ -473,6 +473,44 @@ var UNISWAP_UNIVERSAL_ROUTER_DEFAULT_GAS_UNITS = 1500000n;
 var UNISWAP_TRADE_BASE_DEFAULT = "https://trade-api.gateway.uniswap.org/v1";
 var UNISWAP_UNIVERSAL_ROUTER_VERSION_DEFAULT = "2.0";
 var UNISWAP_SWAP_DEFAULT_EXPIRY_MINUTES = 30;
+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);
+}
+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",
@@ -722,7 +760,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) };
@@ -1290,6 +1337,656 @@ async function buildEvmMultisignBodyUniswapV4SkipPermit2Batch(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) {
+    throw new Error(
+      `Uniswap LP POST /${args.path} failed: ${messageFromUniswapHttpResponseBody(text, res.status, res.statusText)}`
+    );
+  }
+  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 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
+  };
+}
+var erc721BalanceAbi = viem.parseAbi([
+  "function balanceOf(address owner) view returns (uint256)",
+  "function ownerOf(uint256 tokenId) view returns (address)"
+]);
+viem.parseAbi([
+  "function positionInfo(uint256 tokenId) view returns (uint256 info)"
+]);
+viem.parseAbiItem(
+  "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)"
+);
+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 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;
+}
+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 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/swap.ts
 async function swapFromQuote(args) {
   const deadline = args.swapTransactionDeadlineUnix ?? swapTransactionDeadlineUnixFromExpiryMinutes(30);
@@ -1372,6 +2069,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" }
+      }
     }
   ]
 };
@@ -1383,6 +2126,15 @@ 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
 };
 
@@ -1477,44 +2229,64 @@ function swappableCurveGraphNodeKeys(adj) {
 }
 
 // src/protocols/evm/curve-dao/apiSession.ts
+var CURVE_SESSION_CACHE_TTL_MS = 5 * 60 * 1e3;
+var curveSessionCache = /* @__PURE__ */ new Map();
 async function fetchAllCurvePools(curve) {
   const run = (p) => p.catch(() => void 0);
-  await Promise.all([
-    run(curve.factory.fetchPools()),
-    run(curve.crvUSDFactory.fetchPools()),
-    run(curve.EYWAFactory.fetchPools()),
-    run(curve.cryptoFactory.fetchPools()),
-    run(curve.twocryptoFactory.fetchPools()),
-    run(curve.tricryptoFactory.fetchPools()),
-    run(curve.stableNgFactory.fetchPools())
-  ]);
+  const tasks = [];
+  for (const key of [
+    "factory",
+    "crvUSDFactory",
+    "EYWAFactory",
+    "cryptoFactory",
+    "twocryptoFactory",
+    "tricryptoFactory",
+    "stableNgFactory"
+  ]) {
+    const f = curve[key];
+    if (f?.fetchPools) {
+      tasks.push(run(f.fetchPools()));
+    }
+  }
+  await Promise.all(tasks);
 }
 async function loadFullCurveSessionForRpc(rpcUrl) {
   const url = (rpcUrl ?? "").trim();
-  if (!url) return null;
+  if (!url) {
+    throw new Error("rpcUrl is required.");
+  }
+  const cached = curveSessionCache.get(url);
+  if (cached && cached.expiresAt > Date.now()) {
+    return cached.session;
+  }
   try {
     const { default: curve } = await import('@curvefi/api');
     await curve.init("JsonRpc", { url }, {});
     const wrapped = curve.getNetworkConstants().NATIVE_COIN?.wrappedAddress;
     if (!curve.hasRouter || !curve.hasRouter()) {
-      return {
+      const session2 = {
         curve,
         adj: /* @__PURE__ */ new Map(),
         swappableNodeKeys: /* @__PURE__ */ new Set(),
         wrappedNative: wrapped
       };
+      curveSessionCache.set(url, { session: session2, expiresAt: Date.now() + CURVE_SESSION_CACHE_TTL_MS });
+      return session2;
     }
     await fetchAllCurvePools(curve);
     const adj = buildCurveLiquidityGraphFromApi(curve);
     addNativeWethBridge(adj, wrapped);
-    return {
+    const session = {
       curve,
       adj,
       swappableNodeKeys: swappableCurveGraphNodeKeys(adj),
       wrappedNative: wrapped
     };
-  } catch {
-    return null;
+    curveSessionCache.set(url, { session, expiresAt: Date.now() + CURVE_SESSION_CACHE_TTL_MS });
+    return session;
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new Error(`Curve session init failed for RPC: ${msg}`);
   }
 }
 
@@ -1567,7 +2339,7 @@ async function buildEvmMultisignBodyCurveDaoBatch(args) {
     rpcUrls: { default: { http: [args.rpcUrl] } }
   });
   const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
-  const erc20AllowanceAbi = viem.parseAbi([
+  const erc20AllowanceAbi2 = viem.parseAbi([
     "function allowance(address owner, address spender) view returns (uint256)",
     "function decimals() view returns (uint8)"
   ]);
@@ -1576,13 +2348,13 @@ async function buildEvmMultisignBodyCurveDaoBatch(args) {
   if (!isNativeIn) {
     const decimalsN = await publicClient.readContract({
       address: tokenIn,
-      abi: erc20AllowanceAbi,
+      abi: erc20AllowanceAbi2,
       functionName: "decimals"
     });
     const amountWei = viem.parseUnits(args.amountHuman, Number(decimalsN));
     const currentAllowance = await publicClient.readContract({
       address: tokenIn,
-      abi: erc20AllowanceAbi,
+      abi: erc20AllowanceAbi2,
       functionName: "allowance",
       args: [executor, routerAddr]
     });