@continuumdao/ctm-mpc-defi 0.2.1 → 0.2.3

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 export { C as ChainCategory, a as ChainSupportContext, E as EvmTokenKind, K as KeyGenSubset, b as KeyGenSubsetForPermit, M as MultisignBuildResult, c as MultisignCommonArgs, N as NearTokenKind, P as ParamDoc, d as ProtocolActionDescriptor, e as ProtocolModule, S as SolanaTokenKind, T as TokenRef } from './types-BfjWdw1j.js';
 export { getClientIdFromKeyGenResult as firstClientIdFromKeyGen } from '@continuumdao/continuum-node-sdk';
-export { mergePurposeText } from './core/index.js';
+export { getAaveGraphqlProxyUrl, getCoingeckoProxyUrl, getEulerGraphqlProxyUrl, getMapleGraphqlProxyUrl, mergePurposeText, postJsonViaOptionalProxy, setAaveGraphqlProxyUrl, setCoingeckoProxyUrl, setEulerGraphqlProxyUrl, setMapleGraphqlProxyUrl } from './core/index.js';
 export { C as ChainCategoryBuildInput, a as ChainCategoryModule, M as MultisignLeg, c as coreChainCategoryModule, f as finalizeMultisign } from './envelope-CpBUh9eP.js';
 export { g as getActionsByChainCategory, a as getProtocolModule, b as getProtocolModules, r as registerProtocolModule } from './registry-Bv5o37_w.js';
 export { E as EvmChainDetail, a as EvmProtocolContext, b as EvmTxStep, i as isEvmNativeToken, m as matchEvmTokenKind } from './types-DUeNJLr9.js';
-export { EvmBatchMetaBuilder, EvmBuildBatchArgs, buildEvmMultisignBatch, evmChainCategoryModule, parseEvmChainIdToNumber, routerSwapGasLimitFromEstimate } from './chains/evm/index.js';
+export { COINGECKO_PLATFORM_BY_CHAIN_ID, EvmBatchMetaBuilder, EvmBuildBatchArgs, buildEvmMultisignBatch, coingeckoPlatformForChainId, evmChainCategoryModule, normalizeCurveRouterAmountString, normalizeHumanDecimalAmount, parseEvmChainIdToNumber, routerSwapGasLimitFromEstimate } from './chains/evm/index.js';
 export { SOLANA_CHAIN_CATEGORY, solanaChainCategoryModule } from './chains/solana/index.js';
 export { NEAR_CHAIN_CATEGORY, nearChainCategoryModule } from './chains/near/index.js';
 export { uniswapV4, uniswapV4ProtocolModule } from './protocols/evm/uniswap-v4/index.js';

package/dist/index.js

@@ -1,6 +1,6 @@
 import { getClientIdFromKeyGenResult, gasLimitFromEstimateAndChainConfig, fetchChainFeeParams, gweiToDecimalString, proposalTxParamsToFeeSnapshot, alignEip1559FeesWithLatestBase, nodeFetchWithReadAuth } from '@continuumdao/continuum-node-sdk';
 export { getClientIdFromKeyGenResult as firstClientIdFromKeyGen } from '@continuumdao/continuum-node-sdk';
-import { getAddress, zeroAddress, defineChain, createPublicClient, http, parseGwei, serializeTransaction, keccak256, encodeFunctionData, erc20Abi, parseAbi, parseUnits, decodeFunctionData, isAddress } from 'viem';
+import { getAddress, zeroAddress, defineChain, createPublicClient, http, parseGwei, serializeTransaction, keccak256, parseUnits, formatUnits, encodeFunctionData, erc20Abi, parseAbi, decodeFunctionData, isAddress } from 'viem';
 
 // src/core/index.ts
 
