@continuumdao/ctm-mpc-defi 0.2.0 → 0.2.2

package/dist/agent/catalog.cjs

@@ -3,7 +3,11 @@
 var viem = require('viem');
 var zodToJsonSchema = require('zod-to-json-schema');
 var zod = require('zod');
+var fs = require('fs');
+var path = require('path');
+var url = require('url');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 // src/core/registry.ts
 var modules = [];
 function registerProtocolModule(mod) {
@@ -161,6 +165,96 @@ function isCurveApiChainSupported(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 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 swappableCurveGraphNodeKeys(adj) {
+  const out = /* @__PURE__ */ new Set();
+  for (const [k, neigh] of adj) {
+    if (neigh.size > 0) out.add(k);
+  }
+  return out;
+}
+
+// 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/index.ts
 var CURVE_DAO_PROTOCOL_ID = "curve-dao";
@@ -176,6 +270,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,
@@ -250,7 +357,14 @@ var MULTISIGN_OUTPUT_DOC = {
   }
 };
 var MANAGEMENT_SIG_DOC = {
-  description: "Management POST bodies embed NodeMgtKeySig: { nonce, clientSig, nodeKey }. Sign JSON with clientSig cleared; POST with clientSig set to the Ed25519 128-hex or EIP-191 signature. Legacy Nonce/Sig/sig field names are not accepted.",
+  description: "Management POST bodies embed NodeMgtKeySig: { nonce, clientSig, nodeKey }. Sign JSON with clientSig cleared via messageToSignManagementBody; POST with withManagementClientSig(body, sig). Do not put signedMessage in the JSON body for standard management routes. Legacy Nonce/Sig/sig field names are not accepted.",
+  exceptions: {
+    configUpdateImplement: "POST /configUpdateImplement: include nodeKey + plannedYaml + signedMessage (opaque configUpdateImplement|<sha256> line). Sign the opaque line bytes, not the JSON body.",
+    postMSQTTKey: "POST /postMSQTTKey: include nodeKey + caCertPem + clientSig. Sign caCertPem PEM bytes directly (use buildPostMqttKeyBody).",
+    addManagementKey: "POST /addManagementKey / removeManagementKey (EIP-191): may still use signedMessage equal to the canonical JSON string for dual-mode Ethereum signing.",
+    agentLlmConfig: "POST /agentLlmConfig / agentLlmApiKey: sign canonical JSON with action + clientSig cleared; POST body has nonce, clientSig, nodeKey, endpoint fields \u2014 no signedMessage field.",
+    multiSignRequest: "POST /multiSignRequest (client key, not management): POST { ...bodyForSign, clientSig, signedMessage: messageToSign }."
+  },
   fields: {
     nonce: {
       type: "number",
@@ -268,10 +382,15 @@ var MANAGEMENT_SIG_DOC = {
   helpers: {
     managementSigFields: "Base envelope with clientSig cleared.",
     buildManagementPostBody: "Spread managementSigFields then endpoint fields.",
+    buildPostMqttKeyBody: "POST /postMSQTTKey unsigned body (sign PEM directly).",
+    buildPostPreferredKeyGenBody: "POST /postPreferredKeyGen unsigned body.",
+    buildConfigUpdateImplementPostBody: "POST /configUpdateImplement with opaque signedMessage line.",
+    buildSignRequestAgreeUnsignedBody: "POST /signRequestAgree unsigned body with nodeKey.",
     messageToSignManagementBody: "Canonical JSON string to sign.",
     withManagementClientSig: "Attach signature to POST body.",
     fetchNodeKey: "GET /getNodeKey via nodeFetchWithReadAuth.",
-    fetchManagementNonce: "GET nonce for Ed25519 or Ethereum management key."
+    fetchManagementNonce: "GET nonce for Ed25519 or Ethereum management key.",
+    fetchPreferredKeyGen: "GET /getPreferredKeyGen for agent default KeyGen."
   }
 };
 function zodSchemaToMcpJsonSchema(schema) {
@@ -384,6 +503,17 @@ var mcpUniswapV4BuildSwapMultisignInputSchema = evmMultisignCommonInputSchema.ex
   swapDeadlineUnix: zod.z.number().describe("Same deadline passed to create_swap"),
   slippagePercent: zod.z.number().optional().describe("Extra approve headroom for EXACT_OUTPUT")
 });
+var mcpCurveDaoQuoteInputSchema = zod.z.object({
+  chainId: zod.z.number().int().positive().describe("EVM chain id (rpcUrl resolved from get_chain_registry rpcGateway)"),
+  rpcUrl: zod.z.string().min(1).optional().describe("JSON-RPC URL; continuum-mcp-server injects from chain registry \u2014 do not pass a public RPC URL"),
+  tokenIn: zod.z.string().min(1).describe("Input token address, or 0xeeee\u2026 / 0x0 / eth for native"),
+  tokenOut: zod.z.string().min(1).describe("Output token address or 0xeeee\u2026 native placeholder"),
+  amountHuman: zod.z.string().min(1).describe("Human-readable amount of tokenIn"),
+  tokenInDecimals: zod.z.number().int().min(0).max(18).optional().describe("Token-in decimals; omit to read on-chain (native uses 18)")
+});
+var mcpCurveDaoQuoteOutputSchema = jsonObjectSchema.describe(
+  "Curve router quote: { inputAmount, output, route, priceImpactPercent?, tokenInRouterId, tokenOutRouterId }"
+);
 var mcpCurveDaoBuildSwapMultisignInputSchema = evmMultisignCommonInputSchema.extend({
   tokenIn: evmAddressSchema.describe("ERC-20 sold (native in uses WETH path in UI)"),
   tokenOut: zod.z.string().min(1).describe("Output token or 0xeeee\u2026 native placeholder"),
@@ -799,7 +929,7 @@ var MCP_PROTOCOL_TOOL_DEFINITIONS = [
     description: "Build Euler v2 vault withdraw/redeem batch.",
     prerequisites: ["keyGen", "executorAddress", "vault address"],
     followUp: ["Sign messageToSign", "POST /multiSignRequest"],
-    handler: { importPath: "protocols/evm/euler-v2", exportName: "buildEvmMultisignBodyEulerV2VaultWithdrawBatch" },
+    handler: { importPath: "protocols/evm/euler-v2", exportName: "buildEvmMultisignBodyEulerV2VaultWithdraw" },
     inputZod: mcpEulerV2VaultWithdrawInputSchema
   }),
   defineProtocolMcpTool({
@@ -889,13 +1019,32 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     inputZod: mcpUniswapV4BuildSwapMultisignInputSchema,
     outputZod: multisignOutputSchema
   }),
+  defineMcpTool({
+    name: "ctm_curve_dao_quote",
+    actionId: "curve-dao.quote",
+    protocolId: "curve-dao",
+    chainCategory: "evm",
+    description: "Fetch a Curve Router NG quote via @curvefi/api getBestRouteAndOutput. Returns output amount, route, and optional priceImpactPercent. Does NOT create a sign request \u2014 call ctm_curve_dao_build_swap_multisign after quoting. Pass chainId only; rpcUrl is resolved from get_chain_registry rpcGateway.",
+    prerequisites: [
+      "Chain must be supported by Curve (@curvefi/api network constants).",
+      "Configure rpcGateway for chainId in get_chain_registry."
+    ],
+    followUp: ["ctm_curve_dao_build_swap_multisign"],
+    handler: { importPath: "protocols/evm/curve-dao", exportName: "curveDaoQuote" },
+    inputZod: mcpCurveDaoQuoteInputSchema,
+    outputZod: mcpCurveDaoQuoteOutputSchema
+  }),
   defineMcpTool({
     name: "ctm_curve_dao_build_swap_multisign",
     actionId: "curve-dao.swap",
     protocolId: "curve-dao",
     chainCategory: "evm",
     description: "Build mpc-auth multiSignRequest for a Curve Router NG swap via @curvefi/api populateSwap. Optionally batches ERC-20 approve txs when allowance is insufficient, then exchange. Requires JSON-RPC and Curve-supported chain.",
-    prerequisites: ["keyGen", "executorAddress", "tokenIn/tokenOut/amountHuman/slippage", "RPC URL"],
+    prerequisites: [
+      "ctm_curve_dao_quote (recommended) or known-good route",
+      "keyGenId + chainId + purposeText",
+      "tokenIn/tokenOut/amountHuman/slippagePercent"
+    ],
     followUp: ["Sign messageToSign", "POST /multiSignRequest with clientSig and signedMessage"],
     handler: { importPath: "protocols/evm/curve-dao", exportName: "buildEvmMultisignBodyCurveDaoBatch" },
     inputZod: mcpCurveDaoBuildSwapMultisignInputSchema,
@@ -960,7 +1109,13 @@ function getAgentCatalogForMcp() {
         "2. GET /getPublicMgtKeyNonce or /getNodeMgtKeyNonce \u2192 nonce",
         "3. buildManagementPostBody(nonce, nodeKey, { \u2026endpoint fields })",
         "4. messageToSignManagementBody(body) \u2192 sign \u2192 withManagementClientSig(body, sig)",
-        "5. POST management route with signed body"
+        "5. POST management route with signed body (no signedMessage field except configUpdateImplement opaque line)"
+      ],
+      agentMultisignTypical: [
+        "1. load_defi_protocol for the target protocol",
+        "2. get_defi_protocol_supported_chains / get_token_registry to pick chainId and tokens",
+        "3. MCP build_* tool with keyGenId + chainId \u2192 { requestId }",
+        "4. Base MCP: wait_for_sign_request_ready \u2192 sign_request_agree \u2192 trigger_sign_result \u2192 broadcast_sign_result"
       ]
     }
   };
@@ -996,6 +1151,7 @@ var lidoProtocolModule = {
 };
 registerProtocolModule(lidoProtocolModule);
 var USDE_ETHEREUM_MAINNET = "0x4c9edd5852cd905f086c759e8383e09bff1e68b3";
+var SUSDE_ETHEREUM_MAINNET = "0x9d39a5de30e57443bff2a8307a4256c8797a3497";
 var USDE_MOST_L2S = "0x5d3a1Ff2b6BAb83b63cd9AD0787074081a52ef34";
 var USDE_ZKSYNC_ERA = "0x39Fe7a0DACcE31Bd90418e3e659fb0b5f0B3Db0d";
 var L2_SAME_ADDRESS_CHAIN_IDS = /* @__PURE__ */ new Set([
@@ -1036,12 +1192,53 @@ var L2_SAME_ADDRESS_CHAIN_IDS = /* @__PURE__ */ new Set([
   48900
   // Zircuit
 ]);
+var FALLBACK_NAME_BY_ID = {
+  1: "Ethereum",
+  42161: "Arbitrum One",
+  10: "Optimism",
+  8453: "Base",
+  56: "BNB Chain",
+  59144: "Linea",
+  5e3: "Mantle",
+  81457: "Blast",
+  169: "Manta Pacific",
+  534352: "Scroll",
+  252: "Fraxtal",
+  34443: "Mode",
+  196: "X Layer",
+  1088: "Metis",
+  80084: "Berachain",
+  2222: "Kava",
+  2818: "Morph",
+  1923: "Swell",
+  48900: "Zircuit",
+  324: "ZKSync Era"
+};
 function usdeTokenAddressOnEvmChain(chainId) {
   if (chainId === 1) return USDE_ETHEREUM_MAINNET;
   if (chainId === 324) return USDE_ZKSYNC_ERA;
   if (L2_SAME_ADDRESS_CHAIN_IDS.has(chainId)) return USDE_MOST_L2S;
   return null;
 }
+function listEthenaUsdeEvmNetworkRows() {
+  const rows = [
+    { chainId: 1, label: FALLBACK_NAME_BY_ID[1], usde: USDE_ETHEREUM_MAINNET }
+  ];
+  const l2 = [...L2_SAME_ADDRESS_CHAIN_IDS].sort((a, b) => a - b);
+  for (const id of l2) {
+    rows.push({
+      chainId: id,
+      label: FALLBACK_NAME_BY_ID[id] ?? `Chain ${id}`,
+      usde: USDE_MOST_L2S
+    });
+  }
+  rows.push({ chainId: 324, label: FALLBACK_NAME_BY_ID[324], usde: USDE_ZKSYNC_ERA });
+  return rows.sort((a, b) => {
+    if (a.chainId === 1) return -1;
+    if (b.chainId === 1) return 1;
+    return a.chainId - b.chainId;
+  });
+}
 function isEvmChainInEthenaUsdeList(chainId) {
   return usdeTokenAddressOnEvmChain(chainId) != null;
 }
@@ -1072,6 +1269,18 @@ registerProtocolModule(ethenaProtocolModule);
 function isMapleSyrupSupportedChain(chainId) {
   return chainId === 1 || chainId === 11155111;
 }
+async function postJsonViaOptionalProxy(args) {
+  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();
+}
 
 // src/protocols/evm/maple/index.ts
 var MAPLE_PROTOCOL_ID = "maple-syrup";
@@ -1118,6 +1327,77 @@ var skyProtocolModule = {
   ]
 };
 registerProtocolModule(skyProtocolModule);
+var AAVE_V4_GRAPHQL_URL = "https://api.v4.aave.com/graphql";
+async function aaveV4Gql(query, variables) {
+  const body = { query, variables: variables ?? {} };
+  const j = await postJsonViaOptionalProxy({
+    directUrl: AAVE_V4_GRAPHQL_URL,
+    body});
+  if (j.errors?.length) {
+    const msg = j.errors.map((e) => e.message ?? "Unknown").join("; ");
+    throw new Error(msg);
+  }
+  if (j.data == null) {
+    throw new Error("Aave V4 API: empty response");
+  }
+  return j.data;
+}
+async function fetchAaveV4Chains() {
+  const d = await aaveV4Gql(`
+    query C($c: ChainsRequest!) { chains(request: $c) { chainId name nativeWrappedToken } }
+  `, { c: { query: { filter: "ALL" } } });
+  return d.chains ?? [];
+}
+async function loadAaveV4SupportedChainIdsFromV4Api() {
+  const rows = await fetchAaveV4Chains();
+  const s = /* @__PURE__ */ new Set();
+  for (const c of rows) s.add(c.chainId);
+  return s;
+}
+var RESERVES_ADDRESS_FRAGMENT = `
+  asset { underlying { address } }
+`;
+async function fetchAaveV4NativeWrappedToken(chainId) {
+  const all = await fetchAaveV4Chains();
+  const c = all.find((x) => x.chainId === chainId);
+  const t = (c?.nativeWrappedToken ?? "").trim();
+  if (t && viem.isAddress(t)) return viem.getAddress(t);
+  return null;
+}
+async function fetchAaveV4SupportedUnderlyingAddressSet(chainId) {
+  const d = await aaveV4Gql(
+    `
+    query A($r: ReservesRequest!) { reserves(request: $r) { ${RESERVES_ADDRESS_FRAGMENT} } }
+  `,
+    {
+      r: {
+        query: { chainIds: [chainId] },
+        filter: "ALL",
+        orderBy: { supplyApy: "DESC" }
+      }
+    }
+  );
+  const s = /* @__PURE__ */ new Set();
+  for (const r of d.reserves ?? []) {
+    const a = (r.asset?.underlying?.address ?? "").trim();
+    if (a && viem.isAddress(a)) s.add(a.toLowerCase());
+  }
+  return s;
+}
+var aaveV4ChainTokenCache = /* @__PURE__ */ new Map();
+function ensureAaveV4ChainTokenCache(chainId) {
+  const hit = aaveV4ChainTokenCache.get(chainId);
+  if (hit) return hit;
+  const p = (async () => {
+    const [nativeWrapped, supportedUnderlying] = await Promise.all([
+      fetchAaveV4NativeWrappedToken(chainId),
+      fetchAaveV4SupportedUnderlyingAddressSet(chainId)
+    ]);
+    return { supportedUnderlying, nativeWrapped };
+  })();
+  aaveV4ChainTokenCache.set(chainId, p);
+  return p;
+}
 
 // src/protocols/evm/aave-v4/index.ts
 var AAVE_V4_PROTOCOL_ID = "aave-v4";
@@ -1160,6 +1440,271 @@ var eulerV2ProtocolModule = {
   ]
 };
 registerProtocolModule(eulerV2ProtocolModule);
+var skillsDir = path.join(path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('catalog.cjs', document.baseURI).href)))), "skills");
+var SKILL_PROTOCOL_IDS = [
+  "aave-v4",
+  "lido",
+  "uniswap-v4",
+  "curve-dao",
+  "ethena",
+  "euler-v2",
+  "maple-syrup",
+  "sky"
+];
+function getToolsForProtocol(protocolId) {
+  return MCP_TOOL_DEFINITIONS.filter((t) => t.protocolId === protocolId);
+}
+function getProtocolSkill(protocolId) {
+  if (!SKILL_PROTOCOL_IDS.includes(protocolId)) {
+    return void 0;
+  }
+  try {
+    return fs.readFileSync(path.join(skillsDir, protocolId, "SKILL.md"), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function listProtocolsWithSkills() {
+  return [...SKILL_PROTOCOL_IDS];
+}
+function getProtocolDiscoverySummary(protocolId) {
+  const mod = getProtocolModules().find((p) => p.id === protocolId);
+  if (!mod) return void 0;
+  return {
+    protocolId: mod.id,
+    chainCategory: mod.chainCategory,
+    actions: mod.actions.map((a) => ({ id: a.id, description: a.description })),
+    tools: getToolsForProtocol(protocolId).map((t) => ({
+      name: t.name,
+      actionId: t.actionId,
+      description: t.description,
+      prerequisites: t.prerequisites,
+      followUp: t.followUp
+    }))
+  };
+}
+var EULER_V2_SUBGRAPH_CHAIN_IDS = [
+  1,
+  8453,
+  42161,
+  10,
+  137,
+  56,
+  43114,
+  100,
+  59144,
+  146,
+  1923,
+  130
+];
+function advisor(protocolId, tokenFilter, impl) {
+  return { protocolId, tokenFilter, ...impl };
+}
+var PROTOCOL_SUPPORT_ADVISORS = {
+  "aave-v4": advisor("aave-v4", "api_underlyings", {
+    async supportedChainIds() {
+      const set = await loadAaveV4SupportedChainIdsFromV4Api();
+      return [...set].sort((a, b) => a - b);
+    },
+    async supportedTokens(chainId) {
+      const cache = await ensureAaveV4ChainTokenCache(chainId);
+      const tokens = [...cache.supportedUnderlying].map((address) => ({
+        address,
+        roles: ["underlying"]
+      }));
+      if (cache.nativeWrapped) {
+        tokens.unshift({
+          address: cache.nativeWrapped,
+          symbol: "WETH",
+          roles: ["native_wrapped"]
+        });
+      }
+      return {
+        tokens,
+        nativeWrapped: cache.nativeWrapped ?? void 0,
+        notes: "Native ETH deposits use wrapped native token address from Aave v4 API."
+      };
+    },
+    async isTokenSupported(chainId, address) {
+      const cache = await ensureAaveV4ChainTokenCache(chainId);
+      let normalized;
+      try {
+        normalized = viem.getAddress(address).toLowerCase();
+      } catch {
+        return false;
+      }
+      if (cache.nativeWrapped && viem.getAddress(cache.nativeWrapped).toLowerCase() === normalized) {
+        return true;
+      }
+      return cache.supportedUnderlying.has(normalized);
+    }
+  }),
+  "uniswap-v4": advisor("uniswap-v4", "any_erc20_on_chain", {
+    async supportedChainIds() {
+      const ids = [];
+      for (const id of [
+        1,
+        5,
+        11155111,
+        137,
+        80001,
+        10,
+        420,
+        42161,
+        421613,
+        42220,
+        44787,
+        56,
+        43114,
+        84531,
+        8453,
+        81457,
+        7777777,
+        324,
+        480,
+        1301,
+        130,
+        10143,
+        84532,
+        1868,
+        143,
+        59144,
+        4217,
+        196
+      ]) {
+        if (isUniswapV4ChainSupported(id)) ids.push(id);
+      }
+      return ids;
+    },
+    async supportedTokens() {
+      return {
+        tokens: [],
+        notes: "Any ERC-20 or native token on a supported chain may be used. Resolve addresses via get_token_registry; tokenOut may be any address."
+      };
+    }
+  }),
+  "curve-dao": advisor("curve-dao", "pool_graph", {
+    async supportedChainIds() {
+      return [1, 10, 56, 100, 137, 146, 196, 250, 252, 324, 999, 1284, 2222, 5e3, 8453, 42161, 42220, 43114, 1313161554];
+    },
+    async supportedTokens(chainId, ctx) {
+      if (!isCurveApiChainSupported(chainId)) {
+        return { tokens: [], notes: "Chain not supported by Curve SDK network constants." };
+      }
+      const rpcUrl = ctx?.rpcUrl?.trim();
+      if (!rpcUrl) {
+        return {
+          tokens: [],
+          notes: "Provide rpcUrl (from get_chain_registry) to load Curve pool graph token list."
+        };
+      }
+      const session = await loadFullCurveSessionForRpc(rpcUrl);
+      if (!session?.swappableNodeKeys?.size) {
+        return { tokens: [], notes: "Curve session returned no swappable tokens for this RPC." };
+      }
+      return {
+        tokens: [...session.swappableNodeKeys].map((key) => {
+          const address = key.startsWith("0x") ? key : key.split(":")[0] ?? key;
+          return { address, roles: ["swappable"] };
+        })
+      };
+    }
+  }),
+  lido: advisor("lido", "mainnet_only", {
+    async supportedChainIds() {
+      return [LIDO_ETHEREUM_MAINNET_CHAIN_ID];
+    },
+    async supportedTokens() {
+      return {
+        tokens: [
+          { address: "0x0000000000000000000000000000000000000000", symbol: "ETH", roles: ["native", "stake"] },
+          { address: "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84", symbol: "stETH", roles: ["erc20"] },
+          { address: "0x7f39C581F595B853cBbF37C12FfeeA971C5a5bEa", symbol: "wstETH", roles: ["erc20"] }
+        ],
+        notes: "Lido staking and withdrawals are Ethereum mainnet only."
+      };
+    }
+  }),
+  ethena: advisor("ethena", "minting_contract", {
+    async supportedChainIds() {
+      return listEthenaUsdeEvmNetworkRows().map((r) => r.chainId);
+    },
+    async supportedTokens(chainId) {
+      if (chainId === 1) {
+        return {
+          tokens: [
+            { address: USDE_ETHEREUM_MAINNET, symbol: "USDe", roles: ["stake"] },
+            { address: SUSDE_ETHEREUM_MAINNET, symbol: "sUSDe", roles: ["vault"] }
+          ],
+          notes: "Ethena stake/redeem UI actions are mainnet-only; USDe exists on other chains for transfers."
+        };
+      }
+      if (isEvmChainInEthenaUsdeList(chainId)) {
+        const row = listEthenaUsdeEvmNetworkRows().find((r) => r.chainId === chainId);
+        return {
+          tokens: row ? [{ address: row.usde, symbol: "USDe", roles: ["erc20"] }] : [],
+          notes: "USDe on L2; staking MCP tools target mainnet only."
+        };
+      }
+      return { tokens: [] };
+    }
+  }),
+  "euler-v2": advisor("euler-v2", "subgraph_vaults", {
+    async supportedChainIds() {
+      return [...EULER_V2_SUBGRAPH_CHAIN_IDS];
+    },
+    async supportedTokens() {
+      return {
+        tokens: [],
+        notes: "Euler vault/collateral assets vary by chain. Pass vault and asset addresses from Euler app or subgraph."
+      };
+    }
+  }),
+  [MAPLE_PROTOCOL_ID]: advisor(MAPLE_PROTOCOL_ID, "fixed_addresses", {
+    async supportedChainIds() {
+      return [1, 11155111];
+    },
+    async supportedTokens() {
+      return {
+        tokens: [],
+        notes: "Maple Syrup pools are discovered via GraphQL; pass syrupRouter, pool, and asset from Maple UI."
+      };
+    }
+  }),
+  [SKY_PROTOCOL_ID]: advisor(SKY_PROTOCOL_ID, "fixed_addresses", {
+    async supportedChainIds() {
+      return [1];
+    },
+    async supportedTokens() {
+      return {
+        tokens: [],
+        notes: "Sky Lockstake and sUSDS use fixed mainnet contract addresses in protocol builders."
+      };
+    }
+  })
+};
+function getProtocolSupportAdvisor(protocolId) {
+  return PROTOCOL_SUPPORT_ADVISORS[protocolId];
+}
+function listProtocolSupportAdvisorIds() {
+  return Object.keys(PROTOCOL_SUPPORT_ADVISORS);
+}
+var mcpServerCommonInputSchema = zod.z.object({
+  keyGenId: zod.z.string().min(1).describe("KeyGen id from fetch_key_gen_result / node preferred KeyGen"),
+  chainId: zod.z.number().int().positive().describe("EVM chain id; RPC and gas config resolved from chain registry"),
+  purposeText: zod.z.string().min(1).describe("Human-readable purpose for the sign request"),
+  useCustomGas: zod.z.boolean().optional().describe("Apply chain gas settings from registry when true")
+});
+function mcpServerMultisignInput(fields) {
+  return mcpServerCommonInputSchema.extend(fields);
+}
+var mcpServerSubmitOutputSchema = zod.z.object({
+  requestId: zod.z.string().min(1)
+}).describe("mpc-auth multiSignRequest id; continue with trigger_sign_result / broadcast_sign_result");
+var MCP_NON_SUBMIT_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "ctm_uniswap_v4_quote",
+  "ctm_uniswap_v4_create_swap"
+]);
 
 // src/agent/catalog.ts
 registerProtocolModule(uniswapV4ProtocolModule);
@@ -1193,10 +1738,12 @@ function getAgentCatalog() {
 
 exports.EVM_COMMON_PARAM_DOCS = EVM_COMMON_PARAM_DOCS;
 exports.MANAGEMENT_SIG_DOC = MANAGEMENT_SIG_DOC;
+exports.MCP_NON_SUBMIT_TOOL_NAMES = MCP_NON_SUBMIT_TOOL_NAMES;
 exports.MCP_TOOL_DEFINITIONS = MCP_TOOL_DEFINITIONS;
 exports.MCP_TOOL_INPUT_SCHEMAS = MCP_TOOL_INPUT_SCHEMAS;
 exports.MCP_TOOL_OUTPUT_SCHEMAS = MCP_TOOL_OUTPUT_SCHEMAS;
 exports.MULTISIGN_OUTPUT_DOC = MULTISIGN_OUTPUT_DOC;
+exports.PROTOCOL_SUPPORT_ADVISORS = PROTOCOL_SUPPORT_ADVISORS;
 exports.chainDetailSchema = chainDetailSchema;
 exports.evmAddressSchema = evmAddressSchema;
 exports.evmMultisignCommonInputSchema = evmMultisignCommonInputSchema;
@@ -1207,14 +1754,22 @@ exports.getMcpToolByName = getMcpToolByName;
 exports.getMcpToolDefinitions = getMcpToolDefinitions;
 exports.getMcpToolInputSchema = getMcpToolInputSchema;
 exports.getMcpToolOutputSchema = getMcpToolOutputSchema;
+exports.getProtocolDiscoverySummary = getProtocolDiscoverySummary;
 exports.getProtocolModules = getProtocolModules;
+exports.getProtocolSkill = getProtocolSkill;
+exports.getProtocolSupportAdvisor = getProtocolSupportAdvisor;
+exports.getToolsForProtocol = getToolsForProtocol;
 exports.jsonObjectSchema = jsonObjectSchema;
 exports.keyGenSchema = keyGenSchema;
+exports.listProtocolSupportAdvisorIds = listProtocolSupportAdvisorIds;
+exports.listProtocolsWithSkills = listProtocolsWithSkills;
 exports.mcpAaveV4BorrowInputSchema = mcpAaveV4BorrowInputSchema;
 exports.mcpAaveV4DepositInputSchema = mcpAaveV4DepositInputSchema;
 exports.mcpAaveV4RepayInputSchema = mcpAaveV4RepayInputSchema;
 exports.mcpAaveV4WithdrawInputSchema = mcpAaveV4WithdrawInputSchema;
 exports.mcpCurveDaoBuildSwapMultisignInputSchema = mcpCurveDaoBuildSwapMultisignInputSchema;
+exports.mcpCurveDaoQuoteInputSchema = mcpCurveDaoQuoteInputSchema;
+exports.mcpCurveDaoQuoteOutputSchema = mcpCurveDaoQuoteOutputSchema;
 exports.mcpEthenaClaimInputSchema = mcpEthenaClaimInputSchema;
 exports.mcpEthenaCooldownInputSchema = mcpEthenaCooldownInputSchema;
 exports.mcpEthenaRedeemInputSchema = mcpEthenaRedeemInputSchema;
@@ -1234,6 +1789,9 @@ exports.mcpMapleDepositInputSchema = mcpMapleDepositInputSchema;
 exports.mcpMapleRequestRedeemInputSchema = mcpMapleRequestRedeemInputSchema;
 exports.mcpMultisignInput = mcpMultisignInput;
 exports.mcpMultisignOutputSchema = multisignOutputSchema;
+exports.mcpServerCommonInputSchema = mcpServerCommonInputSchema;
+exports.mcpServerMultisignInput = mcpServerMultisignInput;
+exports.mcpServerSubmitOutputSchema = mcpServerSubmitOutputSchema;
 exports.mcpSkyLockstakeCloseInputSchema = mcpSkyLockstakeCloseInputSchema;
 exports.mcpSkyLockstakeDrawInputSchema = mcpSkyLockstakeDrawInputSchema;
 exports.mcpSkyLockstakeGetRewardInputSchema = mcpSkyLockstakeGetRewardInputSchema;