@continuumdao/ctm-mpc-defi 0.2.7 → 0.2.9

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

@@ -0,0 +1,1109 @@
+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";
+
+// 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
+};
+
+// 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 };
+}
+async function hyperliquidFetchCandles(args) {
+  const endTime = args.endTimeMs ?? Date.now();
+  const startTime = args.startTimeMs ?? endTime - 7 * 24 * 60 * 60 * 1e3;
+  const raw = await hyperliquidInfoPost(args.chainId, {
+    type: "candleSnapshot",
+    req: {
+      coin: args.coin,
+      interval: args.interval,
+      startTime,
+      endTime
+    }
+  });
+  const candles = (raw ?? []).map((c) => ({
+    timestampMs: c.t,
+    open: c.o,
+    high: c.h,
+    low: c.l,
+    close: c.c,
+    volume: c.v
+  }));
+  return { candles };
+}
+async function hyperliquidFetchMarketSnapshot(args) {
+  const interval = args.interval ?? "1h";
+  const [{ mids }, { candles }] = await Promise.all([
+    hyperliquidFetchAllMids({ chainId: args.chainId, dex: args.dex }),
+    hyperliquidFetchCandles({ chainId: args.chainId, coin: args.coin, interval })
+  ]);
+  return {
+    coin: args.coin,
+    midUsd: mids[args.coin] ?? null,
+    fetchedAtMs: Date.now(),
+    interval,
+    candles
+  };
+}
+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 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/assets.ts
+async function hyperliquidResolvePerpAsset(args) {
+  const coin = args.coin.trim();
+  const { markets } = await hyperliquidFetchPerpMeta({ chainId: args.chainId, dex: args.dex });
+  const hit = markets.find((m) => m.name.toLowerCase() === coin.toLowerCase());
+  if (!hit) throw new Error(`Unknown Hyperliquid perp market: ${coin}`);
+  return { asset: hit.asset, szDecimals: hit.szDecimals, maxLeverage: hit.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 coin = args.coin.trim();
+  const [{ activeAsset }, { state }] = await Promise.all([
+    hyperliquidFetchActiveAssetData({ chainId: args.chainId, user, coin }),
+    hyperliquidFetchClearinghouseState({ chainId: args.chainId, user, dex: args.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 Promise.all([
+    hyperliquidFetchPerpMeta({ chainId: args.chainId, dex: args.dex }),
+    hyperliquidFetchDexList({ chainId: args.chainId })
+  ]);
+  return { markets, dexes };
+}
+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 snapshot = await hyperliquidFetchMarketSnapshot(args);
+  return { snapshot };
+}
+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_HLP_VAULT_ADDRESS, 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, hyperliquidEncodePx8, hyperliquidEncodeUsd6, hyperliquidEncodeWei8, hyperliquidFetchActiveAssetData, hyperliquidFetchAllMids, hyperliquidFetchCandles, hyperliquidFetchClearinghouseState, hyperliquidFetchDelegations, hyperliquidFetchDelegationsForExecutor, hyperliquidFetchDexList, hyperliquidFetchMarketSnapshot, hyperliquidFetchMarketSnapshotSummary, hyperliquidFetchMarketsSummary, hyperliquidFetchOpenContextSummary, hyperliquidFetchOpenMarketContext, hyperliquidFetchOpenOrders, hyperliquidFetchOpenOrdersSummary, hyperliquidFetchOrdersForExecutor, hyperliquidFetchPerpMeta, hyperliquidFetchPositionDisplayRows, hyperliquidFetchPositionsForExecutor, hyperliquidFetchSpotClearinghouseState, hyperliquidFetchSpotMeta, hyperliquidFetchStakingSummary, hyperliquidFetchStakingSummaryForExecutor, hyperliquidFetchUsdClassBalances, hyperliquidFetchUsdClassBalancesSummary, hyperliquidFetchUserVaultEquities, hyperliquidFetchUserVaultEquitiesSummary, hyperliquidFetchVaultCatalogSummary, hyperliquidFetchVaultSummaries, hyperliquidIsSpotAssetId, hyperliquidProtocolModule, hyperliquidResolveAsset, hyperliquidResolvePerpAsset, hyperliquidResolveSpotAsset, hyperliquidResolveTif, hyperliquidVaultStatsUrl, isHyperliquidChainSupported };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map