@continuumdao/ctm-mpc-defi 0.1.3

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

@@ -0,0 +1,869 @@
+'use strict';
+
+var viem = require('viem');
+
+// src/core/registry.ts
+var modules = [];
+function registerProtocolModule(mod) {
+  const existing = modules.findIndex((m) => m.id === mod.id);
+  if (existing >= 0) {
+    modules[existing] = mod;
+  } else {
+    modules.push(mod);
+  }
+}
+
+// src/chains/evm/chainIdParse.ts
+function parseEvmChainIdToNumber(chainId) {
+  if (chainId == null) return Number.NaN;
+  if (typeof chainId === "bigint") {
+    const n = Number(chainId);
+    return Number.isSafeInteger(n) && n >= 0 ? n : Number.NaN;
+  }
+  if (typeof chainId === "number") {
+    return Number.isInteger(chainId) && chainId >= 0 ? chainId : Number.NaN;
+  }
+  const t = String(chainId).trim();
+  if (!t) return Number.NaN;
+  const low = t.toLowerCase();
+  if (low.startsWith("eip155:")) {
+    const rest = t.slice("eip155:".length).trim();
+    const n = Number.parseInt(rest, 10);
+    return Number.isNaN(n) || n < 0 ? Number.NaN : n;
+  }
+  if (low.startsWith("0x")) {
+    return Number.parseInt(t, 16);
+  }
+  return Number.parseInt(t, 10);
+}
+
+// src/protocols/evm/curve-dao/support.ts
+var CURVE_FULL_NETWORK_CONSTANTS_CHAIN_IDS = /* @__PURE__ */ new Set([
+  1,
+  10,
+  56,
+  100,
+  137,
+  146,
+  196,
+  250,
+  252,
+  324,
+  999,
+  1284,
+  2222,
+  5e3,
+  8453,
+  42161,
+  42220,
+  43114,
+  1313161554
+]);
+function isCurveApiChainSupported(chainId) {
+  const n = parseEvmChainIdToNumber(chainId);
+  if (Number.isNaN(n) || n < 0) return false;
+  return CURVE_FULL_NETWORK_CONSTANTS_CHAIN_IDS.has(n);
+}
+var CURVE_NATIVE_PLACEHOLDER = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+var ETH_PLACEHOLDER = CURVE_NATIVE_PLACEHOLDER;
+function normalizeAddr(a) {
+  return a.toLowerCase();
+}
+function toCurveTokenKey(tokenInAddress, wrappedNative) {
+  if (!viem.isAddress(tokenInAddress)) return normalizeAddr(tokenInAddress);
+  try {
+    const a = viem.getAddress(tokenInAddress);
+    if (wrappedNative && a.toLowerCase() === wrappedNative.toLowerCase()) {
+      return ETH_PLACEHOLDER;
+    }
+    return a.toLowerCase();
+  } catch {
+    return normalizeAddr(tokenInAddress);
+  }
+}
+function toCurveRouterTokenId(tokenAddress, wrappedNative) {
+  const t = (tokenAddress ?? "").trim().toLowerCase();
+  if (t === ETH_PLACEHOLDER) return ETH_PLACEHOLDER;
+  if (!viem.isAddress((tokenAddress ?? "").trim())) return normalizeAddr((tokenAddress ?? "").trim());
+  try {
+    const a = viem.getAddress((tokenAddress ?? "").trim());
+    if (wrappedNative && a.toLowerCase() === wrappedNative.toLowerCase()) {
+      return ETH_PLACEHOLDER;
+    }
+    return a.toLowerCase();
+  } catch {
+    return normalizeAddr((tokenAddress ?? "").trim());
+  }
+}
+function normalizeCurveRouterAmountString(raw, tokenInDecimals) {
+  const t = raw.trim().replace(/,/g, "");
+  if (!t) return "";
+  if (!Number.isInteger(tokenInDecimals) || tokenInDecimals < 0 || tokenInDecimals > 18) {
+    throw new Error("Invalid token-in decimals for amount normalization.");
+  }
+  const wei = viem.parseUnits(t, tokenInDecimals);
+  return viem.formatUnits(wei, tokenInDecimals);
+}
+function addEdge(adj, a, b) {
+  if (a === b) return;
+  if (!adj.has(a)) adj.set(a, /* @__PURE__ */ new Set());
+  if (!adj.has(b)) adj.set(b, /* @__PURE__ */ new Set());
+  adj.get(a).add(b);
+  adj.get(b).add(a);
+}
+function buildCurveLiquidityGraphFromApi(curve) {
+  const adj = /* @__PURE__ */ new Map();
+  for (const id of curve.getPoolList()) {
+    try {
+      const pool = curve.getPool(id);
+      const w = (pool.wrappedCoinAddresses ?? []).map(normalizeAddr);
+      const u = (pool.underlyingCoinAddresses ?? []).map(normalizeAddr);
+      const all = [.../* @__PURE__ */ new Set([...w, ...u])];
+      for (let i = 0; i < all.length; i++) {
+        for (let j = i + 1; j < all.length; j++) {
+          addEdge(adj, all[i], all[j]);
+        }
+      }
+    } catch {
+    }
+  }
+  return adj;
+}
+function addNativeWethBridge(adj, wrappedNative) {
+  if (!wrappedNative) return;
+  const w = wrappedNative.toLowerCase();
+  const a = ETH_PLACEHOLDER;
+  const b = w;
+  if (a === b) return;
+  if (!adj.has(a)) adj.set(a, /* @__PURE__ */ new Set());
+  if (!adj.has(b)) adj.set(b, /* @__PURE__ */ new Set());
+  adj.get(a).add(b);
+  adj.get(b).add(a);
+}
+function isCurveTokenKeySwappable(swappableNodeKeys, graphTokenKey) {
+  return swappableNodeKeys.has(graphTokenKey);
+}
+function swappableCurveGraphNodeKeys(adj) {
+  const out = /* @__PURE__ */ new Set();
+  for (const [k, neigh] of adj) {
+    if (neigh.size > 0) out.add(k);
+  }
+  return out;
+}
+function bfsCurveSwapDestinations(adj, start) {
+  const s = normalizeAddr(start);
+  const visited = /* @__PURE__ */ new Set([s]);
+  const q = [s];
+  while (q.length) {
+    const n = q.shift();
+    for (const nxt of adj.get(n) ?? []) {
+      if (!visited.has(nxt)) {
+        visited.add(nxt);
+        q.push(nxt);
+      }
+    }
+  }
+  visited.delete(s);
+  return visited;
+}
+
+// src/protocols/evm/curve-dao/apiSession.ts
+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())
+  ]);
+}
+async function loadFullCurveSessionForRpc(rpcUrl) {
+  const url = (rpcUrl ?? "").trim();
+  if (!url) return null;
+  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 {
+        curve,
+        adj: /* @__PURE__ */ new Map(),
+        swappableNodeKeys: /* @__PURE__ */ new Set(),
+        wrappedNative: wrapped
+      };
+    }
+    await fetchAllCurvePools(curve);
+    const adj = buildCurveLiquidityGraphFromApi(curve);
+    addNativeWethBridge(adj, wrapped);
+    return {
+      curve,
+      adj,
+      swappableNodeKeys: swappableCurveGraphNodeKeys(adj),
+      wrappedNative: wrapped
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/protocols/evm/curve-dao/purpose.ts
+function buildCurveDaoPurposePrefill(args) {
+  const symIn = (args.tokenInSymbol || "").trim() || "token in";
+  const symOut = (args.tokenOutSymbol || "").trim() || "token out";
+  const rawS = String(args.slippageInput || "0.5").trim().replace(/,/g, "");
+  const parsedSlip = Number.parseFloat(rawS);
+  const slip = Number.isFinite(parsedSlip) ? parsedSlip : 0.5;
+  const slipText = (Math.round(slip * 100) / 100).toString();
+  const cname = (args.chainName || "").trim() || "chain";
+  const amt = (args.amountIn || "").trim();
+  const qo = (args.quoteOutAmount || "").trim();
+  let mid;
+  if (amt && qo) {
+    mid = `${amt} ${symIn} for an estimated ${qo} ${symOut}`;
+  } else if (amt) {
+    mid = `${amt} ${symIn} for an estimated output in ${symOut}`;
+  } else {
+    mid = `\u2026 ${symIn} \u2192 ${symOut}`;
+  }
+  return `Curve: swap ${mid} (max slippage ${slipText}%) on ${cname} (chainId ${args.chainId})`;
+}
+
+// src/protocols/evm/curve-dao/executeHelpers.ts
+function parseOptionalGasLimitString(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 parseExtraJsonObject(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;
+}
+var CURVE_ROUTER_EXCHANGE_DEFAULT_GAS_UNITS = 1200000n;
+function isCurveDaoSwapEvmSignRequest(detail, batchIndex) {
+  const ex = parseExtraJsonObject(detail);
+  if (batchIndex != null && batchIndex >= 0 && ex) {
+    const bm = ex.batchMeta;
+    if (Array.isArray(bm) && bm[batchIndex] && typeof bm[batchIndex] === "object" && !Array.isArray(bm[batchIndex])) {
+      const evm0 = bm[batchIndex].evm;
+      if (evm0 && typeof evm0 === "object" && !Array.isArray(evm0)) {
+        if (String(evm0.type ?? "") === "curve_dao_router_exchange") return true;
+      }
+    }
+  }
+  const evm = ex?.evm;
+  if (!evm || typeof evm !== "object" || Array.isArray(evm)) return false;
+  return String(evm.type ?? "") === "curve_dao_router_exchange";
+}
+function isCurveDaoErc20ApproveEvmSignRequest(detail, batchIndex) {
+  const ex = parseExtraJsonObject(detail);
+  const index = batchIndex != null && batchIndex >= 0 ? batchIndex : 0;
+  const bm = ex?.batchMeta;
+  if (Array.isArray(bm) && bm[index] && typeof bm[index] === "object" && !Array.isArray(bm[index])) {
+    const evm0 = bm[index].evm;
+    if (evm0 && typeof evm0 === "object" && !Array.isArray(evm0)) {
+      const t = String(evm0.type ?? "");
+      return t === "curve_dao_erc20_approve";
+    }
+  }
+  return false;
+}
+function resolveCurveDaoRouterGasUnitsFromSignRequest(detail, batchIndex) {
+  if (!detail) return null;
+  const propBatch = detail.proposal_tx_params ?? detail.proposalTxParams ?? detail.ProposalTxParams;
+  const index = batchIndex != null && batchIndex >= 0 ? batchIndex : 0;
+  if (Array.isArray(propBatch) && propBatch.length > index) {
+    const row = propBatch[index];
+    if (row && typeof row === "object" && !Array.isArray(row)) {
+      const r = row;
+      const gl = parseOptionalGasLimitString(
+        r.gas_limit ?? r.gasLimit ?? r.GasLimit
+      );
+      if (gl != null && gl > 0n) return gl;
+    }
+  }
+  const ex = parseExtraJsonObject(detail);
+  const bm = ex?.batchMeta;
+  if (Array.isArray(bm)) {
+    for (const item of bm) {
+      if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+      const cd = item.curveDao;
+      const gb = cd?.gasBuildExchange;
+      const base = parseOptionalGasLimitString(gb?.baseGasUnits);
+      if (base != null && base > 0n) return base;
+    }
+  }
+  return null;
+}
+
+// src/core/keygen.ts
+function firstClientIdFromKeyGen(data) {
+  const map = data?.ClientKeys;
+  if (!map || typeof map !== "object") return null;
+  for (const v of Object.values(map)) {
+    if (typeof v === "string" && v.trim()) return v.trim();
+  }
+  return null;
+}
+
+// src/core/purpose.ts
+function mergePurposeText(purposeText, purposeSuffix) {
+  const t = purposeText.trim();
+  const suffix = (purposeSuffix ?? "").trim();
+  if (!suffix) return t;
+  return t ? `${t}
+
+${suffix}` : suffix;
+}
+
+// src/core/envelope.ts
+function finalizeMultisign(input) {
+  const { keyGen, destinationChainID, legs } = input;
+  if (legs.length === 0) {
+    throw new Error("finalizeMultisign requires at least one leg");
+  }
+  const ph = (keyGen.pubkeyhex ?? "").trim();
+  if (!ph) throw new Error("keyGen pubKey (pubkeyhex) is required");
+  const keyList = keyGen.keylist ?? [];
+  const clientId = firstClientIdFromKeyGen(keyGen);
+  const first = legs[0];
+  const messageHashes = legs.map((l) => l.msgHash);
+  const messageRawBatch = legs.map((l) => l.msgRaw);
+  const batchMeta = legs.map((l) => ({
+    destinationAddress: l.destinationAddress,
+    signatureText: l.signatureText,
+    ...l.audit
+  }));
+  const proposalTxParams = legs.map((l) => l.proposalTxParams).filter((p) => p != null && typeof p === "object");
+  const extraPayload = {
+    batchMeta,
+    ...input.extraJSON ?? {}
+  };
+  const extraJSON = JSON.stringify(extraPayload);
+  const bodyForSign = {
+    keyList,
+    pubKey: ph,
+    msgHash: messageHashes[0],
+    msgRaw: first.msgRaw,
+    destinationChainID,
+    destinationAddress: input.destinationAddress ?? first.destinationAddress,
+    extraJSON,
+    signatureText: first.signatureText,
+    purpose: mergePurposeText(input.purposeText, input.purposeSuffix),
+    ...first.feeSnapshot
+  };
+  if (legs.length > 1) {
+    bodyForSign.messageHashes = messageHashes;
+    bodyForSign.messageRawBatch = messageRawBatch;
+  }
+  if (proposalTxParams.length > 0) {
+    bodyForSign.proposalTxParams = proposalTxParams;
+  }
+  const valueWei = first.valueWei;
+  if (valueWei != null && valueWei > 0n) {
+    bodyForSign.value = valueWei.toString();
+  }
+  if (clientId) bodyForSign.clientId = clientId;
+  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
+}
+async function fetchChainFeeParams(rpcUrl, chainId) {
+  const url = rpcUrl.trim();
+  if (!url) return { isEip1559: false };
+  const chainIdNum = typeof chainId === "string" ? parseInt(chainId, 10) : chainId;
+  if (Number.isNaN(chainIdNum)) return { isEip1559: false };
+  const chain = viem.defineChain({
+    id: chainIdNum,
+    name: "Discovery",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [url] } }
+  });
+  const publicClient = viem.createPublicClient({
+    chain,
+    transport: viem.http(url)
+  });
+  const getGasPriceGwei = async () => {
+    const gasPriceWei = await publicClient.getGasPrice();
+    return parseFloat(viem.formatUnits(gasPriceWei, 9));
+  };
+  try {
+    const block = await publicClient.getBlock({ blockTag: "latest" });
+    const baseFeePerGas = block?.baseFeePerGas;
+    if (baseFeePerGas == null || baseFeePerGas === void 0) {
+      const gasPriceGwei2 = await getGasPriceGwei();
+      return { isEip1559: false, gasPriceGwei: gasPriceGwei2 };
+    }
+    const baseFeeGwei = parseFloat(viem.formatUnits(baseFeePerGas, 9));
+    let priorityFeeGwei;
+    try {
+      const priorityWei = await publicClient.estimateMaxPriorityFeePerGas();
+      priorityFeeGwei = parseFloat(viem.formatUnits(priorityWei, 9));
+    } catch {
+    }
+    const gasPriceGwei = await getGasPriceGwei();
+    return {
+      isEip1559: true,
+      baseFeeGwei,
+      priorityFeeGwei,
+      gasPriceGwei
+    };
+  } catch {
+    try {
+      const gasPriceWei = await publicClient.getGasPrice();
+      const gasPriceGwei = parseFloat(viem.formatUnits(gasPriceWei, 9));
+      return { isEip1559: false, gasPriceGwei };
+    } catch {
+      return { isEip1559: false };
+    }
+  }
+}
+function finalizeEip1559Fees(maxFeePerGas, maxPriorityFeePerGas, floor, baseWei) {
+  let maxP = maxPriorityFeePerGas;
+  let maxF = maxFeePerGas;
+  if (baseWei > 0n && maxF < baseWei + maxP) {
+    maxF = baseWei + maxP + viem.parseGwei("0.001");
+  }
+  if (maxF < maxP) {
+    maxF = baseWei > 0n ? baseWei + maxP + viem.parseGwei("0.001") : maxP * 2n;
+  }
+  return { maxFeePerGas: maxF, maxPriorityFeePerGas: maxP };
+}
+function alignEip1559FeesWithLatestBase(maxFeePerGas, maxPriorityFeePerGas, latestBlockBaseFeeWei) {
+  return finalizeEip1559Fees(maxFeePerGas, maxPriorityFeePerGas, null, latestBlockBaseFeeWei);
+}
+function gweiToDecimalString(n) {
+  if (!Number.isFinite(n)) return "0";
+  if (n === 0) return "0";
+  const s = String(n);
+  if (s.indexOf("e") !== -1 || s.indexOf("E") !== -1) return n.toFixed(9).replace(/\.?0+$/, "") || "0";
+  return s;
+}
+
+// src/chains/evm/txParams.ts
+function gasLimitFromEstimateAndChainConfig(estimatedGas, chainGasLimit) {
+  if (chainGasLimit == null || !Number.isFinite(chainGasLimit) || chainGasLimit <= 0) {
+    return estimatedGas;
+  }
+  const cfg = BigInt(Math.floor(chainGasLimit));
+  return cfg > estimatedGas ? cfg : estimatedGas;
+}
+function routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimit) {
+  if (chainGasLimit != null && Number.isFinite(chainGasLimit) && chainGasLimit > 0) {
+    return gasLimitFromEstimateAndChainConfig(estimatedGas, chainGasLimit);
+  }
+  return (estimatedGas * 12n + 9n) / 10n;
+}
+function proposalTxParamsToFeeSnapshot(params) {
+  if (params.txType === "legacy") {
+    return {
+      txNonce: params.nonce,
+      txGasLimit: params.gasLimit,
+      txGasPrice: params.gasPrice ?? "0"
+    };
+  }
+  return {
+    txNonce: params.nonce,
+    txGasLimit: params.gasLimit,
+    txMaxFeePerGas: params.maxFeePerGas ?? "",
+    txMaxPriorityFeePerGas: params.maxPriorityFeePerGas ?? ""
+  };
+}
+
+// src/chains/evm/buildBatch.ts
+async function buildEvmMultisignBatch(args) {
+  const { context, steps } = args;
+  const {
+    chainId,
+    rpcUrl,
+    executorAddress,
+    chainDetail,
+    useCustomGas,
+    customGasChainDetails,
+    keyGen,
+    purposeText
+  } = context;
+  if (steps.length === 0) throw new Error("buildEvmMultisignBatch requires at least one step");
+  const ch = viem.defineChain({
+    id: chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.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 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 legs = [];
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const currentNonce = baseNonce + i;
+    let estimatedGas;
+    try {
+      estimatedGas = await publicClient.estimateGas({
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        account: executor
+      });
+    } catch {
+      estimatedGas = step.fallbackGas ?? 100000n;
+    }
+    let gasLimitI;
+    if (args.resolveGasLimit) {
+      gasLimitI = await args.resolveGasLimit({ step, index: i, estimatedGas, publicClient });
+    } else if (step.routerSwap) {
+      gasLimitI = routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimitRouter);
+    } else {
+      gasLimitI = useCustomGas ? gasLimitFromEstimateAndChainConfig(estimatedGas, gasLimitConfig) : estimatedGas;
+    }
+    let proposalTxParams;
+    let feeSnapshot;
+    let serialized;
+    if (legacy) {
+      let gasPriceWei = await publicClient.getGasPrice();
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        gasPriceWei = gasPriceWei * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      if (useCustomGas && chainDetail?.gasPrice != null && chainDetail.gasPrice > 0) {
+        const configured = viem.parseGwei(gweiToDecimalString(Number(chainDetail.gasPrice)));
+        if (configured > gasPriceWei) gasPriceWei = configured;
+      }
+      serialized = viem.serializeTransaction({
+        type: "legacy",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        gasPrice: gasPriceWei,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "legacy",
+        gasPrice: gasPriceWei.toString()
+      };
+      feeSnapshot = proposalTxParamsToFeeSnapshot(proposalTxParams);
+    } else {
+      const fetchedBase = feeParams.baseFeeGwei ?? 0;
+      const fetchedPriority = feeParams.priorityFeeGwei ?? 0;
+      const configuredBase = useCustomGas && chainDetail?.baseFee != null ? Number(chainDetail.baseFee) : 0;
+      const configuredPriority = useCustomGas && chainDetail?.priorityFee != null ? Number(chainDetail.priorityFee) : 0;
+      const effectiveBaseFeeGwei = Math.max(fetchedBase, configuredBase);
+      const effectivePriorityFeeGwei = Math.max(fetchedPriority, configuredPriority);
+      const baseFeeMultiplierPct = useCustomGas && chainDetail?.baseFeeMultiplier != null ? Math.max(100, Number(chainDetail.baseFeeMultiplier)) : 100;
+      const baseComponentGwei = effectiveBaseFeeGwei * baseFeeMultiplierPct / 100;
+      const maxFeePerGasGwei = baseComponentGwei + effectivePriorityFeeGwei;
+      let maxPriorityFeePerGas = effectivePriorityFeeGwei > 0 ? viem.parseGwei(gweiToDecimalString(effectivePriorityFeeGwei)) : viem.parseGwei("1");
+      let maxFeePerGas = viem.parseGwei(gweiToDecimalString(maxFeePerGasGwei));
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        maxPriorityFeePerGas = maxPriorityFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+        maxFeePerGas = maxFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      ({ maxFeePerGas, maxPriorityFeePerGas } = alignEip1559FeesWithLatestBase(
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        latestBaseFeeWei
+      ));
+      serialized = viem.serializeTransaction({
+        type: "eip1559",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "eip1559",
+        maxFeePerGas: maxFeePerGas.toString(),
+        maxPriorityFeePerGas: maxPriorityFeePerGas.toString()
+      };
+      feeSnapshot = i === 0 ? proposalTxParamsToFeeSnapshot(proposalTxParams) : {};
+    }
+    const h = viem.keccak256(serialized);
+    const msgHash = h.startsWith("0x") ? h.slice(2) : h;
+    const batchMetaExtra = args.buildBatchMeta({ step, index: i, gasLimit: gasLimitI });
+    legs.push({
+      msgHash,
+      msgRaw: i === 0 && args.firstMsgRawNo0x != null ? args.firstMsgRawNo0x : serialized,
+      destinationAddress: step.to,
+      signatureText: typeof batchMetaExtra.signatureText === "string" ? batchMetaExtra.signatureText : JSON.stringify(batchMetaExtra.signatureText ?? {}),
+      audit: batchMetaExtra,
+      feeSnapshot: i === 0 ? feeSnapshot : {},
+      proposalTxParams,
+      valueWei: i === 0 ? step.value : void 0
+    });
+    if (i === 0 && args.firstMsgRawNo0x != null) {
+      legs[0].msgRaw = args.firstMsgRawNo0x;
+    }
+  }
+  const extraJSON = {};
+  if (useCustomGas && customGasChainDetails && Object.keys(customGasChainDetails).length > 0) {
+    extraJSON.customGasChainDetails = customGasChainDetails;
+  }
+  const result = finalizeMultisign({
+    keyGen,
+    purposeText,
+    purposeSuffix: args.purposeSuffix,
+    destinationChainID: String(chainId),
+    destinationAddress: args.destinationAddress ?? steps[0].to,
+    legs,
+    extraJSON: Object.keys(extraJSON).length > 0 ? extraJSON : void 0
+  });
+  const pv = args.payableValueWei;
+  if (pv != null && pv > 0n) {
+    result.bodyForSign.value = pv.toString();
+  }
+  return result;
+}
+
+// src/protocols/evm/curve-dao/multisign.ts
+var ETH_PLACEHOLDER2 = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+function txToViemStep(tx) {
+  if (!tx.to) throw new Error("Transaction missing `to`");
+  const to = viem.getAddress((tx.to ?? "").trim());
+  const raw = (tx.data ?? "0x").toString();
+  const data = raw.startsWith("0x") ? raw : `0x${raw}`;
+  let value = 0n;
+  if (tx.value != null) {
+    if (typeof tx.value === "bigint") value = tx.value;
+    else value = BigInt(String(tx.value));
+  }
+  return { to, data, value };
+}
+async function buildEvmMultisignBodyCurveDaoBatch(args) {
+  const tokenIn = viem.getAddress(args.tokenIn);
+  const executor = viem.getAddress(args.executorAddress);
+  const session = await loadFullCurveSessionForRpc(args.rpcUrl);
+  if (!session?.curve?.router?.populateSwap) {
+    throw new Error("Curve router is not available (load session failed or chain has no router).");
+  }
+  const { curve, wrappedNative } = session;
+  const wn = wrappedNative;
+  const tokenInId = toCurveRouterTokenId(tokenIn, wn);
+  const outTrim = (args.tokenOut ?? "").trim();
+  const tokenOutId = toCurveRouterTokenId(
+    outTrim.toLowerCase() === ETH_PLACEHOLDER2 ? ETH_PLACEHOLDER2 : viem.getAddress(outTrim),
+    wn
+  );
+  const isNativeIn = tokenInId.toLowerCase() === ETH_PLACEHOLDER2;
+  const slip = args.slippagePercent;
+  if (!Number.isFinite(slip) || slip <= 0 || slip >= 100) {
+    throw new Error("Slippage must be between 0 and 100 (exclusive).");
+  }
+  const swapPop = await curve.router.populateSwap(tokenInId, tokenOutId, args.amountHuman, slip);
+  const swapBase = txToViemStep(swapPop);
+  const rawTo = swapPop?.to;
+  if (rawTo == null || String(rawTo).trim() === "") {
+    throw new Error("Curve populateSwap did not return a destination address (router).");
+  }
+  const routerAddr = viem.getAddress(String(rawTo).trim());
+  const ch = viem.defineChain({
+    id: args.chainId,
+    name: "Destination",
+    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([
+    "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 steps = [];
+  if (!isNativeIn) {
+    const decimalsN = await publicClient.readContract({
+      address: tokenIn,
+      abi: erc20AllowanceAbi,
+      functionName: "decimals"
+    });
+    const amountWei = viem.parseUnits(args.amountHuman, Number(decimalsN));
+    const currentAllowance = await publicClient.readContract({
+      address: tokenIn,
+      abi: erc20AllowanceAbi,
+      functionName: "allowance",
+      args: [executor, routerAddr]
+    });
+    if (currentAllowance < amountWei) {
+      if (currentAllowance > 0n) {
+        const dataReset = viem.encodeFunctionData({
+          abi: erc20ApproveAbi,
+          functionName: "approve",
+          args: [routerAddr, 0n]
+        });
+        steps.push({ to: tokenIn, data: dataReset, value: 0n, kind: "approve", fallbackGas: 80000n });
+      }
+      const dataApprove = viem.encodeFunctionData({
+        abi: erc20ApproveAbi,
+        functionName: "approve",
+        args: [routerAddr, amountWei]
+      });
+      steps.push({ to: tokenIn, data: dataApprove, value: 0n, kind: "approve", fallbackGas: 80000n });
+    }
+  }
+  steps.push({
+    ...swapBase,
+    kind: "exchange",
+    routerSwap: true,
+    fallbackGas: CURVE_ROUTER_EXCHANGE_DEFAULT_GAS_UNITS
+  });
+  const chainGasLimitRouter = args.chainDetail?.gasLimit != null && Number.isFinite(Number(args.chainDetail.gasLimit)) && Number(args.chainDetail.gasLimit) > 0 ? Number(args.chainDetail.gasLimit) : void 0;
+  const gasLimitByIndex = /* @__PURE__ */ new Map();
+  const n = steps.length;
+  const purposeSuffix = n === 1 ? "Curve (DAO): 1-tx \u2014 CurveRouterNG.exchange (native in or allowance already set)." : `Curve (DAO): ${n}-tx batch \u2014 ERC-20 approve Curve router, then CurveRouterNG.exchange.`;
+  const firstDataNo0x = steps[0].data.startsWith("0x") ? steps[0].data.slice(2) : steps[0].data;
+  const payableValueWei = steps.filter((s) => s.kind === "exchange").reduce((a, s) => a + s.value, 0n);
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: args.keyGen,
+      purposeText: args.purposeText,
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl,
+      executorAddress: executor,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails
+    },
+    steps,
+    purposeSuffix,
+    firstMsgRawNo0x: firstDataNo0x,
+    destinationAddress: steps[0].to,
+    payableValueWei: payableValueWei > 0n ? payableValueWei : void 0,
+    resolveGasLimit: async ({ step, index, estimatedGas }) => {
+      const s = step;
+      let gasLimitI;
+      if (s.kind === "exchange") {
+        gasLimitI = routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimitRouter);
+      } else {
+        gasLimitI = estimatedGas;
+      }
+      gasLimitByIndex.set(index, gasLimitI);
+      return gasLimitI;
+    },
+    buildBatchMeta: ({ step, index, gasLimit }) => {
+      const s = step;
+      const gl = gasLimitByIndex.get(index) ?? gasLimit;
+      if (s.kind === "approve") {
+        return {
+          signatureText: JSON.stringify({
+            kind: "CurveDao",
+            name: "ERC20.approve",
+            to: "Curve router",
+            function: "approve(address spender, uint256 amount)",
+            spender: routerAddr,
+            amountHuman: args.amountHuman,
+            note: "Allowance approved for this swap amount only (not unlimited)."
+          }),
+          evm: { type: "curve_dao_erc20_approve", version: 1, chainId: String(args.chainId) }
+        };
+      }
+      return {
+        signatureText: JSON.stringify({
+          kind: "CurveDao",
+          name: "CurveRouterNG.exchange",
+          note: "Calldata from @curvefi/api `router.populateSwap` (same on-chain as router `exchange`)."
+        }),
+        evm: { type: "curve_dao_router_exchange", version: 1, chainId: String(args.chainId) },
+        curveDao: {
+          slippagePercent: slip,
+          amountHuman: args.amountHuman,
+          tokenIn: tokenInId,
+          tokenOut: tokenOutId,
+          isNativeIn,
+          gasBuildExchange: { baseGasUnits: gl.toString() }
+        }
+      };
+    }
+  });
+}
+
+// src/protocols/evm/curve-dao/index.ts
+var CURVE_DAO_PROTOCOL_ID = "curve-dao";
+var curveDaoProtocolModule = {
+  id: CURVE_DAO_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    return isCurveApiChainSupported(ctx.chainId);
+  },
+  isTokenSupported(token) {
+    if (token.category !== "evm") return false;
+    return token.kind === "native" || token.kind === "erc20";
+  },
+  actions: [
+    {
+      id: "curve-dao.swap",
+      protocolId: CURVE_DAO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Swap via Curve Router NG (optional ERC-20 approve batch)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        tokenIn: { type: "address", required: true, description: "ERC-20 token in (native uses WETH path in UI)" },
+        tokenOut: { type: "address", required: true, description: "Output token or 0xeeee\u2026 native placeholder" },
+        amountHuman: { type: "string", required: true, description: "Human-readable input amount" },
+        slippagePercent: { type: "number", required: true, description: "Slippage percent (0\u2013100 exclusive)" }
+      }
+    }
+  ]
+};
+registerProtocolModule(curveDaoProtocolModule);
+var curveDao = {
+  buildSwapMultisignBody: buildEvmMultisignBodyCurveDaoBatch,
+  isChainSupported: isCurveApiChainSupported,
+  loadSession: loadFullCurveSessionForRpc
+};
+
+exports.CURVE_DAO_PROTOCOL_ID = CURVE_DAO_PROTOCOL_ID;
+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.buildEvmMultisignBodyCurveDaoBatch = buildEvmMultisignBodyCurveDaoBatch;
+exports.curveDao = curveDao;
+exports.curveDaoProtocolModule = curveDaoProtocolModule;
+exports.fetchAllCurvePools = fetchAllCurvePools;
+exports.isCurveApiChainSupported = isCurveApiChainSupported;
+exports.isCurveDaoChainSupported = isCurveApiChainSupported;
+exports.isCurveDaoErc20ApproveEvmSignRequest = isCurveDaoErc20ApproveEvmSignRequest;
+exports.isCurveDaoSwapEvmSignRequest = isCurveDaoSwapEvmSignRequest;
+exports.isCurveTokenKeySwappable = isCurveTokenKeySwappable;
+exports.loadFullCurveSessionForRpc = loadFullCurveSessionForRpc;
+exports.normalizeCurveRouterAmountString = normalizeCurveRouterAmountString;
+exports.resolveCurveDaoRouterGasUnitsFromSignRequest = resolveCurveDaoRouterGasUnitsFromSignRequest;
+exports.swappableCurveGraphNodeKeys = swappableCurveGraphNodeKeys;
+exports.toCurveRouterTokenId = toCurveRouterTokenId;
+exports.toCurveTokenKey = toCurveTokenKey;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map