@continuumdao/ctm-mpc-defi 0.2.34 → 0.2.35

package/dist/protocols/evm/curve-dao/index.d.ts

@@ -199,6 +199,113 @@ declare function formatCurvePriceImpact(percent0to100: number | null | undefined
  */
 declare function formatMinOutAtUserSlippage(quoteOutDecimal: string, userSlippagePercentInput: string, tokenOutSymbol: string): string;
 
+declare const CURVE_IMPORTANT_POOL_CAP = 100;
+type CurveImportantPoolCoin = {
+    address: string;
+    symbol: string;
+    decimals: number;
+};
+type CurveImportantPoolRow = {
+    id: string;
+    address: string;
+    name: string;
+    coins: CurveImportantPoolCoin[];
+    tvlUsd: number;
+    baseApy: string | null;
+    gaugeCrvApy: string | null;
+    gaugeAddress: string | null;
+};
+declare function curveDaoFetchImportantPools(args: {
+    chainId: number;
+    query?: string;
+}): Promise<{
+    chainId: number;
+    pools: CurveImportantPoolRow[];
+    notes: string;
+}>;
+declare function curveDaoFetchLpYields(args: {
+    chainId: number;
+    query?: string;
+    pool?: string;
+}): Promise<{
+    chainId: number;
+    pools: CurveImportantPoolRow[];
+    notes: string;
+}>;
+
+declare function curveDaoQuoteAddLiquidity(args: {
+    chainId: number;
+    rpcUrl: string;
+    pool: string;
+    amountsHuman: string[];
+    stakeInGauge?: boolean;
+}): Promise<{
+    pool: `0x${string}`;
+    poolId: string;
+    name: string;
+    coins: string[];
+    amountsHuman: string[];
+    expectedLp: string;
+    gauge: string | null;
+    stakeInGauge: boolean;
+    baseApy: string | null;
+    gaugeCrvApy: string | null;
+    notes: string;
+}>;
+declare function curveDaoQuoteRemoveLiquidity(args: {
+    chainId: number;
+    rpcUrl: string;
+    pool: string;
+    lpAmountHuman: string;
+}): Promise<{
+    pool: `0x${string}`;
+    poolId: string;
+    coins: string[];
+    lpAmountHuman: string;
+    expectedAmounts: string[];
+    notes: string;
+}>;
+declare function buildEvmMultisignBodyCurveAddLiquidity(args: {
+    keyGen: KeyGenSubsetForPermit;
+    chainId: number;
+    rpcUrl: string;
+    chainDetail: EvmChainDetail;
+    useCustomGas: boolean;
+    customGasChainDetails?: Record<string, unknown> | null;
+    executorAddress: Address;
+    purposeText: string;
+    pool: string;
+    amountsHuman: string[];
+    slippagePercent: number;
+    stakeInGauge?: boolean;
+}): Promise<MultisignBuildResult>;
+declare function buildEvmMultisignBodyCurveRemoveLiquidity(args: {
+    keyGen: KeyGenSubsetForPermit;
+    chainId: number;
+    rpcUrl: string;
+    chainDetail: EvmChainDetail;
+    useCustomGas: boolean;
+    customGasChainDetails?: Record<string, unknown> | null;
+    executorAddress: Address;
+    purposeText: string;
+    pool: string;
+    lpAmountHuman: string;
+    slippagePercent: number;
+}): Promise<MultisignBuildResult>;
+declare function buildEvmMultisignBodyCurveGaugeDeposit(args: {
+    keyGen: KeyGenSubsetForPermit;
+    chainId: number;
+    rpcUrl: string;
+    chainDetail: EvmChainDetail;
+    useCustomGas: boolean;
+    customGasChainDetails?: Record<string, unknown> | null;
+    executorAddress: Address;
+    purposeText: string;
+    pool: string;
+    lpAmountHuman: string;
+    withdraw?: boolean;
+}): Promise<MultisignBuildResult>;
+
 declare const CURVE_DAO_PROTOCOL_ID = "curve-dao";
 declare const curveDaoProtocolModule: ProtocolModule;
 
@@ -208,4 +315,4 @@ declare const curveDao: {
     loadSession: typeof loadFullCurveSessionForRpc;
 };
 
-export { CURVE_DAO_PROTOCOL_ID, CURVE_NATIVE_PLACEHOLDER, CURVE_ROUTER_EXCHANGE_DEFAULT_GAS_UNITS, type CurveCoinDataRow, type CurveDaoQuoteResult, type CurveDestToken, type CurveFullSession, type CurveSessionSnapshot, addNativeWethBridge, bfsCurveSwapDestinations, buildCurveDaoPurposePrefill, buildCurveLiquidityGraphFromApi, buildEvmMultisignBodyCurveDaoBatch, computeCurveExecutionSlippagePercent, curveDao, curveDaoProtocolModule, curveDaoQuote, curveProbeInAmountString, fetchAllCurvePools, fetchCurveCoinsDataForRpc, formatCurveExchangeLine, formatCurvePriceImpact, formatMinOutAtUserSlippage, isCurveApiChainSupported, isCurveApiChainSupported as isCurveDaoChainSupported, isCurveDaoErc20ApproveEvmSignRequest, isCurveDaoSwapEvmSignRequest, isCurveTokenKeySwappable, loadCurveSessionSnapshotForRpc, loadFullCurveSessionForRpc, normalizeCurveRouterAmountString, resolveCurveDaoRouterGasUnitsFromSignRequest, swappableCurveGraphNodeKeys, toCurveRouterTokenId, toCurveTokenKey };
+export { CURVE_DAO_PROTOCOL_ID, CURVE_IMPORTANT_POOL_CAP, CURVE_NATIVE_PLACEHOLDER, CURVE_ROUTER_EXCHANGE_DEFAULT_GAS_UNITS, type CurveCoinDataRow, type CurveDaoQuoteResult, type CurveDestToken, type CurveFullSession, type CurveImportantPoolCoin, type CurveImportantPoolRow, type CurveSessionSnapshot, addNativeWethBridge, bfsCurveSwapDestinations, buildCurveDaoPurposePrefill, buildCurveLiquidityGraphFromApi, buildEvmMultisignBodyCurveAddLiquidity, buildEvmMultisignBodyCurveDaoBatch, buildEvmMultisignBodyCurveGaugeDeposit, buildEvmMultisignBodyCurveRemoveLiquidity, computeCurveExecutionSlippagePercent, curveDao, curveDaoFetchImportantPools, curveDaoFetchLpYields, curveDaoProtocolModule, curveDaoQuote, curveDaoQuoteAddLiquidity, curveDaoQuoteRemoveLiquidity, curveProbeInAmountString, fetchAllCurvePools, fetchCurveCoinsDataForRpc, formatCurveExchangeLine, formatCurvePriceImpact, formatMinOutAtUserSlippage, isCurveApiChainSupported, isCurveApiChainSupported as isCurveDaoChainSupported, isCurveDaoErc20ApproveEvmSignRequest, isCurveDaoSwapEvmSignRequest, isCurveTokenKeySwappable, loadCurveSessionSnapshotForRpc, loadFullCurveSessionForRpc, normalizeCurveRouterAmountString, resolveCurveDaoRouterGasUnitsFromSignRequest, swappableCurveGraphNodeKeys, toCurveRouterTokenId, toCurveTokenKey };

package/dist/protocols/evm/curve-dao/index.js

@@ -467,25 +467,25 @@ async function buildEvmMultisignBatch(args) {
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
     rpcUrls: { default: { http: [rpcUrl] } }
   });
