@continuumdao/ctm-mpc-defi 0.1.4 → 0.2.1

package/dist/agent/catalog.js

@@ -1,4 +1,9 @@
-import 'viem';
+import { getAddress, isAddress } from 'viem';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { z } from 'zod';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 
 // src/core/registry.ts
 var modules = [];
@@ -157,6 +162,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";
@@ -246,7 +341,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",
@@ -264,52 +366,592 @@ 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."
   }
 };
-
-// src/agent/mcpTools.ts
-function paramProperties(params, includeCommon = []) {
-  const out = {};
-  for (const k of includeCommon) {
-    const d = EVM_COMMON_PARAM_DOCS[k];
-    if (d) out[k] = { type: d.type, description: d.description };
+function zodSchemaToMcpJsonSchema(schema) {
+  const raw = zodToJsonSchema(schema, {
+    target: "openApi3",
+    $refStrategy: "none"
+  });
+  if (raw.type === "object" || raw.type === "array" || raw.type === "string") {
+    const { $schema: _s, ...rest } = raw;
+    return rest;
   }
-  for (const [k, d] of Object.entries(params)) {
-    out[k] = { type: d.type, description: d.description };
+  const defs = raw.definitions;
+  if (defs) {
+    const first = Object.values(defs)[0];
+    if (first?.type) {
+      const { $schema: _s, ...rest } = first;
+      return rest;
+    }
   }
-  return out;
+  return raw;
 }
-function requiredKeys(params, includeCommon = []) {
-  const req = [];
-  for (const k of includeCommon) {
-    if (EVM_COMMON_PARAM_DOCS[k]?.required) req.push(k);
-  }
-  for (const [k, d] of Object.entries(params)) {
-    if (d.required) req.push(k);
-  }
-  return req;
+var evmAddressSchema = z.string().min(1).describe("EVM address (0x-prefixed, 40 hex nibbles)");
+var keyGenSchema = z.object({
+  pubkeyhex: z.string().min(1).describe("MPC secp256k1 public key hex (required for multiSignRequest pubKey)"),
+  keylist: z.array(z.string()).optional().describe("Key list on the sign request"),
+  ClientKeys: z.record(z.string()).optional().describe("Optional client key map from keyGen")
+}).describe(
+  "MPC key slice: { pubkeyhex, keylist?, ClientKeys? }. Used for pubKey/keyList on POST /multiSignRequest."
+);
+var chainDetailSchema = z.object({
+  legacy: z.boolean().optional(),
+  gasLimit: z.number().optional(),
+  gasMultiplier: z.number().optional(),
+  gasPrice: z.number().optional(),
+  baseFee: z.number().optional(),
+  priorityFee: z.number().optional(),
+  baseFeeMultiplier: z.number().optional()
+}).passthrough().describe(
+  "Optional gas config: { legacy?, gasLimit?, gasMultiplier?, gasPrice?, baseFee?, priorityFee?, baseFeeMultiplier? }."
+);
+var evmMultisignCommonInputSchema = z.object({
+  keyGen: keyGenSchema,
+  purposeText: z.string().min(1).describe(
+    "Human-readable purpose for the sign request. Stored in bodyForSign.purpose (may be appended with an automatic batch suffix)."
+  ),
+  useCustomGas: z.boolean().describe(
+    "When true, apply chain gas settings from chainDetail / customGasChainDetails instead of raw RPC estimates only."
+  ),
+  chainId: z.number().int().positive().describe("EVM chain id (decimal). Becomes destinationChainID on the sign request."),
+  rpcUrl: z.string().min(1).describe("HTTPS JSON-RPC URL for gas estimation, nonce, and allowance reads."),
+  executorAddress: evmAddressSchema.describe(
+    "MPC wallet address (from keyGen ethereumaddress) \u2014 tx sender for estimates and approvals."
+  ),
+  chainDetail: chainDetailSchema,
+  customGasChainDetails: z.record(z.unknown()).optional().describe("Snapshot written to extraJSON.customGasChainDetails when useCustomGas is true.")
+});
+var multisignOutputSchema = z.object({
+  bodyForSign: z.record(z.unknown()).describe(
+    "POST body fields without clientSig: keyList, pubKey, msgHash, msgRaw, destinationChainID, purpose, extraJSON, proposalTxParams (batch), messageHashes/messageRawBatch when N>1 txs."
+  ),
+  messageToSign: z.string().describe("JSON.stringify(bodyForSign) \u2014 exact string to sign before adding clientSig.")
+}).describe(
+  "Unsigned mpc-auth multiSignRequest payload. Sign messageToSign and POST { ...bodyForSign, clientSig, signedMessage } to /multiSignRequest."
+);
+var jsonObjectSchema = z.record(z.unknown());
+var uniswapQuoteTradeTypeSchema = z.enum(["EXACT_INPUT", "EXACT_OUTPUT"]);
+var mcpUniswapV4QuoteInputSchema = z.object({
+  type: uniswapQuoteTradeTypeSchema.describe("EXACT_INPUT or EXACT_OUTPUT"),
+  amount: z.string().min(1).describe("Amount in token-in base units (wei string for ERC-20)"),
+  tokenIn: z.string().min(1).describe("Input token; 0x0 for native ETH"),
+  tokenOut: z.string().min(1).describe("Output token address"),
+  chainId: z.union([z.number().int().positive(), z.string().min(1)]).describe("tokenInChainId / same-chain default"),
+  uniswapApiKey: z.string().min(1).describe("Uniswap Trade API x-api-key"),
+  swapper: evmAddressSchema.optional().describe("MPC executor; omit if keyGen + managementNodeUrl provided"),
+  slippage: z.union([z.number(), z.string()]).optional().describe("Slippage percent; omit for API auto slippage"),
+  keyGen: z.string().optional().describe("KeyGen id \u2014 resolves swapper via GET /getKeyGenResultById when swapper omitted"),
+  managementNodeUrl: z.string().min(1).optional().describe("MPC node base URL; required with keyGen when swapper is omitted"),
+  tokenInChainId: z.union([z.number(), z.string()]).optional(),
+  tokenOutChainId: z.union([z.number(), z.string()]).optional(),
+  permit2Disabled: z.boolean().optional(),
+  baseUrl: z.string().optional(),
+  universalRouterVersion: z.string().optional()
+});
+var mcpUniswapV4QuoteOutputSchema = jsonObjectSchema.describe(
+  "Full Uniswap POST /quote JSON (includes nested quote object with input/output amounts)."
+);
+var mcpUniswapV4CreateSwapInputSchema = z.object({
+  uniswapApiKey: z.string().min(1).describe("Uniswap Trade API key"),
+  fullQuoteFromPermit: jsonObjectSchema.describe("Full quote JSON from ctm_uniswap_v4_quote"),
+  swapTransactionDeadlineUnix: z.number().int().positive().optional().describe("On-chain deadline unix seconds; default ~30 min from now"),
+  useServerProxy: z.boolean().optional().describe("Set false in Node/agents; true only in browser via Next API route"),
+  baseUrl: z.string().optional(),
+  universalRouterVersion: z.string().optional()
+});
+var mcpUniswapV4CreateSwapOutputSchema = z.object({
+  swap: jsonObjectSchema.describe("Universal Router tx: { to, data, value, gasLimit? }"),
+  requestId: z.string().optional(),
+  gasFee: z.string().optional()
+}).passthrough().describe("{ swap: TransactionRequest, requestId?, gasFee? }");
+var swapTxRequestSchema = jsonObjectSchema.describe("swap field from create_swap response (to, data, value)");
+var mcpUniswapV4BuildSwapMultisignInputSchema = evmMultisignCommonInputSchema.extend({
+  tokenIn: evmAddressSchema.describe("Token in; 0x0 for native ETH"),
+  swap: swapTxRequestSchema,
+  createSwapResponse: z.object({
+    swap: swapTxRequestSchema,
+    requestId: z.string().optional(),
+    gasFee: z.string().optional()
+  }).passthrough().describe("Full create_swap response"),
+  fullQuoteSnapshot: jsonObjectSchema.describe("Quote JSON used for the swap"),
+  swapDeadlineUnix: z.number().describe("Same deadline passed to create_swap"),
+  slippagePercent: z.number().optional().describe("Extra approve headroom for EXACT_OUTPUT")
+});
+var mcpCurveDaoBuildSwapMultisignInputSchema = evmMultisignCommonInputSchema.extend({
+  tokenIn: evmAddressSchema.describe("ERC-20 sold (native in uses WETH path in UI)"),
+  tokenOut: z.string().min(1).describe("Output token or 0xeeee\u2026 native placeholder"),
+  amountHuman: z.string().min(1).describe("Human-readable amount of tokenIn"),
+  slippagePercent: z.number().gt(0).lt(100).describe("Slippage 0\u2013100 exclusive")
+});
+function mcpMultisignInput(fields) {
+  return evmMultisignCommonInputSchema.extend(fields);
 }
-var multisignOutputSchema = {
-  type: "object",
-  description: MULTISIGN_OUTPUT_DOC.description,
-  properties: {
-    bodyForSign: {
-      type: "object",
-      description: MULTISIGN_OUTPUT_DOC.fields.bodyForSign.description
-    },
-    messageToSign: {
-      type: "string",
-      description: MULTISIGN_OUTPUT_DOC.fields.messageToSign.description
-    }
-  },
-  required: ["bodyForSign", "messageToSign"]
-};
-var MCP_TOOL_DEFINITIONS = [
-  {
+var mcpLidoSubmitInputSchema = mcpMultisignInput({
+  valueWei: z.string().min(1).describe("ETH to stake (wei decimal string)"),
+  referral: evmAddressSchema.optional()
+});
+var mcpLidoRequestWithdrawalsInputSchema = mcpMultisignInput({
+  stEthAmountsWei: z.array(z.string()).min(1).describe("stETH amounts per withdrawal request (wei strings)")
+});
+var mcpLidoClaimWithdrawalInputSchema = mcpMultisignInput({
+  requestId: z.union([z.string(), z.number()]).describe("Withdrawal queue request id")
+});
+var mcpLidoWrapStEthInputSchema = mcpMultisignInput({
+  stEthAmountWei: z.string().min(1)
+});
+var mcpLidoUnwrapWstEthInputSchema = mcpMultisignInput({
+  wstEthAmountWei: z.string().min(1)
+});
+var mcpEthenaStakeInputSchema = mcpMultisignInput({
+  usdeAmountHuman: z.string().min(1),
+  susdeVault: evmAddressSchema.optional()
+});
+var mcpEthenaRedeemInputSchema = mcpMultisignInput({
+  susdeSharesHuman: z.string().min(1),
+  susdeVault: evmAddressSchema.optional()
+});
+var mcpEthenaCooldownInputSchema = mcpMultisignInput({
+  susdeSharesHuman: z.string().min(1),
+  susdeVault: evmAddressSchema.optional()
+});
+var mcpEthenaClaimInputSchema = mcpMultisignInput({
+  susdeVault: evmAddressSchema.optional()
+});
+var mcpMapleDepositInputSchema = mcpMultisignInput({
+  syrupRouter: evmAddressSchema,
+  pool: evmAddressSchema,
+  asset: evmAddressSchema,
+  amountHuman: z.string().min(1),
+  authorizeSig: jsonObjectSchema.optional()
+});
+var mcpMapleRequestRedeemInputSchema = mcpMultisignInput({
+  pool: evmAddressSchema,
+  sharesHuman: z.string().min(1),
+  receiver: evmAddressSchema
+});
+var mcpSkyLockstakeStakeInputSchema = mcpMultisignInput({
+  skyAmountHuman: z.string().min(1),
+  usdsDrawHuman: z.string().optional(),
+  farmRef: z.string().optional()
+});
+var mcpSkyLockstakeDrawInputSchema = mcpMultisignInput({
+  usdsAmountHuman: z.string().min(1),
+  urnIndex: z.number().int().nonnegative()
+});
+var mcpSkyLockstakeWipeInputSchema = mcpMultisignInput({
+  usdsAmountHuman: z.string().min(1),
+  urnIndex: z.number().int().nonnegative()
+});
+var mcpSkyLockstakeCloseInputSchema = mcpMultisignInput({
+  urnIndex: z.number().int().nonnegative()
+});
+var mcpSkyLockstakeGetRewardInputSchema = mcpMultisignInput({
+  urnIndex: z.number().int().nonnegative()
+});
+var mcpSkySusdsDepositInputSchema = mcpMultisignInput({
+  usdsAmountHuman: z.string().min(1)
+});
+var mcpSkySusdsRedeemInputSchema = mcpMultisignInput({
+  sharesHuman: z.string().min(1)
+});
+var mcpAaveV4DepositInputSchema = mcpMultisignInput({
+  spoke: evmAddressSchema,
+  underlying: evmAddressSchema,
+  amountHuman: z.string().min(1),
+  marketId: z.string().min(1)
+});
+var mcpAaveV4WithdrawInputSchema = mcpMultisignInput({
+  spoke: evmAddressSchema,
+  underlying: evmAddressSchema,
+  amountHuman: z.string().min(1),
+  marketId: z.string().min(1)
+});
+var mcpAaveV4BorrowInputSchema = mcpMultisignInput({
+  spoke: evmAddressSchema,
+  underlying: evmAddressSchema,
+  amountHuman: z.string().min(1),
+  marketId: z.string().min(1)
+});
+var mcpAaveV4RepayInputSchema = mcpMultisignInput({
+  spoke: evmAddressSchema,
+  underlying: evmAddressSchema,
+  amountHuman: z.string().min(1),
+  marketId: z.string().min(1)
+});
+var mcpEulerV2IsolatedLendInputSchema = mcpMultisignInput({
+  vault: evmAddressSchema,
+  assetAmountHuman: z.string().min(1)
+});
+var mcpEulerV2IsolatedBorrowInputSchema = mcpMultisignInput({
+  vault: evmAddressSchema,
+  collateralAsset: evmAddressSchema,
+  borrowAsset: evmAddressSchema,
+  collateralAmountHuman: z.string().min(1),
+  loopBorrowWeis: z.array(z.string()).min(1)
+});
+var mcpEulerV2VaultWithdrawInputSchema = mcpMultisignInput({
+  vault: evmAddressSchema,
+  sharesHuman: z.string().min(1)
+});
+var mcpEulerV2BorrowRepayInputSchema = mcpMultisignInput({
+  vault: evmAddressSchema,
+  amountHuman: z.string().min(1)
+});
+var mcpEulerV2CollateralDepositInputSchema = mcpMultisignInput({
+  vault: evmAddressSchema,
+  collateralAsset: evmAddressSchema,
+  amountHuman: z.string().min(1)
+});
+var mcpEulerV2CollateralWithdrawInputSchema = mcpMultisignInput({
+  vault: evmAddressSchema,
+  collateralAsset: evmAddressSchema,
+  amountHuman: z.string().min(1)
+});
+
+// src/agent/mcpProtocolTools.ts
+function defineProtocolMcpTool(def) {
+  return {
+    ...def,
+    outputZod: multisignOutputSchema,
+    inputSchema: zodSchemaToMcpJsonSchema(def.inputZod),
+    outputSchema: zodSchemaToMcpJsonSchema(multisignOutputSchema),
+    parseInput: (data) => def.inputZod.parse(data),
+    parseOutput: (data) => multisignOutputSchema.parse(data)
+  };
+}
+var MCP_PROTOCOL_TOOL_DEFINITIONS = [
+  defineProtocolMcpTool({
+    name: "ctm_lido_build_submit_multisign",
+    actionId: "lido.submit",
+    protocolId: "lido",
+    chainCategory: "evm",
+    description: "Build mpc-auth multiSignRequest for Lido ETH stake (submit).",
+    prerequisites: ["keyGen", "executorAddress", "RPC URL"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/lido", exportName: "buildEvmMultisignBodyLidoSubmit" },
+    inputZod: mcpLidoSubmitInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_lido_build_request_withdrawals_multisign",
+    actionId: "lido.request-withdrawals",
+    protocolId: "lido",
+    chainCategory: "evm",
+    description: "Build batch for Lido withdrawal queue (approve + requestWithdrawals).",
+    prerequisites: ["keyGen", "executorAddress", "RPC URL"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/lido", exportName: "buildEvmMultisignBodyLidoRequestWithdrawals" },
+    inputZod: mcpLidoRequestWithdrawalsInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_lido_build_claim_withdrawal_multisign",
+    actionId: "lido.claim-withdrawal",
+    protocolId: "lido",
+    chainCategory: "evm",
+    description: "Build tx for Lido claimWithdrawal.",
+    prerequisites: ["keyGen", "executorAddress", "RPC URL"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/lido", exportName: "buildEvmMultisignBodyLidoClaimWithdrawal" },
+    inputZod: mcpLidoClaimWithdrawalInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_lido_build_wrap_steth_multisign",
+    actionId: "lido.wrap-steth",
+    protocolId: "lido",
+    chainCategory: "evm",
+    description: "Build batch for wstETH wrap.",
+    prerequisites: ["keyGen", "executorAddress", "RPC URL"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/lido", exportName: "buildEvmMultisignBodyLidoWrapStEth" },
+    inputZod: mcpLidoWrapStEthInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_lido_build_unwrap_wsteth_multisign",
+    actionId: "lido.unwrap-wsteth",
+    protocolId: "lido",
+    chainCategory: "evm",
+    description: "Build tx for wstETH unwrap.",
+    prerequisites: ["keyGen", "executorAddress", "RPC URL"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/lido", exportName: "buildEvmMultisignBodyLidoUnwrapWstEth" },
+    inputZod: mcpLidoUnwrapWstEthInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_ethena_build_stake_multisign",
+    actionId: "ethena.stake-usde",
+    protocolId: "ethena",
+    chainCategory: "evm",
+    description: "Build batch: USDe approve + sUSDe deposit.",
+    prerequisites: ["keyGen", "executorAddress", "Ethereum mainnet RPC"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/ethena", exportName: "buildEvmMultisignBodyEthenaUsdeStakeToSusde" },
+    inputZod: mcpEthenaStakeInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_ethena_build_redeem_multisign",
+    actionId: "ethena.redeem-susde",
+    protocolId: "ethena",
+    chainCategory: "evm",
+    description: "Build sUSDe redeem when cooldown is off.",
+    prerequisites: ["keyGen", "executorAddress", "RPC URL"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/ethena", exportName: "buildEvmMultisignBodyEthenaSusdeRedeemToUsde" },
+    inputZod: mcpEthenaRedeemInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_ethena_build_cooldown_multisign",
+    actionId: "ethena.cooldown-shares",
+    protocolId: "ethena",
+    chainCategory: "evm",
+    description: "Build sUSDe cooldownShares batch step.",
+    prerequisites: ["keyGen", "executorAddress", "RPC URL"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/ethena", exportName: "buildEvmMultisignBodyEthenaSusdeCooldownShares" },
+    inputZod: mcpEthenaCooldownInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_ethena_build_claim_multisign",
+    actionId: "ethena.claim-unstake",
+    protocolId: "ethena",
+    chainCategory: "evm",
+    description: "Build unstake claim after cooldown.",
+    prerequisites: ["keyGen", "executorAddress", "RPC URL"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/ethena", exportName: "buildEvmMultisignBodyEthenaUnstakeClaim" },
+    inputZod: mcpEthenaClaimInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_maple_build_deposit_multisign",
+    actionId: "maple-syrup.deposit",
+    protocolId: "maple-syrup",
+    chainCategory: "evm",
+    description: "Build Maple Syrup router deposit batch.",
+    prerequisites: ["keyGen", "executorAddress", "router + pool addresses"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/maple", exportName: "buildEvmMultisignBodyMapleSyrupDeposit" },
+    inputZod: mcpMapleDepositInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_maple_build_request_redeem_multisign",
+    actionId: "maple-syrup.request-redeem",
+    protocolId: "maple-syrup",
+    chainCategory: "evm",
+    description: "Build Maple PoolV2 requestRedeem batch.",
+    prerequisites: ["keyGen", "executorAddress", "pool address"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/maple", exportName: "buildEvmMultisignBodyMaplePoolRequestRedeem" },
+    inputZod: mcpMapleRequestRedeemInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_sky_build_lockstake_stake_multisign",
+    actionId: "sky.lockstake-stake",
+    protocolId: "sky",
+    chainCategory: "evm",
+    description: "Build Sky Lockstake open/stake batch.",
+    prerequisites: ["keyGen", "executorAddress", "Ethereum mainnet RPC"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/sky", exportName: "buildSkyLockstakeStakePositionBatch" },
+    inputZod: mcpSkyLockstakeStakeInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_sky_build_lockstake_draw_multisign",
+    actionId: "sky.lockstake-draw",
+    protocolId: "sky",
+    chainCategory: "evm",
+    description: "Build Lockstake draw (borrow USDS).",
+    prerequisites: ["keyGen", "executorAddress", "open urn"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/sky", exportName: "buildSkyLockstakeDrawBatch" },
+    inputZod: mcpSkyLockstakeDrawInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_sky_build_lockstake_wipe_multisign",
+    actionId: "sky.lockstake-wipe",
+    protocolId: "sky",
+    chainCategory: "evm",
+    description: "Build Lockstake repay/wipe batch.",
+    prerequisites: ["keyGen", "executorAddress", "urn index"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/sky", exportName: "buildSkyLockstakeWipeBatch" },
+    inputZod: mcpSkyLockstakeWipeInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_sky_build_lockstake_close_multisign",
+    actionId: "sky.lockstake-close",
+    protocolId: "sky",
+    chainCategory: "evm",
+    description: "Build Lockstake close position batch.",
+    prerequisites: ["keyGen", "executorAddress", "urn index"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/sky", exportName: "buildSkyLockstakeCloseBatch" },
+    inputZod: mcpSkyLockstakeCloseInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_sky_build_lockstake_get_reward_multisign",
+    actionId: "sky.lockstake-get-reward",
+    protocolId: "sky",
+    chainCategory: "evm",
+    description: "Build Lockstake getReward batch.",
+    prerequisites: ["keyGen", "executorAddress", "urn index"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/sky", exportName: "buildSkyLockstakeGetRewardBatch" },
+    inputZod: mcpSkyLockstakeGetRewardInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_sky_build_susds_deposit_multisign",
+    actionId: "sky.susds-deposit",
+    protocolId: "sky",
+    chainCategory: "evm",
+    description: "Build USDS \u2192 sUSDS ERC-4626 deposit batch.",
+    prerequisites: ["keyGen", "executorAddress", "RPC URL"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/sky", exportName: "buildSkySusdsDepositFromUsdsBatch" },
+    inputZod: mcpSkySusdsDepositInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_sky_build_susds_redeem_multisign",
+    actionId: "sky.susds-redeem",
+    protocolId: "sky",
+    chainCategory: "evm",
+    description: "Build sUSDS redeem to USDS batch.",
+    prerequisites: ["keyGen", "executorAddress", "RPC URL"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/sky", exportName: "buildSkySusdsRedeemToUsdsBatch" },
+    inputZod: mcpSkySusdsRedeemInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_aave_v4_build_deposit_multisign",
+    actionId: "aave-v4.deposit",
+    protocolId: "aave-v4",
+    chainCategory: "evm",
+    description: "Build Aave v4 Spoke supply/deposit batch.",
+    prerequisites: ["keyGen", "executorAddress", "spoke + underlying"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/aave-v4", exportName: "buildEvmMultisignBodyAaveV4DepositBatch" },
+    inputZod: mcpAaveV4DepositInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_aave_v4_build_withdraw_multisign",
+    actionId: "aave-v4.withdraw",
+    protocolId: "aave-v4",
+    chainCategory: "evm",
+    description: "Build Aave v4 Spoke withdraw batch.",
+    prerequisites: ["keyGen", "executorAddress", "spoke + underlying"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/aave-v4", exportName: "buildEvmMultisignBodyAaveV4SpokeWithdraw" },
+    inputZod: mcpAaveV4WithdrawInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_aave_v4_build_borrow_multisign",
+    actionId: "aave-v4.borrow",
+    protocolId: "aave-v4",
+    chainCategory: "evm",
+    description: "Build Aave v4 Spoke borrow batch.",
+    prerequisites: ["keyGen", "executorAddress", "spoke + underlying"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/aave-v4", exportName: "buildEvmMultisignBodyAaveV4SpokeBorrow" },
+    inputZod: mcpAaveV4BorrowInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_aave_v4_build_repay_multisign",
+    actionId: "aave-v4.repay",
+    protocolId: "aave-v4",
+    chainCategory: "evm",
+    description: "Build Aave v4 Spoke repay batch.",
+    prerequisites: ["keyGen", "executorAddress", "spoke + underlying"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/aave-v4", exportName: "buildEvmMultisignBodyAaveV4SpokeRepay" },
+    inputZod: mcpAaveV4RepayInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_euler_v2_build_isolated_lend_multisign",
+    actionId: "euler-v2.isolated-lend",
+    protocolId: "euler-v2",
+    chainCategory: "evm",
+    description: "Build Euler v2 vault deposit/lend batch.",
+    prerequisites: ["keyGen", "executorAddress", "vault address"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/euler-v2", exportName: "buildEvmMultisignBodyEulerV2IsolatedLendDepositBatch" },
+    inputZod: mcpEulerV2IsolatedLendInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_euler_v2_build_isolated_borrow_multisign",
+    actionId: "euler-v2.isolated-borrow",
+    protocolId: "euler-v2",
+    chainCategory: "evm",
+    description: "Build Euler v2 isolated borrow loop batch.",
+    prerequisites: ["keyGen", "executorAddress", "vault + collateral"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/euler-v2", exportName: "buildEvmMultisignBodyEulerV2IsolatedBorrowBatch" },
+    inputZod: mcpEulerV2IsolatedBorrowInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_euler_v2_build_vault_withdraw_multisign",
+    actionId: "euler-v2.vault-withdraw",
+    protocolId: "euler-v2",
+    chainCategory: "evm",
+    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: "buildEvmMultisignBodyEulerV2VaultWithdraw" },
+    inputZod: mcpEulerV2VaultWithdrawInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_euler_v2_build_borrow_repay_multisign",
+    actionId: "euler-v2.borrow-repay",
+    protocolId: "euler-v2",
+    chainCategory: "evm",
+    description: "Build Euler v2 borrow repay batch.",
+    prerequisites: ["keyGen", "executorAddress", "vault address"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/euler-v2", exportName: "buildEvmMultisignBodyEulerV2BorrowRepayBatch" },
+    inputZod: mcpEulerV2BorrowRepayInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_euler_v2_build_collateral_deposit_multisign",
+    actionId: "euler-v2.collateral-deposit",
+    protocolId: "euler-v2",
+    chainCategory: "evm",
+    description: "Build Euler v2 borrow collateral deposit batch.",
+    prerequisites: ["keyGen", "executorAddress", "vault + collateral asset"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/euler-v2", exportName: "buildEvmMultisignBodyEulerV2BorrowCollateralDepositBatch" },
+    inputZod: mcpEulerV2CollateralDepositInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_euler_v2_build_collateral_withdraw_multisign",
+    actionId: "euler-v2.collateral-withdraw",
+    protocolId: "euler-v2",
+    chainCategory: "evm",
+    description: "Build Euler v2 borrow collateral withdraw batch.",
+    prerequisites: ["keyGen", "executorAddress", "vault + collateral asset"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/euler-v2", exportName: "buildEvmMultisignBodyEulerV2BorrowCollateralWithdrawBatch" },
+    inputZod: mcpEulerV2CollateralWithdrawInputSchema
+  })
+];
+
+// src/agent/mcpTools.ts
+function defineMcpTool(def) {
+  return {
+    ...def,
+    inputSchema: zodSchemaToMcpJsonSchema(def.inputZod),
+    outputSchema: zodSchemaToMcpJsonSchema(def.outputZod),
+    parseInput: (data) => def.inputZod.parse(data),
+    parseOutput: (data) => def.outputZod.parse(data)
+  };
+}
+var CORE_MCP_TOOL_DEFINITIONS = [
+  defineMcpTool({
     name: "ctm_uniswap_v4_quote",
     actionId: "uniswap-v4.quote",
     protocolId: "uniswap-v4",
@@ -318,33 +960,10 @@ var MCP_TOOL_DEFINITIONS = [
     prerequisites: ["Chain must be supported by Uniswap V4 (Universal Router map)."],
     followUp: ["ctm_uniswap_v4_create_swap", "ctm_uniswap_v4_build_swap_multisign"],
     handler: { importPath: "protocols/evm/uniswap-v4", exportName: "uniswapTradeQuote" },
-    inputSchema: {
-      type: "object",
-      properties: paramProperties({
-        type: { type: "string", required: true, description: "EXACT_INPUT or EXACT_OUTPUT" },
-        amount: { type: "string", required: true, description: "Amount in token-in base units (wei string for ERC-20)" },
-        tokenIn: { type: "address", required: true, description: "Input token; 0x0 for native ETH" },
-        tokenOut: { type: "address", required: true, description: "Output token address" },
-        chainId: { type: "number", required: true, description: "tokenInChainId / same-chain default" },
-        uniswapApiKey: { type: "string", required: true, description: "Uniswap Trade API x-api-key" },
-        swapper: { type: "address", required: false, description: "MPC executor; omit if keyGen + managementNodeUrl provided" },
-        slippage: { type: "number", required: false, description: "Slippage percent; omit for API auto slippage" }
-      }),
-      required: requiredKeys({
-        type: { type: "string", required: true, description: "" },
-        amount: { type: "string", required: true, description: "" },
-        tokenIn: { type: "address", required: true, description: "" },
-        tokenOut: { type: "address", required: true, description: "" },
-        chainId: { type: "number", required: true, description: "" },
-        uniswapApiKey: { type: "string", required: true, description: "" }
-      })
-    },
-    outputSchema: {
-      type: "object",
-      description: "Full Uniswap POST /quote JSON (includes nested quote object with input/output amounts)."
-    }
-  },
-  {
+    inputZod: mcpUniswapV4QuoteInputSchema,
+    outputZod: mcpUniswapV4QuoteOutputSchema
+  }),
+  defineMcpTool({
     name: "ctm_uniswap_v4_create_swap",
     actionId: "uniswap-v4.create-swap",
     protocolId: "uniswap-v4",
@@ -353,33 +972,10 @@ var MCP_TOOL_DEFINITIONS = [
     prerequisites: ["ctm_uniswap_v4_quote output (fullQuoteFromPermit)"],
     followUp: ["ctm_uniswap_v4_build_swap_multisign"],
     handler: { importPath: "protocols/evm/uniswap-v4", exportName: "uniswapCreateSwap" },
-    inputSchema: {
-      type: "object",
-      properties: paramProperties({
-        uniswapApiKey: { type: "string", required: true, description: "Uniswap Trade API key" },
-        fullQuoteFromPermit: { type: "object", required: true, description: "Full quote JSON from ctm_uniswap_v4_quote" },
-        swapTransactionDeadlineUnix: {
-          type: "number",
-          required: false,
-          description: "On-chain deadline unix seconds; default ~30 min from now"
-        },
-        useServerProxy: {
-          type: "boolean",
-          required: false,
-          description: "Set false in Node/agents; true only in browser via Next API route"
-        }
-      }),
-      required: requiredKeys({
-        uniswapApiKey: { type: "string", required: true, description: "" },
-        fullQuoteFromPermit: { type: "object", required: true, description: "" }
-      })
-    },
-    outputSchema: {
-      type: "object",
-      description: "{ swap: TransactionRequest, requestId?, gasFee? }"
-    }
-  },
-  {
+    inputZod: mcpUniswapV4CreateSwapInputSchema,
+    outputZod: mcpUniswapV4CreateSwapOutputSchema
+  }),
+  defineMcpTool({
     name: "ctm_uniswap_v4_build_swap_multisign",
     actionId: "uniswap-v4.swap-exact-input",
     protocolId: "uniswap-v4",
@@ -393,33 +989,10 @@ var MCP_TOOL_DEFINITIONS = [
     ],
     followUp: ["Sign messageToSign", "POST /multiSignRequest with clientSig and signedMessage"],
     handler: { importPath: "protocols/evm/uniswap-v4", exportName: "buildEvmMultisignBodyUniswapV4SkipPermit2Batch" },
-    inputSchema: {
-      type: "object",
-      properties: paramProperties(
-        {
-          tokenIn: { type: "address", required: true, description: "Token in; 0x0 for native ETH" },
-          swap: { type: "object", required: true, description: "swap field from create_swap response" },
-          createSwapResponse: { type: "object", required: true, description: "Full create_swap response" },
-          fullQuoteSnapshot: { type: "object", required: true, description: "Quote JSON used for the swap" },
-          swapDeadlineUnix: { type: "number", required: true, description: "Same deadline passed to create_swap" },
-          slippagePercent: { type: "number", required: false, description: "Extra approve headroom for EXACT_OUTPUT" }
-        },
-        ["keyGen", "purposeText", "useCustomGas", "chainId", "rpcUrl", "executorAddress", "chainDetail", "customGasChainDetails"]
-      ),
-      required: requiredKeys(
-        {
-          tokenIn: { type: "address", required: true, description: "" },
-          swap: { type: "object", required: true, description: "" },
-          createSwapResponse: { type: "object", required: true, description: "" },
-          fullQuoteSnapshot: { type: "object", required: true, description: "" },
-          swapDeadlineUnix: { type: "number", required: true, description: "" }
-        },
-        ["keyGen", "purposeText", "useCustomGas", "chainId", "rpcUrl", "executorAddress", "chainDetail"]
-      )
-    },
-    outputSchema: multisignOutputSchema
-  },
-  {
+    inputZod: mcpUniswapV4BuildSwapMultisignInputSchema,
+    outputZod: multisignOutputSchema
+  }),
+  defineMcpTool({
     name: "ctm_curve_dao_build_swap_multisign",
     actionId: "curve-dao.swap",
     protocolId: "curve-dao",
@@ -428,36 +1001,45 @@ var MCP_TOOL_DEFINITIONS = [
     prerequisites: ["keyGen", "executorAddress", "tokenIn/tokenOut/amountHuman/slippage", "RPC URL"],
     followUp: ["Sign messageToSign", "POST /multiSignRequest with clientSig and signedMessage"],
     handler: { importPath: "protocols/evm/curve-dao", exportName: "buildEvmMultisignBodyCurveDaoBatch" },
-    inputSchema: {
-      type: "object",
-      properties: paramProperties(
-        {
-          tokenIn: { type: "address", required: true, description: "ERC-20 sold (native in uses WETH path in UI)" },
-          tokenOut: { type: "string", required: true, description: "Output token or 0xeeee\u2026 native placeholder" },
-          amountHuman: { type: "string", required: true, description: "Human-readable amount of tokenIn" },
-          slippagePercent: { type: "number", required: true, description: "Slippage 0\u2013100 exclusive" }
-        },
-        ["keyGen", "purposeText", "useCustomGas", "chainId", "rpcUrl", "executorAddress", "chainDetail", "customGasChainDetails"]
-      ),
-      required: requiredKeys(
-        {
-          tokenIn: { type: "address", required: true, description: "" },
-          tokenOut: { type: "string", required: true, description: "" },
-          amountHuman: { type: "string", required: true, description: "" },
-          slippagePercent: { type: "number", required: true, description: "" }
-        },
-        ["keyGen", "purposeText", "useCustomGas", "chainId", "rpcUrl", "executorAddress", "chainDetail"]
-      )
-    },
-    outputSchema: multisignOutputSchema
-  }
+    inputZod: mcpCurveDaoBuildSwapMultisignInputSchema,
+    outputZod: multisignOutputSchema
+  })
+];
+var MCP_TOOL_DEFINITIONS = [
+  ...CORE_MCP_TOOL_DEFINITIONS,
+  ...MCP_PROTOCOL_TOOL_DEFINITIONS
 ];
+function buildToolSchemaMap(kind) {
+  const out = {};
+  for (const tool of MCP_TOOL_DEFINITIONS) {
+    out[tool.name] = kind === "input" ? tool.inputZod : tool.outputZod;
+  }
+  return out;
+}
+var MCP_TOOL_INPUT_SCHEMAS = buildToolSchemaMap("input");
+var MCP_TOOL_OUTPUT_SCHEMAS = buildToolSchemaMap("output");
 function getMcpToolDefinitions() {
   return MCP_TOOL_DEFINITIONS;
 }
 function getMcpToolByName(name) {
   return MCP_TOOL_DEFINITIONS.find((t) => t.name === name);
 }
+function getMcpToolInputSchema(name) {
+  const schema = MCP_TOOL_INPUT_SCHEMAS[name];
+  if (!schema) throw new Error(`Unknown MCP tool: ${name}`);
+  return schema;
+}
+function getMcpToolOutputSchema(name) {
+  const schema = MCP_TOOL_OUTPUT_SCHEMAS[name];
+  if (!schema) throw new Error(`Unknown MCP tool: ${name}`);
+  return schema;
+}
+function parseMcpToolInput(name, data) {
+  return getMcpToolInputSchema(name).parse(data);
+}
+function parseMcpToolOutput(name, data) {
+  return getMcpToolOutputSchema(name).parse(data);
+}
 function getAgentCatalogForMcp() {
   return {
     tools: MCP_TOOL_DEFINITIONS,
@@ -465,6 +1047,9 @@ function getAgentCatalogForMcp() {
     commonParams: EVM_COMMON_PARAM_DOCS,
     multisignOutput: MULTISIGN_OUTPUT_DOC,
     managementSig: MANAGEMENT_SIG_DOC,
+    /** Zod schemas for MCP tool I/O — source of truth for continuum-mcp-server validation. */
+    inputSchemas: MCP_TOOL_INPUT_SCHEMAS,
+    outputSchemas: MCP_TOOL_OUTPUT_SCHEMAS,
     workflow: {
       evmSwapTypical: [
         "1. Quote (protocol-specific API if needed)",
@@ -478,15 +1063,606 @@ 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"
       ]
     }
   };
 }
+getAddress(
+  "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84"
+);
+getAddress(
+  "0x7f39C581F595B853cBbF37C12FfeeA971C5a5bEa"
+);
+getAddress("0x889edC2eDab5f40e902b864aD4d7AdE8E412F9B1");
+var LIDO_ETHEREUM_MAINNET_CHAIN_ID = 1;
+
+// src/protocols/evm/lido/index.ts
+var LIDO_PROTOCOL_ID = "lido";
+var lidoProtocolModule = {
+  id: LIDO_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    return Number(ctx.chainId) === LIDO_ETHEREUM_MAINNET_CHAIN_ID;
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && (token.kind === "native" || token.kind === "erc20");
+  },
+  actions: [
+    { id: "lido.submit", protocolId: LIDO_PROTOCOL_ID, chainCategory: "evm", description: "Stake ETH via Lido submit()", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { valueWei: { type: "string", required: true, description: "ETH to stake (wei string)" } } },
+    { id: "lido.request-withdrawals", protocolId: LIDO_PROTOCOL_ID, chainCategory: "evm", description: "Queue stETH withdrawal", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "lido.claim-withdrawal", protocolId: LIDO_PROTOCOL_ID, chainCategory: "evm", description: "Claim finalized withdrawal", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "lido.wrap-steth", protocolId: LIDO_PROTOCOL_ID, chainCategory: "evm", description: "Wrap stETH to wstETH", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "lido.unwrap-wsteth", protocolId: LIDO_PROTOCOL_ID, chainCategory: "evm", description: "Unwrap wstETH to stETH", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} }
+  ]
+};
+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([
+  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
+]);
+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;
+}
+
+// src/protocols/evm/ethena/index.ts
+var ETHENA_PROTOCOL_ID = "ethena";
+var ethenaProtocolModule = {
+  id: ETHENA_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    const n = typeof ctx.chainId === "number" ? ctx.chainId : Number.parseInt(String(ctx.chainId), 10);
+    return isEvmChainInEthenaUsdeList(n);
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && token.kind === "erc20";
+  },
+  actions: [
+    { id: "ethena.stake-usde", protocolId: ETHENA_PROTOCOL_ID, chainCategory: "evm", description: "Stake USDe \u2192 sUSDe", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { amountHuman: { type: "string", required: true, description: "USDe amount" } } },
+    { id: "ethena.redeem-susde", protocolId: ETHENA_PROTOCOL_ID, chainCategory: "evm", description: "Redeem sUSDe \u2192 USDe (no cooldown)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "ethena.cooldown-shares", protocolId: ETHENA_PROTOCOL_ID, chainCategory: "evm", description: "Start sUSDe cooldown", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "ethena.claim-unstake", protocolId: ETHENA_PROTOCOL_ID, chainCategory: "evm", description: "Claim after cooldown", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} }
+  ]
+};
+registerProtocolModule(ethenaProtocolModule);
+
+// src/protocols/evm/maple/constants.ts
+function isMapleSyrupSupportedChain(chainId) {
+  return chainId === 1 || chainId === 11155111;
+}
+
+// src/protocols/evm/maple/index.ts
+var MAPLE_PROTOCOL_ID = "maple-syrup";
+var mapleProtocolModule = {
+  id: MAPLE_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    const n = typeof ctx.chainId === "number" ? ctx.chainId : Number.parseInt(String(ctx.chainId), 10);
+    return isMapleSyrupSupportedChain(n);
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && token.kind === "erc20";
+  },
+  actions: [
+    { id: "maple-syrup.deposit", protocolId: MAPLE_PROTOCOL_ID, chainCategory: "evm", description: "Deposit into Maple Syrup pool", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "maple-syrup.request-redeem", protocolId: MAPLE_PROTOCOL_ID, chainCategory: "evm", description: "Request redeem from pool", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} }
+  ]
+};
+registerProtocolModule(mapleProtocolModule);
+
+// src/protocols/evm/sky/mainnet.ts
+var SKY_ETHEREUM_MAINNET_CHAIN_ID = 1;
+
+// src/protocols/evm/sky/index.ts
+var SKY_PROTOCOL_ID = "sky";
+var skyProtocolModule = {
+  id: SKY_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    return Number(ctx.chainId) === SKY_ETHEREUM_MAINNET_CHAIN_ID;
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && token.kind === "erc20";
+  },
+  actions: [
+    { id: "sky.lockstake-stake", protocolId: SKY_PROTOCOL_ID, chainCategory: "evm", description: "Open Lockstake position", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "sky.lockstake-draw", protocolId: SKY_PROTOCOL_ID, chainCategory: "evm", description: "Borrow USDS from Lockstake", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "sky.lockstake-wipe", protocolId: SKY_PROTOCOL_ID, chainCategory: "evm", description: "Repay Lockstake debt", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "sky.lockstake-close", protocolId: SKY_PROTOCOL_ID, chainCategory: "evm", description: "Close Lockstake position", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "sky.susds-deposit", protocolId: SKY_PROTOCOL_ID, chainCategory: "evm", description: "Deposit USDS into sUSDS vault", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "sky.susds-redeem", protocolId: SKY_PROTOCOL_ID, chainCategory: "evm", description: "Redeem sUSDS to USDS", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} }
+  ]
+};
+registerProtocolModule(skyProtocolModule);
+var AAVE_V4_GRAPHQL_URL = "https://api.v4.aave.com/graphql";
+async function aaveV4Gql(query, variables) {
+  const r = await fetch(AAVE_V4_GRAPHQL_URL, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ query, variables: variables ?? {} })
+  });
+  if (!r.ok) {
+    const t = await r.text().catch(() => "");
+    throw new Error(t ? `Aave V4 API HTTP ${r.status}: ${t.slice(0, 200)}` : `Aave V4 API HTTP ${r.status}`);
+  }
+  const j = await r.json();
+  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 && isAddress(t)) return 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 && 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";
+var aaveV4ProtocolModule = {
+  id: AAVE_V4_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    return ctx.chainCategory === "evm";
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && (token.kind === "native" || token.kind === "erc20");
+  },
+  actions: [
+    { id: "aave-v4.deposit", protocolId: AAVE_V4_PROTOCOL_ID, chainCategory: "evm", description: "Supply to Aave v4 Spoke", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "aave-v4.withdraw", protocolId: AAVE_V4_PROTOCOL_ID, chainCategory: "evm", description: "Withdraw from Spoke", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "aave-v4.borrow", protocolId: AAVE_V4_PROTOCOL_ID, chainCategory: "evm", description: "Borrow from Spoke", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "aave-v4.repay", protocolId: AAVE_V4_PROTOCOL_ID, chainCategory: "evm", description: "Repay Spoke debt", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} }
+  ]
+};
+registerProtocolModule(aaveV4ProtocolModule);
+
+// src/protocols/evm/euler-v2/index.ts
+var EULER_V2_PROTOCOL_ID = "euler-v2";
+var eulerV2ProtocolModule = {
+  id: EULER_V2_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    return ctx.chainCategory === "evm";
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && (token.kind === "native" || token.kind === "erc20");
+  },
+  actions: [
+    { id: "euler-v2.isolated-lend", protocolId: EULER_V2_PROTOCOL_ID, chainCategory: "evm", description: "Deposit into Euler vault", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "euler-v2.isolated-borrow", protocolId: EULER_V2_PROTOCOL_ID, chainCategory: "evm", description: "Borrow from Euler vault", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "euler-v2.vault-withdraw", protocolId: EULER_V2_PROTOCOL_ID, chainCategory: "evm", description: "Withdraw from Euler vault", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "euler-v2.borrow-repay", protocolId: EULER_V2_PROTOCOL_ID, chainCategory: "evm", description: "Repay Euler borrow", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "euler-v2.collateral-deposit", protocolId: EULER_V2_PROTOCOL_ID, chainCategory: "evm", description: "Deposit borrow collateral", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "euler-v2.collateral-withdraw", protocolId: EULER_V2_PROTOCOL_ID, chainCategory: "evm", description: "Withdraw borrow collateral", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} }
+  ]
+};
+registerProtocolModule(eulerV2ProtocolModule);
+var skillsDir = join(dirname(fileURLToPath(import.meta.url)), "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 readFileSync(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 = getAddress(address).toLowerCase();
+      } catch {
+        return false;
+      }
+      if (cache.nativeWrapped && 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 = z.object({
+  keyGenId: z.string().min(1).describe("KeyGen id from fetch_key_gen_result / node preferred KeyGen"),
+  chainId: z.number().int().positive().describe("EVM chain id; RPC and gas config resolved from chain registry"),
+  purposeText: z.string().min(1).describe("Human-readable purpose for the sign request"),
+  useCustomGas: z.boolean().optional().describe("Apply chain gas settings from registry when true")
+});
+function mcpServerMultisignInput(fields) {
+  return mcpServerCommonInputSchema.extend(fields);
+}
+var mcpServerSubmitOutputSchema = z.object({
+  requestId: 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);
 registerProtocolModule(curveDaoProtocolModule);
+registerProtocolModule(lidoProtocolModule);
+registerProtocolModule(ethenaProtocolModule);
+registerProtocolModule(mapleProtocolModule);
+registerProtocolModule(skyProtocolModule);
+registerProtocolModule(aaveV4ProtocolModule);
+registerProtocolModule(eulerV2ProtocolModule);
 function getAgentCatalog() {
   return {
     protocols: getProtocolModules(),
@@ -497,11 +1673,17 @@ function getAgentCatalog() {
     },
     uniswapV4: uniswapV4ProtocolModule,
     curveDao: curveDaoProtocolModule,
+    lido: lidoProtocolModule,
+    ethena: ethenaProtocolModule,
+    maple: mapleProtocolModule,
+    sky: skyProtocolModule,
+    aaveV4: aaveV4ProtocolModule,
+    eulerV2: eulerV2ProtocolModule,
     /** Prefer getAgentCatalogForMcp() or getMcpToolDefinitions() for MCP servers. */
     mcp: getAgentCatalogForMcp()
   };
 }
 
-export { EVM_COMMON_PARAM_DOCS, MANAGEMENT_SIG_DOC, MCP_TOOL_DEFINITIONS, MULTISIGN_OUTPUT_DOC, getActionsByChainCategory, getAgentCatalog, getAgentCatalogForMcp, getMcpToolByName, getMcpToolDefinitions, getProtocolModules };
+export { EVM_COMMON_PARAM_DOCS, MANAGEMENT_SIG_DOC, MCP_NON_SUBMIT_TOOL_NAMES, MCP_TOOL_DEFINITIONS, MCP_TOOL_INPUT_SCHEMAS, MCP_TOOL_OUTPUT_SCHEMAS, MULTISIGN_OUTPUT_DOC, PROTOCOL_SUPPORT_ADVISORS, chainDetailSchema, evmAddressSchema, evmMultisignCommonInputSchema, getActionsByChainCategory, getAgentCatalog, getAgentCatalogForMcp, getMcpToolByName, getMcpToolDefinitions, getMcpToolInputSchema, getMcpToolOutputSchema, getProtocolDiscoverySummary, getProtocolModules, getProtocolSkill, getProtocolSupportAdvisor, getToolsForProtocol, jsonObjectSchema, keyGenSchema, listProtocolSupportAdvisorIds, listProtocolsWithSkills, mcpAaveV4BorrowInputSchema, mcpAaveV4DepositInputSchema, mcpAaveV4RepayInputSchema, mcpAaveV4WithdrawInputSchema, mcpCurveDaoBuildSwapMultisignInputSchema, mcpEthenaClaimInputSchema, mcpEthenaCooldownInputSchema, mcpEthenaRedeemInputSchema, mcpEthenaStakeInputSchema, mcpEulerV2BorrowRepayInputSchema, mcpEulerV2CollateralDepositInputSchema, mcpEulerV2CollateralWithdrawInputSchema, mcpEulerV2IsolatedBorrowInputSchema, mcpEulerV2IsolatedLendInputSchema, mcpEulerV2VaultWithdrawInputSchema, mcpLidoClaimWithdrawalInputSchema, mcpLidoRequestWithdrawalsInputSchema, mcpLidoSubmitInputSchema, mcpLidoUnwrapWstEthInputSchema, mcpLidoWrapStEthInputSchema, mcpMapleDepositInputSchema, mcpMapleRequestRedeemInputSchema, mcpMultisignInput, multisignOutputSchema as mcpMultisignOutputSchema, mcpServerCommonInputSchema, mcpServerMultisignInput, mcpServerSubmitOutputSchema, mcpSkyLockstakeCloseInputSchema, mcpSkyLockstakeDrawInputSchema, mcpSkyLockstakeGetRewardInputSchema, mcpSkyLockstakeStakeInputSchema, mcpSkyLockstakeWipeInputSchema, mcpSkySusdsDepositInputSchema, mcpSkySusdsRedeemInputSchema, mcpUniswapV4BuildSwapMultisignInputSchema, mcpUniswapV4CreateSwapInputSchema, mcpUniswapV4CreateSwapOutputSchema, mcpUniswapV4QuoteInputSchema, mcpUniswapV4QuoteOutputSchema, multisignOutputSchema, parseMcpToolInput, parseMcpToolOutput, uniswapQuoteTradeTypeSchema, zodSchemaToMcpJsonSchema };
 //# sourceMappingURL=catalog.js.map
 //# sourceMappingURL=catalog.js.map