@continuumdao/ctm-mpc-defi 0.2.0 → 0.2.2

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

@@ -1,4 +1,5 @@
-import { isAddress, getAddress, parseUnits, formatUnits, defineChain, createPublicClient, http, parseAbi, encodeFunctionData, parseGwei, serializeTransaction, keccak256 } from 'viem';
+import { parseAbi, isAddress, getAddress, defineChain, createPublicClient, http, parseUnits, encodeFunctionData, formatUnits, parseGwei, serializeTransaction, keccak256, zeroAddress } from 'viem';
+import { fetchChainFeeParams, gasLimitFromEstimateAndChainConfig, gweiToDecimalString, proposalTxParamsToFeeSnapshot, alignEip1559FeesWithLatestBase, getClientIdFromKeyGenResult } from '@continuumdao/continuum-node-sdk';
 
 // src/core/registry.ts
 var modules = [];
@@ -62,6 +63,17 @@ function isCurveApiChainSupported(chainId) {
   if (Number.isNaN(n) || n < 0) return false;
   return CURVE_FULL_NETWORK_CONSTANTS_CHAIN_IDS.has(n);
 }
+function normalizeHumanDecimalAmount(raw, tokenDecimals) {
+  const t = raw.trim().replace(/,/g, "");
+  if (!t) return "";
+  if (!Number.isInteger(tokenDecimals) || tokenDecimals < 0 || tokenDecimals > 18) {
+    throw new Error("Invalid token decimals for amount normalization.");
+  }
+  const wei = parseUnits(t, tokenDecimals);
+  return formatUnits(wei, tokenDecimals);
+}
+
+// src/protocols/evm/curve-dao/swapDestinations.ts
 var CURVE_NATIVE_PLACEHOLDER = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
 var ETH_PLACEHOLDER = CURVE_NATIVE_PLACEHOLDER;
 function normalizeAddr(a) {
@@ -94,13 +106,7 @@ function toCurveRouterTokenId(tokenAddress, wrappedNative) {
   }
 }
 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 = parseUnits(t, tokenInDecimals);
-  return formatUnits(wei, tokenInDecimals);
+  return normalizeHumanDecimalAmount(raw, tokenInDecimals);
 }
 function addEdge(adj, a, b) {
   if (a === b) return;
@@ -206,6 +212,36 @@ async function loadFullCurveSessionForRpc(rpcUrl) {
     return null;
   }
 }
