@continuumdao/ctm-mpc-defi 0.1.3 → 0.2.0

package/dist/agent/catalog.cjs

@@ -1,6 +1,8 @@
 'use strict';
 
-require('viem');
+var viem = require('viem');
+var zodToJsonSchema = require('zod-to-json-schema');
+var zod = require('zod');
 
 // src/core/registry.ts
 var modules = [];
@@ -247,46 +249,606 @@ var MULTISIGN_OUTPUT_DOC = {
     }
   }
 };
-
-// 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 };
-  }
-  for (const [k, d] of Object.entries(params)) {
-    out[k] = { type: d.type, description: d.description };
-  }
-  return out;
-}
-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 multisignOutputSchema = {
-  type: "object",
-  description: MULTISIGN_OUTPUT_DOC.description,
-  properties: {
-    bodyForSign: {
-      type: "object",
-      description: MULTISIGN_OUTPUT_DOC.fields.bodyForSign.description
+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.",
+  fields: {
+    nonce: {
+      type: "number",
+      description: "From GET /getPublicMgtKeyNonce (Ed25519) or GET /getNodeMgtKeyNonce (Ethereum NodeMgtKey)."
     },
-    messageToSign: {
+    clientSig: {
+      type: "string",
+      description: "Management signature; empty string in the message to sign."
+    },
+    nodeKey: {
       type: "string",
-      description: MULTISIGN_OUTPUT_DOC.fields.messageToSign.description
+      description: "Required. 128-hex MPC node id from GET /getNodeKey (no 0x prefix)."
     }
   },
-  required: ["bodyForSign", "messageToSign"]
+  helpers: {
+    managementSigFields: "Base envelope with clientSig cleared.",
+    buildManagementPostBody: "Spread managementSigFields then endpoint fields.",
+    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."
+  }
 };
-var MCP_TOOL_DEFINITIONS = [
-  {
+function zodSchemaToMcpJsonSchema(schema) {
+  const raw = zodToJsonSchema.zodToJsonSchema(schema, {
+    target: "openApi3",
+    $refStrategy: "none"
+  });
+  if (raw.type === "object" || raw.type === "array" || raw.type === "string") {
+    const { $schema: _s, ...rest } = raw;
+    return rest;
+  }
+  const defs = raw.definitions;
+  if (defs) {
+    const first = Object.values(defs)[0];
+    if (first?.type) {
+      const { $schema: _s, ...rest } = first;
+      return rest;
+    }
+  }
+  return raw;
+}
+var evmAddressSchema = zod.z.string().min(1).describe("EVM address (0x-prefixed, 40 hex nibbles)");
+var keyGenSchema = zod.z.object({
+  pubkeyhex: zod.z.string().min(1).describe("MPC secp256k1 public key hex (required for multiSignRequest pubKey)"),
+  keylist: zod.z.array(zod.z.string()).optional().describe("Key list on the sign request"),
+  ClientKeys: zod.z.record(zod.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 = zod.z.object({
+  legacy: zod.z.boolean().optional(),
+  gasLimit: zod.z.number().optional(),
+  gasMultiplier: zod.z.number().optional(),
+  gasPrice: zod.z.number().optional(),
+  baseFee: zod.z.number().optional(),
+  priorityFee: zod.z.number().optional(),
+  baseFeeMultiplier: zod.z.number().optional()
+}).passthrough().describe(
+  "Optional gas config: { legacy?, gasLimit?, gasMultiplier?, gasPrice?, baseFee?, priorityFee?, baseFeeMultiplier? }."
+);
+var evmMultisignCommonInputSchema = zod.z.object({
+  keyGen: keyGenSchema,
+  purposeText: zod.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: zod.z.boolean().describe(
+    "When true, apply chain gas settings from chainDetail / customGasChainDetails instead of raw RPC estimates only."
+  ),
+  chainId: zod.z.number().int().positive().describe("EVM chain id (decimal). Becomes destinationChainID on the sign request."),
+  rpcUrl: zod.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: zod.z.record(zod.z.unknown()).optional().describe("Snapshot written to extraJSON.customGasChainDetails when useCustomGas is true.")
+});
+var multisignOutputSchema = zod.z.object({
+  bodyForSign: zod.z.record(zod.z.unknown()).describe(
+    "POST body fields without clientSig: keyList, pubKey, msgHash, msgRaw, destinationChainID, purpose, extraJSON, proposalTxParams (batch), messageHashes/messageRawBatch when N>1 txs."
+  ),
+  messageToSign: zod.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 = zod.z.record(zod.z.unknown());
+var uniswapQuoteTradeTypeSchema = zod.z.enum(["EXACT_INPUT", "EXACT_OUTPUT"]);
+var mcpUniswapV4QuoteInputSchema = zod.z.object({
+  type: uniswapQuoteTradeTypeSchema.describe("EXACT_INPUT or EXACT_OUTPUT"),
+  amount: zod.z.string().min(1).describe("Amount in token-in base units (wei string for ERC-20)"),
+  tokenIn: zod.z.string().min(1).describe("Input token; 0x0 for native ETH"),
+  tokenOut: zod.z.string().min(1).describe("Output token address"),
+  chainId: zod.z.union([zod.z.number().int().positive(), zod.z.string().min(1)]).describe("tokenInChainId / same-chain default"),
+  uniswapApiKey: zod.z.string().min(1).describe("Uniswap Trade API x-api-key"),
+  swapper: evmAddressSchema.optional().describe("MPC executor; omit if keyGen + managementNodeUrl provided"),
+  slippage: zod.z.union([zod.z.number(), zod.z.string()]).optional().describe("Slippage percent; omit for API auto slippage"),
+  keyGen: zod.z.string().optional().describe("KeyGen id \u2014 resolves swapper via GET /getKeyGenResultById when swapper omitted"),
+  managementNodeUrl: zod.z.string().min(1).optional().describe("MPC node base URL; required with keyGen when swapper is omitted"),
+  tokenInChainId: zod.z.union([zod.z.number(), zod.z.string()]).optional(),
+  tokenOutChainId: zod.z.union([zod.z.number(), zod.z.string()]).optional(),
+  permit2Disabled: zod.z.boolean().optional(),
+  baseUrl: zod.z.string().optional(),
+  universalRouterVersion: zod.z.string().optional()
+});
+var mcpUniswapV4QuoteOutputSchema = jsonObjectSchema.describe(
+  "Full Uniswap POST /quote JSON (includes nested quote object with input/output amounts)."
+);
+var mcpUniswapV4CreateSwapInputSchema = zod.z.object({
+  uniswapApiKey: zod.z.string().min(1).describe("Uniswap Trade API key"),
+  fullQuoteFromPermit: jsonObjectSchema.describe("Full quote JSON from ctm_uniswap_v4_quote"),
+  swapTransactionDeadlineUnix: zod.z.number().int().positive().optional().describe("On-chain deadline unix seconds; default ~30 min from now"),
+  useServerProxy: zod.z.boolean().optional().describe("Set false in Node/agents; true only in browser via Next API route"),
+  baseUrl: zod.z.string().optional(),
+  universalRouterVersion: zod.z.string().optional()
+});
+var mcpUniswapV4CreateSwapOutputSchema = zod.z.object({
+  swap: jsonObjectSchema.describe("Universal Router tx: { to, data, value, gasLimit? }"),
+  requestId: zod.z.string().optional(),
+  gasFee: zod.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: zod.z.object({
+    swap: swapTxRequestSchema,
+    requestId: zod.z.string().optional(),
+    gasFee: zod.z.string().optional()
+  }).passthrough().describe("Full create_swap response"),
+  fullQuoteSnapshot: jsonObjectSchema.describe("Quote JSON used for the swap"),
+  swapDeadlineUnix: zod.z.number().describe("Same deadline passed to create_swap"),
+  slippagePercent: zod.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: zod.z.string().min(1).describe("Output token or 0xeeee\u2026 native placeholder"),
+  amountHuman: zod.z.string().min(1).describe("Human-readable amount of tokenIn"),
+  slippagePercent: zod.z.number().gt(0).lt(100).describe("Slippage 0\u2013100 exclusive")
+});
+function mcpMultisignInput(fields) {
+  return evmMultisignCommonInputSchema.extend(fields);
+}
+var mcpLidoSubmitInputSchema = mcpMultisignInput({
+  valueWei: zod.z.string().min(1).describe("ETH to stake (wei decimal string)"),
+  referral: evmAddressSchema.optional()
+});
+var mcpLidoRequestWithdrawalsInputSchema = mcpMultisignInput({
+  stEthAmountsWei: zod.z.array(zod.z.string()).min(1).describe("stETH amounts per withdrawal request (wei strings)")
+});
+var mcpLidoClaimWithdrawalInputSchema = mcpMultisignInput({
+  requestId: zod.z.union([zod.z.string(), zod.z.number()]).describe("Withdrawal queue request id")
+});
+var mcpLidoWrapStEthInputSchema = mcpMultisignInput({
+  stEthAmountWei: zod.z.string().min(1)
+});
+var mcpLidoUnwrapWstEthInputSchema = mcpMultisignInput({
+  wstEthAmountWei: zod.z.string().min(1)
+});
+var mcpEthenaStakeInputSchema = mcpMultisignInput({
+  usdeAmountHuman: zod.z.string().min(1),
+  susdeVault: evmAddressSchema.optional()
+});
+var mcpEthenaRedeemInputSchema = mcpMultisignInput({
+  susdeSharesHuman: zod.z.string().min(1),
+  susdeVault: evmAddressSchema.optional()
+});
+var mcpEthenaCooldownInputSchema = mcpMultisignInput({
+  susdeSharesHuman: zod.z.string().min(1),
+  susdeVault: evmAddressSchema.optional()
+});
+var mcpEthenaClaimInputSchema = mcpMultisignInput({
+  susdeVault: evmAddressSchema.optional()
+});
+var mcpMapleDepositInputSchema = mcpMultisignInput({
+  syrupRouter: evmAddressSchema,
+  pool: evmAddressSchema,
+  asset: evmAddressSchema,
+  amountHuman: zod.z.string().min(1),
+  authorizeSig: jsonObjectSchema.optional()
+});
+var mcpMapleRequestRedeemInputSchema = mcpMultisignInput({
+  pool: evmAddressSchema,
+  sharesHuman: zod.z.string().min(1),
+  receiver: evmAddressSchema
+});
+var mcpSkyLockstakeStakeInputSchema = mcpMultisignInput({
+  skyAmountHuman: zod.z.string().min(1),
+  usdsDrawHuman: zod.z.string().optional(),
+  farmRef: zod.z.string().optional()
+});
+var mcpSkyLockstakeDrawInputSchema = mcpMultisignInput({
+  usdsAmountHuman: zod.z.string().min(1),
+  urnIndex: zod.z.number().int().nonnegative()
+});
+var mcpSkyLockstakeWipeInputSchema = mcpMultisignInput({
+  usdsAmountHuman: zod.z.string().min(1),
+  urnIndex: zod.z.number().int().nonnegative()
+});
+var mcpSkyLockstakeCloseInputSchema = mcpMultisignInput({
+  urnIndex: zod.z.number().int().nonnegative()
+});
+var mcpSkyLockstakeGetRewardInputSchema = mcpMultisignInput({
+  urnIndex: zod.z.number().int().nonnegative()
+});
+var mcpSkySusdsDepositInputSchema = mcpMultisignInput({
+  usdsAmountHuman: zod.z.string().min(1)
+});
+var mcpSkySusdsRedeemInputSchema = mcpMultisignInput({
+  sharesHuman: zod.z.string().min(1)
+});
+var mcpAaveV4DepositInputSchema = mcpMultisignInput({
+  spoke: evmAddressSchema,
+  underlying: evmAddressSchema,
+  amountHuman: zod.z.string().min(1),
+  marketId: zod.z.string().min(1)
+});
+var mcpAaveV4WithdrawInputSchema = mcpMultisignInput({
+  spoke: evmAddressSchema,
+  underlying: evmAddressSchema,
+  amountHuman: zod.z.string().min(1),
+  marketId: zod.z.string().min(1)
+});
+var mcpAaveV4BorrowInputSchema = mcpMultisignInput({
+  spoke: evmAddressSchema,
+  underlying: evmAddressSchema,
+  amountHuman: zod.z.string().min(1),
+  marketId: zod.z.string().min(1)
+});
+var mcpAaveV4RepayInputSchema = mcpMultisignInput({
+  spoke: evmAddressSchema,
+  underlying: evmAddressSchema,
+  amountHuman: zod.z.string().min(1),
+  marketId: zod.z.string().min(1)
+});
+var mcpEulerV2IsolatedLendInputSchema = mcpMultisignInput({
+  vault: evmAddressSchema,
+  assetAmountHuman: zod.z.string().min(1)
+});
+var mcpEulerV2IsolatedBorrowInputSchema = mcpMultisignInput({
+  vault: evmAddressSchema,
+  collateralAsset: evmAddressSchema,
+  borrowAsset: evmAddressSchema,
+  collateralAmountHuman: zod.z.string().min(1),
+  loopBorrowWeis: zod.z.array(zod.z.string()).min(1)
+});
+var mcpEulerV2VaultWithdrawInputSchema = mcpMultisignInput({
+  vault: evmAddressSchema,
+  sharesHuman: zod.z.string().min(1)
+});
+var mcpEulerV2BorrowRepayInputSchema = mcpMultisignInput({
+  vault: evmAddressSchema,
+  amountHuman: zod.z.string().min(1)
+});
+var mcpEulerV2CollateralDepositInputSchema = mcpMultisignInput({
+  vault: evmAddressSchema,
+  collateralAsset: evmAddressSchema,
+  amountHuman: zod.z.string().min(1)
+});
+var mcpEulerV2CollateralWithdrawInputSchema = mcpMultisignInput({
+  vault: evmAddressSchema,
+  collateralAsset: evmAddressSchema,
+  amountHuman: zod.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: "buildEvmMultisignBodyEulerV2VaultWithdrawBatch" },
+    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",
@@ -295,33 +857,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",
@@ -330,33 +869,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",
@@ -368,79 +884,69 @@ var MCP_TOOL_DEFINITIONS = [
       "executorAddress matching MPC wallet",
       "RPC URL and chainDetail from node chain config"
     ],
-    followUp: ["Sign messageToSign", "POST /multiSignRequest with clientSig"],
+    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",
     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"],
-    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    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,
     protocols: getProtocolModules(),
     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)",
@@ -448,14 +954,222 @@ function getAgentCatalogForMcp() {
         "3. build_*_multisign \u2192 { bodyForSign, messageToSign }",
         "4. Sign messageToSign (MetaMask or Ed25519)",
         "5. POST /multiSignRequest with clientSig and signedMessage"
+      ],
+      managementPostTypical: [
+        "1. GET /getNodeKey \u2192 nodeKey (128 hex)",
+        "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"
       ]
     }
   };
 }
+viem.getAddress(
+  "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84"
+);
+viem.getAddress(
+  "0x7f39C581F595B853cBbF37C12FfeeA971C5a5bEa"
+);
+viem.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 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
+]);
+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 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);
+
+// 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);
 
 // 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(),
@@ -466,19 +1180,76 @@ 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()
   };
 }
 
 exports.EVM_COMMON_PARAM_DOCS = EVM_COMMON_PARAM_DOCS;
+exports.MANAGEMENT_SIG_DOC = MANAGEMENT_SIG_DOC;
 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.chainDetailSchema = chainDetailSchema;
+exports.evmAddressSchema = evmAddressSchema;
+exports.evmMultisignCommonInputSchema = evmMultisignCommonInputSchema;
 exports.getActionsByChainCategory = getActionsByChainCategory;
 exports.getAgentCatalog = getAgentCatalog;
 exports.getAgentCatalogForMcp = getAgentCatalogForMcp;
 exports.getMcpToolByName = getMcpToolByName;
 exports.getMcpToolDefinitions = getMcpToolDefinitions;
+exports.getMcpToolInputSchema = getMcpToolInputSchema;
+exports.getMcpToolOutputSchema = getMcpToolOutputSchema;
 exports.getProtocolModules = getProtocolModules;
+exports.jsonObjectSchema = jsonObjectSchema;
+exports.keyGenSchema = keyGenSchema;
+exports.mcpAaveV4BorrowInputSchema = mcpAaveV4BorrowInputSchema;
+exports.mcpAaveV4DepositInputSchema = mcpAaveV4DepositInputSchema;
+exports.mcpAaveV4RepayInputSchema = mcpAaveV4RepayInputSchema;
+exports.mcpAaveV4WithdrawInputSchema = mcpAaveV4WithdrawInputSchema;
+exports.mcpCurveDaoBuildSwapMultisignInputSchema = mcpCurveDaoBuildSwapMultisignInputSchema;
+exports.mcpEthenaClaimInputSchema = mcpEthenaClaimInputSchema;
+exports.mcpEthenaCooldownInputSchema = mcpEthenaCooldownInputSchema;
+exports.mcpEthenaRedeemInputSchema = mcpEthenaRedeemInputSchema;
+exports.mcpEthenaStakeInputSchema = mcpEthenaStakeInputSchema;
+exports.mcpEulerV2BorrowRepayInputSchema = mcpEulerV2BorrowRepayInputSchema;
+exports.mcpEulerV2CollateralDepositInputSchema = mcpEulerV2CollateralDepositInputSchema;
+exports.mcpEulerV2CollateralWithdrawInputSchema = mcpEulerV2CollateralWithdrawInputSchema;
+exports.mcpEulerV2IsolatedBorrowInputSchema = mcpEulerV2IsolatedBorrowInputSchema;
+exports.mcpEulerV2IsolatedLendInputSchema = mcpEulerV2IsolatedLendInputSchema;
+exports.mcpEulerV2VaultWithdrawInputSchema = mcpEulerV2VaultWithdrawInputSchema;
+exports.mcpLidoClaimWithdrawalInputSchema = mcpLidoClaimWithdrawalInputSchema;
+exports.mcpLidoRequestWithdrawalsInputSchema = mcpLidoRequestWithdrawalsInputSchema;
+exports.mcpLidoSubmitInputSchema = mcpLidoSubmitInputSchema;
+exports.mcpLidoUnwrapWstEthInputSchema = mcpLidoUnwrapWstEthInputSchema;
+exports.mcpLidoWrapStEthInputSchema = mcpLidoWrapStEthInputSchema;
+exports.mcpMapleDepositInputSchema = mcpMapleDepositInputSchema;
+exports.mcpMapleRequestRedeemInputSchema = mcpMapleRequestRedeemInputSchema;
+exports.mcpMultisignInput = mcpMultisignInput;
+exports.mcpMultisignOutputSchema = multisignOutputSchema;
+exports.mcpSkyLockstakeCloseInputSchema = mcpSkyLockstakeCloseInputSchema;
+exports.mcpSkyLockstakeDrawInputSchema = mcpSkyLockstakeDrawInputSchema;
+exports.mcpSkyLockstakeGetRewardInputSchema = mcpSkyLockstakeGetRewardInputSchema;
+exports.mcpSkyLockstakeStakeInputSchema = mcpSkyLockstakeStakeInputSchema;
+exports.mcpSkyLockstakeWipeInputSchema = mcpSkyLockstakeWipeInputSchema;
+exports.mcpSkySusdsDepositInputSchema = mcpSkySusdsDepositInputSchema;
+exports.mcpSkySusdsRedeemInputSchema = mcpSkySusdsRedeemInputSchema;
+exports.mcpUniswapV4BuildSwapMultisignInputSchema = mcpUniswapV4BuildSwapMultisignInputSchema;
+exports.mcpUniswapV4CreateSwapInputSchema = mcpUniswapV4CreateSwapInputSchema;
+exports.mcpUniswapV4CreateSwapOutputSchema = mcpUniswapV4CreateSwapOutputSchema;
+exports.mcpUniswapV4QuoteInputSchema = mcpUniswapV4QuoteInputSchema;
+exports.mcpUniswapV4QuoteOutputSchema = mcpUniswapV4QuoteOutputSchema;
+exports.multisignOutputSchema = multisignOutputSchema;
+exports.parseMcpToolInput = parseMcpToolInput;
+exports.parseMcpToolOutput = parseMcpToolOutput;
+exports.uniswapQuoteTradeTypeSchema = uniswapQuoteTradeTypeSchema;
+exports.zodSchemaToMcpJsonSchema = zodSchemaToMcpJsonSchema;
 //# sourceMappingURL=catalog.cjs.map
 //# sourceMappingURL=catalog.cjs.map