-  const publicClient = createPublicClient({ chain: ch, transport: http(rpcUrl) });
+  const publicClient2 = createPublicClient({ chain: ch, transport: http(rpcUrl) });
   const feeParams = await fetchChainFeeParams(rpcUrl, chainId);
   const legacy = Boolean(chainDetail?.legacy) || !feeParams.isEip1559;
-  const latestBaseFeeWei = !legacy ? (await publicClient.getBlock({ blockTag: "latest" })).baseFeePerGas ?? 0n : 0n;
+  const latestBaseFeeWei = !legacy ? (await publicClient2.getBlock({ blockTag: "latest" })).baseFeePerGas ?? 0n : 0n;
   const gasLimitConfig = useCustomGas && chainDetail?.gasLimit != null ? Number(chainDetail.gasLimit) : void 0;
   const chainGasLimitRouter = chainDetail?.gasLimit != null && Number.isFinite(Number(chainDetail.gasLimit)) && Number(chainDetail.gasLimit) > 0 ? Number(chainDetail.gasLimit) : void 0;
   const gasFeeMultiplier = useCustomGas && chainDetail?.gasMultiplier != null ? Number(chainDetail.gasMultiplier) : void 0;
   const executor = getAddress(executorAddress);
-  const baseNonce = await publicClient.getTransactionCount({ address: executor, blockTag: "pending" });
+  const baseNonce = await publicClient2.getTransactionCount({ address: executor, blockTag: "pending" });
   const legs = [];
   for (let i = 0; i < steps.length; i++) {
     const step = steps[i];
     const currentNonce = baseNonce + i;
     let estimatedGas;
     if (args.estimateGasForStep) {
-      estimatedGas = await args.estimateGasForStep({ step, index: i, publicClient, executor });
+      estimatedGas = await args.estimateGasForStep({ step, index: i, publicClient: publicClient2, executor });
     } else {
       try {
-        estimatedGas = await publicClient.estimateGas({
+        estimatedGas = await publicClient2.estimateGas({
           to: step.to,
           data: step.data,
           value: step.value,
@@ -497,7 +497,7 @@ async function buildEvmMultisignBatch(args) {
     }
     let gasLimitI;
     if (args.resolveGasLimit) {
-      gasLimitI = await args.resolveGasLimit({ step, index: i, estimatedGas, publicClient });
+      gasLimitI = await args.resolveGasLimit({ step, index: i, estimatedGas, publicClient: publicClient2 });
     } else if (step.routerSwap) {
       gasLimitI = routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimitRouter);
     } else {
@@ -507,7 +507,7 @@ async function buildEvmMultisignBatch(args) {
     let feeSnapshot;
     let serialized;
     if (legacy) {
-      let gasPriceWei = await publicClient.getGasPrice();
+      let gasPriceWei = await publicClient2.getGasPrice();
       if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
         gasPriceWei = gasPriceWei * BigInt(100 + gasFeeMultiplier) / 100n;
       }
@@ -658,37 +658,37 @@ async function buildEvmMultisignBodyCurveDaoBatch(args) {
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
     rpcUrls: { default: { http: [args.rpcUrl] } }
   });
-  const publicClient = createPublicClient({ chain: ch, transport: http(args.rpcUrl) });
-  const erc20AllowanceAbi = parseAbi([
+  const publicClient2 = createPublicClient({ chain: ch, transport: http(args.rpcUrl) });
+  const erc20AllowanceAbi2 = parseAbi([
     "function allowance(address owner, address spender) view returns (uint256)",
     "function decimals() view returns (uint8)"
   ]);
-  const erc20ApproveAbi = parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+  const erc20ApproveAbi2 = parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
   const steps = [];
   if (!isNativeIn) {
-    const decimalsN = await publicClient.readContract({
+    const decimalsN = await publicClient2.readContract({
       address: tokenIn,
-      abi: erc20AllowanceAbi,
+      abi: erc20AllowanceAbi2,
       functionName: "decimals"
     });
     const amountWei = parseUnits(args.amountHuman, Number(decimalsN));
-    const currentAllowance = await publicClient.readContract({
+    const currentAllowance = await publicClient2.readContract({
       address: tokenIn,
-      abi: erc20AllowanceAbi,
+      abi: erc20AllowanceAbi2,
       functionName: "allowance",
       args: [executor, routerAddr]
     });
     if (currentAllowance < amountWei) {
       if (currentAllowance > 0n) {
         const dataReset = encodeFunctionData({
-          abi: erc20ApproveAbi,
+          abi: erc20ApproveAbi2,
           functionName: "approve",
           args: [routerAddr, 0n]
         });
         steps.push({ to: tokenIn, data: dataReset, value: 0n, kind: "approve", fallbackGas: 80000n });
       }
       const dataApprove = encodeFunctionData({
-        abi: erc20ApproveAbi,
+        abi: erc20ApproveAbi2,
         functionName: "approve",
         args: [routerAddr, amountWei]
       });
@@ -798,8 +798,8 @@ async function resolveTokenInDecimals(args) {
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
     rpcUrls: { default: { http: [args.rpcUrl] } }
   });
-  const publicClient = createPublicClient({ chain: ch, transport: http(args.rpcUrl) });
-  const decimalsN = await publicClient.readContract({
+  const publicClient2 = createPublicClient({ chain: ch, transport: http(args.rpcUrl) });
+  const decimalsN = await publicClient2.readContract({
     address: addr,
     abi: erc20DecimalsAbi,
     functionName: "decimals"
@@ -948,6 +948,411 @@ function formatMinOutAtUserSlippage(quoteOutDecimal, userSlippagePercentInput, t
   return `${t} ${sOut}`.trim();
 }
 
+// src/protocols/evm/curve-dao/importantPools.ts
+var CURVE_IMPORTANT_POOL_CAP = 100;
+var CURVE_API_BASE = "https://api.curve.finance/api/getPools";
+var CHAIN_SLUG = {
+  1: "ethereum",
+  10: "optimism",
+  56: "bsc",
+  100: "xdai",
+  137: "polygon",
+  146: "sonic",
+  250: "fantom",
+  324: "zksync",
+  8453: "base",
+  42161: "arbitrum",
+  43114: "avalanche",
+  42220: "celo",
+  1313161554: "aurora"
+};
+var REGISTRIES = [
+  "main",
+  "crypto",
+  "factory",
+  "factory-crypto",
+  "factory-crvusd",
+  "factory-stable-ng",
+  "factory-twocrypto",
+  "factory-tricrypto"
+];
+function formatApy(n) {
+  if (typeof n === "number" && Number.isFinite(n) && n >= 0) return `${n.toFixed(2)}%`;
+  if (Array.isArray(n) && typeof n[0] === "number" && Number.isFinite(n[0])) return `${n[0].toFixed(2)}%`;
+  return null;
+}
+function pickApy(pool, keys) {
+  for (const k of keys) {
+    const label = formatApy(pool[k]);
+    if (label) return label;
+  }
+  return null;
+}
+function mapPool(raw) {
+  const address = String(raw.address ?? raw.id ?? "").trim();
+  if (!address) return null;
+  const tvl = Number(raw.usdTotal ?? raw.tvl ?? raw.usd_total ?? 0);
+  if (!Number.isFinite(tvl) || tvl <= 0) return null;
+  const coinsRaw = raw.coins ?? raw.underlyingCoins ?? [];
+  const coins = coinsRaw.map((c) => ({
+    address: String(c.address ?? c.addr ?? "").trim(),
+    symbol: String(c.symbol ?? c.coinsymbol ?? "").trim() || "TOKEN",
+    decimals: Number(c.decimals ?? 18) || 18
+  })).filter((c) => c.address);
+  if (!coins.length) return null;
+  const gauge = String(raw.gaugeAddress ?? raw.gauge ?? "").trim();
+  return {
+    id: String(raw.id ?? address),
+    address,
+    name: String(raw.name ?? raw.poolName ?? coins.map((c) => c.symbol).join("/")),
+    coins,
+    tvlUsd: tvl,
+    baseApy: pickApy(raw, ["latestDailyApy", "latestWeeklyApy", "baseApy", "apy"]),
+    gaugeCrvApy: pickApy(raw, ["gaugeCrvApy", "gauge_crv_apy", "crvApy"]),
+    gaugeAddress: gauge || null
+  };
+}
+async function fetchRegistry(slug, registry) {
+  try {
+    const res = await fetch(`${CURVE_API_BASE}/${slug}/${registry}`, { cache: "no-store" });
+    if (!res.ok) return [];
+    const j = await res.json();
+    return j.data?.poolData ?? j.poolData ?? [];
+  } catch {
+    return [];
+  }
+}
+async function curveDaoFetchImportantPools(args) {
+  if (!isCurveApiChainSupported(args.chainId)) {
+    return { chainId: args.chainId, pools: [], notes: `Curve is not supported on chain ${args.chainId}.` };
+  }
+  const slug = CHAIN_SLUG[args.chainId];
+  if (!slug) {
+    return { chainId: args.chainId, pools: [], notes: `No official Curve API slug for chain ${args.chainId}.` };
+  }
+  const pages = await Promise.all(REGISTRIES.map((r) => fetchRegistry(slug, r)));
+  const byAddr = /* @__PURE__ */ new Map();
+  for (const raw of pages.flat()) {
+    const row = mapPool(raw);
+    if (!row) continue;
+    const key = row.address.toLowerCase();
+    const prev = byAddr.get(key);
+    if (!prev || row.tvlUsd > prev.tvlUsd) byAddr.set(key, row);
+  }
+  let pools = [...byAddr.values()].sort((a, b) => b.tvlUsd - a.tvlUsd);
+  const q = (args.query ?? "").trim().toLowerCase();
+  if (q) {
+    pools = pools.filter(
+      (p) => [p.name, p.address, p.id, ...p.coins.map((c) => c.symbol)].join(" ").toLowerCase().includes(q)
+    );
+  }
+  pools = pools.slice(0, CURVE_IMPORTANT_POOL_CAP);
+  return {
+    chainId: args.chainId,
+    pools,
+    notes: `Official api.curve.fi catalog, TVL-ranked, hard cap ${CURVE_IMPORTANT_POOL_CAP}. Dead/zero-TVL dropped. Do not call fetchAllCurvePools or invent a list-all-pools tool. gauge_crv_apy requires staking LP in the gauge.`
+  };
+}
+async function curveDaoFetchLpYields(args) {
+  const { pools, notes } = await curveDaoFetchImportantPools({ chainId: args.chainId, query: args.query });
+  const poolFilter = (args.pool ?? "").trim().toLowerCase();
+  const filtered = poolFilter ? pools.filter((p) => p.address.toLowerCase() === poolFilter || p.id.toLowerCase() === poolFilter) : pools;
+  return { chainId: args.chainId, pools: filtered, notes };
+}
+var erc20ApproveAbi = parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+var erc20AllowanceAbi = parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function decimals() view returns (uint8)"
+]);
+var gaugeAbi = parseAbi(["function deposit(uint256 value)", "function withdraw(uint256 value)"]);
+function findCurvePool(curve, poolRef) {
+  const want = poolRef.trim().toLowerCase();
+  const ids = [];
+  try {
+    ids.push(...curve.getPoolList?.() ?? []);
+  } catch {
+  }
+  for (const id of ids) {
+    try {
+      const p = curve.getPool(id);
+      if (!p) continue;
+      if (String(p.id ?? "").toLowerCase() === want) return p;
+      if (String(p.address ?? "").toLowerCase() === want) return p;
+    } catch {
+    }
+  }
+  throw new Error(
+    `Curve pool ${poolRef} is not in the loaded session. Copy address/id from ctm_curve_dao_fetch_important_pools.`
+  );
+}
+function addLiquidityAbi(n, ng) {
+  if (ng) return parseAbi(["function add_liquidity(uint256[] amounts, uint256 min_mint_amount)"]);
+  if (n === 2) return parseAbi(["function add_liquidity(uint256[2] amounts, uint256 min_mint_amount)"]);
+  if (n === 3) return parseAbi(["function add_liquidity(uint256[3] amounts, uint256 min_mint_amount)"]);
+  if (n === 4) return parseAbi(["function add_liquidity(uint256[4] amounts, uint256 min_mint_amount)"]);
+  return parseAbi(["function add_liquidity(uint256[] amounts, uint256 min_mint_amount)"]);
+}
+function removeLiquidityAbi(n, ng) {
+  if (ng) return parseAbi(["function remove_liquidity(uint256 amount, uint256[] min_amounts)"]);
+  if (n === 2) return parseAbi(["function remove_liquidity(uint256 amount, uint256[2] min_amounts)"]);
+  if (n === 3) return parseAbi(["function remove_liquidity(uint256 amount, uint256[3] min_amounts)"]);
+  if (n === 4) return parseAbi(["function remove_liquidity(uint256 amount, uint256[4] min_amounts)"]);
+  return parseAbi(["function remove_liquidity(uint256 amount, uint256[] min_amounts)"]);
+}
+function applySlippage(expected, slipPercent) {
+  const bps = BigInt(Math.round((1 - slipPercent / 100) * 1e4));
+  return expected * bps / 10000n;
+}
+function publicClient(rpcUrl, chainId) {
+  const ch = defineChain({
+    id: chainId,
+    name: "CurveLp",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  return createPublicClient({ chain: ch, transport: http(rpcUrl) });
+}
+function isNativeCoin(addr) {
+  return addr.trim().toLowerCase() === CURVE_NATIVE_PLACEHOLDER.toLowerCase();
+}
+async function curveDaoQuoteAddLiquidity(args) {
+  const session = await loadFullCurveSessionForRpc(args.rpcUrl);
+  const pool = findCurvePool(session.curve, args.pool);
+  const coins = pool.underlyingCoins ?? pool.wrappedCoins ?? [];
+  if (args.amountsHuman.length !== coins.length) {
+    throw new Error(`Expected ${coins.length} amounts (coins: ${coins.join(", ")}).`);
+  }
+  const expected = await pool.depositExpected(args.amountsHuman);
+  const catalog = await curveDaoFetchImportantPools({ chainId: args.chainId, query: args.pool });
+  const meta = catalog.pools.find(
+    (p) => p.address.toLowerCase() === String(pool.address).toLowerCase() || p.id.toLowerCase() === String(pool.id).toLowerCase()
+  );
+  const gauge = String(pool.gauge?.address ?? meta?.gaugeAddress ?? "");
+  return {
+    pool: getAddress(pool.address),
+    poolId: String(pool.id),
+    name: String(pool.name ?? pool.fullName ?? ""),
+    coins,
+    amountsHuman: args.amountsHuman,
+    expectedLp: expected,
+    gauge: gauge || null,
+    stakeInGauge: Boolean(args.stakeInGauge && gauge),
+    baseApy: meta?.baseApy ?? null,
+    gaugeCrvApy: meta?.gaugeCrvApy ?? null,
+    notes: meta?.gaugeCrvApy ? "gauge_crv_apy requires staking the LP token in the gauge (stakeInGauge or ctm_curve_dao_build_gauge_deposit_multisign)." : "Fee APY only unless this pool advertises gauge_crv_apy."
+  };
+}
+async function curveDaoQuoteRemoveLiquidity(args) {
+  const session = await loadFullCurveSessionForRpc(args.rpcUrl);
+  const pool = findCurvePool(session.curve, args.pool);
+  const coins = pool.underlyingCoins ?? pool.wrappedCoins ?? [];
+  const expected = await pool.withdrawExpected(args.lpAmountHuman);
+  return {
+    pool: getAddress(pool.address),
+    poolId: String(pool.id),
+    coins,
+    lpAmountHuman: args.lpAmountHuman,
+    expectedAmounts: expected,
+    notes: "Balanced remove. Gauge must be unstaked first if LP is in the gauge."
+  };
+}
+async function pushApproves(args) {
+  for (const { token, amount, spender } of args.tokens) {
+    if (amount <= 0n || isNativeCoin(token)) continue;
+    const current = await args.client.readContract({ address: token, abi: erc20AllowanceAbi, functionName: "allowance", args: [args.owner, spender] }).catch(() => 0n);
+    if (current >= amount) continue;
+    if (current > 0n) {
+      args.steps.push({
+        to: token,
+        data: encodeFunctionData({ abi: erc20ApproveAbi, functionName: "approve", args: [spender, 0n] }),
+        value: 0n
+      });
+    }
+    args.steps.push({
+      to: token,
+      data: encodeFunctionData({ abi: erc20ApproveAbi, functionName: "approve", args: [spender, amount] }),
+      value: 0n
+    });
+  }
+}
+async function buildEvmMultisignBodyCurveAddLiquidity(args) {
+  const slip = args.slippagePercent;
+  if (!Number.isFinite(slip) || slip <= 0 || slip >= 100) {
+    throw new Error("Slippage must be between 0 and 100 (exclusive).");
+  }
+  const session = await loadFullCurveSessionForRpc(args.rpcUrl);
+  const pool = findCurvePool(session.curve, args.pool);
+  const coins = pool.underlyingCoinAddresses ?? pool.wrappedCoinAddresses ?? [];
+  const decimals = pool.underlyingDecimals ?? pool.wrappedDecimals ?? coins.map(() => 18);
+  if (args.amountsHuman.length !== coins.length) {
+    throw new Error(`Expected ${coins.length} amounts.`);
+  }
+  const amounts = args.amountsHuman.map((h, i) => parseUnits(h.trim() || "0", decimals[i] ?? 18));
+  const expectedHuman = await pool.depositExpected(args.amountsHuman);
+  const expectedLp = parseUnits(expectedHuman, 18);
+  const minMint = applySlippage(expectedLp, slip);
+  const ng = Boolean(pool.isNg);
+  const abi = addLiquidityAbi(coins.length, ng);
+  const amountsArg = ng ? amounts : amounts;
+  const data = encodeFunctionData({
+    abi,
+    functionName: "add_liquidity",
+    args: [amountsArg, minMint]
+  });
+  const poolAddr = getAddress(pool.address);
+  const executor = getAddress(args.executorAddress);
+  const client = publicClient(args.rpcUrl, args.chainId);
+  const steps = [];
+  await pushApproves({
+    client,
+    steps,
+    owner: executor,
+    tokens: coins.map((c, i) => ({
+      token: isNativeCoin(c) ? CURVE_NATIVE_PLACEHOLDER : getAddress(c),
+      amount: amounts[i],
+      spender: poolAddr
+    }))
+  });
+  const value = coins.reduce((acc, c, i) => isNativeCoin(c) ? acc + amounts[i] : acc, 0n);
+  steps.push({ to: poolAddr, data, value });
+  if (args.stakeInGauge) {
+    const gaugeAddr = String(pool.gauge?.address ?? "").trim();
+    if (!gaugeAddr || gaugeAddr.toLowerCase() === "0x0000000000000000000000000000000000000000") {
+      throw new Error("This pool has no gauge. Fee APY only \u2014 omit stakeInGauge.");
+    }
+    const lp = getAddress(pool.lpToken || pool.address);
+    await pushApproves({
+      client,
+      steps,
+      owner: executor,
+      tokens: [{ token: lp, amount: expectedLp, spender: getAddress(gaugeAddr) }]
+    });
+    steps.push({
+      to: getAddress(gaugeAddr),
+      data: encodeFunctionData({ abi: gaugeAbi, functionName: "deposit", args: [expectedLp] }),
+      value: 0n
+    });
+  }
+  return finishCurveLpBatch({
+    args,
+    executor,
+    steps,
+    purposeSuffix: args.stakeInGauge ? "Curve LP: approve + add_liquidity + gauge.deposit" : "Curve LP: approve + add_liquidity",
+    evmType: "curve_dao_add_liquidity"
+  });
+}
+async function buildEvmMultisignBodyCurveRemoveLiquidity(args) {
+  const slip = args.slippagePercent;
+  if (!Number.isFinite(slip) || slip <= 0 || slip >= 100) {
+    throw new Error("Slippage must be between 0 and 100 (exclusive).");
+  }
+  const session = await loadFullCurveSessionForRpc(args.rpcUrl);
+  const pool = findCurvePool(session.curve, args.pool);
+  const coins = pool.underlyingCoinAddresses ?? pool.wrappedCoinAddresses ?? [];
+  const expected = await pool.withdrawExpected(args.lpAmountHuman);
+  const decimals = pool.underlyingDecimals ?? pool.wrappedDecimals ?? coins.map(() => 18);
+  const minAmounts = expected.map((h, i) => applySlippage(parseUnits(h || "0", decimals[i] ?? 18), slip));
+  const lpAmount = parseUnits(args.lpAmountHuman, 18);
+  const ng = Boolean(pool.isNg);
+  const abi = removeLiquidityAbi(coins.length, ng);
+  const minArg = ng ? minAmounts : minAmounts;
+  const data = encodeFunctionData({
+    abi,
+    functionName: "remove_liquidity",
+    args: [lpAmount, minArg]
+  });
+  const poolAddr = getAddress(pool.address);
+  const lp = getAddress(pool.lpToken || pool.address);
+  const executor = getAddress(args.executorAddress);
+  const client = publicClient(args.rpcUrl, args.chainId);
+  const steps = [];
+  await pushApproves({
+    client,
+    steps,
+    owner: executor,
+    tokens: [{ token: lp, amount: lpAmount, spender: poolAddr }]
+  });
+  steps.push({ to: poolAddr, data, value: 0n });
+  return finishCurveLpBatch({
+    args,
+    executor,
+    steps,
+    purposeSuffix: "Curve LP: approve + remove_liquidity",
+    evmType: "curve_dao_remove_liquidity"
+  });
+}
+async function buildEvmMultisignBodyCurveGaugeDeposit(args) {
+  const session = await loadFullCurveSessionForRpc(args.rpcUrl);
+  const pool = findCurvePool(session.curve, args.pool);
+  const gaugeAddr = String(pool.gauge?.address ?? "").trim();
+  if (!gaugeAddr || gaugeAddr.toLowerCase() === "0x0000000000000000000000000000000000000000") {
+    throw new Error("This pool has no gauge.");
+  }
+  const lpAmount = parseUnits(args.lpAmountHuman, 18);
+  const executor = getAddress(args.executorAddress);
+  const lp = getAddress(pool.lpToken || pool.address);
+  const client = publicClient(args.rpcUrl, args.chainId);
+  const steps = [];
+  if (!args.withdraw) {
+    await pushApproves({
+      client,
+      steps,
+      owner: executor,
+      tokens: [{ token: lp, amount: lpAmount, spender: getAddress(gaugeAddr) }]
+    });
+    steps.push({
+      to: getAddress(gaugeAddr),
+      data: encodeFunctionData({ abi: gaugeAbi, functionName: "deposit", args: [lpAmount] }),
+      value: 0n
+    });
+  } else {
+    steps.push({
+      to: getAddress(gaugeAddr),
+      data: encodeFunctionData({ abi: gaugeAbi, functionName: "withdraw", args: [lpAmount] }),
+      value: 0n
+    });
+  }
+  return finishCurveLpBatch({
+    args,
+    executor,
+    steps,
+    purposeSuffix: args.withdraw ? "Curve LP: gauge.withdraw" : "Curve LP: approve + gauge.deposit",
+    evmType: args.withdraw ? "curve_dao_gauge_withdraw" : "curve_dao_gauge_deposit"
+  });
+}
+function finishCurveLpBatch(opts) {
+  const first = opts.steps[0];
+  if (!first) throw new Error("No Curve LP transaction steps.");
+  const firstDataNo0x = first.data.startsWith("0x") ? first.data.slice(2) : first.data;
+  const payableValueWei = opts.steps.reduce((a, s) => a + (s.value ?? 0n), 0n);
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: opts.args.keyGen,
+      purposeText: opts.args.purposeText,
+      chainId: opts.args.chainId,
+      rpcUrl: opts.args.rpcUrl,
+      executorAddress: opts.executor,
+      chainDetail: opts.args.chainDetail,
+      useCustomGas: opts.args.useCustomGas,
+      customGasChainDetails: opts.args.customGasChainDetails
+    },
+    steps: opts.steps,
+    purposeSuffix: opts.purposeSuffix,
+    firstMsgRawNo0x: firstDataNo0x,
+    destinationAddress: first.to,
+    payableValueWei: payableValueWei > 0n ? payableValueWei : void 0,
+    buildBatchMeta: ({ step }) => ({
+      signatureText: JSON.stringify({
+        kind: "CurveDao",
+        name: opts.evmType,
+        to: step.to
+      }),
+      evm: { type: opts.evmType, version: 1, chainId: String(opts.args.chainId) }
+    })
+  });
+}
+
 // src/protocols/evm/curve-dao/index.ts
 var CURVE_DAO_PROTOCOL_ID = "curve-dao";
 var curveDaoProtocolModule = {
@@ -987,6 +1392,22 @@ var curveDaoProtocolModule = {
         amountHuman: { type: "string", required: true, description: "Human-readable input amount" },
         slippagePercent: { type: "number", required: true, description: "Slippage percent (0\u2013100 exclusive)" }
       }
+    },
+    {
+      id: "curve-dao.add-liquidity",
+      protocolId: CURVE_DAO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Add liquidity to an important Curve pool (optional gauge stake)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "curve-dao.remove-liquidity",
+      protocolId: CURVE_DAO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Remove liquidity from an important Curve pool",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
     }
   ]
 };
@@ -997,6 +1418,6 @@ var curveDao = {
   loadSession: loadFullCurveSessionForRpc
 };
 
-export { CURVE_DAO_PROTOCOL_ID, CURVE_NATIVE_PLACEHOLDER, CURVE_ROUTER_EXCHANGE_DEFAULT_GAS_UNITS, addNativeWethBridge, bfsCurveSwapDestinations, buildCurveDaoPurposePrefill, buildCurveLiquidityGraphFromApi, buildEvmMultisignBodyCurveDaoBatch, computeCurveExecutionSlippagePercent, curveDao, curveDaoProtocolModule, curveDaoQuote, curveProbeInAmountString, fetchAllCurvePools, fetchCurveCoinsDataForRpc, formatCurveExchangeLine, formatCurvePriceImpact, formatMinOutAtUserSlippage, isCurveApiChainSupported, isCurveApiChainSupported as isCurveDaoChainSupported, isCurveDaoErc20ApproveEvmSignRequest, isCurveDaoSwapEvmSignRequest, isCurveTokenKeySwappable, loadCurveSessionSnapshotForRpc, loadFullCurveSessionForRpc, normalizeCurveRouterAmountString, resolveCurveDaoRouterGasUnitsFromSignRequest, swappableCurveGraphNodeKeys, toCurveRouterTokenId, toCurveTokenKey };
+export { CURVE_DAO_PROTOCOL_ID, CURVE_IMPORTANT_POOL_CAP, CURVE_NATIVE_PLACEHOLDER, CURVE_ROUTER_EXCHANGE_DEFAULT_GAS_UNITS, addNativeWethBridge, bfsCurveSwapDestinations, buildCurveDaoPurposePrefill, buildCurveLiquidityGraphFromApi, buildEvmMultisignBodyCurveAddLiquidity, buildEvmMultisignBodyCurveDaoBatch, buildEvmMultisignBodyCurveGaugeDeposit, buildEvmMultisignBodyCurveRemoveLiquidity, computeCurveExecutionSlippagePercent, curveDao, curveDaoFetchImportantPools, curveDaoFetchLpYields, curveDaoProtocolModule, curveDaoQuote, curveDaoQuoteAddLiquidity, curveDaoQuoteRemoveLiquidity, curveProbeInAmountString, fetchAllCurvePools, fetchCurveCoinsDataForRpc, formatCurveExchangeLine, formatCurvePriceImpact, formatMinOutAtUserSlippage, isCurveApiChainSupported, isCurveApiChainSupported as isCurveDaoChainSupported, isCurveDaoErc20ApproveEvmSignRequest, isCurveDaoSwapEvmSignRequest, isCurveTokenKeySwappable, loadCurveSessionSnapshotForRpc, loadFullCurveSessionForRpc, normalizeCurveRouterAmountString, resolveCurveDaoRouterGasUnitsFromSignRequest, swappableCurveGraphNodeKeys, toCurveRouterTokenId, toCurveTokenKey };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map