@continuumdao/ctm-mpc-defi 0.2.8 → 0.2.10

package/dist/agent/catalog.js

@@ -924,6 +924,74 @@ var mcpEulerV2CollateralWithdrawInputSchema = mcpMultisignInput({
   collateralAsset: evmAddressSchema,
   amountHuman: z.string().min(1)
 });
+var mcpMorphoVaultDepositInputSchema = mcpMultisignInput({
+  vault: evmAddressSchema,
+  underlying: evmAddressSchema.describe("Underlying asset; use wrapped native with isNativeIn for ETH."),
+  amountHuman: z.string().min(1),
+  isNativeIn: z.boolean().optional()
+});
+var mcpMorphoVaultWithdrawInputSchema = mcpMultisignInput({
+  vault: evmAddressSchema,
+  amountHuman: z.string().min(1)
+});
+var mcpMorphoBlueCollateralDepositInputSchema = mcpMultisignInput({
+  marketId: z.string().min(1).describe("Morpho Blue marketId from API."),
+  collateralToken: evmAddressSchema,
+  amountHuman: z.string().min(1),
+  isNativeIn: z.boolean().optional()
+});
+var mcpMorphoBlueBorrowInputSchema = mcpMultisignInput({
+  marketId: z.string().min(1),
+  loanToken: evmAddressSchema,
+  amountHuman: z.string().min(1)
+});
+var mcpMorphoBlueRepayInputSchema = mcpMultisignInput({
+  marketId: z.string().min(1),
+  loanToken: evmAddressSchema,
+  amountHuman: z.string().min(1)
+});
+var mcpMorphoBlueCollateralWithdrawInputSchema = mcpMultisignInput({
+  marketId: z.string().min(1),
+  amountHuman: z.string().min(1),
+  collateralDecimals: z.number().int().min(0).max(36).optional()
+});
+var mcpMorphoMerklClaimInputSchema = mcpMultisignInput({
+  claimData: z.string().min(1).describe("Hex calldata for Merkl Distributor.claim from Merkl API."),
+  distributor: evmAddressSchema.optional(),
+  valueWei: z.string().optional()
+});
+var morphoExposureRowSchema = z.object({
+  label: z.string(),
+  allocatedUsdLabel: z.string(),
+  allocationPercentLabel: z.string()
+});
+var mcpMorphoFetchEarnVaultsInputSchema = z.object({
+  chainId: z.number().int().positive(),
+  underlying: 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: z.string().trim().min(1).optional().describe("Case-insensitive filter on vault name, symbol, address, or underlying symbol (e.g. Steakhouse, bbqUSDC)."),
+  limit: z.number().int().min(1).max(200).optional().describe("Max rows (default 50).")
+});
+var mcpMorphoFetchEarnVaultsOutputSchema = z.object({
+  vaults: z.array(
+    z.object({
+      vaultAddress: z.string(),
+      vaultName: z.string(),
+      vaultSymbol: z.string(),
+      underlyingAddress: z.string(),
+      underlyingSymbol: z.string(),
+      apy: z.string(),
+      netApy: z.string(),
+      netApy7d: z.string(),
+      netApy30d: z.string(),
+      netApy90d: z.string(),
+      performanceFee: z.string(),
+      managementFee: z.string().nullable(),
+      totalDepositsUsd: z.string(),
+      liquidityUsd: z.string(),
+      exposure: z.array(morphoExposureRowSchema)
+    })
+  )
+});
 function mcpGmxMultisignInput(fields) {
   return evmMultisignCommonInputSchema.extend(fields);
 }
@@ -1072,6 +1140,311 @@ var mcpGmxFetchOhlcvOutputSchema = z.object({
   timeframe: gmxOhlcvTimeframeSchema,
   candles: z.array(gmxOhlcvCandleSchema)
 });