@@ -86,6 +86,61 @@ function getProtocolModule(id) {
 function getActionsByChainCategory(category) {
   return modules.filter((m) => m.chainCategory === category).flatMap((m) => m.actions);
 }
+
+// src/core/defiProxy.ts
+var aaveGraphqlProxyUrl;
+var eulerGraphqlProxyUrl;
+var mapleGraphqlProxyUrl;
+var coingeckoProxyUrl;
+function setAaveGraphqlProxyUrl(url) {
+  aaveGraphqlProxyUrl = url?.trim() || void 0;
+}
+function getAaveGraphqlProxyUrl() {
+  return aaveGraphqlProxyUrl;
+}
+function setEulerGraphqlProxyUrl(url) {
+  eulerGraphqlProxyUrl = url?.trim() || void 0;
+}
+function getEulerGraphqlProxyUrl() {
+  return eulerGraphqlProxyUrl;
+}
+function setMapleGraphqlProxyUrl(url) {
+  mapleGraphqlProxyUrl = url?.trim() || void 0;
+}
+function getMapleGraphqlProxyUrl() {
+  return mapleGraphqlProxyUrl;
+}
+function setCoingeckoProxyUrl(url) {
+  coingeckoProxyUrl = url?.trim() || void 0;
+}
+function getCoingeckoProxyUrl() {
+  return coingeckoProxyUrl;
+}
+async function postJsonViaOptionalProxy(args) {
+  const proxy = args.proxyUrl?.trim();
+  if (proxy) {
+    const r2 = await fetch(proxy, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(args.proxyEnvelope ?? args.body)
+    });
+    if (!r2.ok) {
+      const t = await r2.text().catch(() => "");
+      throw new Error(t ? `Proxy HTTP ${r2.status}: ${t.slice(0, 200)}` : `Proxy HTTP ${r2.status}`);
+    }
+    return await r2.json();
+  }
+  const r = await fetch(args.directUrl, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(args.body)
+  });
+  if (!r.ok) {
+    const t = await r.text().catch(() => "");
+    throw new Error(t ? `HTTP ${r.status}: ${t.slice(0, 200)}` : `HTTP ${r.status}`);
+  }
+  return await r.json();
+}
 function isEvmNativeToken(address) {
   try {
     return getAddress(address) === zeroAddress;
@@ -298,6 +353,56 @@ function parseEvmChainIdToNumber(chainId) {
   }
   return Number.parseInt(t, 10);
 }
+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);
+}
+var normalizeCurveRouterAmountString = normalizeHumanDecimalAmount;
+
+// src/chains/evm/coingecko.ts
+var COINGECKO_PLATFORM_BY_CHAIN_ID = {
+  "1": "ethereum",
+  "56": "binance-smart-chain",
+  "137": "polygon-pos",
+  "42161": "arbitrum-one",
+  "10": "optimistic-ethereum",
+  "43114": "avalanche",
+  "8453": "base",
+  "324": "zk-sync-era",
+  "42220": "celo",
+  "250": "fantom",
+  "100": "gnosis",
+  "204": "op-bnb",
+  "534352": "scroll",
+  "5000": "mantle",
+  "169": "manta-pacific",
+  "1116": "core",
+  "30": "rootstock",
+  "288": "boba",
+  "1088": "metis-andromeda",
+  "34443": "mode",
+  "80084": "berachain",
+  "146": "sonic",
+  "60808": "bob-network",
+  "80094": "berachain",
+  "130": "unichain",
+  "57073": "ink",
+  "999": "hyperevm",
+  "239": "tac",
+  "9745": "plasma",
+  "1923": "swellchain",
+  "59144": "linea",
+  "81457": "blast",
+  "7777777": "zora"
+};
+function coingeckoPlatformForChainId(chainId) {
+  return COINGECKO_PLATFORM_BY_CHAIN_ID[String(chainId).trim()];
+}
 
 // src/chains/solana/types.ts
 var solanaChainCategoryModule = {
@@ -1371,44 +1476,64 @@ function swappableCurveGraphNodeKeys(adj) {
 }
 
 // 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}`);
   }
 }
 
@@ -1588,6 +1713,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,
@@ -1614,6 +1752,6 @@ var curveDao = {
 registerProtocolModule(uniswapV4ProtocolModule);
 registerProtocolModule(curveDaoProtocolModule);
 
-export { NEAR_CHAIN_CATEGORY, SOLANA_CHAIN_CATEGORY, buildEvmMultisignBatch, coreChainCategoryModule, curveDao, curveDaoProtocolModule, evmChainCategoryModule, finalizeMultisign, getActionsByChainCategory, getProtocolModule, getProtocolModules, isEvmNativeToken, matchEvmTokenKind, mergePurposeText, nearChainCategoryModule, parseEvmChainIdToNumber, registerProtocolModule, routerSwapGasLimitFromEstimate, solanaChainCategoryModule, uniswapV4, uniswapV4ProtocolModule };
+export { COINGECKO_PLATFORM_BY_CHAIN_ID, NEAR_CHAIN_CATEGORY, SOLANA_CHAIN_CATEGORY, buildEvmMultisignBatch, coingeckoPlatformForChainId, coreChainCategoryModule, curveDao, curveDaoProtocolModule, evmChainCategoryModule, finalizeMultisign, getAaveGraphqlProxyUrl, getActionsByChainCategory, getCoingeckoProxyUrl, getEulerGraphqlProxyUrl, getMapleGraphqlProxyUrl, getProtocolModule, getProtocolModules, isEvmNativeToken, matchEvmTokenKind, mergePurposeText, nearChainCategoryModule, normalizeCurveRouterAmountString, normalizeHumanDecimalAmount, parseEvmChainIdToNumber, postJsonViaOptionalProxy, registerProtocolModule, routerSwapGasLimitFromEstimate, setAaveGraphqlProxyUrl, setCoingeckoProxyUrl, setEulerGraphqlProxyUrl, setMapleGraphqlProxyUrl, solanaChainCategoryModule, uniswapV4, uniswapV4ProtocolModule };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map