@continuumdao/ctm-mpc-defi 0.2.34 → 0.2.35

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

@@ -469,25 +469,25 @@ async function buildEvmMultisignBatch(args) {
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
     rpcUrls: { default: { http: [rpcUrl] } }
   });
-  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(rpcUrl) });
+  const publicClient2 = viem.createPublicClient({ chain: ch, transport: viem.http(rpcUrl) });
   const feeParams = await continuumNodeSdk.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 = viem.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,
@@ -499,7 +499,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 {
@@ -509,7 +509,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;
       }
@@ -660,37 +660,37 @@ async function buildEvmMultisignBodyCurveDaoBatch(args) {
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
     rpcUrls: { default: { http: [args.rpcUrl] } }
   });
-  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
-  const erc20AllowanceAbi = viem.parseAbi([
+  const publicClient2 = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const erc20AllowanceAbi2 = viem.parseAbi([
     "function allowance(address owner, address spender) view returns (uint256)",
     "function decimals() view returns (uint8)"
   ]);
-  const erc20ApproveAbi = viem.parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+  const erc20ApproveAbi2 = viem.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 = viem.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 = viem.encodeFunctionData({
-          abi: erc20ApproveAbi,
+          abi: erc20ApproveAbi2,
           functionName: "approve",
           args: [routerAddr, 0n]
         });
         steps.push({ to: tokenIn, data: dataReset, value: 0n, kind: "approve", fallbackGas: 80000n });
       }
       const dataApprove = viem.encodeFunctionData({
-        abi: erc20ApproveAbi,
+        abi: erc20ApproveAbi2,
         functionName: "approve",
         args: [routerAddr, amountWei]
       });
@@ -800,8 +800,8 @@ async function resolveTokenInDecimals(args) {
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
     rpcUrls: { default: { http: [args.rpcUrl] } }
   });
