@continuumdao/ctm-mpc-defi 0.2.9 → 0.2.11

package/dist/agent/catalog.cjs

@@ -523,6 +523,9 @@ var chainDetailSchema = zod.z.object({
   "Optional gas config: { legacy?, gasLimit?, gasMultiplier?, gasPrice?, baseFee?, priorityFee?, baseFeeMultiplier? }."
 );
 var evmMultisignCommonInputSchema = zod.z.object({
+  keyGenId: zod.z.string().min(1).optional().describe(
+    "KeyGen request id from get_preferred_key_gen / conversation context. MCP server resolves keyGen, executorAddress, rpcUrl, and chainDetail \u2014 do not pass those fields when keyGenId is set."
+  ),
   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)."
@@ -927,6 +930,74 @@ var mcpEulerV2CollateralWithdrawInputSchema = mcpMultisignInput({
   collateralAsset: evmAddressSchema,
   amountHuman: zod.z.string().min(1)
 });
+var mcpMorphoVaultDepositInputSchema = mcpMultisignInput({
+  vault: evmAddressSchema,
+  underlying: evmAddressSchema.describe("Underlying asset; use wrapped native with isNativeIn for ETH."),
+  amountHuman: zod.z.string().min(1),
+  isNativeIn: zod.z.boolean().optional()
+});
+var mcpMorphoVaultWithdrawInputSchema = mcpMultisignInput({
+  vault: evmAddressSchema,
+  amountHuman: zod.z.string().min(1)
+});
+var mcpMorphoBlueCollateralDepositInputSchema = mcpMultisignInput({
+  marketId: zod.z.string().min(1).describe("Morpho Blue marketId from API."),
+  collateralToken: evmAddressSchema,
+  amountHuman: zod.z.string().min(1),
+  isNativeIn: zod.z.boolean().optional()
+});
+var mcpMorphoBlueBorrowInputSchema = mcpMultisignInput({
+  marketId: zod.z.string().min(1),
+  loanToken: evmAddressSchema,
+  amountHuman: zod.z.string().min(1)
+});
+var mcpMorphoBlueRepayInputSchema = mcpMultisignInput({
+  marketId: zod.z.string().min(1),
+  loanToken: evmAddressSchema,
+  amountHuman: zod.z.string().min(1)
+});
+var mcpMorphoBlueCollateralWithdrawInputSchema = mcpMultisignInput({
+  marketId: zod.z.string().min(1),
+  amountHuman: zod.z.string().min(1),
+  collateralDecimals: zod.z.number().int().min(0).max(36).optional()
+});
+var mcpMorphoMerklClaimInputSchema = mcpMultisignInput({
+  claimData: zod.z.string().min(1).describe("Hex calldata for Merkl Distributor.claim from Merkl API."),
+  distributor: evmAddressSchema.optional(),
+  valueWei: zod.z.string().optional()
+});
+var morphoExposureRowSchema = zod.z.object({
+  label: zod.z.string(),
+  allocatedUsdLabel: zod.z.string(),
+  allocationPercentLabel: zod.z.string()
+});
+var mcpMorphoFetchEarnVaultsInputSchema = zod.z.object({
+  chainId: zod.z.number().int().positive(),
+  underlying: zod.z.string().trim().min(1).optional().describe("Deposit asset symbol (e.g. USDC) or ERC-20 address. Omit to search all listed vaults on the chain."),
+  query: zod.z.string().trim().min(1).optional().describe("Case-insensitive filter on vault name, symbol, address, or underlying symbol (e.g. Steakhouse, bbqUSDC)."),
+  limit: zod.z.number().int().min(1).max(200).optional().describe("Max rows (default 50).")
+});
+var mcpMorphoFetchEarnVaultsOutputSchema = zod.z.object({
+  vaults: zod.z.array(
+    zod.z.object({
+      vaultAddress: zod.z.string(),
+      vaultName: zod.z.string(),
+      vaultSymbol: zod.z.string(),
+      underlyingAddress: zod.z.string(),
+      underlyingSymbol: zod.z.string(),
+      apy: zod.z.string(),
+      netApy: zod.z.string(),
+      netApy7d: zod.z.string(),
+      netApy30d: zod.z.string(),
+      netApy90d: zod.z.string(),
+      performanceFee: zod.z.string(),
+      managementFee: zod.z.string().nullable(),
+      totalDepositsUsd: zod.z.string(),
+      liquidityUsd: zod.z.string(),
+      exposure: zod.z.array(morphoExposureRowSchema)
+    })
+  )
+});
 function mcpGmxMultisignInput(fields) {
   return evmMultisignCommonInputSchema.extend(fields);
 }
@@ -1131,7 +1202,8 @@ var mcpHyperliquidFetchMarketsOutputSchema = zod.z.object({
       asset: zod.z.number(),
       szDecimals: zod.z.number(),
       maxLeverage: zod.z.number(),
-      onlyIsolated: zod.z.boolean().optional()
+      onlyIsolated: zod.z.boolean().optional(),
+      dex: zod.z.string().optional()
     })
   ),
   dexes: zod.z.array(
@@ -1141,6 +1213,30 @@ var mcpHyperliquidFetchMarketsOutputSchema = zod.z.object({
     })
   )
 });