+async function loadCurveSessionSnapshotForRpc(rpcUrl) {
+  const session = await loadFullCurveSessionForRpc(rpcUrl);
+  if (!session) return null;
+  const adj = {};
+  for (const [key, neighbors] of session.adj) {
+    adj[key] = [...neighbors];
+  }
+  return {
+    wrappedNative: session.wrappedNative,
+    swappableNodeKeys: [...session.swappableNodeKeys],
+    routerReady: Boolean(session.curve?.hasRouter?.() && session.curve.hasRouter()),
+    adj
+  };
+}
+async function fetchCurveCoinsDataForRpc(rpcUrl, addresses) {
+  const session = await loadFullCurveSessionForRpc(rpcUrl);
+  if (!session?.curve?.getCoinsData) return [];
+  const coins = await session.curve.getCoinsData(addresses);
+  return addresses.map((addr, i) => {
+    const c = coins[i];
+    const dec = c?.decimals;
+    const decimals = typeof dec === "number" && Number.isInteger(dec) && dec >= 0 && dec <= 18 ? dec : null;
+    return {
+      address: addr,
+      name: c?.name && String(c.name).trim() || "\u2014",
+      symbol: c?.symbol && String(c.symbol).trim() || addr.slice(0, 6),
+      decimals
+    };
+  });
+}
 
 // src/protocols/evm/curve-dao/purpose.ts
 function buildCurveDaoPurposePrefill(args) {
@@ -313,16 +349,6 @@ function resolveCurveDaoRouterGasUnitsFromSignRequest(detail, batchIndex) {
   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();
@@ -342,7 +368,7 @@ function finalizeMultisign(input) {
   const ph = (keyGen.pubkeyhex ?? "").trim();
   if (!ph) throw new Error("keyGen pubKey (pubkeyhex) is required");
   const keyList = keyGen.keylist ?? [];
-  const clientId = firstClientIdFromKeyGen(keyGen);
+  const clientId = getClientIdFromKeyGenResult(keyGen);
   const first = legs[0];
   const messageHashes = legs.map((l) => l.msgHash);
   const messageRawBatch = legs.map((l) => l.msgRaw);
@@ -383,107 +409,12 @@ function finalizeMultisign(input) {
   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 = defineChain({
-    id: chainIdNum,
-    name: "Discovery",
-    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
-    rpcUrls: { default: { http: [url] } }
-  });
-  const publicClient = createPublicClient({
-    chain,
-    transport: http(url)
-  });
-  const getGasPriceGwei = async () => {
-    const gasPriceWei = await publicClient.getGasPrice();
-    return parseFloat(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(formatUnits(baseFeePerGas, 9));
-    let priorityFeeGwei;
-    try {
-      const priorityWei = await publicClient.estimateMaxPriorityFeePerGas();
-      priorityFeeGwei = parseFloat(formatUnits(priorityWei, 9));
-    } catch {
-    }
-    const gasPriceGwei = await getGasPriceGwei();
-    return {
-      isEip1559: true,
-      baseFeeGwei,
-      priorityFeeGwei,
-      gasPriceGwei
-    };
-  } catch {
-    try {
-      const gasPriceWei = await publicClient.getGasPrice();
-      const gasPriceGwei = parseFloat(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 + parseGwei("0.001");
-  }
-  if (maxF < maxP) {
-    maxF = baseWei > 0n ? baseWei + maxP + 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) {
@@ -519,15 +450,19 @@ async function buildEvmMultisignBatch(args) {
     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;
+    if (args.estimateGasForStep) {
+      estimatedGas = await args.estimateGasForStep({ step, index: i, publicClient, executor });
+    } else {
+      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) {
@@ -804,6 +739,176 @@ async function buildEvmMultisignBodyCurveDaoBatch(args) {
     }
   });
 }
+var erc20DecimalsAbi = parseAbi(["function decimals() view returns (uint8)"]);
+function normalizeNativeTokenIn(tokenIn) {
+  const trimmed = tokenIn.trim();
+  if (!trimmed) return tokenIn;
+  const lower = trimmed.toLowerCase();
+  if (lower === "eth" || lower === "native" || lower === "native_eth" || lower === zeroAddress.toLowerCase() || lower === CURVE_NATIVE_PLACEHOLDER.toLowerCase()) {
+    return CURVE_NATIVE_PLACEHOLDER;
+  }
+  return trimmed;
+}
+async function resolveTokenInDecimals(args) {
+  if (args.tokenInDecimals != null && Number.isInteger(args.tokenInDecimals) && args.tokenInDecimals >= 0 && args.tokenInDecimals <= 18) {
+    return args.tokenInDecimals;
+  }
+  const normalized = normalizeNativeTokenIn(args.tokenIn);
+  if (normalized.toLowerCase() === CURVE_NATIVE_PLACEHOLDER.toLowerCase()) {
+    return 18;
+  }
+  const addr = getAddress(
+    normalized.startsWith("0x") ? normalized : `0x${normalized}`
+  );
+  const ch = defineChain({
+    id: args.chainId,
+    name: "CurveQuote",
+    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({
+    address: addr,
+    abi: erc20DecimalsAbi,
+    functionName: "decimals"
+  });
+  return Number(decimalsN);
+}
+async function curveDaoQuote(args) {
+  const rpcUrl = (args.rpcUrl ?? "").trim();
+  if (!rpcUrl) {
+    throw new Error("rpcUrl is required.");
+  }
+  if (!Number.isFinite(args.chainId) || args.chainId <= 0) {
+    throw new Error("chainId must be a positive integer.");
+  }
+  if (!isCurveApiChainSupported(args.chainId)) {
+    throw new Error(`Chain ${args.chainId} is not supported by Curve Router NG.`);
+  }
+  const tokenInDecimals = await resolveTokenInDecimals({
+    rpcUrl,
+    chainId: args.chainId,
+    tokenIn: args.tokenIn,
+    tokenInDecimals: args.tokenInDecimals
+  });
+  const amountForRouter = normalizeCurveRouterAmountString(
+    args.amountHuman,
+    tokenInDecimals
+  );
+  if (!amountForRouter) {
+    throw new Error("amountHuman must be a positive decimal string.");
+  }
+  const session = await loadFullCurveSessionForRpc(rpcUrl);
+  if (!session?.curve?.router?.getBestRouteAndOutput) {
+    throw new Error("Curve router is not available (session load failed or chain has no router).");
+  }
+  const { curve, wrappedNative: wn } = session;
+  const tokenInRouterId = toCurveRouterTokenId(normalizeNativeTokenIn(args.tokenIn), wn);
+  const tokenOutTrim = (args.tokenOut ?? "").trim();
+  const tokenOutRouterId = toCurveRouterTokenId(
+    tokenOutTrim.toLowerCase() === CURVE_NATIVE_PLACEHOLDER.toLowerCase() ? CURVE_NATIVE_PLACEHOLDER : getAddress(
+      tokenOutTrim.startsWith("0x") ? tokenOutTrim : `0x${tokenOutTrim}`
+    ),
+    wn
+  );
+  const res = await curve.router.getBestRouteAndOutput(
+    tokenInRouterId,
+    tokenOutRouterId,
+    amountForRouter
+  );
+  const route = res?.route;
+  if (!route || Array.isArray(route) && route.length === 0) {
+    throw new Error(
+      "Curve router could not find a pool route for this pair and size."
+    );
+  }
+  const outStr = String(res?.output ?? "0");
+  let priceImpactPercent = null;
+  try {
+    const pi = await curve.router.swapPriceImpact(
+      tokenInRouterId,
+      tokenOutRouterId,
+      amountForRouter
+    );
+    if (typeof pi === "number" && Number.isFinite(pi)) {
+      priceImpactPercent = pi;
+    }
+  } catch {
+  }
+  return {
+    inputAmount: amountForRouter,
+    output: outStr,
+    route,
+    priceImpactPercent,
+    tokenInRouterId,
+    tokenOutRouterId
+  };
+}
+function curveProbeInAmountString(fullNormalizedHuman, tokenInDecimals) {
+  const t = (fullNormalizedHuman ?? "").trim();
+  if (!t) return null;
+  if (!Number.isInteger(tokenInDecimals) || tokenInDecimals < 0 || tokenInDecimals > 18) return null;
+  let wei;
+  try {
+    wei = parseUnits(t, tokenInDecimals);
+  } catch {
+    return null;
+  }
+  if (wei <= 1n) return null;
+  let p = wei / 10000n;
+  if (p < 1n) p = 1n;
+  if (p >= wei) p = wei - 1n;
+  return formatUnits(p, tokenInDecimals);
+}
+function computeCurveExecutionSlippagePercent(args) {
+  const aIn = parseFloat((args.fullInHuman ?? "").replace(/,/g, "").trim());
+  const aOut = parseFloat((args.fullOutHuman ?? "").replace(/,/g, "").trim());
+  const pIn = parseFloat((args.probeInHuman ?? "").replace(/,/g, "").trim());
+  const pOut = parseFloat((args.probeOutHuman ?? "").replace(/,/g, "").trim());
+  if (!(aIn > 0) || !(aOut >= 0) || !(pIn > 0) || !Number.isFinite(pOut) || pOut < 0) return null;
+  const marginal = pOut / pIn;
+  const avg = aOut / aIn;
+  if (!Number.isFinite(marginal) || marginal <= 0 || !Number.isFinite(avg)) return null;
+  const pct = (1 - avg / marginal) * 100;
+  if (!Number.isFinite(pct)) return null;
+  return Math.max(0, pct);
+}
+function formatCurveExchangeLine(amountIn, amountOut, tokenInSymbol, tokenOutSymbol) {
+  const a = parseFloat((amountIn ?? "").replace(/,/g, "").trim());
+  const b = parseFloat((amountOut ?? "").replace(/,/g, "").trim());
+  const sIn = (tokenInSymbol || "").trim() || "in";
+  const sOut = (tokenOutSymbol || "").trim() || "out";
+  if (!(a > 0) || !Number.isFinite(b)) return "\u2014";
+  const r = b / a;
+  let rate;
+  if (r >= 1e-4) {
+    rate = r.toFixed(8).replace(/0+$/, "").replace(/\.$/, "");
+  } else if (r > 0) {
+    rate = r.toPrecision(6);
+  } else {
+    rate = "0";
+  }
+  if (!rate) rate = "0";
+  return `1 ${sIn} \u2248 ${rate} ${sOut}`;
+}
+function formatCurvePriceImpact(percent0to100) {
+  if (percent0to100 == null || !Number.isFinite(percent0to100) || percent0to100 < 0) return "\u2014";
+  if (percent0to100 === 0) return "0%";
+  if (percent0to100 < 1e-4) return "<0.0001%";
+  const t = percent0to100 < 0.01 ? percent0to100.toFixed(4) : percent0to100 < 1 ? percent0to100.toFixed(3) : percent0to100 < 10 ? percent0to100.toFixed(2) : percent0to100.toFixed(1);
+  return `${t.replace(/(\.\d*?[1-9])0+$/g, "$1").replace(/\.0$/, "")}%`;
+}
+function formatMinOutAtUserSlippage(quoteOutDecimal, userSlippagePercentInput, tokenOutSymbol) {
+  const q = parseFloat((quoteOutDecimal ?? "").replace(/,/g, "").trim());
+  const rawS = (userSlippagePercentInput ?? "0.5").trim().replace(/,/g, "");
+  const slip = Number.parseFloat(rawS);
+  const s = Number.isFinite(slip) && slip >= 0 && slip < 100 ? slip : 0.5;
+  if (!Number.isFinite(q) || q < 0) return "\u2014";
+  const min = q * ((100 - s) / 100);
+  const sOut = (tokenOutSymbol || "").trim() || "out";
+  const t = min.toFixed(8).replace(/\.?0+$/, "").replace(/(\.\d*?[1-9])0+$/, "$1");
+  return `${t} ${sOut}`.trim();
+}
 
 // src/protocols/evm/curve-dao/index.ts
 var CURVE_DAO_PROTOCOL_ID = "curve-dao";
@@ -819,6 +924,19 @@ var curveDaoProtocolModule = {
     return token.kind === "native" || token.kind === "erc20";
   },
   actions: [
+    {
+      id: "curve-dao.quote",
+      protocolId: CURVE_DAO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Quote swap via Curve Router NG (getBestRouteAndOutput)",
+      commonParams: [],
+      params: {
+        chainId: { type: "number", required: true, description: "EVM chain id" },
+        tokenIn: { type: "address", required: true, description: "Token in or native placeholder" },
+        tokenOut: { type: "address", required: true, description: "Token out or native placeholder" },
+        amountHuman: { type: "string", required: true, description: "Human-readable input amount" }
+      }
+    },
     {
       id: "curve-dao.swap",
       protocolId: CURVE_DAO_PROTOCOL_ID,
@@ -841,6 +959,6 @@ var curveDao = {
   loadSession: loadFullCurveSessionForRpc
 };
 
-export { CURVE_DAO_PROTOCOL_ID, CURVE_NATIVE_PLACEHOLDER, CURVE_ROUTER_EXCHANGE_DEFAULT_GAS_UNITS, addNativeWethBridge, bfsCurveSwapDestinations, buildCurveDaoPurposePrefill, buildCurveLiquidityGraphFromApi, buildEvmMultisignBodyCurveDaoBatch, curveDao, curveDaoProtocolModule, fetchAllCurvePools, isCurveApiChainSupported, isCurveApiChainSupported as isCurveDaoChainSupported, isCurveDaoErc20ApproveEvmSignRequest, isCurveDaoSwapEvmSignRequest, isCurveTokenKeySwappable, loadFullCurveSessionForRpc, normalizeCurveRouterAmountString, resolveCurveDaoRouterGasUnitsFromSignRequest, swappableCurveGraphNodeKeys, toCurveRouterTokenId, toCurveTokenKey };
+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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map