@continuumdao/ctm-mpc-defi 0.2.8 → 0.2.10

package/dist/protocols/evm/hyperliquid/index.js

@@ -0,0 +1,1464 @@
+import { parseAbi, encodeAbiParameters, getAddress, encodeFunctionData, defineChain, createPublicClient, http, parseGwei, serializeTransaction, keccak256 } from 'viem';
+import { fetchChainFeeParams, gasLimitFromEstimateAndChainConfig, gweiToDecimalString, proposalTxParamsToFeeSnapshot, alignEip1559FeesWithLatestBase, getClientIdFromKeyGenResult } from '@continuumdao/continuum-node-sdk';
+
+// src/core/registry.ts
+var modules = [];
+function registerProtocolModule(mod) {
+  const existing = modules.findIndex((m) => m.id === mod.id);
+  if (existing >= 0) {
+    modules[existing] = mod;
+  } else {
+    modules.push(mod);
+  }
+}
+
+// src/protocols/evm/hyperliquid/support.ts
+var HYPERLIQUID_SUPPORTED_CHAIN_IDS = [999, 998];
+function isHyperliquidChainSupported(chainId) {
+  return HYPERLIQUID_SUPPORTED_CHAIN_IDS.includes(chainId);
+}
+function hyperliquidApiBaseUrl(chainId) {
+  return chainId === 998 ? "https://api.hyperliquid-testnet.xyz" : "https://api.hyperliquid.xyz";
+}
+function hyperliquidVaultStatsUrl(chainId) {
+  return chainId === 998 ? null : "https://stats-data.hyperliquid.xyz/Mainnet/vaults";
+}
+var HYPERLIQUID_HLP_VAULT_ADDRESS = "0xdfc24b077bc1425ad1dea75bcb6f8158e10df303";
+function hyperliquidInferDexFromCoin(coin) {
+  const trimmed = coin.trim();
+  const sep = trimmed.indexOf(":");
+  if (sep <= 0) return void 0;
+  return trimmed.slice(0, sep);
+}
+
+// src/protocols/evm/hyperliquid/constants.ts
+var HYPERLIQUID_CORE_WRITER_ADDRESS = "0x3333333333333333333333333333333333333333";
+var HYPERLIQUID_SPOT_ASSET_OFFSET = 1e4;
+var HYPERLIQUID_CORE_WRITER_GAS_FALLBACK = 120000n;
+var HYPERLIQUID_TIF = {
+  alo: 1,
+  gtc: 2,
+  ioc: 3
+};
+var HYPERLIQUID_INTERVAL_MS = {
+  "1m": 6e4,
+  "3m": 18e4,
+  "5m": 3e5,
+  "15m": 9e5,
+  "30m": 18e5,
+  "1h": 36e5,
+  "2h": 72e5,
+  "4h": 144e5,
+  "8h": 288e5,
+  "12h": 432e5,
+  "1d": 864e5,
+  "3d": 2592e5,
+  "1w": 6048e5,
+  "1M": 2592e6
+};
+var HYPERLIQUID_DEFAULT_OHLCV_INTERVAL = "15m";
+var HYPERLIQUID_DEFAULT_CANDLE_LIMIT = 48;
+var HYPERLIQUID_MAX_CANDLE_LIMIT = 200;
+var HYPERLIQUID_MAX_OHLCV_BARS = 2e3;
+var HYPERLIQUID_DEFAULT_LOOKBACK_DAYS = 1;
+var HYPERLIQUID_MAX_LOOKBACK_DAYS = 90;
+
+// src/protocols/evm/hyperliquid/api.ts
+async function hyperliquidInfoPost(chainId, body) {
+  const base = hyperliquidApiBaseUrl(chainId);
+  const res = await fetch(`${base}/info`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    cache: "no-store"
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Hyperliquid info API failed (${res.status}): ${text.slice(0, 200)}`);
+  }
+  return await res.json();
+}
+async function hyperliquidFetchPerpMeta(args) {
+  const req = { type: "meta" };
+  if (args.dex?.trim()) req.dex = args.dex.trim();
+  const meta = await hyperliquidInfoPost(args.chainId, req);
+  const markets = (meta.universe ?? []).map((u, i) => ({
+    name: u.name,
+    asset: i,
+    szDecimals: u.szDecimals,
+    maxLeverage: u.maxLeverage,
+    onlyIsolated: u.onlyIsolated
+  }));
+  return { markets };
+}
+async function hyperliquidFetchSpotMeta(args) {
+  const meta = await hyperliquidInfoPost(args.chainId, { type: "spotMeta" });
+  const tokenByIndex = new Map((meta.tokens ?? []).map((t) => [t.index, t]));
+  const markets = (meta.universe ?? []).map((u, i) => {
+    const baseTokenIdx = u.tokens[0];
+    const token = baseTokenIdx != null ? tokenByIndex.get(baseTokenIdx) : void 0;
+    return {
+      name: u.name,
+      asset: 1e4 + i,
+      tokenIndex: i,
+      szDecimals: token?.szDecimals ?? 8
+    };
+  });
+  return { markets };
+}
+async function hyperliquidFetchAllMids(args) {
+  const req = { type: "allMids" };
+  if (args.dex?.trim()) req.dex = args.dex.trim();
+  const mids = await hyperliquidInfoPost(args.chainId, req);
+  return { mids };
+}
+function hyperliquidMapCandles(raw) {
+  return (raw ?? []).map((c) => ({
+    timestampMs: c.t,
+    open: c.o,
+    high: c.h,
+    low: c.l,
+    close: c.c,
+    volume: c.v
+  }));
+}
+async function hyperliquidFetchCandlesRaw(args) {
+  const raw = await hyperliquidInfoPost(args.chainId, {
+    type: "candleSnapshot",
+    req: {
+      coin: args.coin,
+      interval: args.interval,
+      startTime: args.startTimeMs,
+      endTime: args.endTimeMs
+    }
+  });
+  return hyperliquidMapCandles(raw);
+}
+function hyperliquidResolveOhlcvWindow(args) {
+  const endTimeMs = args.endTimeMs ?? Date.now();
+  const intervalMs = HYPERLIQUID_INTERVAL_MS[args.interval] ?? HYPERLIQUID_INTERVAL_MS["15m"];
+  let startTimeMs;
+  if (args.startTimeMs != null) {
+    startTimeMs = args.startTimeMs;
+  } else if (args.lookbackDays != null) {
+    if (args.lookbackDays <= 0 || args.lookbackDays > HYPERLIQUID_MAX_LOOKBACK_DAYS) {
+      throw new Error(`lookbackDays must be between 1 and ${HYPERLIQUID_MAX_LOOKBACK_DAYS}`);
+    }
+    startTimeMs = endTimeMs - args.lookbackDays * 864e5;
+  } else if (args.lookbackHours != null) {
+    if (args.lookbackHours <= 0 || args.lookbackHours > HYPERLIQUID_MAX_LOOKBACK_DAYS * 24) {
+      throw new Error(`lookbackHours must be between 1 and ${HYPERLIQUID_MAX_LOOKBACK_DAYS * 24}`);
+    }
+    startTimeMs = endTimeMs - args.lookbackHours * 36e5;
+  } else {
+    startTimeMs = endTimeMs - HYPERLIQUID_DEFAULT_LOOKBACK_DAYS * 864e5;
+  }
+  if (!Number.isFinite(startTimeMs) || !Number.isFinite(endTimeMs) || startTimeMs >= endTimeMs) {
+    throw new Error("Invalid OHLCV time range: startTimeMs must be before endTimeMs");
+  }
+  const expectedBars = Math.ceil((endTimeMs - startTimeMs) / intervalMs);
+  if (expectedBars > HYPERLIQUID_MAX_OHLCV_BARS) {
+    throw new Error(
+      `OHLCV range needs ~${expectedBars} bars at ${args.interval} (max ${HYPERLIQUID_MAX_OHLCV_BARS}). Use a coarser interval or shorter lookback.`
+    );
+  }
+  return { startTimeMs, endTimeMs, expectedBars };
+}
+async function hyperliquidFetchCandles(args) {
+  const endTime = args.endTimeMs ?? Date.now();
+  const intervalMs = HYPERLIQUID_INTERVAL_MS[args.interval] ?? HYPERLIQUID_INTERVAL_MS["15m"];
+  const limit = Math.min(Math.max(args.limit ?? HYPERLIQUID_DEFAULT_CANDLE_LIMIT, 1), HYPERLIQUID_MAX_CANDLE_LIMIT);
+  const startTime = args.startTimeMs ?? endTime - intervalMs * (limit + 4);
+  const candles = await hyperliquidFetchCandlesRaw({
+    chainId: args.chainId,
+    coin: args.coin,
+    interval: args.interval,
+    startTimeMs: startTime,
+    endTimeMs: endTime
+  });
+  return { candles: candles.slice(-limit) };
+}
+async function hyperliquidFetchOhlcvRange(args) {
+  const coin = args.coin.trim();
+  const interval = args.interval ?? HYPERLIQUID_DEFAULT_OHLCV_INTERVAL;
+  const dex = args.dex?.trim() || hyperliquidInferDexFromCoin(coin) || null;
+  const { startTimeMs, endTimeMs, expectedBars } = hyperliquidResolveOhlcvWindow({
+    interval,
+    lookbackDays: args.lookbackDays,
+    lookbackHours: args.lookbackHours,
+    startTimeMs: args.startTimeMs,
+    endTimeMs: args.endTimeMs
+  });
+  const candles = await hyperliquidFetchCandlesRaw({
+    chainId: args.chainId,
+    coin,
+    interval,
+    startTimeMs,
+    endTimeMs
+  });
+  if (candles.length === 0) {
+    throw new Error(
+      `No OHLCV data for ${coin} between ${startTimeMs} and ${endTimeMs} at ${interval}. Check coin/dex.`
+    );
+  }
+  const latestCandle = candles.length > 0 ? candles[candles.length - 1] : null;
+  return {
+    coin,
+    dex,
+    interval,
+    startTimeMs,
+    endTimeMs,
+    expectedBars,
+    candleCount: candles.length,
+    latestCandle,
+    candles,
+    fetchedAtMs: Date.now()
+  };
+}
+async function hyperliquidFetchPerpAssetContext(args) {
+  const coin = args.coin.trim();
+  const dex = args.dex?.trim() || hyperliquidInferDexFromCoin(coin) || "";
+  const req = { type: "metaAndAssetCtxs" };
+  if (dex) req.dex = dex;
+  const raw = await hyperliquidInfoPost(args.chainId, req);
+  const universe = raw?.[0]?.universe ?? [];
+  const contexts = raw?.[1] ?? [];
+  const idx = universe.findIndex((u) => u.name === coin);
+  if (idx < 0) {
+    throw new Error(`Hyperliquid asset context not found for ${coin}${dex ? ` on dex ${dex}` : ""}`);
+  }
+  const ctx = contexts[idx] ?? {};
+  const str = (v) => {
+    const s = String(v ?? "").trim();
+    return s || null;
+  };
+  return {
+    markPx: str(ctx.markPx),
+    midPx: str(ctx.midPx),
+    oraclePx: str(ctx.oraclePx),
+    prevDayPx: str(ctx.prevDayPx),
+    funding: str(ctx.funding),
+    openInterest: str(ctx.openInterest)
+  };
+}
+function hyperliquidPickLivePrice(args) {
+  const midUsd = args.midPx ?? args.markPx ?? args.midFromAllMids;
+  if (!midUsd) {
+    throw new Error("Could not fetch live Hyperliquid price (mark, mid, and allMids all empty)");
+  }
+  const source = args.midPx ? "midPx" : args.markPx ? "markPx" : "allMids";
+  return {
+    markPx: args.markPx,
+    midPx: args.midPx,
+    oraclePx: null,
+    prevDayPx: null,
+    midUsd,
+    source
+  };
+}
+async function hyperliquidFetchMarketSnapshot(args) {
+  const coin = args.coin.trim();
+  const interval = args.interval ?? HYPERLIQUID_DEFAULT_OHLCV_INTERVAL;
+  const dex = args.dex?.trim() || hyperliquidInferDexFromCoin(coin) || null;
+  const candleLimit = Math.min(
+    Math.max(args.candleLimit ?? HYPERLIQUID_DEFAULT_CANDLE_LIMIT, 1),
+    HYPERLIQUID_MAX_CANDLE_LIMIT
+  );
+  const [{ mids }, assetCtx, { candles }] = await Promise.all([
+    hyperliquidFetchAllMids({ chainId: args.chainId, dex: dex ?? void 0 }),
+    hyperliquidFetchPerpAssetContext({ chainId: args.chainId, coin, dex: dex ?? void 0 }),
+    hyperliquidFetchCandles({
+      chainId: args.chainId,
+      coin,
+      interval,
+      limit: candleLimit
+    })
+  ]);
+  const midFromAllMids = mids[coin] ?? null;
+  const livePrice = {
+    ...hyperliquidPickLivePrice({
+      markPx: assetCtx.markPx,
+      midPx: assetCtx.midPx,
+      midFromAllMids
+    }),
+    oraclePx: assetCtx.oraclePx,
+    prevDayPx: assetCtx.prevDayPx
+  };
+  const latestCandle = candles.length > 0 ? candles[candles.length - 1] : null;
+  return {
+    coin,
+    dex,
+    livePrice,
+    midUsd: livePrice.midUsd,
+    fetchedAtMs: Date.now(),
+    interval,
+    latestCandle,
+    candles,
+    candleCount: candles.length
+  };
+}
+async function hyperliquidFetchClearinghouseState(args) {
+  const req = { type: "clearinghouseState", user: args.user };
+  if (args.dex?.trim()) req.dex = args.dex.trim();
+  const state = await hyperliquidInfoPost(args.chainId, req);
+  return { state };
+}
+async function hyperliquidFetchSpotClearinghouseState(args) {
+  const state = await hyperliquidInfoPost(args.chainId, {
+    type: "spotClearinghouseState",
+    user: args.user
+  });
+  return { state };
+}
+function hyperliquidFmtLeverage(leverage) {
+  if (leverage?.value == null) return null;
+  const t = leverage.type === "isolated" ? "iso" : "cross";
+  return `${leverage.value}x ${t}`;
+}
+function hyperliquidPositiveSizeString(value) {
+  const n = Number.parseFloat(String(value ?? "0"));
+  if (!Number.isFinite(n) || n <= 0) return null;
+  return String(n);
+}
+async function hyperliquidFetchActiveAssetData(args) {
+  const raw = await hyperliquidInfoPost(args.chainId, {
+    type: "activeAssetData",
+    user: args.user,
+    coin: args.coin.trim()
+  });
+  const avail = raw.availableToTrade;
+  return {
+    activeAsset: {
+      markPx: raw.markPx?.trim() || null,
+      leverageLabel: hyperliquidFmtLeverage(raw.leverage),
+      availableToBuy: avail?.[0] != null ? hyperliquidPositiveSizeString(avail[0]) : null,
+      availableToSell: avail?.[1] != null ? hyperliquidPositiveSizeString(avail[1]) : null
+    }
+  };
+}
+async function hyperliquidFetchOpenOrders(args) {
+  const req = { type: "openOrders", user: args.user };
+  if (args.dex?.trim()) req.dex = args.dex.trim();
+  const orders = await hyperliquidInfoPost(args.chainId, req);
+  return { orders: orders ?? [] };
+}
+async function hyperliquidFetchUserVaultEquities(args) {
+  const rows = await hyperliquidInfoPost(args.chainId, {
+    type: "userVaultEquities",
+    user: args.user
+  });
+  return { rows: rows ?? [] };
+}
+var VAULT_CATALOG_MAX = 40;
+var VAULT_MIN_TVL_USD = 1e3;
+function vaultSummaryFromStatsRow(row) {
+  const summary = row.summary;
+  if (!summary?.vaultAddress?.trim() || !summary.name?.trim() || summary.isClosed) return null;
+  const tvl = Number.parseFloat(summary.tvl ?? "");
+  if (!Number.isFinite(tvl) || tvl < VAULT_MIN_TVL_USD) return null;
+  return {
+    vaultAddress: summary.vaultAddress,
+    name: summary.name.trim(),
+    apr: typeof row.apr === "number" && Number.isFinite(row.apr) ? row.apr : null,
+    tvlUsd: summary.tvl ?? null
+  };
+}
+function sortVaultCatalog(vaults) {
+  const hlp = HYPERLIQUID_HLP_VAULT_ADDRESS.toLowerCase();
+  return [...vaults].sort((a, b) => {
+    const aHlp = a.vaultAddress.toLowerCase() === hlp;
+    const bHlp = b.vaultAddress.toLowerCase() === hlp;
+    if (aHlp && !bHlp) return -1;
+    if (bHlp && !aHlp) return 1;
+    return Number.parseFloat(b.tvlUsd ?? "0") - Number.parseFloat(a.tvlUsd ?? "0");
+  });
+}
+async function hyperliquidFetchVaultCatalogFromStats(chainId) {
+  const statsUrl = hyperliquidVaultStatsUrl(chainId);
+  if (!statsUrl) return [];
+  const res = await fetch(statsUrl, { cache: "no-store" });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Hyperliquid vault stats failed (${res.status}): ${text.slice(0, 200)}`);
+  }
+  const raw = await res.json();
+  const byAddr = /* @__PURE__ */ new Map();
+  for (const row of raw ?? []) {
+    const vault = vaultSummaryFromStatsRow(row);
+    if (!vault) continue;
+    byAddr.set(vault.vaultAddress.toLowerCase(), vault);
+  }
+  return sortVaultCatalog([...byAddr.values()]).slice(0, VAULT_CATALOG_MAX);
+}
+async function hyperliquidFetchVaultDetails(args) {
+  const raw = await hyperliquidInfoPost(args.chainId, {
+    type: "vaultDetails",
+    vaultAddress: args.vaultAddress
+  });
+  if (!raw?.vaultAddress?.trim() || !raw.name?.trim() || raw.isClosed) return null;
+  return {
+    vaultAddress: raw.vaultAddress,
+    name: raw.name.trim(),
+    apr: typeof raw.apr === "number" && Number.isFinite(raw.apr) ? raw.apr : null,
+    tvlUsd: null
+  };
+}
+async function hyperliquidFetchVaultSummaries(args) {
+  const catalog = await hyperliquidFetchVaultCatalogFromStats(args.chainId);
+  const byAddr = new Map(catalog.map((v) => [v.vaultAddress.toLowerCase(), v]));
+  const executor = args.executorAddress?.trim().toLowerCase();
+  if (executor) {
+    const { rows } = await hyperliquidFetchUserVaultEquities({ chainId: args.chainId, user: executor });
+    const missing = rows.filter((r) => r.vaultAddress && !byAddr.has(r.vaultAddress.toLowerCase()));
+    const extras = await Promise.all(
+      missing.map(async (r) => hyperliquidFetchVaultDetails({ chainId: args.chainId, vaultAddress: r.vaultAddress }))
+    );
+    for (const vault of extras) {
+      if (vault) byAddr.set(vault.vaultAddress.toLowerCase(), vault);
+    }
+  }
+  return { vaults: sortVaultCatalog([...byAddr.values()]) };
+}
+async function hyperliquidFetchDexList(args) {
+  const raw = await hyperliquidInfoPost(args.chainId, {
+    type: "perpDexs"
+  });
+  if (!Array.isArray(raw)) return { dexes: [] };
+  const dexes = [];
+  for (const entry of raw) {
+    if (entry == null) continue;
+    if (typeof entry === "string") {
+      const name2 = entry.trim();
+      if (name2) dexes.push({ name: name2, fullName: name2 });
+      continue;
+    }
+    const name = entry.name?.trim();
+    if (!name) continue;
+    const fullName = entry.fullName?.trim() || name;
+    dexes.push({ name, fullName });
+  }
+  return { dexes };
+}
+async function hyperliquidFetchPerpConciseAnnotations(args) {
+  const raw = await hyperliquidInfoPost(args.chainId, {
+    type: "perpConciseAnnotations"
+  });
+  const map = /* @__PURE__ */ new Map();
+  if (!Array.isArray(raw)) return map;
+  for (const entry of raw) {
+    if (!Array.isArray(entry) || entry.length < 2) continue;
+    const coin = String(entry[0] ?? "").trim();
+    const meta = entry[1];
+    if (!coin || !meta || typeof meta !== "object") continue;
+    map.set(coin, meta);
+  }
+  return map;
+}
+async function hyperliquidFetchDelegations(args) {
+  const raw = await hyperliquidInfoPost(args.chainId, {
+    type: "delegations",
+    user: args.user
+  });
+  return { delegations: raw ?? [] };
+}
+async function hyperliquidFetchStakingSummary(args) {
+  const raw = await hyperliquidInfoPost(args.chainId, {
+    type: "delegatorSummary",
+    user: args.user
+  });
+  return { delegated: raw?.delegated ?? "0", undelegated: raw?.undelegated ?? "0" };
+}
+
+// src/protocols/evm/hyperliquid/marketSearch.ts
+function normalizeQuery(value) {
+  return value.trim().toLowerCase();
+}
+function compactCoin(value) {
+  return normalizeQuery(value).replace(/[^a-z0-9]/g, "");
+}
+function hyperliquidMarketSymbol(coin) {
+  const sep = coin.indexOf(":");
+  return sep >= 0 ? coin.slice(sep + 1) : coin;
+}
+function scoreMarketMatch(query, market, annotation) {
+  const q = normalizeQuery(query);
+  if (!q) return null;
+  const coin = market.name;
+  const symbol = hyperliquidMarketSymbol(coin);
+  const coinLower = normalizeQuery(coin);
+  const symbolLower = normalizeQuery(symbol);
+  if (coinLower === q) return { score: 100, reason: "exact coin name" };
+  if (symbolLower === q) return { score: 95, reason: "exact ticker symbol" };
+  if (compactCoin(coin) === compactCoin(q)) return { score: 92, reason: "coin name without separators" };
+  if (annotation?.displayName) {
+    const display = normalizeQuery(annotation.displayName);
+    if (display === q) return { score: 94, reason: "exact display name" };
+    if (display.includes(q) || q.includes(display)) return { score: 72, reason: "display name partial match" };
+  }
+  for (const keyword of annotation?.keywords ?? []) {
+    const kw = normalizeQuery(keyword);
+    if (!kw) continue;
+    if (kw === q) return { score: 88, reason: `keyword "${keyword}"` };
+    if (kw.includes(q) || q.includes(kw)) return { score: 68, reason: `keyword partial "${keyword}"` };
+  }
+  if (symbolLower.includes(q) || q.includes(symbolLower)) {
+    return { score: 78, reason: "ticker partial match" };
+  }
+  if (!coin.includes(":") && coinLower.includes(q)) {
+    return { score: 65, reason: "native coin partial match" };
+  }
+  if (market.dex && normalizeQuery(market.dex) === q) {
+    return { score: 40, reason: "dex name match" };
+  }
+  return null;
+}
+async function hyperliquidCollectAllPerpMarkets(args) {
+  const dexFilter = args.dex?.trim();
+  const { dexes } = await hyperliquidFetchDexList({ chainId: args.chainId });
+  if (dexFilter) {
+    const { markets: markets2 } = await hyperliquidFetchPerpMeta({ chainId: args.chainId, dex: dexFilter });
+    return { markets: markets2.map((m) => ({ ...m, dex: dexFilter })), dexes };
+  }
+  const { markets: nativeMarkets } = await hyperliquidFetchPerpMeta({ chainId: args.chainId });
+  const markets = [...nativeMarkets];
+  const hip3Batches = await Promise.all(
+    dexes.map(async (d) => {
+      const { markets: dexMarkets } = await hyperliquidFetchPerpMeta({ chainId: args.chainId, dex: d.name });
+      return dexMarkets.map((m) => ({ ...m, dex: d.name }));
+    })
+  );
+  for (const batch of hip3Batches) markets.push(...batch);
+  return { markets, dexes };
+}
+async function hyperliquidSearchMarkets(args) {
+  const query = args.query.trim();
+  if (!query) return { matches: [] };
+  const limit = Math.max(1, Math.min(args.limit ?? 20, 50));
+  const [{ markets }, annotationMap] = await Promise.all([
+    hyperliquidCollectAllPerpMarkets({ chainId: args.chainId, dex: args.dex?.trim() }),
+    hyperliquidFetchPerpConciseAnnotations({ chainId: args.chainId })
+  ]);
+  const hits = [];
+  for (const market of markets) {
+    const annotation = annotationMap.get(market.name);
+    const scored = scoreMarketMatch(query, market, annotation);
+    if (!scored || scored.score < 40) continue;
+    hits.push({
+      coin: market.name,
+      symbol: hyperliquidMarketSymbol(market.name),
+      dex: market.dex,
+      asset: market.asset,
+      szDecimals: market.szDecimals,
+      maxLeverage: market.maxLeverage,
+      onlyIsolated: market.onlyIsolated,
+      displayName: annotation?.displayName,
+      category: annotation?.category,
+      keywords: annotation?.keywords,
+      matchScore: scored.score,
+      matchReason: scored.reason
+    });
+  }
+  hits.sort((a, b) => b.matchScore - a.matchScore || a.coin.localeCompare(b.coin));
+  return { matches: hits.slice(0, limit) };
+}
+async function hyperliquidResolvePerpMarket(args) {
+  const coin = args.coin.trim();
+  if (!coin) throw new Error("coin is required");
+  const dex = args.dex?.trim() || hyperliquidInferDexFromCoin(coin);
+  if (dex || !coin.includes(":")) {
+    const { markets } = await hyperliquidFetchPerpMeta({ chainId: args.chainId, dex });
+    const direct = markets.find((m) => m.name.toLowerCase() === coin.toLowerCase());
+    if (direct) {
+      return {
+        ...direct,
+        dex: dex || direct.dex,
+        symbol: hyperliquidMarketSymbol(direct.name)
+      };
+    }
+  }
+  const { matches } = await hyperliquidSearchMarkets({ chainId: args.chainId, query: coin, dex: args.dex, limit: 10 });
+  const bestScore = matches[0]?.matchScore ?? 0;
+  if (bestScore < 60) throw new Error(`Unknown Hyperliquid perp market: ${coin}`);
+  const top = matches.filter((m) => m.matchScore === bestScore);
+  if (top.length === 1) {
+    const m = top[0];
+    return {
+      name: m.coin,
+      asset: m.asset,
+      szDecimals: m.szDecimals,
+      maxLeverage: m.maxLeverage,
+      onlyIsolated: m.onlyIsolated,
+      dex: m.dex,
+      symbol: m.symbol
+    };
+  }
+  throw new Error(
+    `Ambiguous Hyperliquid market for "${coin}": ${top.map((m) => m.coin).join(", ")}. Pass dex or full coin name (e.g. xyz:AAPL).`
+  );
+}
+
+// src/protocols/evm/hyperliquid/assets.ts
+async function hyperliquidResolvePerpAsset(args) {
+  const resolved = await hyperliquidResolvePerpMarket(args);
+  return { asset: resolved.asset, szDecimals: resolved.szDecimals, maxLeverage: resolved.maxLeverage };
+}
+async function hyperliquidResolveSpotAsset(args) {
+  const coin = args.coin.trim();
+  const { markets } = await hyperliquidFetchSpotMeta({ chainId: args.chainId });
+  const hit = markets.find((m) => m.name.toLowerCase() === coin.toLowerCase());
+  if (!hit) throw new Error(`Unknown Hyperliquid spot market: ${coin}`);
+  return { asset: hit.asset, szDecimals: hit.szDecimals };
+}
+async function hyperliquidResolveAsset(args) {
+  if (args.marketKind === "spot") {
+    const r = await hyperliquidResolveSpotAsset({ chainId: args.chainId, coin: args.coin });
+    return r;
+  }
+  return hyperliquidResolvePerpAsset({ chainId: args.chainId, coin: args.coin, dex: args.dex });
+}
+function hyperliquidIsSpotAssetId(asset) {
+  return asset >= HYPERLIQUID_SPOT_ASSET_OFFSET;
+}
+
+// src/protocols/evm/hyperliquid/reads.ts
+function hyperliquidUsdAmountString(value) {
+  const n = Number.parseFloat(String(value ?? "0"));
+  if (!Number.isFinite(n) || n <= 0) return "0";
+  return n.toFixed(6).replace(/\.?0+$/, "") || "0";
+}
+function hyperliquidSpotUsdcAvailable(balances) {
+  const usdc = balances.find((b) => b.coin === "USDC");
+  if (!usdc) return "0";
+  const total = Number.parseFloat(String(usdc.total ?? "0"));
+  const hold = Number.parseFloat(String(usdc.hold ?? "0"));
+  if (!Number.isFinite(total)) return "0";
+  const avail = Math.max(0, total - (Number.isFinite(hold) ? hold : 0));
+  return hyperliquidUsdAmountString(String(avail));
+}
+async function hyperliquidFetchUsdClassBalances(args) {
+  const user = args.executorAddress.trim().toLowerCase();
+  const [{ state: spotState }, { state: perpState }] = await Promise.all([
+    hyperliquidFetchSpotClearinghouseState({ chainId: args.chainId, user }),
+    hyperliquidFetchClearinghouseState({ chainId: args.chainId, user })
+  ]);
+  return {
+    balances: {
+      spotUsdcAvailable: hyperliquidSpotUsdcAvailable(spotState.balances ?? []),
+      perpWithdrawable: hyperliquidUsdAmountString(perpState.withdrawable)
+    }
+  };
+}
+function fmtLeverage(leverage) {
+  if (leverage?.value == null) return null;
+  const t = leverage.type === "isolated" ? "iso" : "cross";
+  return `${leverage.value}x ${t}`;
+}
+function mapPositionRow(p) {
+  if (!p.coin) return null;
+  const szi = Number.parseFloat(String(p.szi ?? "0"));
+  if (!Number.isFinite(szi) || szi === 0) return null;
+  return {
+    key: `${p.coin}:${szi > 0 ? "long" : "short"}`,
+    coin: p.coin,
+    isLong: szi > 0,
+    size: String(Math.abs(szi)),
+    entryPx: p.entryPx ?? null,
+    positionValueUsd: p.positionValue ?? null,
+    unrealizedPnlUsd: p.unrealizedPnl ?? null,
+    liquidationPx: p.liquidationPx ?? null,
+    leverageLabel: fmtLeverage(p.leverage),
+    maxLeverage: typeof p.maxLeverage === "number" && Number.isFinite(p.maxLeverage) ? p.maxLeverage : null,
+    marginUsedUsd: p.marginUsed ?? null,
+    returnOnEquity: p.returnOnEquity ?? null
+  };
+}
+async function hyperliquidFetchOpenMarketContext(args) {
+  const user = args.executorAddress.trim().toLowerCase();
+  const resolved = await hyperliquidResolvePerpMarket({
+    chainId: args.chainId,
+    coin: args.coin,
+    dex: args.dex
+  });
+  const coin = resolved.name;
+  const dex = args.dex?.trim() || resolved.dex;
+  const [{ activeAsset }, { state }] = await Promise.all([
+    hyperliquidFetchActiveAssetData({ chainId: args.chainId, user, coin }),
+    hyperliquidFetchClearinghouseState({ chainId: args.chainId, user, dex })
+  ]);
+  return {
+    context: {
+      activeAsset,
+      account: {
+        accountValueUsd: state.marginSummary?.accountValue ?? null,
+        totalMarginUsedUsd: state.marginSummary?.totalMarginUsed ?? null,
+        withdrawableUsd: state.withdrawable ?? null
+      }
+    }
+  };
+}
+async function hyperliquidFetchPositionDisplayRows(args) {
+  const user = args.executorAddress.trim().toLowerCase();
+  const { state } = await hyperliquidFetchClearinghouseState({
+    chainId: args.chainId,
+    user,
+    dex: args.dex
+  });
+  const rows = [];
+  for (const ap of state.assetPositions ?? []) {
+    const row = mapPositionRow(ap.position ?? {});
+    if (row) rows.push(row);
+  }
+  return { rows };
+}
+async function hyperliquidFetchOrdersForExecutor(args) {
+  return hyperliquidFetchOpenOrders({
+    chainId: args.chainId,
+    user: args.executorAddress.trim().toLowerCase(),
+    dex: args.dex
+  });
+}
+async function hyperliquidFetchMarketsSummary(args) {
+  const { markets, dexes } = await hyperliquidCollectAllPerpMarkets({
+    chainId: args.chainId,
+    dex: args.dex?.trim()
+  });
+  return { markets, dexes };
+}
+async function hyperliquidSearchMarketsSummary(args) {
+  return hyperliquidSearchMarkets(args);
+}
+async function hyperliquidFetchPositionsForExecutor(args) {
+  const { rows } = await hyperliquidFetchPositionDisplayRows(args);
+  return { positions: rows };
+}
+async function hyperliquidFetchOpenOrdersSummary(args) {
+  const { orders } = await hyperliquidFetchOrdersForExecutor(args);
+  return { orders };
+}
+async function hyperliquidFetchOpenContextSummary(args) {
+  const { context } = await hyperliquidFetchOpenMarketContext(args);
+  return { context };
+}
+async function hyperliquidFetchUsdClassBalancesSummary(args) {
+  const { balances } = await hyperliquidFetchUsdClassBalances(args);
+  return { balances };
+}
+async function hyperliquidFetchVaultCatalogSummary(args) {
+  const { vaults } = await hyperliquidFetchVaultSummaries({
+    chainId: args.chainId,
+    executorAddress: args.executorAddress
+  });
+  return { vaults };
+}
+async function hyperliquidFetchUserVaultEquitiesSummary(args) {
+  const { rows } = await hyperliquidFetchUserVaultEquities({
+    chainId: args.chainId,
+    user: args.executorAddress.trim().toLowerCase()
+  });
+  return { rows };
+}
+async function hyperliquidFetchStakingSummaryForExecutor(args) {
+  const summary = await hyperliquidFetchStakingSummary({
+    chainId: args.chainId,
+    user: args.executorAddress.trim().toLowerCase()
+  });
+  return { summary };
+}
+async function hyperliquidFetchDelegationsForExecutor(args) {
+  const { delegations } = await hyperliquidFetchDelegations({
+    chainId: args.chainId,
+    user: args.executorAddress.trim().toLowerCase()
+  });
+  return { delegations };
+}
+async function hyperliquidFetchMarketSnapshotSummary(args) {
+  const resolved = await hyperliquidResolvePerpMarket({
+    chainId: args.chainId,
+    coin: args.coin,
+    dex: args.dex
+  });
+  const snapshot = await hyperliquidFetchMarketSnapshot({
+    chainId: args.chainId,
+    coin: resolved.name,
+    interval: args.interval,
+    dex: args.dex?.trim() || resolved.dex,
+    candleLimit: args.candleLimit
+  });
+  return { snapshot, resolvedCoin: resolved.name, dex: resolved.dex ?? null };
+}
+async function hyperliquidFetchOhlcvSummary(args) {
+  const resolved = await hyperliquidResolvePerpMarket({
+    chainId: args.chainId,
+    coin: args.coin,
+    dex: args.dex
+  });
+  const ohlcv = await hyperliquidFetchOhlcvRange({
+    chainId: args.chainId,
+    coin: resolved.name,
+    interval: args.interval,
+    dex: args.dex?.trim() || resolved.dex,
+    lookbackDays: args.lookbackDays,
+    lookbackHours: args.lookbackHours,
+    startTimeMs: args.startTimeMs,
+    endTimeMs: args.endTimeMs
+  });
+  return { ohlcv, resolvedCoin: resolved.name, dex: resolved.dex ?? null };
+}
+var coreWriterAbi = parseAbi(["function sendRawAction(bytes data) external"]);
+var ACTION_LIMIT_ORDER = 1;
+var ACTION_VAULT_TRANSFER = 2;
+var ACTION_TOKEN_DELEGATE = 3;
+var ACTION_STAKING_DEPOSIT = 4;
+var ACTION_STAKING_WITHDRAW = 5;
+var ACTION_USD_CLASS_TRANSFER = 7;
+var ACTION_CANCEL_BY_OID = 10;
+var ACTION_CANCEL_BY_CLOID = 11;
+function encodeActionHeader(actionId) {
+  const idHex = actionId.toString(16).padStart(6, "0");
+  return `0x01${idHex}`;
+}
+function encodeCoreWriterCalldata(actionId, paramsEncoded) {
+  const header = encodeActionHeader(actionId).slice(2);
+  const params = paramsEncoded.startsWith("0x") ? paramsEncoded.slice(2) : paramsEncoded;
+  const actionBytes = `0x${header}${params}`;
+  return encodeFunctionData({
+    abi: coreWriterAbi,
+    functionName: "sendRawAction",
+    args: [actionBytes]
+  });
+}
+function hyperliquidEncodePx8(human) {
+  const n = typeof human === "number" ? human : Number.parseFloat(String(human).trim());
+  if (!Number.isFinite(n) || n < 0) throw new Error("Invalid price or size for Hyperliquid encoding.");
+  return BigInt(Math.round(n * 1e8));
+}
+function hyperliquidEncodeUsd6(human) {
+  const n = typeof human === "number" ? human : Number.parseFloat(String(human).trim());
+  if (!Number.isFinite(n) || n < 0) throw new Error("Invalid USD amount for Hyperliquid encoding.");
+  return BigInt(Math.round(n * 1e6));
+}
+function hyperliquidEncodeWei8(human) {
+  return hyperliquidEncodePx8(human);
+}
+function hyperliquidResolveTif(tif) {
+  const key = String(tif).trim().toLowerCase();
+  const v = HYPERLIQUID_TIF[key];
+  if (v == null) throw new Error(`Unknown time-in-force: ${tif}. Use alo, gtc, or ioc.`);
+  return v;
+}
+function buildCoreWriterLimitOrderCalldata(args) {
+  const params = encodeAbiParameters(
+    [
+      { type: "uint32" },
+      { type: "bool" },
+      { type: "uint64" },
+      { type: "uint64" },
+      { type: "bool" },
+      { type: "uint8" },
+      { type: "uint128" }
+    ],
+    [
+      args.asset,
+      args.isBuy,
+      hyperliquidEncodePx8(args.limitPxHuman),
+      hyperliquidEncodePx8(args.szHuman),
+      Boolean(args.reduceOnly),
+      hyperliquidResolveTif(args.tif ?? "gtc"),
+      args.cloid ?? 0n
+    ]
+  );
+  return encodeCoreWriterCalldata(ACTION_LIMIT_ORDER, params);
+}
+function buildCoreWriterCancelByOidCalldata(args) {
+  const params = encodeAbiParameters(
+    [{ type: "uint32" }, { type: "uint64" }],
+    [args.asset, BigInt(args.oid)]
+  );
+  return encodeCoreWriterCalldata(ACTION_CANCEL_BY_OID, params);
+}
+function buildCoreWriterCancelByCloidCalldata(args) {
+  const params = encodeAbiParameters(
+    [{ type: "uint32" }, { type: "uint128" }],
+    [args.asset, args.cloid]
+  );
+  return encodeCoreWriterCalldata(ACTION_CANCEL_BY_CLOID, params);
+}
+function buildCoreWriterUsdClassTransferCalldata(args) {
+  const params = encodeAbiParameters(
+    [{ type: "uint64" }, { type: "bool" }],
+    [hyperliquidEncodeUsd6(args.usdHuman), args.toPerp]
+  );
+  return encodeCoreWriterCalldata(ACTION_USD_CLASS_TRANSFER, params);
+}
+function buildCoreWriterVaultTransferCalldata(args) {
+  const params = encodeAbiParameters(
+    [{ type: "address" }, { type: "bool" }, { type: "uint64" }],
+    [args.vault, args.isDeposit, hyperliquidEncodeUsd6(args.usdHuman)]
+  );
+  return encodeCoreWriterCalldata(ACTION_VAULT_TRANSFER, params);
+}
+function buildCoreWriterStakingDepositCalldata(args) {
+  const params = encodeAbiParameters([{ type: "uint64" }], [hyperliquidEncodeWei8(args.hypeHuman)]);
+  return encodeCoreWriterCalldata(ACTION_STAKING_DEPOSIT, params);
+}
+function buildCoreWriterStakingWithdrawCalldata(args) {
+  const params = encodeAbiParameters([{ type: "uint64" }], [hyperliquidEncodeWei8(args.hypeHuman)]);
+  return encodeCoreWriterCalldata(ACTION_STAKING_WITHDRAW, params);
+}
+function buildCoreWriterTokenDelegateCalldata(args) {
+  const params = encodeAbiParameters(
+    [{ type: "address" }, { type: "uint64" }, { type: "bool" }],
+    [args.validator, hyperliquidEncodeWei8(args.hypeHuman), args.isUndelegate]
+  );
+  return encodeCoreWriterCalldata(ACTION_TOKEN_DELEGATE, params);
+}
+function coreWriterStep(data) {
+  return {
+    to: HYPERLIQUID_CORE_WRITER_ADDRESS,
+    data,
+    value: 0n
+  };
+}
+
+// src/core/purpose.ts
+function mergePurposeText(purposeText, purposeSuffix) {
+  const t = purposeText.trim();
+  const suffix = (purposeSuffix ?? "").trim();
+  if (!suffix) return t;
+  return t ? `${t}
+
+${suffix}` : suffix;
+}
+
+// src/core/envelope.ts
+function finalizeMultisign(input) {
+  const { keyGen, destinationChainID, legs } = input;
+  if (legs.length === 0) {
+    throw new Error("finalizeMultisign requires at least one leg");
+  }
+  const ph = (keyGen.pubkeyhex ?? "").trim();
+  if (!ph) throw new Error("keyGen pubKey (pubkeyhex) is required");
+  const keyList = keyGen.keylist ?? [];
+  const clientId = getClientIdFromKeyGenResult(keyGen);
+  const first = legs[0];
+  const messageHashes = legs.map((l) => l.msgHash);
+  const messageRawBatch = legs.map((l) => l.msgRaw);
+  const batchMeta = legs.map((l) => ({
+    destinationAddress: l.destinationAddress,
+    signatureText: l.signatureText,
+    ...l.audit
+  }));
+  const proposalTxParams = legs.map((l) => l.proposalTxParams).filter((p) => p != null && typeof p === "object");
+  const extraPayload = {
+    batchMeta,
+    ...input.extraJSON ?? {}
+  };
+  const extraJSON = JSON.stringify(extraPayload);
+  const bodyForSign = {
+    keyList,
+    pubKey: ph,
+    msgHash: messageHashes[0],
+    msgRaw: first.msgRaw,
+    destinationChainID,
+    destinationAddress: input.destinationAddress ?? first.destinationAddress,
+    extraJSON,
+    signatureText: first.signatureText,
+    purpose: mergePurposeText(input.purposeText, input.purposeSuffix),
+    ...first.feeSnapshot
+  };
+  if (legs.length > 1) {
+    bodyForSign.messageHashes = messageHashes;
+    bodyForSign.messageRawBatch = messageRawBatch;
+  }
+  if (proposalTxParams.length > 0) {
+    bodyForSign.proposalTxParams = proposalTxParams;
+  }
+  const valueWei = first.valueWei;
+  if (valueWei != null && valueWei > 0n) {
+    bodyForSign.value = valueWei.toString();
+  }
+  if (clientId) bodyForSign.clientId = clientId;
+  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
+}
+function routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimit) {
+  if (chainGasLimit != null && Number.isFinite(chainGasLimit) && chainGasLimit > 0) {
+    return gasLimitFromEstimateAndChainConfig(estimatedGas, chainGasLimit);
+  }
+  return (estimatedGas * 12n + 9n) / 10n;
+}
+
+// src/chains/evm/buildBatch.ts
+async function buildEvmMultisignBatch(args) {
+  const { context, steps } = args;
+  const {
+    chainId,
+    rpcUrl,
+    executorAddress,
+    chainDetail,
+    useCustomGas,
+    customGasChainDetails,
+    keyGen,
+    purposeText
+  } = context;
+  if (steps.length === 0) throw new Error("buildEvmMultisignBatch requires at least one step");
+  const ch = defineChain({
+    id: chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(rpcUrl) });
+  const feeParams = await fetchChainFeeParams(rpcUrl, chainId);
+  const legacy = Boolean(chainDetail?.legacy) || !feeParams.isEip1559;
+  const latestBaseFeeWei = !legacy ? (await publicClient.getBlock({ blockTag: "latest" })).baseFeePerGas ?? 0n : 0n;
+  const gasLimitConfig = useCustomGas && chainDetail?.gasLimit != null ? Number(chainDetail.gasLimit) : void 0;
+  const chainGasLimitRouter = chainDetail?.gasLimit != null && Number.isFinite(Number(chainDetail.gasLimit)) && Number(chainDetail.gasLimit) > 0 ? Number(chainDetail.gasLimit) : void 0;
+  const gasFeeMultiplier = useCustomGas && chainDetail?.gasMultiplier != null ? Number(chainDetail.gasMultiplier) : void 0;
+  const executor = getAddress(executorAddress);
+  const baseNonce = await publicClient.getTransactionCount({ address: executor, blockTag: "pending" });
+  const legs = [];
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const currentNonce = baseNonce + i;
+    let estimatedGas;
+    if (args.estimateGasForStep) {
+      estimatedGas = await args.estimateGasForStep({ step, index: i, publicClient, executor });
+    } else {
+      try {
+        estimatedGas = await publicClient.estimateGas({
+          to: step.to,
+          data: step.data,
+          value: step.value,
+          account: executor
+        });
+      } catch {
+        estimatedGas = step.fallbackGas ?? 100000n;
+      }
+    }
+    let gasLimitI;
+    if (args.resolveGasLimit) {
+      gasLimitI = await args.resolveGasLimit({ step, index: i, estimatedGas, publicClient });
+    } else if (step.routerSwap) {
+      gasLimitI = routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimitRouter);
+    } else {
+      gasLimitI = useCustomGas ? gasLimitFromEstimateAndChainConfig(estimatedGas, gasLimitConfig) : estimatedGas;
+    }
+    let proposalTxParams;
+    let feeSnapshot;
+    let serialized;
+    if (legacy) {
+      let gasPriceWei = await publicClient.getGasPrice();
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        gasPriceWei = gasPriceWei * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      if (useCustomGas && chainDetail?.gasPrice != null && chainDetail.gasPrice > 0) {
+        const configured = parseGwei(gweiToDecimalString(Number(chainDetail.gasPrice)));
+        if (configured > gasPriceWei) gasPriceWei = configured;
+      }
+      serialized = serializeTransaction({
+        type: "legacy",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        gasPrice: gasPriceWei,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "legacy",
+        gasPrice: gasPriceWei.toString()
+      };
+      feeSnapshot = proposalTxParamsToFeeSnapshot(proposalTxParams);
+    } else {
+      const fetchedBase = feeParams.baseFeeGwei ?? 0;
+      const fetchedPriority = feeParams.priorityFeeGwei ?? 0;
+      const configuredBase = useCustomGas && chainDetail?.baseFee != null ? Number(chainDetail.baseFee) : 0;
+      const configuredPriority = useCustomGas && chainDetail?.priorityFee != null ? Number(chainDetail.priorityFee) : 0;
+      const effectiveBaseFeeGwei = Math.max(fetchedBase, configuredBase);
+      const effectivePriorityFeeGwei = Math.max(fetchedPriority, configuredPriority);
+      const baseFeeMultiplierPct = useCustomGas && chainDetail?.baseFeeMultiplier != null ? Math.max(100, Number(chainDetail.baseFeeMultiplier)) : 100;
+      const baseComponentGwei = effectiveBaseFeeGwei * baseFeeMultiplierPct / 100;
+      const maxFeePerGasGwei = baseComponentGwei + effectivePriorityFeeGwei;
+      let maxPriorityFeePerGas = effectivePriorityFeeGwei > 0 ? parseGwei(gweiToDecimalString(effectivePriorityFeeGwei)) : parseGwei("1");
+      let maxFeePerGas = parseGwei(gweiToDecimalString(maxFeePerGasGwei));
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        maxPriorityFeePerGas = maxPriorityFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+        maxFeePerGas = maxFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      ({ maxFeePerGas, maxPriorityFeePerGas } = alignEip1559FeesWithLatestBase(
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        latestBaseFeeWei
+      ));
+      serialized = serializeTransaction({
+        type: "eip1559",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "eip1559",
+        maxFeePerGas: maxFeePerGas.toString(),
+        maxPriorityFeePerGas: maxPriorityFeePerGas.toString()
+      };
+      feeSnapshot = i === 0 ? proposalTxParamsToFeeSnapshot(proposalTxParams) : {};
+    }
+    const h = keccak256(serialized);
+    const msgHash = h.startsWith("0x") ? h.slice(2) : h;
+    const batchMetaExtra = args.buildBatchMeta({ step, index: i, gasLimit: gasLimitI });
+    legs.push({
+      msgHash,
+      msgRaw: i === 0 && args.firstMsgRawNo0x != null ? args.firstMsgRawNo0x : serialized,
+      destinationAddress: step.to,
+      signatureText: typeof batchMetaExtra.signatureText === "string" ? batchMetaExtra.signatureText : JSON.stringify(batchMetaExtra.signatureText ?? {}),
+      audit: batchMetaExtra,
+      feeSnapshot: i === 0 ? feeSnapshot : {},
+      proposalTxParams,
+      valueWei: i === 0 ? step.value : void 0
+    });
+    if (i === 0 && args.firstMsgRawNo0x != null) {
+      legs[0].msgRaw = args.firstMsgRawNo0x;
+    }
+  }
+  const extraJSON = {};
+  if (useCustomGas && customGasChainDetails && Object.keys(customGasChainDetails).length > 0) {
+    extraJSON.customGasChainDetails = customGasChainDetails;
+  }
+  const result = finalizeMultisign({
+    keyGen,
+    purposeText,
+    purposeSuffix: args.purposeSuffix,
+    destinationChainID: String(chainId),
+    destinationAddress: args.destinationAddress ?? steps[0].to,
+    legs,
+    extraJSON: Object.keys(extraJSON).length > 0 ? extraJSON : void 0
+  });
+  const pv = args.payableValueWei;
+  if (pv != null && pv > 0n) {
+    result.bodyForSign.value = pv.toString();
+  }
+  return result;
+}
+
+// src/protocols/evm/hyperliquid/multisign.ts
+async function buildCoreWriterMultisign(common, data, signatureMeta) {
+  const step = coreWriterStep(data);
+  return buildEvmMultisignBatch({
+    context: {
+      keyGen: common.keyGen,
+      chainCategory: "evm",
+      chainId: common.chainId,
+      rpcUrl: common.rpcUrl,
+      chainDetail: common.chainDetail,
+      useCustomGas: common.useCustomGas,
+      customGasChainDetails: common.customGasChainDetails ?? null,
+      executorAddress: getAddress(common.executorAddress),
+      purposeText: common.purposeText
+    },
+    steps: [{ ...step, fallbackGas: HYPERLIQUID_CORE_WRITER_GAS_FALLBACK }],
+    destinationAddress: step.to,
+    buildBatchMeta: () => ({
+      kind: "Hyperliquid",
+      ...signatureMeta,
+      evm: { type: "hyperliquid_core_writer", version: 1, chainId: String(common.chainId) }
+    })
+  });
+}
+async function buildEvmMultisignBodyHyperliquidLimitOrderBatch(args) {
+  const marketKind = args.marketKind ?? "perp";
+  const { asset } = await hyperliquidResolveAsset({
+    chainId: args.chainId,
+    coin: args.coin,
+    marketKind,
+    dex: args.dex
+  });
+  const data = buildCoreWriterLimitOrderCalldata({
+    asset,
+    isBuy: args.isBuy,
+    limitPxHuman: args.limitPxHuman,
+    szHuman: args.szHuman,
+    reduceOnly: args.reduceOnly,
+    tif: args.tif
+  });
+  return buildCoreWriterMultisign(args, data, {
+    action: "limitOrder",
+    coin: args.coin,
+    marketKind,
+    isBuy: args.isBuy,
+    limitPxHuman: args.limitPxHuman,
+    szHuman: args.szHuman,
+    reduceOnly: Boolean(args.reduceOnly),
+    tif: args.tif ?? "gtc",
+    asset
+  });
+}
+async function buildEvmMultisignBodyHyperliquidCloseBatch(args) {
+  return buildEvmMultisignBodyHyperliquidLimitOrderBatch({
+    ...args,
+    marketKind: "perp",
+    isBuy: !args.isLong,
+    reduceOnly: true,
+    tif: args.tif ?? "ioc"
+  });
+}
+async function buildEvmMultisignBodyHyperliquidCancelBatch(args) {
+  const marketKind = args.marketKind ?? "perp";
+  const { asset } = await hyperliquidResolveAsset({
+    chainId: args.chainId,
+    coin: args.coin,
+    marketKind,
+    dex: args.dex
+  });
+  const data = buildCoreWriterCancelByOidCalldata({ asset, oid: args.oid });
+  return buildCoreWriterMultisign(args, data, {
+    action: "cancelOrder",
+    coin: args.coin,
+    marketKind,
+    oid: args.oid,
+    asset
+  });
+}
+async function buildEvmMultisignBodyHyperliquidUsdClassTransferBatch(args) {
+  const data = buildCoreWriterUsdClassTransferCalldata({
+    usdHuman: args.usdHuman,
+    toPerp: args.toPerp
+  });
+  return buildCoreWriterMultisign(args, data, {
+    action: "usdClassTransfer",
+    usdHuman: args.usdHuman,
+    toPerp: args.toPerp
+  });
+}
+async function buildVaultMultisign(common, isDeposit) {
+  const vault = getAddress(common.vaultAddress);
+  const data = buildCoreWriterVaultTransferCalldata({
+    vault,
+    isDeposit,
+    usdHuman: common.usdHuman
+  });
+  const step = coreWriterStep(data);
+  return buildEvmMultisignBatch({
+    context: {
+      keyGen: common.keyGen,
+      chainCategory: "evm",
+      chainId: common.chainId,
+      rpcUrl: common.rpcUrl,
+      chainDetail: common.chainDetail,
+      useCustomGas: common.useCustomGas,
+      customGasChainDetails: common.customGasChainDetails ?? null,
+      executorAddress: getAddress(common.executorAddress),
+      purposeText: common.purposeText
+    },
+    steps: [{ ...step, fallbackGas: HYPERLIQUID_CORE_WRITER_GAS_FALLBACK }],
+    destinationAddress: step.to,
+    buildBatchMeta: () => ({
+      kind: "Hyperliquid",
+      action: isDeposit ? "vaultDeposit" : "vaultWithdraw",
+      vault,
+      usdHuman: common.usdHuman,
+      evm: { type: "hyperliquid_vault", version: 1, chainId: String(common.chainId) }
+    })
+  });
+}
+async function buildEvmMultisignBodyHyperliquidVaultDepositBatch(args) {
+  return buildVaultMultisign(args, true);
+}
+async function buildEvmMultisignBodyHyperliquidVaultWithdrawBatch(args) {
+  return buildVaultMultisign(args, false);
+}
+async function buildStakingMultisign(common, data, action, extra = {}) {
+  const step = coreWriterStep(data);
+  return buildEvmMultisignBatch({
+    context: {
+      keyGen: common.keyGen,
+      chainCategory: "evm",
+      chainId: common.chainId,
+      rpcUrl: common.rpcUrl,
+      chainDetail: common.chainDetail,
+      useCustomGas: common.useCustomGas,
+      customGasChainDetails: common.customGasChainDetails ?? null,
+      executorAddress: getAddress(common.executorAddress),
+      purposeText: common.purposeText
+    },
+    steps: [{ ...step, fallbackGas: HYPERLIQUID_CORE_WRITER_GAS_FALLBACK }],
+    destinationAddress: step.to,
+    buildBatchMeta: () => ({
+      kind: "Hyperliquid",
+      action,
+      hypeHuman: common.hypeHuman,
+      ...extra,
+      evm: { type: "hyperliquid_staking", version: 1, chainId: String(common.chainId) }
+    })
+  });
+}
+async function buildEvmMultisignBodyHyperliquidStakeDepositBatch(args) {
+  const data = buildCoreWriterStakingDepositCalldata({ hypeHuman: args.hypeHuman });
+  return buildStakingMultisign(args, data, "stakingDeposit");
+}
+async function buildEvmMultisignBodyHyperliquidStakeWithdrawBatch(args) {
+  const data = buildCoreWriterStakingWithdrawCalldata({ hypeHuman: args.hypeHuman });
+  return buildStakingMultisign(args, data, "stakingWithdraw");
+}
+async function buildEvmMultisignBodyHyperliquidDelegateBatch(args) {
+  const validator = getAddress(args.validator);
+  const data = buildCoreWriterTokenDelegateCalldata({
+    validator,
+    hypeHuman: args.hypeHuman,
+    isUndelegate: args.isUndelegate
+  });
+  return buildStakingMultisign(args, data, args.isUndelegate ? "undelegate" : "delegate", { validator });
+}
+async function buildEvmMultisignBodyHyperliquidDelegateOnlyBatch(args) {
+  return buildEvmMultisignBodyHyperliquidDelegateBatch({ ...args, isUndelegate: false });
+}
+async function buildEvmMultisignBodyHyperliquidUndelegateBatch(args) {
+  return buildEvmMultisignBodyHyperliquidDelegateBatch({ ...args, isUndelegate: true });
+}
+
+// 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);
+
+export { HYPERLIQUID_CORE_WRITER_ADDRESS, HYPERLIQUID_CORE_WRITER_GAS_FALLBACK, HYPERLIQUID_DEFAULT_CANDLE_LIMIT, HYPERLIQUID_DEFAULT_LOOKBACK_DAYS, HYPERLIQUID_DEFAULT_OHLCV_INTERVAL, HYPERLIQUID_HLP_VAULT_ADDRESS, HYPERLIQUID_INTERVAL_MS, HYPERLIQUID_MAX_CANDLE_LIMIT, HYPERLIQUID_MAX_LOOKBACK_DAYS, HYPERLIQUID_MAX_OHLCV_BARS, HYPERLIQUID_PROTOCOL_ID, HYPERLIQUID_SPOT_ASSET_OFFSET, HYPERLIQUID_SUPPORTED_CHAIN_IDS, HYPERLIQUID_TIF, buildCoreWriterCancelByCloidCalldata, buildCoreWriterCancelByOidCalldata, buildCoreWriterLimitOrderCalldata, buildCoreWriterStakingDepositCalldata, buildCoreWriterStakingWithdrawCalldata, buildCoreWriterTokenDelegateCalldata, buildCoreWriterUsdClassTransferCalldata, buildCoreWriterVaultTransferCalldata, buildEvmMultisignBodyHyperliquidCancelBatch, buildEvmMultisignBodyHyperliquidCloseBatch, buildEvmMultisignBodyHyperliquidDelegateBatch, buildEvmMultisignBodyHyperliquidDelegateOnlyBatch, buildEvmMultisignBodyHyperliquidLimitOrderBatch, buildEvmMultisignBodyHyperliquidStakeDepositBatch, buildEvmMultisignBodyHyperliquidStakeWithdrawBatch, buildEvmMultisignBodyHyperliquidUndelegateBatch, buildEvmMultisignBodyHyperliquidUsdClassTransferBatch, buildEvmMultisignBodyHyperliquidVaultDepositBatch, buildEvmMultisignBodyHyperliquidVaultWithdrawBatch, coreWriterStep, hyperliquidApiBaseUrl, hyperliquidCollectAllPerpMarkets, hyperliquidEncodePx8, hyperliquidEncodeUsd6, hyperliquidEncodeWei8, hyperliquidFetchActiveAssetData, hyperliquidFetchAllMids, hyperliquidFetchCandles, hyperliquidFetchClearinghouseState, hyperliquidFetchDelegations, hyperliquidFetchDelegationsForExecutor, hyperliquidFetchDexList, hyperliquidFetchMarketSnapshot, hyperliquidFetchMarketSnapshotSummary, hyperliquidFetchMarketsSummary, hyperliquidFetchOhlcvRange, hyperliquidFetchOhlcvSummary, hyperliquidFetchOpenContextSummary, hyperliquidFetchOpenMarketContext, hyperliquidFetchOpenOrders, hyperliquidFetchOpenOrdersSummary, hyperliquidFetchOrdersForExecutor, hyperliquidFetchPerpAssetContext, hyperliquidFetchPerpConciseAnnotations, hyperliquidFetchPerpMeta, hyperliquidFetchPositionDisplayRows, hyperliquidFetchPositionsForExecutor, hyperliquidFetchSpotClearinghouseState, hyperliquidFetchSpotMeta, hyperliquidFetchStakingSummary, hyperliquidFetchStakingSummaryForExecutor, hyperliquidFetchUsdClassBalances, hyperliquidFetchUsdClassBalancesSummary, hyperliquidFetchUserVaultEquities, hyperliquidFetchUserVaultEquitiesSummary, hyperliquidFetchVaultCatalogSummary, hyperliquidFetchVaultSummaries, hyperliquidInferDexFromCoin, hyperliquidIsSpotAssetId, hyperliquidMarketSymbol, hyperliquidProtocolModule, hyperliquidResolveAsset, hyperliquidResolveOhlcvWindow, hyperliquidResolvePerpAsset, hyperliquidResolvePerpMarket, hyperliquidResolveSpotAsset, hyperliquidResolveTif, hyperliquidSearchMarkets, hyperliquidSearchMarketsSummary, hyperliquidVaultStatsUrl, isHyperliquidChainSupported };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map