+var mcpHyperliquidSearchMarketsInputSchema = zod.z.object({
+  chainId: zod.z.number().int().positive(),
+  query: zod.z.string().min(1),
+  dex: zod.z.string().optional(),
+  limit: zod.z.number().int().positive().max(50).optional()
+});
+var mcpHyperliquidSearchMarketsOutputSchema = zod.z.object({
+  matches: zod.z.array(
+    zod.z.object({
+      coin: zod.z.string(),
+      symbol: zod.z.string(),
+      dex: zod.z.string().optional(),
+      asset: zod.z.number(),
+      szDecimals: zod.z.number(),
+      maxLeverage: zod.z.number(),
+      onlyIsolated: zod.z.boolean().optional(),
+      displayName: zod.z.string().optional(),
+      category: zod.z.string().optional(),
+      keywords: zod.z.array(zod.z.string()).optional(),
+      matchScore: zod.z.number(),
+      matchReason: zod.z.string()
+    })
+  )
+});
 var mcpHyperliquidFetchOpenContextInputSchema = zod.z.object({
   chainId: zod.z.number().int().positive(),
   executorAddress: evmAddressSchema,
@@ -1183,25 +1279,70 @@ var mcpHyperliquidFetchMarketSnapshotInputSchema = zod.z.object({
   chainId: zod.z.number().int().positive(),
   coin: zod.z.string().min(1),
   interval: hyperliquidOhlcvIntervalSchema.optional(),
-  dex: zod.z.string().optional()
+  dex: zod.z.string().optional(),
+  /** Recent OHLCV bars to return (default 48, max 200). Live price is always current. */
+  candleLimit: zod.z.number().int().positive().max(200).optional()
+});
+var hyperliquidOhlcvCandleSchema = zod.z.object({
+  timestampMs: zod.z.number(),
+  open: zod.z.string(),
+  high: zod.z.string(),
+  low: zod.z.string(),
+  close: zod.z.string(),
+  volume: zod.z.string()
+});
+var hyperliquidLivePriceSchema = zod.z.object({
+  markPx: zod.z.string().nullable(),
+  midPx: zod.z.string().nullable(),
+  oraclePx: zod.z.string().nullable(),
+  prevDayPx: zod.z.string().nullable(),
+  midUsd: zod.z.string(),
+  source: zod.z.enum(["midPx", "markPx", "allMids"])
 });
 var mcpHyperliquidFetchMarketSnapshotOutputSchema = zod.z.object({
   snapshot: zod.z.object({
     coin: zod.z.string(),
-    midUsd: zod.z.string().nullable(),
+    dex: zod.z.string().nullable(),
+    livePrice: hyperliquidLivePriceSchema,
+    midUsd: zod.z.string(),
     fetchedAtMs: zod.z.number(),
     interval: hyperliquidOhlcvIntervalSchema,
-    candles: zod.z.array(
-      zod.z.object({
-        timestampMs: zod.z.number(),
-        open: zod.z.string(),
-        high: zod.z.string(),
-        low: zod.z.string(),
-        close: zod.z.string(),
-        volume: zod.z.string()
-      })
-    )
-  })
+    latestCandle: hyperliquidOhlcvCandleSchema.nullable(),
+    candles: zod.z.array(hyperliquidOhlcvCandleSchema),
+    candleCount: zod.z.number()
+  }),
+  resolvedCoin: zod.z.string(),
+  dex: zod.z.string().nullable()
+});
+var mcpHyperliquidFetchOhlcvInputSchema = zod.z.object({
+  chainId: zod.z.number().int().positive(),
+  coin: zod.z.string().min(1),
+  interval: hyperliquidOhlcvIntervalSchema.optional(),
+  dex: zod.z.string().optional(),
+  /** Calendar-day lookback ending now (e.g. 7 = last week). Preferred for agent requests. */
+  lookbackDays: zod.z.number().positive().max(90).optional(),
+  /** Hour lookback ending now. Alternative to lookbackDays. */
+  lookbackHours: zod.z.number().positive().max(90 * 24).optional(),
+  /** Explicit range start (ms since epoch). Use with endTimeMs. */
+  startTimeMs: zod.z.number().int().positive().optional(),
+  /** Explicit range end (ms since epoch). Defaults to now. */
+  endTimeMs: zod.z.number().int().positive().optional()
+});
+var mcpHyperliquidFetchOhlcvOutputSchema = zod.z.object({
+  ohlcv: zod.z.object({
+    coin: zod.z.string(),
+    dex: zod.z.string().nullable(),
+    interval: hyperliquidOhlcvIntervalSchema,
+    startTimeMs: zod.z.number(),
+    endTimeMs: zod.z.number(),
+    expectedBars: zod.z.number(),
+    candleCount: zod.z.number(),
+    latestCandle: hyperliquidOhlcvCandleSchema.nullable(),
+    candles: zod.z.array(hyperliquidOhlcvCandleSchema),
+    fetchedAtMs: zod.z.number()
+  }),
+  resolvedCoin: zod.z.string(),
+  dex: zod.z.string().nullable()
 });
 var mcpHyperliquidFetchUsdClassBalancesInputSchema = zod.z.object({
   chainId: zod.z.number().int().positive(),
@@ -1612,6 +1753,87 @@ var MCP_PROTOCOL_TOOL_DEFINITIONS = [
     handler: { importPath: "protocols/evm/euler-v2", exportName: "buildEvmMultisignBodyEulerV2BorrowCollateralWithdrawBatch" },
     inputZod: mcpEulerV2CollateralWithdrawInputSchema
   }),
+  defineProtocolMcpTool({
+    name: "ctm_morpho_build_vault_deposit_multisign",
+    actionId: "morpho.vault-deposit",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Build Morpho vault deposit batch (wrap/approve + deposit). Works with listed V1 and V2 vaults.",
+    prerequisites: [
+      "keyGenId",
+      "chainId",
+      "vaultAddress from ctm_morpho_fetch_earn_vaults",
+      "underlying",
+      "amountHuman"
+    ],
+    handler: { importPath: "protocols/evm/morpho", exportName: "buildEvmMultisignBodyMorphoVaultDepositBatch" },
+    inputZod: mcpMorphoVaultDepositInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_morpho_build_vault_withdraw_multisign",
+    actionId: "morpho.vault-withdraw",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Build Morpho vault withdraw batch. Works with listed V1 and V2 vaults.",
+    prerequisites: [
+      "keyGenId",
+      "chainId",
+      "vaultAddress from ctm_morpho_fetch_earn_vaults or user positions",
+      "amountHuman"
+    ],
+    handler: { importPath: "protocols/evm/morpho", exportName: "buildEvmMultisignBodyMorphoVaultWithdraw" },
+    inputZod: mcpMorphoVaultWithdrawInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_morpho_build_blue_collateral_deposit_multisign",
+    actionId: "morpho.blue-collateral-deposit",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Build Morpho Blue supplyCollateral batch.",
+    prerequisites: ["keyGenId", "chainId", "marketId", "collateralToken", "amountHuman"],
+    handler: { importPath: "protocols/evm/morpho", exportName: "buildEvmMultisignBodyMorphoBlueSupplyCollateralBatch" },
+    inputZod: mcpMorphoBlueCollateralDepositInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_morpho_build_blue_borrow_multisign",
+    actionId: "morpho.blue-borrow",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Build Morpho Blue borrow batch.",
+    prerequisites: ["keyGenId", "chainId", "marketId", "loanToken", "amountHuman"],
+    handler: { importPath: "protocols/evm/morpho", exportName: "buildEvmMultisignBodyMorphoBlueBorrowBatch" },
+    inputZod: mcpMorphoBlueBorrowInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_morpho_build_blue_repay_multisign",
+    actionId: "morpho.blue-repay",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Build Morpho Blue repay batch.",
+    prerequisites: ["keyGenId", "chainId", "marketId", "loanToken", "amountHuman"],
+    handler: { importPath: "protocols/evm/morpho", exportName: "buildEvmMultisignBodyMorphoBlueRepayBatch" },
+    inputZod: mcpMorphoBlueRepayInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_morpho_build_blue_collateral_withdraw_multisign",
+    actionId: "morpho.blue-collateral-withdraw",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Build Morpho Blue withdrawCollateral batch.",
+    prerequisites: ["keyGenId", "chainId", "marketId", "amountHuman"],
+    handler: { importPath: "protocols/evm/morpho", exportName: "buildEvmMultisignBodyMorphoBlueWithdrawCollateralBatch" },
+    inputZod: mcpMorphoBlueCollateralWithdrawInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_morpho_build_merkl_claim_multisign",
+    actionId: "morpho.merkl-claim",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Build Morpho Merkl Distributor.claim transaction.",
+    prerequisites: ["keyGenId", "chainId", "claim calldata from Merkl API"],
+    handler: { importPath: "protocols/evm/morpho", exportName: "buildEvmMultisignBodyMorphoMerklDistributorClaim" },
+    inputZod: mcpMorphoMerklClaimInputSchema
+  }),
   defineProtocolMcpTool({
     name: "ctm_gmx_build_increase_multisign",
     actionId: "gmx.increase",
@@ -2135,19 +2357,31 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     actionId: "hyperliquid.fetch-markets",
     protocolId: "hyperliquid",
     chainCategory: "evm",
-    description: "List Hyperliquid perp markets (coin, maxLeverage, szDecimals) and HIP-3 dex names. chainId 999 mainnet or 998 testnet.",
+    description: "List Hyperliquid perp markets (native + all HIP-3 dexes when dex omitted). Each market has coin name, maxLeverage, szDecimals, and optional dex (e.g. xyz for xyz:AAPL). chainId 999 mainnet or 998 testnet.",
     prerequisites: ["chainId 999 or 998"],
     followUp: ["ctm_hyperliquid_fetch_open_context", "ctm_hyperliquid_build_limit_order_multisign"],
     handler: { importPath: "protocols/evm/hyperliquid", exportName: "hyperliquidFetchMarketsSummary" },
     inputZod: mcpHyperliquidFetchMarketsInputSchema,
     outputZod: mcpHyperliquidFetchMarketsOutputSchema
   }),
+  defineMcpTool({
+    name: "ctm_hyperliquid_search_markets",
+    actionId: "hyperliquid.search-markets",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "Search Hyperliquid perp markets across all dexes by ticker (AAPL, BTC), display name, or keyword (Apple, tesla). Case-insensitive. Returns canonical coin names (e.g. xyz:AAPL).",
+    prerequisites: ["chainId 999 or 998", "query"],
+    followUp: ["ctm_hyperliquid_fetch_open_context", "ctm_hyperliquid_build_limit_order_multisign"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "hyperliquidSearchMarketsSummary" },
+    inputZod: mcpHyperliquidSearchMarketsInputSchema,
+    outputZod: mcpHyperliquidSearchMarketsOutputSchema
+  }),
   defineMcpTool({
     name: "ctm_hyperliquid_fetch_open_context",
     actionId: "hyperliquid.fetch-open-context",
     protocolId: "hyperliquid",
     chainCategory: "evm",
-    description: "Per-market trading context: account value, withdrawable, margin used, leverage setting, mark price, available buy/sell size.",
+    description: "Per-market trading context: account value, withdrawable, margin used, leverage setting, mark price, available buy/sell size. Resolves ticker/name (AAPL, Apple) across dexes.",
     prerequisites: ["chainId", "executorAddress", "coin from fetch_markets"],
     followUp: ["ctm_hyperliquid_build_limit_order_multisign"],
     handler: { importPath: "protocols/evm/hyperliquid", exportName: "hyperliquidFetchOpenContextSummary" },
@@ -2183,13 +2417,25 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     actionId: "hyperliquid.fetch-market-snapshot",
     protocolId: "hyperliquid",
     chainCategory: "evm",
-    description: "Mid price and OHLCV candles for a Hyperliquid perp coin. Default interval 15m.",
+    description: "Live mark/mid price plus recent OHLCV candles for a Hyperliquid perp. Uses metaAndAssetCtxs for live prices (not stale candle close). Default interval 15m, 48 bars. Throws if live price unavailable.",
     prerequisites: ["chainId", "coin"],
     followUp: ["ctm_hyperliquid_fetch_open_context", "ctm_hyperliquid_build_limit_order_multisign"],
     handler: { importPath: "protocols/evm/hyperliquid", exportName: "hyperliquidFetchMarketSnapshotSummary" },
     inputZod: mcpHyperliquidFetchMarketSnapshotInputSchema,
     outputZod: mcpHyperliquidFetchMarketSnapshotOutputSchema
   }),
+  defineMcpTool({
+    name: "ctm_hyperliquid_fetch_ohlcv",
+    actionId: "hyperliquid.fetch-ohlcv",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "OHLCV candle history for a Hyperliquid perp over an explicit lookback or time range. Requests only the needed window from Hyperliquid (e.g. lookbackDays: 7, interval: 15m \u2192 ~672 bars). Max 2000 bars \u2014 use coarser interval for longer history. Resolves ticker/name across dexes.",
+    prerequisites: ["chainId 999 or 998", "coin", "lookbackDays or lookbackHours or startTimeMs"],
+    followUp: ["ctm_hyperliquid_fetch_market_snapshot", "ctm_hyperliquid_build_limit_order_multisign"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "hyperliquidFetchOhlcvSummary" },
+    inputZod: mcpHyperliquidFetchOhlcvInputSchema,
+    outputZod: mcpHyperliquidFetchOhlcvOutputSchema
+  }),
   defineMcpTool({
     name: "ctm_hyperliquid_fetch_usd_class_balances",
     actionId: "hyperliquid.fetch-usd-balances",
@@ -2249,6 +2495,21 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     handler: { importPath: "protocols/evm/hyperliquid", exportName: "hyperliquidFetchDelegationsForExecutor" },
     inputZod: mcpHyperliquidFetchDelegationsInputSchema,
     outputZod: mcpHyperliquidFetchDelegationsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_morpho_fetch_earn_vaults",
+    actionId: "morpho.fetch-earn-vaults",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Morpho-listed earn vaults (V1 + V2 unified). Filter by deposit asset symbol/address and/or case-insensitive vault name search. Returns vaultAddress for deposit/withdraw multisign tools.",
+    prerequisites: ["chainId"],
+    followUp: [
+      "ctm_morpho_build_vault_deposit_multisign",
+      "ctm_morpho_build_vault_withdraw_multisign"
+    ],
+    handler: { importPath: "protocols/evm/morpho", exportName: "morphoFetchEarnVaultsSummary" },
+    inputZod: mcpMorphoFetchEarnVaultsInputSchema,
+    outputZod: mcpMorphoFetchEarnVaultsOutputSchema
   })
 ];
 var MCP_TOOL_DEFINITIONS = [
@@ -2475,7 +2736,30 @@ registerProtocolModule(ethenaProtocolModule);
 function isMapleSyrupSupportedChain(chainId) {
   return chainId === 1 || chainId === 11155111;
 }
+
+// src/core/defiProxy.ts
+var aaveGraphqlProxyUrl;
+var morphoGraphqlProxyUrl;
+function getAaveGraphqlProxyUrl() {
+  return aaveGraphqlProxyUrl;
+}
+function getMorphoGraphqlProxyUrl() {
+  return morphoGraphqlProxyUrl;
+}
 async function postJsonViaOptionalProxy(args) {
+  const proxy = args.proxyUrl?.trim();
+  if (proxy) {
+    const r2 = await fetch(proxy, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(args.proxyEnvelope ?? args.body)
+    });
+    if (!r2.ok) {
+      const t = await r2.text().catch(() => "");
+      throw new Error(t ? `Proxy HTTP ${r2.status}: ${t.slice(0, 200)}` : `Proxy HTTP ${r2.status}`);
+    }
+    return await r2.json();
+  }
   const r = await fetch(args.directUrl, {
     method: "POST",
     headers: { "content-type": "application/json" },
@@ -2538,7 +2822,10 @@ async function aaveV4Gql(query, variables) {
   const body = { query, variables: variables ?? {} };
   const j = await postJsonViaOptionalProxy({
     directUrl: AAVE_V4_GRAPHQL_URL,
-    body});
+    body,
+    proxyUrl: getAaveGraphqlProxyUrl(),
+    proxyEnvelope: body
+  });
   if (j.errors?.length) {
     const msg = j.errors.map((e) => e.message ?? "Unknown").join("; ");
     throw new Error(msg);
@@ -3011,6 +3298,175 @@ var hyperliquidProtocolModule = {
   ]
 };
 registerProtocolModule(hyperliquidProtocolModule);
+var MORPHO_GRAPHQL_URL = "https://api.morpho.org/graphql";
+async function morphoGql(query, variables) {
+  const body = { query, variables: variables ?? {} };
+  const j = await postJsonViaOptionalProxy({
+    directUrl: MORPHO_GRAPHQL_URL,
+    body,
+    proxyUrl: getMorphoGraphqlProxyUrl(),
+    proxyEnvelope: body
+  });
+  if (j.errors?.length) {
+    const msg = j.errors.map((e) => e.message ?? "Unknown").join("; ");
+    throw new Error(msg);
+  }
+  if (j.data == null) throw new Error("Morpho API: empty response");
+  return j.data;
+}
+async function fetchMorphoChains() {
+  const d = await morphoGql(`
+    query { chains { id network } }
+  `);
+  return d.chains ?? [];
+}
+async function loadMorphoSupportedChainIds() {
+  const rows = await fetchMorphoChains();
+  const s = /* @__PURE__ */ new Set();
+  for (const c of rows) {
+    if (typeof c.id === "number" && Number.isFinite(c.id)) s.add(c.id);
+  }
+  return s;
+}
+var VAULT_PAGE_SIZE = 100;
+async function fetchMorphoVaultsForChain(chainId, first = 100) {
+  const d = await morphoGql(
+    `
+    query MorphoVaults($chainId: Int!, $first: Int!) {
+      vaults(first: $first, where: { chainId_in: [$chainId], listed: true }, orderBy: TotalAssetsUsd, orderDirection: Desc) {
+        items {
+          address symbol name listed
+          asset { address symbol decimals price { usd } }
+          chain { id }
+          state { apy netApy fee totalAssetsUsd allRewards { supplyApr asset { address symbol } } }
+        }
+      }
+    }
+  `,
+    { chainId, first }
+  );
+  return d.vaults?.items ?? [];
+}
+async function fetchMorphoVaultV2sForChain(chainId, first = 100, skip = 0) {
+  const d = await morphoGql(
+    `
+    query MorphoVaultV2s($chainId: Int!, $first: Int!, $skip: Int!) {
+      vaultV2s(
+        first: $first
+        skip: $skip
+        where: { chainId_in: [$chainId], listed: true }
+        orderBy: TotalAssetsUsd
+        orderDirection: Desc
+      ) {
+        items {
+          address symbol name listed
+          asset { address symbol decimals price { usd } }
+          chain { id }
+          apy netApy performanceFee managementFee totalAssetsUsd
+          rewards { supplyApr asset { address symbol } }
+        }
+      }
+    }
+  `,
+    { chainId, first, skip }
+  );
+  return d.vaultV2s?.items ?? [];
+}
+async function fetchAllMorphoVaultV2AssetAddresses(chainId) {
+  const out = /* @__PURE__ */ new Set();
+  let skip = 0;
+  for (let page = 0; page < 20; page++) {
+    const batch = await fetchMorphoVaultV2sForChain(chainId, VAULT_PAGE_SIZE, skip);
+    if (!batch.length) break;
+    for (const v of batch) {
+      const a = (v.asset?.address ?? "").trim();
+      if (viem.isAddress(a)) out.add(viem.getAddress(a).toLowerCase());
+    }
+    if (batch.length < VAULT_PAGE_SIZE) break;
+    skip += VAULT_PAGE_SIZE;
+  }
+  return out;
+}
+var chainAssetCache = /* @__PURE__ */ new Map();
+async function ensureMorphoChainAssetCache(chainId) {
+  const hit = chainAssetCache.get(chainId);
+  if (hit) return hit;
+  const modes = /* @__PURE__ */ new Map();
+  const [v1Vaults, v2Assets] = await Promise.all([
+    fetchMorphoVaultsForChain(chainId, 300),
+    fetchAllMorphoVaultV2AssetAddresses(chainId)
+  ]);
+  for (const v of v1Vaults) {
+    const a = (v.asset?.address ?? "").trim();
+    if (!viem.isAddress(a)) continue;
+    const k = viem.getAddress(a).toLowerCase();
+    const prev = modes.get(k) ?? { earn: false, borrow: false, collateral: false };
+    prev.earn = true;
+    modes.set(k, prev);
+  }
+  for (const k of v2Assets) {
+    const prev = modes.get(k) ?? { earn: false, borrow: false, collateral: false };
+    prev.earn = true;
+    modes.set(k, prev);
+  }
+  const marketsD = await morphoGql(
+    `
+    query MorphoMarketsAssets($chainId: Int!) {
+      markets(first: 500, where: { chainId_in: [$chainId] }) {
+        items {
+          loanAsset { address }
+          collateralAsset { address }
+        }
+      }
+    }
+  `,
+    { chainId }
+  );
+  for (const m of marketsD.markets?.items ?? []) {
+    const loanAddr = (m.loanAsset?.address ?? "").trim();
+    const colAddr = (m.collateralAsset?.address ?? "").trim();
+    if (viem.isAddress(loanAddr)) {
+      const k = viem.getAddress(loanAddr).toLowerCase();
+      const prev = modes.get(k) ?? { earn: false, borrow: false, collateral: false };
+      prev.borrow = true;
+      modes.set(k, prev);
+    }
+    if (viem.isAddress(colAddr)) {
+      const k = viem.getAddress(colAddr).toLowerCase();
+      const prev = modes.get(k) ?? { earn: false, borrow: false, collateral: false };
+      prev.collateral = true;
+      modes.set(k, prev);
+    }
+  }
+  const cache = { modesByUnderlying: modes, nativeWrapped: null };
+  chainAssetCache.set(chainId, cache);
+  return cache;
+}
+
+// src/protocols/evm/morpho/index.ts
+var MORPHO_PROTOCOL_ID = "morpho";
+var morphoProtocolModule = {
+  id: MORPHO_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    return ctx.chainCategory === "evm";
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && (token.kind === "native" || token.kind === "erc20");
+  },
+  actions: [
+    { id: "morpho.fetch-earn-vaults", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Search Morpho-listed earn vaults by asset or name", commonParams: [], params: {} },
+    { id: "morpho.vault-deposit", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Deposit into Morpho-listed earn vault (V1 or V2)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "morpho.vault-withdraw", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Withdraw from Morpho earn vault (V1 or V2)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "morpho.blue-collateral-deposit", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Supply collateral to Morpho Blue market", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "morpho.blue-borrow", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Borrow from Morpho Blue market", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "morpho.blue-repay", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Repay Morpho Blue borrow", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "morpho.blue-collateral-withdraw", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Withdraw Morpho Blue collateral", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "morpho.merkl-claim", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Claim Morpho Merkl rewards", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "morpho.midnight-borrow", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Morpho Midnight fixed-rate borrow (coming soon)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} }
+  ]
+};
+registerProtocolModule(morphoProtocolModule);
 var skillsDir = path.join(path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('catalog.cjs', document.baseURI).href)))), "skills");
 var SKILL_PROTOCOL_IDS = [
   "aave-v4",
@@ -3022,7 +3478,8 @@ var SKILL_PROTOCOL_IDS = [
   "maple-syrup",
   "sky",
   "gmx",
-  "hyperliquid"
+  "hyperliquid",
+  "morpho"
 ];
 function getToolsForProtocol(protocolId) {
   return MCP_TOOL_DEFINITIONS.filter((t) => t.protocolId === protocolId);
@@ -3236,6 +3693,37 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       return { tokens: [] };
     }
   }),
