@continuumdao/ctm-mpc-defi 0.2.8 → 0.2.10

package/dist/agent/catalog.cjs

@@ -927,6 +927,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);
 }
@@ -1075,6 +1143,311 @@ var mcpGmxFetchOhlcvOutputSchema = zod.z.object({
   timeframe: gmxOhlcvTimeframeSchema,
   candles: zod.z.array(gmxOhlcvCandleSchema)
 });
+function mcpHyperliquidMultisignInput(fields) {
+  return evmMultisignCommonInputSchema.extend(fields);
+}
+var hyperliquidTifSchema = zod.z.enum(["alo", "gtc", "ioc"]);
+var hyperliquidOhlcvIntervalSchema = zod.z.enum([
+  "1m",
+  "3m",
+  "5m",
+  "15m",
+  "30m",
+  "1h",
+  "2h",
+  "4h",
+  "8h",
+  "12h",
+  "1d",
+  "3d",
+  "1w",
+  "1M"
+]);
+var hyperliquidPositionRowSchema = zod.z.object({
+  key: zod.z.string(),
+  coin: zod.z.string(),
+  isLong: zod.z.boolean(),
+  size: zod.z.string().nullable(),
+  entryPx: zod.z.string().nullable(),
+  positionValueUsd: zod.z.string().nullable(),
+  unrealizedPnlUsd: zod.z.string().nullable(),
+  liquidationPx: zod.z.string().nullable(),
+  leverageLabel: zod.z.string().nullable(),
+  maxLeverage: zod.z.number().nullable(),
+  marginUsedUsd: zod.z.string().nullable(),
+  returnOnEquity: zod.z.string().nullable()
+});
+var hyperliquidActiveAssetSchema = zod.z.object({
+  markPx: zod.z.string().nullable(),
+  leverageLabel: zod.z.string().nullable(),
+  availableToBuy: zod.z.string().nullable(),
+  availableToSell: zod.z.string().nullable()
+});
+var hyperliquidAccountSummarySchema = zod.z.object({
+  accountValueUsd: zod.z.string().nullable(),
+  totalMarginUsedUsd: zod.z.string().nullable(),
+  withdrawableUsd: zod.z.string().nullable()
+});
+var mcpHyperliquidFetchMarketsInputSchema = zod.z.object({
+  chainId: zod.z.number().int().positive(),
+  dex: zod.z.string().optional()
+});
+var mcpHyperliquidFetchMarketsOutputSchema = zod.z.object({
+  markets: zod.z.array(
+    zod.z.object({
+      name: zod.z.string(),
+      asset: zod.z.number(),
+      szDecimals: zod.z.number(),
+      maxLeverage: zod.z.number(),
+      onlyIsolated: zod.z.boolean().optional(),
+      dex: zod.z.string().optional()
+    })
+  ),
+  dexes: zod.z.array(
+    zod.z.object({
+      name: zod.z.string(),
+      fullName: zod.z.string()
+    })
+  )
+});
+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,
+  coin: zod.z.string().min(1),
+  dex: zod.z.string().optional()
+});
+var mcpHyperliquidFetchOpenContextOutputSchema = zod.z.object({
+  context: zod.z.object({
+    account: hyperliquidAccountSummarySchema,
+    activeAsset: hyperliquidActiveAssetSchema
+  })
+});
+var mcpHyperliquidFetchPositionsInputSchema = zod.z.object({
+  chainId: zod.z.number().int().positive(),
+  executorAddress: evmAddressSchema,
+  dex: zod.z.string().optional()
+});
+var mcpHyperliquidFetchPositionsOutputSchema = zod.z.object({
+  positions: zod.z.array(hyperliquidPositionRowSchema)
+});
+var mcpHyperliquidFetchOpenOrdersInputSchema = zod.z.object({
+  chainId: zod.z.number().int().positive(),
+  executorAddress: evmAddressSchema,
+  dex: zod.z.string().optional()
+});
+var mcpHyperliquidFetchOpenOrdersOutputSchema = zod.z.object({
+  orders: zod.z.array(
+    zod.z.object({
+      coin: zod.z.string(),
+      side: zod.z.string(),
+      limitPx: zod.z.string(),
+      sz: zod.z.string(),
+      oid: zod.z.number(),
+      timestamp: zod.z.number(),
+      reduceOnly: zod.z.boolean().optional()
+    })
+  )
+});
+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(),
+  /** 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(),
+    dex: zod.z.string().nullable(),
+    livePrice: hyperliquidLivePriceSchema,
+    midUsd: zod.z.string(),
+    fetchedAtMs: zod.z.number(),
+    interval: hyperliquidOhlcvIntervalSchema,
+    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(),
+  executorAddress: evmAddressSchema
+});
+var mcpHyperliquidFetchUsdClassBalancesOutputSchema = zod.z.object({
+  balances: zod.z.object({
+    spotUsdcAvailable: zod.z.string(),
+    perpWithdrawable: zod.z.string()
+  })
+});
+var mcpHyperliquidFetchVaultsInputSchema = zod.z.object({
+  chainId: zod.z.number().int().positive(),
+  executorAddress: evmAddressSchema.optional()
+});
+var mcpHyperliquidFetchVaultsOutputSchema = zod.z.object({
+  vaults: zod.z.array(
+    zod.z.object({
+      vaultAddress: zod.z.string(),
+      name: zod.z.string(),
+      apr: zod.z.number().nullable(),
+      tvlUsd: zod.z.string().nullable()
+    })
+  )
+});
+var mcpHyperliquidFetchUserVaultEquitiesInputSchema = zod.z.object({
+  chainId: zod.z.number().int().positive(),
+  executorAddress: evmAddressSchema
+});
+var mcpHyperliquidFetchUserVaultEquitiesOutputSchema = zod.z.object({
+  rows: zod.z.array(
+    zod.z.object({
+      vaultAddress: zod.z.string(),
+      equity: zod.z.string()
+    })
+  )
+});
+var mcpHyperliquidFetchStakingSummaryInputSchema = zod.z.object({
+  chainId: zod.z.number().int().positive(),
+  executorAddress: evmAddressSchema
+});
+var mcpHyperliquidFetchStakingSummaryOutputSchema = zod.z.object({
+  summary: zod.z.object({
+    delegated: zod.z.string(),
+    undelegated: zod.z.string()
+  })
+});
+var mcpHyperliquidFetchDelegationsInputSchema = zod.z.object({
+  chainId: zod.z.number().int().positive(),
+  executorAddress: evmAddressSchema
+});
+var mcpHyperliquidFetchDelegationsOutputSchema = zod.z.object({
+  delegations: zod.z.array(
+    zod.z.object({
+      validator: zod.z.string(),
+      amount: zod.z.string()
+    })
+  )
+});
+var mcpHyperliquidLimitOrderInputSchema = mcpHyperliquidMultisignInput({
+  coin: zod.z.string().min(1),
+  isBuy: zod.z.boolean(),
+  limitPxHuman: zod.z.string().min(1),
+  szHuman: zod.z.string().min(1),
+  marketKind: zod.z.enum(["perp", "spot"]).optional(),
+  tif: hyperliquidTifSchema.optional(),
+  dex: zod.z.string().optional()
+});
+var mcpHyperliquidCloseInputSchema = mcpHyperliquidMultisignInput({
+  coin: zod.z.string().min(1),
+  isLong: zod.z.boolean(),
+  limitPxHuman: zod.z.string().min(1),
+  szHuman: zod.z.string().min(1),
+  dex: zod.z.string().optional(),
+  tif: hyperliquidTifSchema.optional()
+});
+var mcpHyperliquidCancelInputSchema = mcpHyperliquidMultisignInput({
+  coin: zod.z.string().min(1),
+  oid: zod.z.number().int().positive(),
+  marketKind: zod.z.enum(["perp", "spot"]).optional(),
+  dex: zod.z.string().optional()
+});
+var mcpHyperliquidUsdTransferInputSchema = mcpHyperliquidMultisignInput({
+  usdHuman: zod.z.string().min(1),
+  toPerp: zod.z.boolean()
+});
+var mcpHyperliquidVaultDepositInputSchema = mcpHyperliquidMultisignInput({
+  vaultAddress: evmAddressSchema,
+  usdHuman: zod.z.string().min(1)
+});
+var mcpHyperliquidVaultWithdrawInputSchema = mcpHyperliquidMultisignInput({
+  vaultAddress: evmAddressSchema,
+  usdHuman: zod.z.string().min(1)
+});
+var mcpHyperliquidStakeInputSchema = mcpHyperliquidMultisignInput({
+  hypeHuman: zod.z.string().min(1)
+});
+var mcpHyperliquidUnstakeInputSchema = mcpHyperliquidMultisignInput({
+  hypeHuman: zod.z.string().min(1)
+});
+var mcpHyperliquidDelegateInputSchema = mcpHyperliquidMultisignInput({
+  hypeHuman: zod.z.string().min(1),
+  validator: evmAddressSchema
+});
+var mcpHyperliquidUndelegateInputSchema = mcpHyperliquidMultisignInput({
+  hypeHuman: zod.z.string().min(1),
+  validator: evmAddressSchema
+});
 
 // src/agent/mcpProtocolTools.ts
 function defineProtocolMcpTool(def) {
@@ -1377,6 +1750,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",
@@ -1446,6 +1900,109 @@ var MCP_PROTOCOL_TOOL_DEFINITIONS = [
     prerequisites: ["keyGen", "executorAddress", "staked GMX balance"],
     handler: { importPath: "protocols/evm/gmx", exportName: "buildEvmMultisignBodyGmxUnstakeGmxBatch" },
     inputZod: mcpGmxUnstakeGmxInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_hyperliquid_build_limit_order_multisign",
+    actionId: "hyperliquid.limitOrder",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "Create and submit mpc-auth multiSignRequest for a Hyperliquid limit/IoC order via HyperEVM CoreWriter.",
+    prerequisites: ["keyGen", "executorAddress", "chainId 999 or 998", "coin", "limitPxHuman", "szHuman"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "buildEvmMultisignBodyHyperliquidLimitOrderBatch" },
+    inputZod: mcpHyperliquidLimitOrderInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_hyperliquid_build_close_multisign",
+    actionId: "hyperliquid.close",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "Create and submit mpc-auth multiSignRequest to close/reduce a perp (IoC reduce-only limit via CoreWriter).",
+    prerequisites: ["keyGen", "executorAddress", "open position from fetch_positions", "isLong matches position"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "buildEvmMultisignBodyHyperliquidCloseBatch" },
+    inputZod: mcpHyperliquidCloseInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_hyperliquid_build_cancel_multisign",
+    actionId: "hyperliquid.cancel",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "Create and submit mpc-auth multiSignRequest to cancel a Hyperliquid open order.",
+    prerequisites: ["keyGen", "executorAddress", "oid from fetch_open_orders"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "buildEvmMultisignBodyHyperliquidCancelBatch" },
+    inputZod: mcpHyperliquidCancelInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_hyperliquid_build_usd_transfer_multisign",
+    actionId: "hyperliquid.usdTransfer",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "Create and submit mpc-auth multiSignRequest to move USDC between spot and perp margin.",
+    prerequisites: ["keyGen", "executorAddress", "usdHuman", "toPerp boolean"],
+    handler: {
+      importPath: "protocols/evm/hyperliquid",
+      exportName: "buildEvmMultisignBodyHyperliquidUsdClassTransferBatch"
+    },
+    inputZod: mcpHyperliquidUsdTransferInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_hyperliquid_build_vault_deposit_multisign",
+    actionId: "hyperliquid.vaultDeposit",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "Create and submit mpc-auth multiSignRequest for Hyperliquid vault deposit.",
+    prerequisites: ["keyGen", "executorAddress", "vaultAddress from fetch_vaults"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "buildEvmMultisignBodyHyperliquidVaultDepositBatch" },
+    inputZod: mcpHyperliquidVaultDepositInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_hyperliquid_build_vault_withdraw_multisign",
+    actionId: "hyperliquid.vaultWithdraw",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "Create and submit mpc-auth multiSignRequest for Hyperliquid vault withdraw (includes accrued PnL).",
+    prerequisites: ["keyGen", "executorAddress", "vaultAddress", "equity from fetch_user_vault_equities"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "buildEvmMultisignBodyHyperliquidVaultWithdrawBatch" },
+    inputZod: mcpHyperliquidVaultWithdrawInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_hyperliquid_build_stake_multisign",
+    actionId: "hyperliquid.stake",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "Create and submit mpc-auth multiSignRequest to stake HYPE via CoreWriter.",
+    prerequisites: ["keyGen", "executorAddress", "HYPE balance on Hyperliquid account"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "buildEvmMultisignBodyHyperliquidStakeDepositBatch" },
+    inputZod: mcpHyperliquidStakeInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_hyperliquid_build_unstake_multisign",
+    actionId: "hyperliquid.unstake",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "Create and submit mpc-auth multiSignRequest to unstake HYPE via CoreWriter.",
+    prerequisites: ["keyGen", "executorAddress", "staked HYPE"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "buildEvmMultisignBodyHyperliquidStakeWithdrawBatch" },
+    inputZod: mcpHyperliquidUnstakeInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_hyperliquid_build_delegate_multisign",
+    actionId: "hyperliquid.delegate",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "Create and submit mpc-auth multiSignRequest to delegate staked HYPE to a validator.",
+    prerequisites: ["keyGen", "executorAddress", "validator address", "hypeHuman"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "buildEvmMultisignBodyHyperliquidDelegateOnlyBatch" },
+    inputZod: mcpHyperliquidDelegateInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_hyperliquid_build_undelegate_multisign",
+    actionId: "hyperliquid.undelegate",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "Create and submit mpc-auth multiSignRequest to undelegate HYPE from a validator.",
+    prerequisites: ["keyGen", "executorAddress", "delegation from fetch_delegations"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "buildEvmMultisignBodyHyperliquidUndelegateBatch" },
+    inputZod: mcpHyperliquidUndelegateInputSchema
   })
 ];
 
@@ -1791,6 +2348,165 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     handler: { importPath: "protocols/evm/gmx", exportName: "gmxFetchStakingPower" },
     inputZod: mcpGmxFetchStakingPowerInputSchema,
     outputZod: mcpGmxFetchStakingPowerOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_hyperliquid_fetch_markets",
+    actionId: "hyperliquid.fetch-markets",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    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. 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" },
+    inputZod: mcpHyperliquidFetchOpenContextInputSchema,
+    outputZod: mcpHyperliquidFetchOpenContextOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_hyperliquid_fetch_positions",
+    actionId: "hyperliquid.fetch-positions",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "Open Hyperliquid perp positions for executor (size, entry, uPnL, liq price, leverage, margin).",
+    prerequisites: ["chainId", "executorAddress"],
+    followUp: ["ctm_hyperliquid_build_close_multisign"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "hyperliquidFetchPositionsForExecutor" },
+    inputZod: mcpHyperliquidFetchPositionsInputSchema,
+    outputZod: mcpHyperliquidFetchPositionsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_hyperliquid_fetch_open_orders",
+    actionId: "hyperliquid.fetch-open-orders",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "Pending Hyperliquid open orders for executor (oid, coin, side, price, size).",
+    prerequisites: ["chainId", "executorAddress"],
+    followUp: ["ctm_hyperliquid_build_cancel_multisign"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "hyperliquidFetchOpenOrdersSummary" },
+    inputZod: mcpHyperliquidFetchOpenOrdersInputSchema,
+    outputZod: mcpHyperliquidFetchOpenOrdersOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_hyperliquid_fetch_market_snapshot",
+    actionId: "hyperliquid.fetch-market-snapshot",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    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",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "Spot USDC available and perp withdrawable USD for spot\u2194perp transfers.",
+    prerequisites: ["chainId", "executorAddress"],
+    followUp: ["ctm_hyperliquid_build_usd_transfer_multisign"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "hyperliquidFetchUsdClassBalancesSummary" },
+    inputZod: mcpHyperliquidFetchUsdClassBalancesInputSchema,
+    outputZod: mcpHyperliquidFetchUsdClassBalancesOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_hyperliquid_fetch_vaults",
+    actionId: "hyperliquid.fetch-vaults",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "Vault catalog by TVL with APR (mainnet only; may take ~10\u201315s). Pass executorAddress to merge user-held vaults.",
+    prerequisites: ["chainId 999 for catalog"],
+    followUp: ["ctm_hyperliquid_build_vault_deposit_multisign"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "hyperliquidFetchVaultCatalogSummary" },
+    inputZod: mcpHyperliquidFetchVaultsInputSchema,
+    outputZod: mcpHyperliquidFetchVaultsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_hyperliquid_fetch_user_vault_equities",
+    actionId: "hyperliquid.fetch-user-vault-equities",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "USD equity the user holds in Hyperliquid vaults.",
+    prerequisites: ["chainId", "executorAddress"],
+    followUp: ["ctm_hyperliquid_build_vault_withdraw_multisign"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "hyperliquidFetchUserVaultEquitiesSummary" },
+    inputZod: mcpHyperliquidFetchUserVaultEquitiesInputSchema,
+    outputZod: mcpHyperliquidFetchUserVaultEquitiesOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_hyperliquid_fetch_staking_summary",
+    actionId: "hyperliquid.fetch-staking-summary",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "HYPE staking summary: delegated and undelegated amounts.",
+    prerequisites: ["chainId", "executorAddress"],
+    followUp: ["ctm_hyperliquid_build_stake_multisign", "ctm_hyperliquid_build_delegate_multisign"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "hyperliquidFetchStakingSummaryForExecutor" },
+    inputZod: mcpHyperliquidFetchStakingSummaryInputSchema,
+    outputZod: mcpHyperliquidFetchStakingSummaryOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_hyperliquid_fetch_delegations",
+    actionId: "hyperliquid.fetch-delegations",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "HYPE delegations by validator for executor.",
+    prerequisites: ["chainId", "executorAddress"],
+    followUp: ["ctm_hyperliquid_build_undelegate_multisign"],
+    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 = [
@@ -2017,7 +2733,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" },
@@ -2080,7 +2819,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);
@@ -2413,6 +3155,315 @@ var gmxProtocolModule = {
   ]
 };
 registerProtocolModule(gmxProtocolModule);
+
+// src/protocols/evm/hyperliquid/support.ts
+var HYPERLIQUID_SUPPORTED_CHAIN_IDS = [999, 998];
+function isHyperliquidChainSupported(chainId) {
+  return HYPERLIQUID_SUPPORTED_CHAIN_IDS.includes(chainId);
+}
+
+// src/protocols/evm/hyperliquid/index.ts
+var HYPERLIQUID_PROTOCOL_ID = "hyperliquid";
+var hyperliquidProtocolModule = {
+  id: HYPERLIQUID_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    const chainId = typeof ctx.chainId === "number" ? ctx.chainId : Number(ctx.chainId);
+    return Number.isFinite(chainId) && isHyperliquidChainSupported(chainId);
+  },
+  isTokenSupported(token) {
+    if (token.category !== "evm") return false;
+    return token.kind === "erc20" || token.kind === "native";
+  },
+  actions: [
+    {
+      id: "hyperliquid.limitOrder",
+      protocolId: HYPERLIQUID_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Place a Hyperliquid limit/IoC order via HyperEVM CoreWriter",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        coin: { type: "string", required: true, description: "Market coin e.g. BTC" },
+        isBuy: { type: "boolean", required: true, description: "true for buy/long, false for sell/short" },
+        limitPxHuman: { type: "string", required: true, description: "Limit price" },
+        szHuman: { type: "string", required: true, description: "Order size in coin units" },
+        marketKind: { type: "string", required: false, description: "perp (default) or spot" },
+        tif: { type: "string", required: false, description: "gtc, ioc, or alo" },
+        dex: { type: "string", required: false, description: "HIP-3 dex name when applicable" }
+      }
+    },
+    {
+      id: "hyperliquid.close",
+      protocolId: HYPERLIQUID_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Close or reduce a perp via IoC reduce-only limit order (CoreWriter)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        coin: { type: "string", required: true, description: "Market coin" },
+        isLong: { type: "boolean", required: true, description: "true if closing a long position" },
+        limitPxHuman: { type: "string", required: true, description: "Limit price" },
+        szHuman: { type: "string", required: true, description: "Size to close in coin units" }
+      }
+    },
+    {
+      id: "hyperliquid.cancel",
+      protocolId: HYPERLIQUID_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Cancel a Hyperliquid open order via CoreWriter",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        coin: { type: "string", required: true, description: "Market coin" },
+        oid: { type: "number", required: true, description: "Order id from openOrders" }
+      }
+    },
+    {
+      id: "hyperliquid.usdTransfer",
+      protocolId: HYPERLIQUID_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Move USDC between Hyperliquid spot and perp margin accounts",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        usdHuman: { type: "string", required: true, description: "USD amount" },
+        toPerp: { type: "boolean", required: true, description: "true spot\u2192perp, false perp\u2192spot" }
+      }
+    },
+    {
+      id: "hyperliquid.vaultDeposit",
+      protocolId: HYPERLIQUID_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Deposit USD into a Hyperliquid vault",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        vaultAddress: { type: "string", required: true, description: "Vault address" },
+        usdHuman: { type: "string", required: true, description: "USD amount" }
+      }
+    },
+    {
+      id: "hyperliquid.vaultWithdraw",
+      protocolId: HYPERLIQUID_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Withdraw USD from a Hyperliquid vault (includes accrued PnL)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        vaultAddress: { type: "string", required: true, description: "Vault address" },
+        usdHuman: { type: "string", required: true, description: "USD amount" }
+      }
+    },
+    {
+      id: "hyperliquid.stake",
+      protocolId: HYPERLIQUID_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Stake HYPE via CoreWriter",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        hypeHuman: { type: "string", required: true, description: "HYPE amount" }
+      }
+    },
+    {
+      id: "hyperliquid.unstake",
+      protocolId: HYPERLIQUID_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Unstake HYPE via CoreWriter",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        hypeHuman: { type: "string", required: true, description: "HYPE amount" }
+      }
+    },
+    {
+      id: "hyperliquid.delegate",
+      protocolId: HYPERLIQUID_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Delegate staked HYPE to a validator",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        hypeHuman: { type: "string", required: true, description: "HYPE amount" },
+        validator: { type: "string", required: true, description: "Validator address" }
+      }
+    },
+    {
+      id: "hyperliquid.undelegate",
+      protocolId: HYPERLIQUID_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Undelegate HYPE from a validator",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        hypeHuman: { type: "string", required: true, description: "HYPE amount" },
+        validator: { type: "string", required: true, description: "Validator address" }
+      }
+    }
+  ]
+};
+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",
@@ -2423,7 +3474,9 @@ var SKILL_PROTOCOL_IDS = [
   "euler-v2",
   "maple-syrup",
   "sky",
-  "gmx"
+  "gmx",
+  "hyperliquid",
+  "morpho"
 ];
 function getToolsForProtocol(protocolId) {
   return MCP_TOOL_DEFINITIONS.filter((t) => t.protocolId === protocolId);
@@ -2637,6 +3690,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];
@@ -2717,6 +3801,8 @@ registerProtocolModule(skyProtocolModule);
 registerProtocolModule(aaveV4ProtocolModule);
 registerProtocolModule(eulerV2ProtocolModule);
 registerProtocolModule(gmxProtocolModule);
+registerProtocolModule(hyperliquidProtocolModule);
+registerProtocolModule(morphoProtocolModule);
 function getAgentCatalog() {
   return {
     protocols: getProtocolModules(),
@@ -2734,6 +3820,8 @@ function getAgentCatalog() {
     aaveV4: aaveV4ProtocolModule,
     eulerV2: eulerV2ProtocolModule,
     gmx: gmxProtocolModule,
+    hyperliquid: hyperliquidProtocolModule,
+    morpho: morphoProtocolModule,
     /** Prefer getAgentCatalogForMcp() or getMcpToolDefinitions() for MCP servers. */
     mcp: getAgentCatalogForMcp()
   };