+function mcpHyperliquidMultisignInput(fields) {
+  return evmMultisignCommonInputSchema.extend(fields);
+}
+var hyperliquidTifSchema = z.enum(["alo", "gtc", "ioc"]);
+var hyperliquidOhlcvIntervalSchema = z.enum([
+  "1m",
+  "3m",
+  "5m",
+  "15m",
+  "30m",
+  "1h",
+  "2h",
+  "4h",
+  "8h",
+  "12h",
+  "1d",
+  "3d",
+  "1w",
+  "1M"
+]);
+var hyperliquidPositionRowSchema = z.object({
+  key: z.string(),
+  coin: z.string(),
+  isLong: z.boolean(),
+  size: z.string().nullable(),
+  entryPx: z.string().nullable(),
+  positionValueUsd: z.string().nullable(),
+  unrealizedPnlUsd: z.string().nullable(),
+  liquidationPx: z.string().nullable(),
+  leverageLabel: z.string().nullable(),
+  maxLeverage: z.number().nullable(),
+  marginUsedUsd: z.string().nullable(),
+  returnOnEquity: z.string().nullable()
+});
+var hyperliquidActiveAssetSchema = z.object({
+  markPx: z.string().nullable(),
+  leverageLabel: z.string().nullable(),
+  availableToBuy: z.string().nullable(),
+  availableToSell: z.string().nullable()
+});
+var hyperliquidAccountSummarySchema = z.object({
+  accountValueUsd: z.string().nullable(),
+  totalMarginUsedUsd: z.string().nullable(),
+  withdrawableUsd: z.string().nullable()
+});
+var mcpHyperliquidFetchMarketsInputSchema = z.object({
+  chainId: z.number().int().positive(),
+  dex: z.string().optional()
+});
+var mcpHyperliquidFetchMarketsOutputSchema = z.object({
+  markets: z.array(
+    z.object({
+      name: z.string(),
+      asset: z.number(),
+      szDecimals: z.number(),
+      maxLeverage: z.number(),
+      onlyIsolated: z.boolean().optional(),
+      dex: z.string().optional()
+    })
+  ),
+  dexes: z.array(
+    z.object({
+      name: z.string(),
+      fullName: z.string()
+    })
+  )
+});
+var mcpHyperliquidSearchMarketsInputSchema = z.object({
+  chainId: z.number().int().positive(),
+  query: z.string().min(1),
+  dex: z.string().optional(),
+  limit: z.number().int().positive().max(50).optional()
+});
+var mcpHyperliquidSearchMarketsOutputSchema = z.object({
+  matches: z.array(
+    z.object({
+      coin: z.string(),
+      symbol: z.string(),
+      dex: z.string().optional(),
+      asset: z.number(),
+      szDecimals: z.number(),
+      maxLeverage: z.number(),
+      onlyIsolated: z.boolean().optional(),
+      displayName: z.string().optional(),
+      category: z.string().optional(),
+      keywords: z.array(z.string()).optional(),
+      matchScore: z.number(),
+      matchReason: z.string()
+    })
+  )
+});
+var mcpHyperliquidFetchOpenContextInputSchema = z.object({
+  chainId: z.number().int().positive(),
+  executorAddress: evmAddressSchema,
+  coin: z.string().min(1),
+  dex: z.string().optional()
+});
+var mcpHyperliquidFetchOpenContextOutputSchema = z.object({
+  context: z.object({
+    account: hyperliquidAccountSummarySchema,
+    activeAsset: hyperliquidActiveAssetSchema
+  })
+});
+var mcpHyperliquidFetchPositionsInputSchema = z.object({
+  chainId: z.number().int().positive(),
+  executorAddress: evmAddressSchema,
+  dex: z.string().optional()
+});
+var mcpHyperliquidFetchPositionsOutputSchema = z.object({
+  positions: z.array(hyperliquidPositionRowSchema)
+});
+var mcpHyperliquidFetchOpenOrdersInputSchema = z.object({
+  chainId: z.number().int().positive(),
+  executorAddress: evmAddressSchema,
+  dex: z.string().optional()
+});
+var mcpHyperliquidFetchOpenOrdersOutputSchema = z.object({
+  orders: z.array(
+    z.object({
+      coin: z.string(),
+      side: z.string(),
+      limitPx: z.string(),
+      sz: z.string(),
+      oid: z.number(),
+      timestamp: z.number(),
+      reduceOnly: z.boolean().optional()
+    })
+  )
+});
+var mcpHyperliquidFetchMarketSnapshotInputSchema = z.object({
+  chainId: z.number().int().positive(),
+  coin: z.string().min(1),
+  interval: hyperliquidOhlcvIntervalSchema.optional(),
+  dex: z.string().optional(),
+  /** Recent OHLCV bars to return (default 48, max 200). Live price is always current. */
+  candleLimit: z.number().int().positive().max(200).optional()
+});
+var hyperliquidOhlcvCandleSchema = z.object({
+  timestampMs: z.number(),
+  open: z.string(),
+  high: z.string(),
+  low: z.string(),
+  close: z.string(),
+  volume: z.string()
+});
+var hyperliquidLivePriceSchema = z.object({
+  markPx: z.string().nullable(),
+  midPx: z.string().nullable(),
+  oraclePx: z.string().nullable(),
+  prevDayPx: z.string().nullable(),
+  midUsd: z.string(),
+  source: z.enum(["midPx", "markPx", "allMids"])
+});
+var mcpHyperliquidFetchMarketSnapshotOutputSchema = z.object({
+  snapshot: z.object({
+    coin: z.string(),
+    dex: z.string().nullable(),
+    livePrice: hyperliquidLivePriceSchema,
+    midUsd: z.string(),
+    fetchedAtMs: z.number(),
+    interval: hyperliquidOhlcvIntervalSchema,
+    latestCandle: hyperliquidOhlcvCandleSchema.nullable(),
+    candles: z.array(hyperliquidOhlcvCandleSchema),
+    candleCount: z.number()
+  }),
+  resolvedCoin: z.string(),
+  dex: z.string().nullable()
+});
+var mcpHyperliquidFetchOhlcvInputSchema = z.object({
+  chainId: z.number().int().positive(),
+  coin: z.string().min(1),
+  interval: hyperliquidOhlcvIntervalSchema.optional(),
+  dex: z.string().optional(),
+  /** Calendar-day lookback ending now (e.g. 7 = last week). Preferred for agent requests. */
+  lookbackDays: z.number().positive().max(90).optional(),
+  /** Hour lookback ending now. Alternative to lookbackDays. */
+  lookbackHours: z.number().positive().max(90 * 24).optional(),
+  /** Explicit range start (ms since epoch). Use with endTimeMs. */
+  startTimeMs: z.number().int().positive().optional(),
+  /** Explicit range end (ms since epoch). Defaults to now. */
+  endTimeMs: z.number().int().positive().optional()
+});
+var mcpHyperliquidFetchOhlcvOutputSchema = z.object({
+  ohlcv: z.object({
+    coin: z.string(),
+    dex: z.string().nullable(),
+    interval: hyperliquidOhlcvIntervalSchema,
+    startTimeMs: z.number(),
+    endTimeMs: z.number(),
+    expectedBars: z.number(),
+    candleCount: z.number(),
+    latestCandle: hyperliquidOhlcvCandleSchema.nullable(),
+    candles: z.array(hyperliquidOhlcvCandleSchema),
+    fetchedAtMs: z.number()
+  }),
+  resolvedCoin: z.string(),
+  dex: z.string().nullable()
+});
+var mcpHyperliquidFetchUsdClassBalancesInputSchema = z.object({
+  chainId: z.number().int().positive(),
+  executorAddress: evmAddressSchema
+});
+var mcpHyperliquidFetchUsdClassBalancesOutputSchema = z.object({
+  balances: z.object({
+    spotUsdcAvailable: z.string(),
+    perpWithdrawable: z.string()
+  })
+});
+var mcpHyperliquidFetchVaultsInputSchema = z.object({
+  chainId: z.number().int().positive(),
+  executorAddress: evmAddressSchema.optional()
+});
+var mcpHyperliquidFetchVaultsOutputSchema = z.object({
+  vaults: z.array(
+    z.object({
+      vaultAddress: z.string(),
+      name: z.string(),
+      apr: z.number().nullable(),
+      tvlUsd: z.string().nullable()
+    })
+  )
+});
+var mcpHyperliquidFetchUserVaultEquitiesInputSchema = z.object({
+  chainId: z.number().int().positive(),
+  executorAddress: evmAddressSchema
+});
+var mcpHyperliquidFetchUserVaultEquitiesOutputSchema = z.object({
+  rows: z.array(
+    z.object({
+      vaultAddress: z.string(),
+      equity: z.string()
+    })
+  )
+});
+var mcpHyperliquidFetchStakingSummaryInputSchema = z.object({
+  chainId: z.number().int().positive(),
+  executorAddress: evmAddressSchema
+});
+var mcpHyperliquidFetchStakingSummaryOutputSchema = z.object({
+  summary: z.object({
+    delegated: z.string(),
+    undelegated: z.string()
+  })
+});
+var mcpHyperliquidFetchDelegationsInputSchema = z.object({
+  chainId: z.number().int().positive(),
+  executorAddress: evmAddressSchema
+});
+var mcpHyperliquidFetchDelegationsOutputSchema = z.object({
+  delegations: z.array(
+    z.object({
+      validator: z.string(),
+      amount: z.string()
+    })
+  )
+});
+var mcpHyperliquidLimitOrderInputSchema = mcpHyperliquidMultisignInput({
+  coin: z.string().min(1),
+  isBuy: z.boolean(),
+  limitPxHuman: z.string().min(1),
+  szHuman: z.string().min(1),
+  marketKind: z.enum(["perp", "spot"]).optional(),
+  tif: hyperliquidTifSchema.optional(),
+  dex: z.string().optional()
+});
+var mcpHyperliquidCloseInputSchema = mcpHyperliquidMultisignInput({
+  coin: z.string().min(1),
+  isLong: z.boolean(),
+  limitPxHuman: z.string().min(1),
+  szHuman: z.string().min(1),
+  dex: z.string().optional(),
+  tif: hyperliquidTifSchema.optional()
+});
+var mcpHyperliquidCancelInputSchema = mcpHyperliquidMultisignInput({
+  coin: z.string().min(1),
+  oid: z.number().int().positive(),
+  marketKind: z.enum(["perp", "spot"]).optional(),
+  dex: z.string().optional()
+});
+var mcpHyperliquidUsdTransferInputSchema = mcpHyperliquidMultisignInput({
+  usdHuman: z.string().min(1),
+  toPerp: z.boolean()
+});
+var mcpHyperliquidVaultDepositInputSchema = mcpHyperliquidMultisignInput({
+  vaultAddress: evmAddressSchema,
+  usdHuman: z.string().min(1)
+});
+var mcpHyperliquidVaultWithdrawInputSchema = mcpHyperliquidMultisignInput({
+  vaultAddress: evmAddressSchema,
+  usdHuman: z.string().min(1)
+});
+var mcpHyperliquidStakeInputSchema = mcpHyperliquidMultisignInput({
+  hypeHuman: z.string().min(1)
+});
+var mcpHyperliquidUnstakeInputSchema = mcpHyperliquidMultisignInput({
+  hypeHuman: z.string().min(1)
+});
+var mcpHyperliquidDelegateInputSchema = mcpHyperliquidMultisignInput({
+  hypeHuman: z.string().min(1),
+  validator: evmAddressSchema
+});
+var mcpHyperliquidUndelegateInputSchema = mcpHyperliquidMultisignInput({
+  hypeHuman: z.string().min(1),
+  validator: evmAddressSchema
+});
 
 // src/agent/mcpProtocolTools.ts
 function defineProtocolMcpTool(def) {
@@ -1374,6 +1747,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",
@@ -1443,6 +1897,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
   })
 ];
 
