@continuumdao/ctm-mpc-defi 0.2.1 → 0.2.3

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

@@ -65,6 +65,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 = viem.parseUnits(t, tokenDecimals);
+  return viem.formatUnits(wei, tokenDecimals);
+}
+
+// src/protocols/evm/curve-dao/swapDestinations.ts
 var CURVE_NATIVE_PLACEHOLDER = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
 var ETH_PLACEHOLDER = CURVE_NATIVE_PLACEHOLDER;
 function normalizeAddr(a) {
@@ -97,13 +108,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 = viem.parseUnits(t, tokenInDecimals);
-  return viem.formatUnits(wei, tokenInDecimals);
+  return normalizeHumanDecimalAmount(raw, tokenInDecimals);
 }
 function addEdge(adj, a, b) {
   if (a === b) return;
@@ -169,46 +174,97 @@ function bfsCurveSwapDestinations(adj, start) {
 }
 
 // src/protocols/evm/curve-dao/apiSession.ts
+var CURVE_SESSION_CACHE_TTL_MS = 5 * 60 * 1e3;
+var curveSessionCache = /* @__PURE__ */ new Map();
 async function fetchAllCurvePools(curve) {
   const run = (p) => p.catch(() => void 0);
-  await Promise.all([
-    run(curve.factory.fetchPools()),
-    run(curve.crvUSDFactory.fetchPools()),
-    run(curve.EYWAFactory.fetchPools()),
-    run(curve.cryptoFactory.fetchPools()),
-    run(curve.twocryptoFactory.fetchPools()),
-    run(curve.tricryptoFactory.fetchPools()),
-    run(curve.stableNgFactory.fetchPools())
-  ]);
+  const tasks = [];
+  for (const key of [
+    "factory",
+    "crvUSDFactory",
+    "EYWAFactory",
+    "cryptoFactory",
+    "twocryptoFactory",
+    "tricryptoFactory",
+    "stableNgFactory"
+  ]) {
+    const f = curve[key];
+    if (f?.fetchPools) {
+      tasks.push(run(f.fetchPools()));
+    }
+  }
+  await Promise.all(tasks);
 }
 async function loadFullCurveSessionForRpc(rpcUrl) {
   const url = (rpcUrl ?? "").trim();
-  if (!url) return null;
+  if (!url) {
+    throw new Error("rpcUrl is required.");
+  }
+  const cached = curveSessionCache.get(url);
+  if (cached && cached.expiresAt > Date.now()) {
+    return cached.session;
+  }
   try {
     const { default: curve } = await import('@curvefi/api');
     await curve.init("JsonRpc", { url }, {});
     const wrapped = curve.getNetworkConstants().NATIVE_COIN?.wrappedAddress;
     if (!curve.hasRouter || !curve.hasRouter()) {
-      return {
+      const session2 = {
         curve,
         adj: /* @__PURE__ */ new Map(),
         swappableNodeKeys: /* @__PURE__ */ new Set(),
         wrappedNative: wrapped
       };
+      curveSessionCache.set(url, { session: session2, expiresAt: Date.now() + CURVE_SESSION_CACHE_TTL_MS });
+      return session2;
     }
     await fetchAllCurvePools(curve);
     const adj = buildCurveLiquidityGraphFromApi(curve);
     addNativeWethBridge(adj, wrapped);
-    return {
+    const session = {
       curve,
       adj,
       swappableNodeKeys: swappableCurveGraphNodeKeys(adj),
       wrappedNative: wrapped
     };
-  } catch {
-    return null;
+    curveSessionCache.set(url, { session, expiresAt: Date.now() + CURVE_SESSION_CACHE_TTL_MS });
+    return session;
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new Error(`Curve session init failed for RPC: ${msg}`);
   }
 }
+async function loadCurveSessionSnapshotForRpc(rpcUrl) {
+  const session = await loadFullCurveSessionForRpc(rpcUrl);
+  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) {
+    throw new Error("Curve getCoinsData is not available for this RPC session.");
+  }
+  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) {
@@ -706,6 +762,176 @@ async function buildEvmMultisignBodyCurveDaoBatch(args) {
     }
   });
 }
+var erc20DecimalsAbi = viem.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 === viem.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 = viem.getAddress(
+    normalized.startsWith("0x") ? normalized : `0x${normalized}`
+  );
+  const ch = viem.defineChain({
+    id: args.chainId,
+    name: "CurveQuote",
+    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({
+    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 : viem.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 = viem.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 viem.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";
@@ -721,6 +947,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,
@@ -751,14 +990,22 @@ exports.bfsCurveSwapDestinations = bfsCurveSwapDestinations;
 exports.buildCurveDaoPurposePrefill = buildCurveDaoPurposePrefill;
 exports.buildCurveLiquidityGraphFromApi = buildCurveLiquidityGraphFromApi;
 exports.buildEvmMultisignBodyCurveDaoBatch = buildEvmMultisignBodyCurveDaoBatch;
+exports.computeCurveExecutionSlippagePercent = computeCurveExecutionSlippagePercent;
 exports.curveDao = curveDao;
 exports.curveDaoProtocolModule = curveDaoProtocolModule;
+exports.curveDaoQuote = curveDaoQuote;
+exports.curveProbeInAmountString = curveProbeInAmountString;
 exports.fetchAllCurvePools = fetchAllCurvePools;
+exports.fetchCurveCoinsDataForRpc = fetchCurveCoinsDataForRpc;
+exports.formatCurveExchangeLine = formatCurveExchangeLine;
+exports.formatCurvePriceImpact = formatCurvePriceImpact;
+exports.formatMinOutAtUserSlippage = formatMinOutAtUserSlippage;
 exports.isCurveApiChainSupported = isCurveApiChainSupported;
 exports.isCurveDaoChainSupported = isCurveApiChainSupported;
 exports.isCurveDaoErc20ApproveEvmSignRequest = isCurveDaoErc20ApproveEvmSignRequest;
 exports.isCurveDaoSwapEvmSignRequest = isCurveDaoSwapEvmSignRequest;
 exports.isCurveTokenKeySwappable = isCurveTokenKeySwappable;
+exports.loadCurveSessionSnapshotForRpc = loadCurveSessionSnapshotForRpc;
 exports.loadFullCurveSessionForRpc = loadFullCurveSessionForRpc;
 exports.normalizeCurveRouterAmountString = normalizeCurveRouterAmountString;
 exports.resolveCurveDaoRouterGasUnitsFromSignRequest = resolveCurveDaoRouterGasUnitsFromSignRequest;