@@ -2806,6 +3894,40 @@ exports.mcpGmxIncreaseInputSchema = mcpGmxIncreaseInputSchema;
 exports.mcpGmxMultisignOutputSchema = mcpServerSubmitOutputSchema;
 exports.mcpGmxStakeGmxInputSchema = mcpGmxStakeGmxInputSchema;
 exports.mcpGmxUnstakeGmxInputSchema = mcpGmxUnstakeGmxInputSchema;
+exports.mcpHyperliquidCancelInputSchema = mcpHyperliquidCancelInputSchema;
+exports.mcpHyperliquidCloseInputSchema = mcpHyperliquidCloseInputSchema;
+exports.mcpHyperliquidDelegateInputSchema = mcpHyperliquidDelegateInputSchema;
+exports.mcpHyperliquidFetchDelegationsInputSchema = mcpHyperliquidFetchDelegationsInputSchema;
+exports.mcpHyperliquidFetchDelegationsOutputSchema = mcpHyperliquidFetchDelegationsOutputSchema;
+exports.mcpHyperliquidFetchMarketSnapshotInputSchema = mcpHyperliquidFetchMarketSnapshotInputSchema;
+exports.mcpHyperliquidFetchMarketSnapshotOutputSchema = mcpHyperliquidFetchMarketSnapshotOutputSchema;
+exports.mcpHyperliquidFetchMarketsInputSchema = mcpHyperliquidFetchMarketsInputSchema;
+exports.mcpHyperliquidFetchMarketsOutputSchema = mcpHyperliquidFetchMarketsOutputSchema;
+exports.mcpHyperliquidFetchOhlcvInputSchema = mcpHyperliquidFetchOhlcvInputSchema;
+exports.mcpHyperliquidFetchOhlcvOutputSchema = mcpHyperliquidFetchOhlcvOutputSchema;
+exports.mcpHyperliquidFetchOpenContextInputSchema = mcpHyperliquidFetchOpenContextInputSchema;
+exports.mcpHyperliquidFetchOpenContextOutputSchema = mcpHyperliquidFetchOpenContextOutputSchema;
+exports.mcpHyperliquidFetchOpenOrdersInputSchema = mcpHyperliquidFetchOpenOrdersInputSchema;
+exports.mcpHyperliquidFetchOpenOrdersOutputSchema = mcpHyperliquidFetchOpenOrdersOutputSchema;
+exports.mcpHyperliquidFetchPositionsInputSchema = mcpHyperliquidFetchPositionsInputSchema;
+exports.mcpHyperliquidFetchPositionsOutputSchema = mcpHyperliquidFetchPositionsOutputSchema;
+exports.mcpHyperliquidFetchStakingSummaryInputSchema = mcpHyperliquidFetchStakingSummaryInputSchema;
+exports.mcpHyperliquidFetchStakingSummaryOutputSchema = mcpHyperliquidFetchStakingSummaryOutputSchema;
+exports.mcpHyperliquidFetchUsdClassBalancesInputSchema = mcpHyperliquidFetchUsdClassBalancesInputSchema;
+exports.mcpHyperliquidFetchUsdClassBalancesOutputSchema = mcpHyperliquidFetchUsdClassBalancesOutputSchema;
+exports.mcpHyperliquidFetchUserVaultEquitiesInputSchema = mcpHyperliquidFetchUserVaultEquitiesInputSchema;
+exports.mcpHyperliquidFetchUserVaultEquitiesOutputSchema = mcpHyperliquidFetchUserVaultEquitiesOutputSchema;
+exports.mcpHyperliquidFetchVaultsInputSchema = mcpHyperliquidFetchVaultsInputSchema;
+exports.mcpHyperliquidFetchVaultsOutputSchema = mcpHyperliquidFetchVaultsOutputSchema;
+exports.mcpHyperliquidLimitOrderInputSchema = mcpHyperliquidLimitOrderInputSchema;
+exports.mcpHyperliquidSearchMarketsInputSchema = mcpHyperliquidSearchMarketsInputSchema;
+exports.mcpHyperliquidSearchMarketsOutputSchema = mcpHyperliquidSearchMarketsOutputSchema;
+exports.mcpHyperliquidStakeInputSchema = mcpHyperliquidStakeInputSchema;
+exports.mcpHyperliquidUndelegateInputSchema = mcpHyperliquidUndelegateInputSchema;
+exports.mcpHyperliquidUnstakeInputSchema = mcpHyperliquidUnstakeInputSchema;
+exports.mcpHyperliquidUsdTransferInputSchema = mcpHyperliquidUsdTransferInputSchema;
+exports.mcpHyperliquidVaultDepositInputSchema = mcpHyperliquidVaultDepositInputSchema;
+exports.mcpHyperliquidVaultWithdrawInputSchema = mcpHyperliquidVaultWithdrawInputSchema;
 exports.mcpLidoClaimWithdrawalInputSchema = mcpLidoClaimWithdrawalInputSchema;
 exports.mcpLidoRequestWithdrawalsInputSchema = mcpLidoRequestWithdrawalsInputSchema;
 exports.mcpLidoSubmitInputSchema = mcpLidoSubmitInputSchema;
@@ -2813,6 +3935,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;