@continuumdao/ctm-mpc-defi 0.2.8 → 0.2.9

package/dist/agent/catalog.cjs

@@ -1075,6 +1075,241 @@ 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()
+    })
+  ),
+  dexes: zod.z.array(
+    zod.z.object({
+      name: zod.z.string(),
+      fullName: 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()
+});
+var mcpHyperliquidFetchMarketSnapshotOutputSchema = zod.z.object({
+  snapshot: zod.z.object({
+    coin: zod.z.string(),
+    midUsd: zod.z.string().nullable(),
+    fetchedAtMs: zod.z.number(),
+    interval: hyperliquidOhlcvIntervalSchema,
+    candles: zod.z.array(
+      zod.z.object({
+        timestampMs: zod.z.number(),
+        open: zod.z.string(),
+        high: zod.z.string(),
+        low: zod.z.string(),
+        close: zod.z.string(),
+        volume: zod.z.string()
+      })
+    )
+  })
+});
+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) {
@@ -1446,6 +1681,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 +2129,126 @@ 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 (coin, maxLeverage, szDecimals) and HIP-3 dex names. 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_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.",
+    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: "Mid price and OHLCV candles for a Hyperliquid perp coin. Default interval 15m.",
+    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_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
   })
 ];
 var MCP_TOOL_DEFINITIONS = [
@@ -2413,6 +2871,146 @@ 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 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 +3021,8 @@ var SKILL_PROTOCOL_IDS = [
   "euler-v2",
   "maple-syrup",
   "sky",
-  "gmx"
+  "gmx",
+  "hyperliquid"
 ];
 function getToolsForProtocol(protocolId) {
   return MCP_TOOL_DEFINITIONS.filter((t) => t.protocolId === protocolId);
@@ -2717,6 +3316,7 @@ registerProtocolModule(skyProtocolModule);
 registerProtocolModule(aaveV4ProtocolModule);
 registerProtocolModule(eulerV2ProtocolModule);
 registerProtocolModule(gmxProtocolModule);
+registerProtocolModule(hyperliquidProtocolModule);
 function getAgentCatalog() {
   return {
     protocols: getProtocolModules(),
@@ -2734,6 +3334,7 @@ function getAgentCatalog() {
     aaveV4: aaveV4ProtocolModule,
     eulerV2: eulerV2ProtocolModule,
     gmx: gmxProtocolModule,
+    hyperliquid: hyperliquidProtocolModule,
     /** Prefer getAgentCatalogForMcp() or getMcpToolDefinitions() for MCP servers. */
     mcp: getAgentCatalogForMcp()
   };
@@ -2806,6 +3407,36 @@ 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.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.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;