@@ -1788,6 +2345,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 = [
@@ -2014,7 +2730,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" },
@@ -2077,7 +2816,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);
@@ -2410,6 +3152,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 (isAddress(a)) out.add(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 (!isAddress(a)) continue;
+    const k = 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 (isAddress(loanAddr)) {
+      const k = getAddress(loanAddr).toLowerCase();
+      const prev = modes.get(k) ?? { earn: false, borrow: false, collateral: false };
+      prev.borrow = true;
+      modes.set(k, prev);
+    }
+    if (isAddress(colAddr)) {
+      const k = 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 = join(dirname(fileURLToPath(import.meta.url)), "skills");
 var SKILL_PROTOCOL_IDS = [
   "aave-v4",
@@ -2420,7 +3471,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);
@@ -2634,6 +3687,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 = 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];
@@ -2714,6 +3798,8 @@ registerProtocolModule(skyProtocolModule);
 registerProtocolModule(aaveV4ProtocolModule);
 registerProtocolModule(eulerV2ProtocolModule);
 registerProtocolModule(gmxProtocolModule);
+registerProtocolModule(hyperliquidProtocolModule);
+registerProtocolModule(morphoProtocolModule);
 function getAgentCatalog() {
   return {
     protocols: getProtocolModules(),
@@ -2731,11 +3817,13 @@ function getAgentCatalog() {
     aaveV4: aaveV4ProtocolModule,
     eulerV2: eulerV2ProtocolModule,
     gmx: gmxProtocolModule,
+    hyperliquid: hyperliquidProtocolModule,
+    morpho: morphoProtocolModule,
     /** Prefer getAgentCatalogForMcp() or getMcpToolDefinitions() for MCP servers. */
     mcp: getAgentCatalogForMcp()
   };
 }
 
-export { EVM_COMMON_PARAM_DOCS, MANAGEMENT_SIG_DOC, MCP_NON_SUBMIT_TOOL_NAMES, MCP_TOOL_DEFINITIONS, MCP_TOOL_INPUT_SCHEMAS, MCP_TOOL_OUTPUT_SCHEMAS, MULTISIGN_OUTPUT_DOC, MULTISIGN_SUBMIT_OUTPUT_DOC, PROTOCOL_SUPPORT_ADVISORS, chainDetailSchema, evmAddressSchema, evmMultisignCommonInputSchema, getActionsByChainCategory, getAgentCatalog, getAgentCatalogForMcp, getMcpToolByName, getMcpToolDefinitions, getMcpToolInputSchema, getMcpToolOutputSchema, getProtocolDiscoverySummary, getProtocolModules, getProtocolSkill, getProtocolSupportAdvisor, getToolsForProtocol, jsonObjectSchema, keyGenSchema, listProtocolSupportAdvisorIds, listProtocolsWithSkills, mcpAaveV4BorrowInputSchema, mcpAaveV4DepositInputSchema, mcpAaveV4RepayInputSchema, mcpAaveV4WithdrawInputSchema, mcpCurveDaoBuildSwapMultisignInputSchema, mcpCurveDaoQuoteInputSchema, mcpCurveDaoQuoteOutputSchema, mcpEthenaClaimInputSchema, mcpEthenaCooldownInputSchema, mcpEthenaRedeemInputSchema, mcpEthenaStakeInputSchema, mcpEulerV2BorrowRepayInputSchema, mcpEulerV2CollateralDepositInputSchema, mcpEulerV2CollateralWithdrawInputSchema, mcpEulerV2IsolatedBorrowInputSchema, mcpEulerV2IsolatedLendInputSchema, mcpEulerV2VaultWithdrawInputSchema, mcpGmxCancelInputSchema, mcpGmxDecreaseInputSchema, mcpGmxFetchGmApyInputSchema, mcpGmxFetchGmApyOutputSchema, mcpGmxFetchGmMarketsInputSchema, mcpGmxFetchGmMarketsOutputSchema, mcpGmxFetchMarketPricesInputSchema, mcpGmxFetchMarketPricesOutputSchema, mcpGmxFetchMarketsInputSchema, mcpGmxFetchMarketsOutputSchema, mcpGmxFetchOhlcvInputSchema, mcpGmxFetchOhlcvOutputSchema, mcpGmxFetchPositionsInputSchema, mcpGmxFetchPositionsOutputSchema, mcpGmxFetchStakingPowerInputSchema, mcpGmxFetchStakingPowerOutputSchema, mcpGmxGmDepositInputSchema, mcpGmxGmWithdrawInputSchema, mcpGmxIncreaseInputSchema, mcpServerSubmitOutputSchema as mcpGmxMultisignOutputSchema, mcpGmxStakeGmxInputSchema, mcpGmxUnstakeGmxInputSchema, mcpLidoClaimWithdrawalInputSchema, mcpLidoRequestWithdrawalsInputSchema, mcpLidoSubmitInputSchema, mcpLidoUnwrapWstEthInputSchema, mcpLidoWrapStEthInputSchema, mcpMapleDepositInputSchema, mcpMapleRequestRedeemInputSchema, mcpMultisignInput, multisignOutputSchema as mcpMultisignOutputSchema, mcpServerSubmitOutputSchema as mcpMultisignSubmitOutputSchema, mcpServerCommonInputSchema, mcpServerMultisignInput, mcpServerSubmitOutputSchema, mcpSkyLockstakeCloseInputSchema, mcpSkyLockstakeDrawInputSchema, mcpSkyLockstakeGetRewardInputSchema, mcpSkyLockstakeStakeInputSchema, mcpSkyLockstakeWipeInputSchema, mcpSkySusdsDepositInputSchema, mcpSkySusdsRedeemInputSchema, mcpUniswapV4BuildCollectFeesMultisignInputSchema, mcpUniswapV4BuildDecreaseLiquidityMultisignInputSchema, mcpUniswapV4BuildIncreaseLiquidityMultisignInputSchema, mcpUniswapV4BuildMintLiquidityMultisignInputSchema, mcpUniswapV4BuildSwapMultisignInputSchema, mcpUniswapV4CreateSwapInputSchema, mcpUniswapV4CreateSwapOutputSchema, mcpUniswapV4LpClaimInputSchema, mcpUniswapV4LpClaimOutputSchema, mcpUniswapV4LpCreatePositionInputSchema, mcpUniswapV4LpCreatePositionOutputSchema, mcpUniswapV4LpDecreaseInputSchema, mcpUniswapV4LpDecreaseOutputSchema, mcpUniswapV4LpIncreaseInputSchema, mcpUniswapV4LpIncreaseOutputSchema, mcpUniswapV4LpListPoolsInputSchema, mcpUniswapV4LpListPoolsOutputSchema, mcpUniswapV4LpListPositionsInputSchema, mcpUniswapV4LpListPositionsOutputSchema, mcpUniswapV4QuoteInputSchema, mcpUniswapV4QuoteOutputSchema, mcpUniswapV4RegisterPositionFromMintTxInputSchema, mcpUniswapV4RegisterPositionFromMintTxOutputSchema, mcpUniswapV4RegisterPositionNftInputSchema, mcpUniswapV4RegisterPositionNftOutputSchema, multisignOutputSchema, parseMcpToolInput, parseMcpToolOutput, parseMultisignBuilderOutput, uniswapQuoteTradeTypeSchema, zodSchemaToMcpJsonSchema };
+export { EVM_COMMON_PARAM_DOCS, MANAGEMENT_SIG_DOC, MCP_NON_SUBMIT_TOOL_NAMES, MCP_TOOL_DEFINITIONS, MCP_TOOL_INPUT_SCHEMAS, MCP_TOOL_OUTPUT_SCHEMAS, MULTISIGN_OUTPUT_DOC, MULTISIGN_SUBMIT_OUTPUT_DOC, PROTOCOL_SUPPORT_ADVISORS, chainDetailSchema, evmAddressSchema, evmMultisignCommonInputSchema, getActionsByChainCategory, getAgentCatalog, getAgentCatalogForMcp, getMcpToolByName, getMcpToolDefinitions, getMcpToolInputSchema, getMcpToolOutputSchema, getProtocolDiscoverySummary, getProtocolModules, getProtocolSkill, getProtocolSupportAdvisor, getToolsForProtocol, jsonObjectSchema, keyGenSchema, listProtocolSupportAdvisorIds, listProtocolsWithSkills, mcpAaveV4BorrowInputSchema, mcpAaveV4DepositInputSchema, mcpAaveV4RepayInputSchema, mcpAaveV4WithdrawInputSchema, mcpCurveDaoBuildSwapMultisignInputSchema, mcpCurveDaoQuoteInputSchema, mcpCurveDaoQuoteOutputSchema, mcpEthenaClaimInputSchema, mcpEthenaCooldownInputSchema, mcpEthenaRedeemInputSchema, mcpEthenaStakeInputSchema, mcpEulerV2BorrowRepayInputSchema, mcpEulerV2CollateralDepositInputSchema, mcpEulerV2CollateralWithdrawInputSchema, mcpEulerV2IsolatedBorrowInputSchema, mcpEulerV2IsolatedLendInputSchema, mcpEulerV2VaultWithdrawInputSchema, mcpGmxCancelInputSchema, mcpGmxDecreaseInputSchema, mcpGmxFetchGmApyInputSchema, mcpGmxFetchGmApyOutputSchema, mcpGmxFetchGmMarketsInputSchema, mcpGmxFetchGmMarketsOutputSchema, mcpGmxFetchMarketPricesInputSchema, mcpGmxFetchMarketPricesOutputSchema, mcpGmxFetchMarketsInputSchema, mcpGmxFetchMarketsOutputSchema, mcpGmxFetchOhlcvInputSchema, mcpGmxFetchOhlcvOutputSchema, mcpGmxFetchPositionsInputSchema, mcpGmxFetchPositionsOutputSchema, mcpGmxFetchStakingPowerInputSchema, mcpGmxFetchStakingPowerOutputSchema, mcpGmxGmDepositInputSchema, mcpGmxGmWithdrawInputSchema, mcpGmxIncreaseInputSchema, mcpServerSubmitOutputSchema as mcpGmxMultisignOutputSchema, mcpGmxStakeGmxInputSchema, mcpGmxUnstakeGmxInputSchema, mcpHyperliquidCancelInputSchema, mcpHyperliquidCloseInputSchema, mcpHyperliquidDelegateInputSchema, mcpHyperliquidFetchDelegationsInputSchema, mcpHyperliquidFetchDelegationsOutputSchema, mcpHyperliquidFetchMarketSnapshotInputSchema, mcpHyperliquidFetchMarketSnapshotOutputSchema, mcpHyperliquidFetchMarketsInputSchema, mcpHyperliquidFetchMarketsOutputSchema, mcpHyperliquidFetchOhlcvInputSchema, mcpHyperliquidFetchOhlcvOutputSchema, mcpHyperliquidFetchOpenContextInputSchema, mcpHyperliquidFetchOpenContextOutputSchema, mcpHyperliquidFetchOpenOrdersInputSchema, mcpHyperliquidFetchOpenOrdersOutputSchema, mcpHyperliquidFetchPositionsInputSchema, mcpHyperliquidFetchPositionsOutputSchema, mcpHyperliquidFetchStakingSummaryInputSchema, mcpHyperliquidFetchStakingSummaryOutputSchema, mcpHyperliquidFetchUsdClassBalancesInputSchema, mcpHyperliquidFetchUsdClassBalancesOutputSchema, mcpHyperliquidFetchUserVaultEquitiesInputSchema, mcpHyperliquidFetchUserVaultEquitiesOutputSchema, mcpHyperliquidFetchVaultsInputSchema, mcpHyperliquidFetchVaultsOutputSchema, mcpHyperliquidLimitOrderInputSchema, mcpHyperliquidSearchMarketsInputSchema, mcpHyperliquidSearchMarketsOutputSchema, mcpHyperliquidStakeInputSchema, mcpHyperliquidUndelegateInputSchema, mcpHyperliquidUnstakeInputSchema, mcpHyperliquidUsdTransferInputSchema, mcpHyperliquidVaultDepositInputSchema, mcpHyperliquidVaultWithdrawInputSchema, mcpLidoClaimWithdrawalInputSchema, mcpLidoRequestWithdrawalsInputSchema, mcpLidoSubmitInputSchema, mcpLidoUnwrapWstEthInputSchema, mcpLidoWrapStEthInputSchema, mcpMapleDepositInputSchema, mcpMapleRequestRedeemInputSchema, mcpMorphoBlueBorrowInputSchema, mcpMorphoBlueCollateralDepositInputSchema, mcpMorphoBlueCollateralWithdrawInputSchema, mcpMorphoBlueRepayInputSchema, mcpMorphoFetchEarnVaultsInputSchema, mcpMorphoFetchEarnVaultsOutputSchema, mcpMorphoMerklClaimInputSchema, mcpMorphoVaultDepositInputSchema, mcpMorphoVaultWithdrawInputSchema, mcpMultisignInput, multisignOutputSchema as mcpMultisignOutputSchema, mcpServerSubmitOutputSchema as mcpMultisignSubmitOutputSchema, mcpServerCommonInputSchema, mcpServerMultisignInput, mcpServerSubmitOutputSchema, mcpSkyLockstakeCloseInputSchema, mcpSkyLockstakeDrawInputSchema, mcpSkyLockstakeGetRewardInputSchema, mcpSkyLockstakeStakeInputSchema, mcpSkyLockstakeWipeInputSchema, mcpSkySusdsDepositInputSchema, mcpSkySusdsRedeemInputSchema, mcpUniswapV4BuildCollectFeesMultisignInputSchema, mcpUniswapV4BuildDecreaseLiquidityMultisignInputSchema, mcpUniswapV4BuildIncreaseLiquidityMultisignInputSchema, mcpUniswapV4BuildMintLiquidityMultisignInputSchema, mcpUniswapV4BuildSwapMultisignInputSchema, mcpUniswapV4CreateSwapInputSchema, mcpUniswapV4CreateSwapOutputSchema, mcpUniswapV4LpClaimInputSchema, mcpUniswapV4LpClaimOutputSchema, mcpUniswapV4LpCreatePositionInputSchema, mcpUniswapV4LpCreatePositionOutputSchema, mcpUniswapV4LpDecreaseInputSchema, mcpUniswapV4LpDecreaseOutputSchema, mcpUniswapV4LpIncreaseInputSchema, mcpUniswapV4LpIncreaseOutputSchema, mcpUniswapV4LpListPoolsInputSchema, mcpUniswapV4LpListPoolsOutputSchema, mcpUniswapV4LpListPositionsInputSchema, mcpUniswapV4LpListPositionsOutputSchema, mcpUniswapV4QuoteInputSchema, mcpUniswapV4QuoteOutputSchema, mcpUniswapV4RegisterPositionFromMintTxInputSchema, mcpUniswapV4RegisterPositionFromMintTxOutputSchema, mcpUniswapV4RegisterPositionNftInputSchema, mcpUniswapV4RegisterPositionNftOutputSchema, multisignOutputSchema, parseMcpToolInput, parseMcpToolOutput, parseMultisignBuilderOutput, uniswapQuoteTradeTypeSchema, zodSchemaToMcpJsonSchema };
 //# sourceMappingURL=catalog.js.map
 //# sourceMappingURL=catalog.js.map