-  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
-  const decimalsN = await publicClient.readContract({
+  const publicClient2 = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl) });
+  const decimalsN = await publicClient2.readContract({
     address: addr,
     abi: erc20DecimalsAbi,
     functionName: "decimals"
@@ -950,6 +950,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 = viem.parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+var erc20AllowanceAbi = viem.parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function decimals() view returns (uint8)"
+]);
+var gaugeAbi = viem.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 viem.parseAbi(["function add_liquidity(uint256[] amounts, uint256 min_mint_amount)"]);
+  if (n === 2) return viem.parseAbi(["function add_liquidity(uint256[2] amounts, uint256 min_mint_amount)"]);
+  if (n === 3) return viem.parseAbi(["function add_liquidity(uint256[3] amounts, uint256 min_mint_amount)"]);
+  if (n === 4) return viem.parseAbi(["function add_liquidity(uint256[4] amounts, uint256 min_mint_amount)"]);
+  return viem.parseAbi(["function add_liquidity(uint256[] amounts, uint256 min_mint_amount)"]);
+}
+function removeLiquidityAbi(n, ng) {
+  if (ng) return viem.parseAbi(["function remove_liquidity(uint256 amount, uint256[] min_amounts)"]);
+  if (n === 2) return viem.parseAbi(["function remove_liquidity(uint256 amount, uint256[2] min_amounts)"]);
+  if (n === 3) return viem.parseAbi(["function remove_liquidity(uint256 amount, uint256[3] min_amounts)"]);
+  if (n === 4) return viem.parseAbi(["function remove_liquidity(uint256 amount, uint256[4] min_amounts)"]);
+  return viem.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 = viem.defineChain({
+    id: chainId,
+    name: "CurveLp",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  return viem.createPublicClient({ chain: ch, transport: viem.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: viem.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: viem.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: viem.encodeFunctionData({ abi: erc20ApproveAbi, functionName: "approve", args: [spender, 0n] }),
+        value: 0n
+      });
+    }
+    args.steps.push({
+      to: token,
+      data: viem.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) => viem.parseUnits(h.trim() || "0", decimals[i] ?? 18));
+  const expectedHuman = await pool.depositExpected(args.amountsHuman);
+  const expectedLp = viem.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 = viem.encodeFunctionData({
+    abi,
+    functionName: "add_liquidity",
+    args: [amountsArg, minMint]
+  });
+  const poolAddr = viem.getAddress(pool.address);
+  const executor = viem.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 : viem.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 = viem.getAddress(pool.lpToken || pool.address);
+    await pushApproves({
+      client,
+      steps,
+      owner: executor,
+      tokens: [{ token: lp, amount: expectedLp, spender: viem.getAddress(gaugeAddr) }]
+    });
+    steps.push({
+      to: viem.getAddress(gaugeAddr),
+      data: viem.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(viem.parseUnits(h || "0", decimals[i] ?? 18), slip));
+  const lpAmount = viem.parseUnits(args.lpAmountHuman, 18);
+  const ng = Boolean(pool.isNg);
+  const abi = removeLiquidityAbi(coins.length, ng);
+  const minArg = ng ? minAmounts : minAmounts;
+  const data = viem.encodeFunctionData({
+    abi,
+    functionName: "remove_liquidity",
+    args: [lpAmount, minArg]
+  });
+  const poolAddr = viem.getAddress(pool.address);
+  const lp = viem.getAddress(pool.lpToken || pool.address);
+  const executor = viem.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 = viem.parseUnits(args.lpAmountHuman, 18);
+  const executor = viem.getAddress(args.executorAddress);
+  const lp = viem.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: viem.getAddress(gaugeAddr) }]
+    });
+    steps.push({
+      to: viem.getAddress(gaugeAddr),
+      data: viem.encodeFunctionData({ abi: gaugeAbi, functionName: "deposit", args: [lpAmount] }),
+      value: 0n
+    });
+  } else {
+    steps.push({
+      to: viem.getAddress(gaugeAddr),
+      data: viem.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 = {
@@ -989,6 +1394,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: {}
     }
   ]
 };
@@ -1000,17 +1421,25 @@ var curveDao = {
 };
 
 exports.CURVE_DAO_PROTOCOL_ID = CURVE_DAO_PROTOCOL_ID;
+exports.CURVE_IMPORTANT_POOL_CAP = CURVE_IMPORTANT_POOL_CAP;
 exports.CURVE_NATIVE_PLACEHOLDER = CURVE_NATIVE_PLACEHOLDER;
 exports.CURVE_ROUTER_EXCHANGE_DEFAULT_GAS_UNITS = CURVE_ROUTER_EXCHANGE_DEFAULT_GAS_UNITS;
 exports.addNativeWethBridge = addNativeWethBridge;
 exports.bfsCurveSwapDestinations = bfsCurveSwapDestinations;
 exports.buildCurveDaoPurposePrefill = buildCurveDaoPurposePrefill;
 exports.buildCurveLiquidityGraphFromApi = buildCurveLiquidityGraphFromApi;
+exports.buildEvmMultisignBodyCurveAddLiquidity = buildEvmMultisignBodyCurveAddLiquidity;
 exports.buildEvmMultisignBodyCurveDaoBatch = buildEvmMultisignBodyCurveDaoBatch;
+exports.buildEvmMultisignBodyCurveGaugeDeposit = buildEvmMultisignBodyCurveGaugeDeposit;
+exports.buildEvmMultisignBodyCurveRemoveLiquidity = buildEvmMultisignBodyCurveRemoveLiquidity;
 exports.computeCurveExecutionSlippagePercent = computeCurveExecutionSlippagePercent;
 exports.curveDao = curveDao;
+exports.curveDaoFetchImportantPools = curveDaoFetchImportantPools;
+exports.curveDaoFetchLpYields = curveDaoFetchLpYields;
 exports.curveDaoProtocolModule = curveDaoProtocolModule;
 exports.curveDaoQuote = curveDaoQuote;
+exports.curveDaoQuoteAddLiquidity = curveDaoQuoteAddLiquidity;
+exports.curveDaoQuoteRemoveLiquidity = curveDaoQuoteRemoveLiquidity;
 exports.curveProbeInAmountString = curveProbeInAmountString;
 exports.fetchAllCurvePools = fetchAllCurvePools;
 exports.fetchCurveCoinsDataForRpc = fetchCurveCoinsDataForRpc;