+  morpho: advisor("morpho", "api_underlyings", {
+    async supportedChainIds() {
+      const set = await loadMorphoSupportedChainIds();
+      return [...set].sort((a, b) => a - b);
+    },
+    async supportedTokens(chainId) {
+      const cache = await ensureMorphoChainAssetCache(chainId);
+      const tokens = [...cache.modesByUnderlying.entries()].map(([address, modes]) => ({
+        address,
+        roles: [
+          ...modes.earn ? ["vault_underlying"] : [],
+          ...modes.borrow ? ["loan"] : [],
+          ...modes.collateral ? ["collateral"] : []
+        ]
+      }));
+      return {
+        tokens,
+        notes: "Morpho vault assets and Blue market loan/collateral tokens from api.morpho.org."
+      };
+    },
+    async isTokenSupported(chainId, address) {
+      const cache = await ensureMorphoChainAssetCache(chainId);
+      let normalized;
+      try {
+        normalized = viem.getAddress(address).toLowerCase();
+      } catch {
+        return false;
+      }
+      return cache.modesByUnderlying.has(normalized);
+    }
+  }),
   "euler-v2": advisor("euler-v2", "subgraph_vaults", {
     async supportedChainIds() {
       return [...EULER_V2_SUBGRAPH_CHAIN_IDS];
@@ -3317,6 +3805,7 @@ registerProtocolModule(aaveV4ProtocolModule);
 registerProtocolModule(eulerV2ProtocolModule);
 registerProtocolModule(gmxProtocolModule);
 registerProtocolModule(hyperliquidProtocolModule);
+registerProtocolModule(morphoProtocolModule);
 function getAgentCatalog() {
   return {
     protocols: getProtocolModules(),
@@ -3335,6 +3824,7 @@ function getAgentCatalog() {
     eulerV2: eulerV2ProtocolModule,
     gmx: gmxProtocolModule,
     hyperliquid: hyperliquidProtocolModule,
+    morpho: morphoProtocolModule,
     /** Prefer getAgentCatalogForMcp() or getMcpToolDefinitions() for MCP servers. */
     mcp: getAgentCatalogForMcp()
   };
@@ -3416,6 +3906,8 @@ exports.mcpHyperliquidFetchMarketSnapshotInputSchema = mcpHyperliquidFetchMarket
 exports.mcpHyperliquidFetchMarketSnapshotOutputSchema = mcpHyperliquidFetchMarketSnapshotOutputSchema;
 exports.mcpHyperliquidFetchMarketsInputSchema = mcpHyperliquidFetchMarketsInputSchema;
 exports.mcpHyperliquidFetchMarketsOutputSchema = mcpHyperliquidFetchMarketsOutputSchema;
+exports.mcpHyperliquidFetchOhlcvInputSchema = mcpHyperliquidFetchOhlcvInputSchema;
+exports.mcpHyperliquidFetchOhlcvOutputSchema = mcpHyperliquidFetchOhlcvOutputSchema;
 exports.mcpHyperliquidFetchOpenContextInputSchema = mcpHyperliquidFetchOpenContextInputSchema;
 exports.mcpHyperliquidFetchOpenContextOutputSchema = mcpHyperliquidFetchOpenContextOutputSchema;
 exports.mcpHyperliquidFetchOpenOrdersInputSchema = mcpHyperliquidFetchOpenOrdersInputSchema;
@@ -3431,6 +3923,8 @@ exports.mcpHyperliquidFetchUserVaultEquitiesOutputSchema = mcpHyperliquidFetchUs
 exports.mcpHyperliquidFetchVaultsInputSchema = mcpHyperliquidFetchVaultsInputSchema;
 exports.mcpHyperliquidFetchVaultsOutputSchema = mcpHyperliquidFetchVaultsOutputSchema;
 exports.mcpHyperliquidLimitOrderInputSchema = mcpHyperliquidLimitOrderInputSchema;
+exports.mcpHyperliquidSearchMarketsInputSchema = mcpHyperliquidSearchMarketsInputSchema;
+exports.mcpHyperliquidSearchMarketsOutputSchema = mcpHyperliquidSearchMarketsOutputSchema;
 exports.mcpHyperliquidStakeInputSchema = mcpHyperliquidStakeInputSchema;
 exports.mcpHyperliquidUndelegateInputSchema = mcpHyperliquidUndelegateInputSchema;
 exports.mcpHyperliquidUnstakeInputSchema = mcpHyperliquidUnstakeInputSchema;
@@ -3444,6 +3938,15 @@ exports.mcpLidoUnwrapWstEthInputSchema = mcpLidoUnwrapWstEthInputSchema;
 exports.mcpLidoWrapStEthInputSchema = mcpLidoWrapStEthInputSchema;
 exports.mcpMapleDepositInputSchema = mcpMapleDepositInputSchema;
 exports.mcpMapleRequestRedeemInputSchema = mcpMapleRequestRedeemInputSchema;
+exports.mcpMorphoBlueBorrowInputSchema = mcpMorphoBlueBorrowInputSchema;
+exports.mcpMorphoBlueCollateralDepositInputSchema = mcpMorphoBlueCollateralDepositInputSchema;
+exports.mcpMorphoBlueCollateralWithdrawInputSchema = mcpMorphoBlueCollateralWithdrawInputSchema;
+exports.mcpMorphoBlueRepayInputSchema = mcpMorphoBlueRepayInputSchema;
+exports.mcpMorphoFetchEarnVaultsInputSchema = mcpMorphoFetchEarnVaultsInputSchema;
+exports.mcpMorphoFetchEarnVaultsOutputSchema = mcpMorphoFetchEarnVaultsOutputSchema;
+exports.mcpMorphoMerklClaimInputSchema = mcpMorphoMerklClaimInputSchema;
+exports.mcpMorphoVaultDepositInputSchema = mcpMorphoVaultDepositInputSchema;
+exports.mcpMorphoVaultWithdrawInputSchema = mcpMorphoVaultWithdrawInputSchema;
 exports.mcpMultisignInput = mcpMultisignInput;
 exports.mcpMultisignOutputSchema = multisignOutputSchema;
 exports.mcpMultisignSubmitOutputSchema = mcpServerSubmitOutputSchema;