opentool 0.13.0 → 0.15.0

package/dist/adapters/hyperliquid/browser.js

@@ -156,11 +156,31 @@ function computeHyperliquidMarketIocLimitPrice(params) {
   const slippage = bps / 1e4;
   const multiplier = params.side === "buy" ? 1 + slippage : 1 - slippage;
   const price = params.markPrice * multiplier;
-  return formatRoundedDecimal(price, decimals);
+  const precision = Math.max(0, Math.min(12, Math.floor(decimals)));
+  const factor = 10 ** precision;
+  const scaled = price * factor;
+  const directionalRounded = params.side === "buy" ? Math.ceil(scaled) / factor : Math.floor(scaled) / factor;
+  return formatRoundedDecimal(directionalRounded, precision);
 }
 var HyperliquidApiError = class extends Error {
   constructor(message, response) {
-    super(message);
+    const responseRecord = response && typeof response === "object" ? response : null;
+    const explicitErrors = Array.isArray(responseRecord?.errors) ? responseRecord.errors.filter(
+      (entry) => typeof entry === "string" && entry.trim().length > 0
+    ) : [];
+    const bodyStatuses = responseRecord?.body && typeof responseRecord.body === "object" && responseRecord.body !== null && "response" in responseRecord.body ? (responseRecord.body.response?.data?.statuses ?? []).map((status) => typeof status?.error === "string" ? status.error : null).filter((entry) => Boolean(entry && entry.trim().length > 0)) : [];
+    const singleStatusError = responseRecord?.body && typeof responseRecord.body === "object" && responseRecord.body !== null && "response" in responseRecord.body ? responseRecord.body.response?.data?.status?.error : null;
+    const details = Array.from(
+      new Set(
+        [
+          ...explicitErrors,
+          ...bodyStatuses,
+          typeof singleStatusError === "string" ? singleStatusError : null
+        ].filter((entry) => Boolean(entry && entry.trim().length > 0))
+      )
+    );
+    const enrichedMessage = details.length > 0 ? `${message} ${details.join(" | ")}` : message;
+    super(enrichedMessage);
     this.response = response;
     this.name = "HyperliquidApiError";
   }
@@ -388,7 +408,14 @@ async function resolveHyperliquidAssetIndex(args) {
 }
 function toApiDecimal(value) {
   if (typeof value === "string") {
-    return value;
+    const trimmed = value.trim();
+    if (!trimmed.length) {
+      throw new Error("Decimal strings must be non-empty.");
+    }
+    if (!/^-?(?:\d+\.?\d*|\.\d+)$/.test(trimmed)) {
+      throw new Error("Decimal strings must be plain base-10 numbers.");
+    }
+    return trimmed.replace(/^(-?)0+(?=\d)/, "$1").replace(/\.0*$|(\.\d+?)0+$/, "$1").replace(/^(-?)\./, "$10.").replace(/^-?$/, "0").replace(/^-0$/, "0");
   }
   if (typeof value === "bigint") {
     return value.toString();
@@ -1224,7 +1251,7 @@ async function placeHyperliquidTwapOrder(options) {
     symbol: twap.symbol,
     baseUrl: API_BASES[env],
     environment: env,
-    fetcher: fetch
+    fetcher: (...args) => fetch(...args)
   });
   const action = {
     type: "twapOrder",
@@ -1246,7 +1273,7 @@ async function cancelHyperliquidTwapOrder(options) {
     symbol: options.cancel.symbol,
     baseUrl: API_BASES[env],
     environment: env,
-    fetcher: fetch
+    fetcher: (...args) => fetch(...args)
   });
   const action = {
     type: "twapCancel",
@@ -1263,7 +1290,7 @@ async function updateHyperliquidLeverage(options) {
     symbol: options.input.symbol,
     baseUrl: API_BASES[env],
     environment: env,
-    fetcher: fetch
+    fetcher: (...args) => fetch(...args)
   });
   const action = {
     type: "updateLeverage",
@@ -1281,7 +1308,7 @@ async function updateHyperliquidIsolatedMargin(options) {
     symbol: options.input.symbol,
     baseUrl: API_BASES[env],
     environment: env,
-    fetcher: fetch
+    fetcher: (...args) => fetch(...args)
   });
   const action = {
     type: "updateIsolatedMargin",
@@ -1396,7 +1423,7 @@ async function withAssetIndexes(options, entries, mapper) {
         symbol: entry.symbol,
         baseUrl: API_BASES[env],
         environment: env,
-        fetcher: fetch
+        fetcher: (...args) => fetch(...args)
       });
       return mapper(assetIndex, entry);
     })
@@ -1411,7 +1438,7 @@ async function buildOrder(intent, options) {
     symbol: intent.symbol,
     baseUrl: API_BASES[env],
     environment: env,
-    fetcher: fetch
+    fetcher: (...args) => fetch(...args)
   });
   const limitOrTrigger = intent.trigger ? mapTrigger(intent.trigger) : {
     limit: {
@@ -1574,7 +1601,7 @@ function assertPositiveDecimalInput(value, label) {
   if (!trimmed.length) {
     throw new Error(`${label} must be a non-empty string.`);
   }
-  if (!/^(?:\\d+\\.?\\d*|\\.\\d+)$/.test(trimmed)) {
+  if (!/^(?:\d+\.?\d*|\.\d+)$/.test(trimmed)) {
     throw new Error(`${label} must be a positive decimal string.`);
   }
   const numeric = Number(trimmed);
@@ -1587,10 +1614,10 @@ function normalizePositiveDecimalString(raw, label) {
   if (!trimmed.length) {
     throw new Error(`${label} must be a non-empty decimal string.`);
   }
-  if (!/^(?:\\d+\\.?\\d*|\\.\\d+)$/.test(trimmed)) {
+  if (!/^(?:\d+\.?\d*|\.\d+)$/.test(trimmed)) {
     throw new Error(`${label} must be a positive decimal string.`);
   }
-  const normalized = trimmed.replace(/^0+(?=\\d)/, "").replace(/(\\.\\d*?)0+$/, "$1").replace(/\\.$/, "");
+  const normalized = trimmed.replace(/^0+(?=\d)/, "").replace(/(\.\d*?)0+$/, "$1").replace(/\.$/, "");
   const numeric = Number(normalized);
   if (!Number.isFinite(numeric) || numeric <= 0) {
     throw new Error(`${label} must be positive.`);
@@ -1626,7 +1653,7 @@ async function placeHyperliquidOrder(options) {
         symbol: intent.symbol,
         baseUrl: resolvedBaseUrl,
         environment: inferredEnvironment,
-        fetcher: fetch
+        fetcher: (...args) => fetch(...args)
       });
       const order = {
         a: assetIndex,
@@ -1925,6 +1952,812 @@ function createHyperliquidActionHash(params) {
   return createL1ActionHash(params);
 }
 
-export { DEFAULT_HYPERLIQUID_MARKET_SLIPPAGE_BPS, HyperliquidApiError, HyperliquidBuilderApprovalError, HyperliquidExchangeClient, HyperliquidGuardError, HyperliquidInfoClient, HyperliquidTermsError, approveHyperliquidBuilderFee, batchModifyHyperliquidOrders, buildHyperliquidMarketIdentity, cancelAllHyperliquidOrders, cancelHyperliquidOrders, cancelHyperliquidOrdersByCloid, cancelHyperliquidTwapOrder, computeHyperliquidMarketIocLimitPrice, createHyperliquidActionHash, createHyperliquidSubAccount, createMonotonicNonceFactory, depositToHyperliquidBridge, fetchHyperliquidAssetCtxs, fetchHyperliquidClearinghouseState, fetchHyperliquidFrontendOpenOrders, fetchHyperliquidHistoricalOrders, fetchHyperliquidMeta, fetchHyperliquidMetaAndAssetCtxs, fetchHyperliquidOpenOrders, fetchHyperliquidOrderStatus, fetchHyperliquidPreTransferCheck, fetchHyperliquidSpotAssetCtxs, fetchHyperliquidSpotClearinghouseState, fetchHyperliquidSpotMeta, fetchHyperliquidSpotMetaAndAssetCtxs, fetchHyperliquidUserFills, fetchHyperliquidUserFillsByTime, fetchHyperliquidUserRateLimit, getHyperliquidMaxBuilderFee, modifyHyperliquidOrder, placeHyperliquidOrder, placeHyperliquidTwapOrder, reserveHyperliquidRequestWeight, resolveHyperliquidAbstractionFromMode, scheduleHyperliquidCancel, sendHyperliquidSpot, setHyperliquidAccountAbstractionMode, setHyperliquidDexAbstraction, setHyperliquidPortfolioMargin, transferHyperliquidSubAccount, updateHyperliquidIsolatedMargin, updateHyperliquidLeverage, withdrawFromHyperliquid };
+// src/adapters/hyperliquid/symbols.ts
+var UNKNOWN_SYMBOL2 = "UNKNOWN";
+function extractHyperliquidDex(symbol) {
+  const idx = symbol.indexOf(":");
+  if (idx <= 0) return null;
+  const dex = symbol.slice(0, idx).trim().toLowerCase();
+  return dex || null;
+}
+function parseHyperliquidSymbol(value) {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("@")) {
+    return {
+      raw: trimmed,
+      kind: "spotIndex",
+      normalized: trimmed,
+      routeTicker: trimmed,
+      displaySymbol: trimmed,
+      base: null,
+      quote: null,
+      pair: null,
+      dex: null,
+      leverageMode: "cross"
+    };
+  }
+  const dex = extractHyperliquidDex(trimmed);
+  const pair = resolveHyperliquidPair(trimmed);
+  const base = normalizeHyperliquidBaseSymbol(trimmed);
+  if (dex) {
+    if (!base) return null;
+    return {
+      raw: trimmed,
+      kind: "perp",
+      normalized: `${dex}:${base}`,
+      routeTicker: `${dex}:${base}`,
+      displaySymbol: `${dex.toUpperCase()}:${base}-USDC`,
+      base,
+      quote: null,
+      pair: null,
+      dex,
+      leverageMode: "isolated"
+    };
+  }
+  if (pair) {
+    const [pairBase, pairQuote] = pair.split("/");
+    return {
+      raw: trimmed,
+      kind: "spot",
+      normalized: pair,
+      routeTicker: pair.replace("/", "-"),
+      displaySymbol: pair.replace("/", "-"),
+      base: pairBase ?? null,
+      quote: pairQuote ?? null,
+      pair,
+      dex: null,
+      leverageMode: "cross"
+    };
+  }
+  if (!base) return null;
+  return {
+    raw: trimmed,
+    kind: "perp",
+    normalized: base,
+    routeTicker: base,
+    displaySymbol: `${base}-USDC`,
+    base,
+    quote: null,
+    pair: null,
+    dex: null,
+    leverageMode: "cross"
+  };
+}
+function normalizeSpotTokenName2(value) {
+  const raw = (value ?? "").trim();
+  if (!raw) return "";
+  if (raw.endsWith("0") && raw.length > 1) {
+    return raw.slice(0, -1);
+  }
+  return raw;
+}
+function normalizeHyperliquidBaseSymbol(value) {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  const withoutDex = trimmed.includes(":") ? trimmed.split(":").slice(1).join(":") : trimmed;
+  const base = withoutDex.split("-")[0] ?? withoutDex;
+  const baseNoPair = base.split("/")[0] ?? base;
+  const normalized = baseNoPair.trim().toUpperCase();
+  if (!normalized || normalized === UNKNOWN_SYMBOL2) return null;
+  return normalized;
+}
+function normalizeHyperliquidMetaSymbol(symbol) {
+  const trimmed = symbol.trim();
+  const noDex = trimmed.includes(":") ? trimmed.split(":").slice(1).join(":") : trimmed;
+  const noPair = noDex.split("-")[0] ?? noDex;
+  return (noPair.split("/")[0] ?? noPair).trim();
+}
+function resolveHyperliquidPair(value) {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  const withoutDex = trimmed.includes(":") ? trimmed.split(":").slice(1).join(":") : trimmed;
+  if (withoutDex.includes("/")) {
+    return withoutDex.toUpperCase();
+  }
+  if (withoutDex.includes("-")) {
+    const [base, ...rest] = withoutDex.split("-");
+    const quote = rest.join("-").trim();
+    if (!base || !quote) return null;
+    return `${base.toUpperCase()}/${quote.toUpperCase()}`;
+  }
+  return null;
+}
+function resolveHyperliquidLeverageMode(symbol) {
+  return symbol.includes(":") ? "isolated" : "cross";
+}
+function resolveHyperliquidProfileChain(environment) {
+  return environment === "testnet" ? "hyperliquid-testnet" : "hyperliquid";
+}
+function buildHyperliquidProfileAssets(params) {
+  const chain = resolveHyperliquidProfileChain(params.environment);
+  return params.assets.map((asset) => {
+    const symbols = asset.assetSymbols.map((symbol) => normalizeHyperliquidBaseSymbol(symbol)).filter((symbol) => Boolean(symbol));
+    if (symbols.length === 0) return null;
+    const explicitPair = typeof asset.pair === "string" ? resolveHyperliquidPair(asset.pair) : null;
+    const derivedPair = symbols.length === 1 ? resolveHyperliquidPair(asset.assetSymbols[0] ?? symbols[0]) : null;
+    const pair = explicitPair ?? derivedPair ?? void 0;
+    const leverage = typeof asset.leverage === "number" && Number.isFinite(asset.leverage) && asset.leverage > 0 ? asset.leverage : void 0;
+    const walletAddress = typeof asset.walletAddress === "string" && asset.walletAddress.trim().length > 0 ? asset.walletAddress.trim() : void 0;
+    return {
+      venue: "hyperliquid",
+      chain,
+      assetSymbols: symbols,
+      ...pair ? { pair } : {},
+      ...leverage ? { leverage } : {},
+      ...walletAddress ? { walletAddress } : {}
+    };
+  }).filter((asset) => asset !== null);
+}
+function parseSpotPairSymbol(symbol) {
+  const trimmed = symbol.trim();
+  if (!trimmed.includes("/")) return null;
+  const [rawBase, rawQuote] = trimmed.split("/");
+  const base = rawBase?.trim().toUpperCase() ?? "";
+  const quote = rawQuote?.trim().toUpperCase() ?? "";
+  if (!base || !quote) return null;
+  return { base, quote };
+}
+function isHyperliquidSpotSymbol(symbol) {
+  return symbol.startsWith("@") || symbol.includes("/");
+}
+function resolveSpotMidCandidates(baseSymbol) {
+  const base = baseSymbol.trim().toUpperCase();
+  if (!base) return [];
+  const candidates = [base];
+  if (base.startsWith("U") && base.length > 1) {
+    candidates.push(base.slice(1));
+  }
+  return Array.from(new Set(candidates));
+}
+function resolveSpotTokenCandidates(value) {
+  const normalized = normalizeSpotTokenName2(value).toUpperCase();
+  if (!normalized) return [];
+  const candidates = [normalized];
+  if (normalized.startsWith("U") && normalized.length > 1) {
+    candidates.push(normalized.slice(1));
+  }
+  return Array.from(new Set(candidates));
+}
+function resolveHyperliquidOrderSymbol(value) {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("@")) return trimmed;
+  if (trimmed.includes(":")) {
+    const [rawDex, ...restParts] = trimmed.split(":");
+    const dex = rawDex.trim().toLowerCase();
+    const rest = restParts.join(":");
+    const base = rest.split("/")[0]?.split("-")[0] ?? rest;
+    const normalizedBase = base.trim().toUpperCase();
+    if (!dex || !normalizedBase || normalizedBase === UNKNOWN_SYMBOL2) {
+      return null;
+    }
+    return `${dex}:${normalizedBase}`;
+  }
+  const pair = resolveHyperliquidPair(trimmed);
+  if (pair) return pair;
+  return normalizeHyperliquidBaseSymbol(trimmed);
+}
+function resolveHyperliquidSymbol(asset, override) {
+  const raw = override && override.trim().length > 0 ? override.trim() : asset.trim();
+  if (!raw) return raw;
+  if (raw.startsWith("@")) return raw;
+  if (raw.includes(":")) {
+    const [dexRaw, ...restParts] = raw.split(":");
+    const dex = dexRaw.trim().toLowerCase();
+    const rest = restParts.join(":");
+    const base2 = rest.split("/")[0]?.split("-")[0] ?? rest;
+    const normalizedBase = base2.trim().toUpperCase();
+    if (!dex) return normalizedBase;
+    return `${dex}:${normalizedBase}`;
+  }
+  if (raw.includes("/")) {
+    return raw.toUpperCase();
+  }
+  if (raw.includes("-")) {
+    const [base2, ...rest] = raw.split("-");
+    const quote = rest.join("-").trim();
+    if (base2 && quote) {
+      return `${base2.toUpperCase()}/${quote.toUpperCase()}`;
+    }
+  }
+  const base = raw.split("-")[0] ?? raw;
+  const baseNoPair = base.split("/")[0] ?? base;
+  return baseNoPair.trim().toUpperCase();
+}
+function resolveHyperliquidPerpSymbol(asset) {
+  const raw = asset.trim();
+  if (!raw) return raw;
+  const dex = extractHyperliquidDex(raw);
+  const base = normalizeHyperliquidBaseSymbol(raw) ?? raw.toUpperCase();
+  return dex ? `${dex}:${base}` : base;
+}
+function resolveHyperliquidSpotSymbol(asset, defaultQuote = "USDC") {
+  const quote = defaultQuote.trim().toUpperCase() || "USDC";
+  const raw = asset.trim().toUpperCase();
+  if (!raw) {
+    return { symbol: raw, base: raw, quote };
+  }
+  const pair = resolveHyperliquidPair(raw);
+  if (pair) {
+    const [base2, pairQuote] = pair.split("/");
+    return {
+      symbol: pair,
+      base: base2?.trim() ?? raw,
+      quote: pairQuote?.trim() ?? quote
+    };
+  }
+  const base = normalizeHyperliquidBaseSymbol(raw) ?? raw;
+  return { symbol: `${base}/${quote}`, base, quote };
+}
+function gcd(a, b) {
+  let left = a < 0n ? -a : a;
+  let right = b < 0n ? -b : b;
+  while (right !== 0n) {
+    const next = left % right;
+    left = right;
+    right = next;
+  }
+  return left;
+}
+function maxDecimals(values) {
+  let max = 0;
+  for (const value of values) {
+    const dot = value.indexOf(".");
+    if (dot === -1) continue;
+    const decimals = value.length - dot - 1;
+    if (decimals > max) max = decimals;
+  }
+  return max;
+}
+function toScaledInt(value, decimals) {
+  const trimmed = value.trim();
+  const negative = trimmed.startsWith("-");
+  const unsigned = negative ? trimmed.slice(1) : trimmed;
+  const [intPart, fracPart = ""] = unsigned.split(".");
+  const padded = fracPart.padEnd(decimals, "0").slice(0, decimals);
+  const combined = `${intPart || "0"}${padded}`;
+  const asInt = BigInt(combined || "0");
+  return negative ? -asInt : asInt;
+}
+function resolveSpotSizeDecimals(meta, symbol) {
+  const universe = meta.universe ?? [];
+  const tokens = meta.tokens ?? [];
+  if (!universe.length || !tokens.length) {
+    throw new Error(`Spot metadata unavailable for ${symbol}.`);
+  }
+  const tokenMap = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    const index = token?.index;
+    const szDecimals = typeof token?.szDecimals === "number" ? token.szDecimals : null;
+    if (typeof index !== "number" || szDecimals == null) continue;
+    tokenMap.set(index, {
+      name: normalizeSpotTokenName2(token?.name),
+      szDecimals
+    });
+  }
+  if (symbol.startsWith("@")) {
+    const targetIndex = Number.parseInt(symbol.slice(1), 10);
+    if (!Number.isFinite(targetIndex)) {
+      throw new Error(`Invalid spot pair id: ${symbol}`);
+    }
+    for (let idx = 0; idx < universe.length; idx += 1) {
+      const market = universe[idx];
+      const marketIndex = typeof market?.index === "number" ? market.index : idx;
+      if (marketIndex !== targetIndex) continue;
+      const [baseIndex] = Array.isArray(market?.tokens) ? market.tokens : [];
+      const baseToken = tokenMap.get(baseIndex ?? -1);
+      if (!baseToken) break;
+      return baseToken.szDecimals;
+    }
+    throw new Error(`Unknown spot pair id: ${symbol}`);
+  }
+  const pair = parseSpotPairSymbol(symbol);
+  if (!pair) {
+    throw new Error(`Invalid spot symbol: ${symbol}`);
+  }
+  const normalizedBase = normalizeSpotTokenName2(pair.base).toUpperCase();
+  const normalizedQuote = normalizeSpotTokenName2(pair.quote).toUpperCase();
+  for (const market of universe) {
+    const [baseIndex, quoteIndex] = Array.isArray(market?.tokens) ? market.tokens : [];
+    const baseToken = tokenMap.get(baseIndex ?? -1);
+    const quoteToken = tokenMap.get(quoteIndex ?? -1);
+    if (!baseToken || !quoteToken) continue;
+    if (baseToken.name.toUpperCase() === normalizedBase && quoteToken.name.toUpperCase() === normalizedQuote) {
+      return baseToken.szDecimals;
+    }
+  }
+  throw new Error(`No size decimals found for ${symbol}.`);
+}
+async function fetchHyperliquidTickSize(params) {
+  return fetchHyperliquidTickSizeForCoin(params.environment, params.symbol);
+}
+async function fetchHyperliquidTickSizeForCoin(environment, coin) {
+  const base = API_BASES[environment];
+  const res = await fetch(`${base}/info`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ type: "l2Book", coin })
+  });
+  if (!res.ok) {
+    throw new Error(`Hyperliquid l2Book failed for ${coin}`);
+  }
+  const data = await res.json().catch(() => null);
+  const levels = Array.isArray(data?.levels) ? data?.levels ?? [] : [];
+  const prices = levels.flatMap((side) => Array.isArray(side) ? side.map((entry) => String(entry?.px ?? "")) : []).filter((px) => px.length > 0);
+  if (prices.length < 2) {
+    throw new Error(`Hyperliquid l2Book missing price levels for ${coin}`);
+  }
+  const decimals = maxDecimals(prices);
+  const scaled = prices.map((px) => toScaledInt(px, decimals));
+  const unique = Array.from(new Set(scaled.map((v) => v.toString()))).map((v) => BigInt(v)).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  let tick = 0n;
+  for (let i = 1; i < unique.length; i += 1) {
+    const diff = unique[i] - unique[i - 1];
+    if (diff <= 0n) continue;
+    tick = tick === 0n ? diff : gcd(tick, diff);
+  }
+  if (tick === 0n) {
+    tick = 1n;
+  }
+  return { tickSizeInt: tick, tickDecimals: decimals };
+}
+async function fetchHyperliquidSizeDecimals(params) {
+  const { symbol, environment } = params;
+  if (isHyperliquidSpotSymbol(symbol)) {
+    const meta2 = await fetchHyperliquidSpotMeta(environment);
+    return resolveSpotSizeDecimals(meta2, symbol);
+  }
+  const meta = await fetchHyperliquidMeta(environment);
+  const universe = Array.isArray(meta?.universe) ? meta.universe : [];
+  const normalized = normalizeHyperliquidMetaSymbol(symbol).toUpperCase();
+  const match = universe.find(
+    (entry) => normalizeHyperliquidMetaSymbol(entry?.name ?? "").toUpperCase() === normalized
+  );
+  if (!match || typeof match.szDecimals !== "number") {
+    throw new Error(`No size decimals found for ${symbol}.`);
+  }
+  return match.szDecimals;
+}
+
+// src/adapters/hyperliquid/order-utils.ts
+function countDecimalPlaces(value) {
+  const [, dec = ""] = value.split(".");
+  return dec.length;
+}
+function assertNumberString(value) {
+  if (!/^-?(?:\d+\.?\d*|\.\d+)$/.test(value)) {
+    throw new TypeError("Invalid decimal number string.");
+  }
+}
+function normalizeDecimalString(value) {
+  return value.trim().replace(/^(-?)0+(?=\d)/, "$1").replace(/\.0*$|(\.\d+?)0+$/, "$1").replace(/^(-?)\./, "$10.").replace(/^-?$/, "0").replace(/^-0$/, "0");
+}
+var StringMath = {
+  log10Floor(value) {
+    const abs = value.startsWith("-") ? value.slice(1) : value;
+    const num = Number(abs);
+    if (!Number.isFinite(num) || num === 0) return -Infinity;
+    const [intPart, fracPart = ""] = abs.split(".");
+    if (Number(intPart) !== 0) {
+      return intPart.replace(/^0+/, "").length - 1;
+    }
+    const leadingZeros = fracPart.match(/^0*/)?.[0]?.length ?? 0;
+    return -(leadingZeros + 1);
+  },
+  multiplyByPow10(value, exp) {
+    if (!Number.isInteger(exp)) {
+      throw new RangeError("Exponent must be an integer.");
+    }
+    if (exp === 0) return normalizeDecimalString(value);
+    const negative = value.startsWith("-");
+    const abs = negative ? value.slice(1) : value;
+    const [intRaw, fracRaw = ""] = abs.split(".");
+    const intPart = intRaw || "0";
+    let output;
+    if (exp > 0) {
+      if (exp >= fracRaw.length) {
+        output = intPart + fracRaw + "0".repeat(exp - fracRaw.length);
+      } else {
+        output = `${intPart}${fracRaw.slice(0, exp)}.${fracRaw.slice(exp)}`;
+      }
+    } else {
+      const absExp = -exp;
+      if (absExp >= intPart.length) {
+        output = `0.${"0".repeat(absExp - intPart.length)}${intPart}${fracRaw}`;
+      } else {
+        output = `${intPart.slice(0, -absExp)}.${intPart.slice(-absExp)}${fracRaw}`;
+      }
+    }
+    return normalizeDecimalString((negative ? "-" : "") + output);
+  },
+  trunc(value) {
+    const index = value.indexOf(".");
+    return index === -1 ? value : value.slice(0, index) || "0";
+  },
+  roundInteger(value, mode) {
+    const normalized = normalizeDecimalString(value);
+    const negative = normalized.startsWith("-");
+    if (negative) {
+      throw new RangeError("Directional rounding only supports positive values.");
+    }
+    const [intPartRaw, fracPart = ""] = normalized.split(".");
+    const intPart = intPartRaw.replace(/^0+(?=\d)/, "") || "0";
+    const hasFraction = /[1-9]/.test(fracPart);
+    if (!hasFraction) return intPart;
+    if (mode === "down") return intPart;
+    const digits = intPart.split("");
+    let carry = 1;
+    for (let idx = digits.length - 1; idx >= 0 && carry > 0; idx -= 1) {
+      const next = Number(digits[idx] ?? "0") + carry;
+      digits[idx] = String(next % 10);
+      carry = next >= 10 ? 1 : 0;
+    }
+    if (carry > 0) {
+      digits.unshift("1");
+    }
+    return digits.join("").replace(/^0+(?=\d)/, "") || "0";
+  },
+  toPrecisionTruncate(value, precision) {
+    if (!Number.isInteger(precision) || precision < 1) {
+      throw new RangeError("Precision must be a positive integer.");
+    }
+    if (/^-?0+(\.0*)?$/.test(value)) return "0";
+    const negative = value.startsWith("-");
+    const abs = negative ? value.slice(1) : value;
+    const magnitude = StringMath.log10Floor(abs);
+    const shiftAmount = precision - magnitude - 1;
+    const shifted = StringMath.multiplyByPow10(abs, shiftAmount);
+    const truncated = StringMath.trunc(shifted);
+    const shiftedBack = StringMath.multiplyByPow10(truncated, -shiftAmount);
+    return normalizeDecimalString(negative ? `-${shiftedBack}` : shiftedBack);
+  },
+  toFixedTruncate(value, decimals) {
+    if (!Number.isInteger(decimals) || decimals < 0) {
+      throw new RangeError("Decimals must be a non-negative integer.");
+    }
+    const matcher = new RegExp(`^-?(?:\\d+)?(?:\\.\\d{0,${decimals}})?`);
+    const result = value.match(matcher)?.[0];
+    if (!result) {
+      throw new TypeError("Invalid number format.");
+    }
+    return normalizeDecimalString(result);
+  }
+};
+function ceilDiv(numerator, denominator) {
+  if (denominator <= 0n) {
+    throw new RangeError("Denominator must be positive.");
+  }
+  return (numerator + denominator - 1n) / denominator;
+}
+function scaleDecimalToInt(value, decimals, mode) {
+  if (!Number.isInteger(decimals) || decimals < 0) {
+    throw new RangeError("Decimals must be a non-negative integer.");
+  }
+  const normalized = normalizeDecimalString(value);
+  assertNumberString(normalized);
+  const negative = normalized.startsWith("-");
+  if (negative) {
+    throw new RangeError("Only positive values are supported.");
+  }
+  const shifted = StringMath.multiplyByPow10(normalized, decimals);
+  const rounded = StringMath.roundInteger(shifted, mode);
+  return BigInt(rounded);
+}
+function formatScaledDecimal(value, decimals) {
+  if (!Number.isInteger(decimals) || decimals < 0) {
+    throw new RangeError("Decimals must be a non-negative integer.");
+  }
+  const negative = value < 0n;
+  const abs = negative ? -value : value;
+  const raw = abs.toString();
+  if (decimals === 0) {
+    return `${negative ? "-" : ""}${raw}`;
+  }
+  const padded = raw.padStart(decimals + 1, "0");
+  const intPart = padded.slice(0, -decimals) || "0";
+  const fracPart = padded.slice(-decimals);
+  return normalizeDecimalString(`${negative ? "-" : ""}${intPart}.${fracPart}`);
+}
+function formatHyperliquidPrice(price, szDecimals, marketType = "perp") {
+  const normalized = price.toString().trim();
+  assertNumberString(normalized);
+  if (/^-?\d+$/.test(normalized)) {
+    return normalizeDecimalString(normalized);
+  }
+  const maxDecimals2 = Math.max((marketType === "perp" ? 6 : 8) - szDecimals, 0);
+  const decimalsTrimmed = StringMath.toFixedTruncate(normalized, maxDecimals2);
+  const sigFigTrimmed = StringMath.toPrecisionTruncate(decimalsTrimmed, 5);
+  if (sigFigTrimmed === "0") {
+    throw new RangeError("Price is too small and was truncated to 0.");
+  }
+  return sigFigTrimmed;
+}
+function formatHyperliquidSize(size, szDecimals) {
+  const normalized = size.toString().trim();
+  assertNumberString(normalized);
+  const truncated = StringMath.toFixedTruncate(normalized, szDecimals);
+  if (truncated === "0") {
+    throw new RangeError("Size is too small and was truncated to 0.");
+  }
+  return truncated;
+}
+function roundHyperliquidPriceToTick(price, tick, side) {
+  if (!Number.isFinite(tick.tickDecimals) || tick.tickDecimals < 0) {
+    throw new Error("tick.tickDecimals must be a non-negative number.");
+  }
+  if (tick.tickSizeInt <= 0n) {
+    throw new Error("tick.tickSizeInt must be positive.");
+  }
+  const normalized = normalizeDecimalString(price.toString());
+  assertNumberString(normalized);
+  if (Number.parseFloat(normalized) <= 0) {
+    throw new Error("Price must be positive.");
+  }
+  const scaled = scaleDecimalToInt(
+    normalized,
+    tick.tickDecimals,
+    side === "buy" ? "up" : "down"
+  );
+  const tickSize = tick.tickSizeInt;
+  const rounded = side === "sell" ? scaled / tickSize * tickSize : (scaled + tickSize - 1n) / tickSize * tickSize;
+  return formatScaledDecimal(rounded, tick.tickDecimals);
+}
+function formatHyperliquidMarketablePrice(params) {
+  const { mid, side, slippageBps, tick } = params;
+  if (!Number.isFinite(mid) || mid <= 0) {
+    throw new Error("mid must be a positive number.");
+  }
+  if (!Number.isFinite(slippageBps) || slippageBps < 0) {
+    throw new Error("slippageBps must be a non-negative number.");
+  }
+  const midString = normalizeDecimalString(mid.toString());
+  const baseDecimals = countDecimalPlaces(midString);
+  const workDecimals = Math.max(baseDecimals + 4, tick?.tickDecimals ?? 0, 8);
+  const scaledMid = scaleDecimalToInt(midString, workDecimals, "down");
+  const slippageNumerator = BigInt(
+    side === "buy" ? 1e4 + slippageBps : 1e4 - slippageBps
+  );
+  const adjustedScaled = side === "buy" ? ceilDiv(scaledMid * slippageNumerator, 10000n) : scaledMid * slippageNumerator / 10000n;
+  const adjusted = formatScaledDecimal(adjustedScaled, workDecimals);
+  if (tick) {
+    return roundHyperliquidPriceToTick(adjusted, tick, side);
+  }
+  const roundedScaled = scaleDecimalToInt(
+    adjusted,
+    baseDecimals,
+    side === "buy" ? "up" : "down"
+  );
+  return formatScaledDecimal(roundedScaled, baseDecimals);
+}
+
+// src/adapters/hyperliquid/tpsl.ts
+var DEFAULT_HYPERLIQUID_TPSL_MARKET_SLIPPAGE_BPS = 1e3;
+function toDecimalInput(value, label) {
+  if (typeof value === "bigint") {
+    if (value <= 0n) {
+      throw new Error(`${label} must be positive.`);
+    }
+    return value.toString();
+  }
+  return value;
+}
+function toPositiveNumber(value, label) {
+  if (typeof value === "bigint") {
+    if (value <= 0n) {
+      throw new Error(`${label} must be positive.`);
+    }
+    return Number(value);
+  }
+  const numeric = typeof value === "number" ? value : Number.parseFloat(value.toString().trim());
+  if (!Number.isFinite(numeric) || numeric <= 0) {
+    throw new Error(`${label} must be positive.`);
+  }
+  return numeric;
+}
+function normalizeExecutionType(value) {
+  return value ?? "market";
+}
+function resolveTriggerDirection(params) {
+  const isLong = params.parentSide === "buy";
+  if (params.leg === "tp") {
+    if (isLong && params.triggerPx <= params.referencePrice) {
+      throw new Error("Take profit trigger must be above the current price for long positions.");
+    }
+    if (!isLong && params.triggerPx >= params.referencePrice) {
+      throw new Error("Take profit trigger must be below the current price for short positions.");
+    }
+    return;
+  }
+  if (isLong && params.triggerPx >= params.referencePrice) {
+    throw new Error("Stop loss trigger must be below the current price for long positions.");
+  }
+  if (!isLong && params.triggerPx <= params.referencePrice) {
+    throw new Error("Stop loss trigger must be above the current price for short positions.");
+  }
+}
+async function buildTpSlChildOrder(params) {
+  const marketType = isHyperliquidSpotSymbol(params.symbol) ? "spot" : "perp";
+  const [szDecimals, tick] = await Promise.all([
+    fetchHyperliquidSizeDecimals({
+      environment: params.environment,
+      symbol: params.symbol
+    }),
+    fetchHyperliquidTickSize({
+      environment: params.environment,
+      symbol: params.symbol
+    }).catch(() => null)
+  ]);
+  const childSide = params.parentSide === "buy" ? "sell" : "buy";
+  const triggerPxNumeric = toPositiveNumber(params.leg.triggerPx, `${params.legType} triggerPx`);
+  resolveTriggerDirection({
+    leg: params.legType,
+    parentSide: params.parentSide,
+    referencePrice: params.referencePrice,
+    triggerPx: triggerPxNumeric
+  });
+  const execution = normalizeExecutionType(params.leg.execution);
+  const size = formatHyperliquidSize(toDecimalInput(params.size, "size"), szDecimals);
+  const triggerPx = formatHyperliquidPrice(triggerPxNumeric, szDecimals, marketType);
+  const explicitLimitPrice = params.leg.price != null ? toDecimalInput(params.leg.price, `${params.legType} price`) : null;
+  const explicitLimitPriceNumeric = explicitLimitPrice != null ? toPositiveNumber(explicitLimitPrice, `${params.legType} price`) : null;
+  if (execution === "limit" && explicitLimitPriceNumeric == null) {
+    throw new Error(`${params.legType} limit price is required for limit execution.`);
+  }
+  if (execution === "limit" && explicitLimitPriceNumeric != null) {
+    if (childSide === "sell" && explicitLimitPriceNumeric > triggerPxNumeric) {
+      throw new Error(`${params.legType} sell limit price must be at or below the trigger price.`);
+    }
+    if (childSide === "buy" && explicitLimitPriceNumeric < triggerPxNumeric) {
+      throw new Error(`${params.legType} buy limit price must be at or above the trigger price.`);
+    }
+  }
+  const price = execution === "limit" ? formatHyperliquidPrice(
+    explicitLimitPrice,
+    szDecimals,
+    marketType
+  ) : formatHyperliquidMarketablePrice({
+    mid: triggerPxNumeric,
+    side: childSide,
+    slippageBps: params.triggerMarketSlippageBps,
+    tick
+  });
+  return {
+    symbol: params.symbol,
+    side: childSide,
+    price,
+    size,
+    reduceOnly: true,
+    trigger: {
+      triggerPx,
+      isMarket: execution === "market",
+      tpsl: params.legType
+    },
+    ...params.leg.clientId ? { clientId: params.leg.clientId } : {}
+  };
+}
+async function buildAttachedTpSlOrders(params) {
+  const referencePrice = toPositiveNumber(params.referencePrice, "referencePrice");
+  const legs = await Promise.all(
+    [
+      params.takeProfit ? buildTpSlChildOrder({
+        symbol: params.symbol,
+        parentSide: params.parentSide,
+        size: params.size,
+        referencePrice,
+        legType: "tp",
+        leg: params.takeProfit,
+        environment: params.environment,
+        triggerMarketSlippageBps: params.triggerMarketSlippageBps
+      }) : null,
+      params.stopLoss ? buildTpSlChildOrder({
+        symbol: params.symbol,
+        parentSide: params.parentSide,
+        size: params.size,
+        referencePrice,
+        legType: "sl",
+        leg: params.stopLoss,
+        environment: params.environment,
+        triggerMarketSlippageBps: params.triggerMarketSlippageBps
+      }) : null
+    ]
+  );
+  return legs.filter((entry) => Boolean(entry));
+}
+async function placeHyperliquidOrderWithTpSl(options) {
+  const env = options.environment ?? "mainnet";
+  const childOrders = await buildAttachedTpSlOrders({
+    symbol: options.parent.symbol,
+    parentSide: options.parent.side,
+    size: options.parent.size,
+    referencePrice: options.referencePrice,
+    takeProfit: options.takeProfit ?? null,
+    stopLoss: options.stopLoss ?? null,
+    environment: env,
+    triggerMarketSlippageBps: options.triggerMarketSlippageBps ?? DEFAULT_HYPERLIQUID_TPSL_MARKET_SLIPPAGE_BPS
+  });
+  return placeHyperliquidOrder({
+    wallet: options.wallet,
+    orders: [options.parent, ...childOrders],
+    grouping: options.grouping ?? "normalTpsl",
+    environment: env,
+    ...options.vaultAddress ? { vaultAddress: options.vaultAddress } : {},
+    ...typeof options.expiresAfter === "number" ? { expiresAfter: options.expiresAfter } : {},
+    ...typeof options.nonce === "number" ? { nonce: options.nonce } : {},
+    ...options.nonceSource ? { nonceSource: options.nonceSource } : {}
+  });
+}
+async function placeHyperliquidPositionTpSl(options) {
+  const env = options.environment ?? "mainnet";
+  const parentSide = options.positionSide === "long" ? "buy" : "sell";
+  const childOrders = await buildAttachedTpSlOrders({
+    symbol: options.symbol,
+    parentSide,
+    size: options.size,
+    referencePrice: options.referencePrice,
+    takeProfit: options.takeProfit ?? null,
+    stopLoss: options.stopLoss ?? null,
+    environment: env,
+    triggerMarketSlippageBps: options.triggerMarketSlippageBps ?? DEFAULT_HYPERLIQUID_TPSL_MARKET_SLIPPAGE_BPS
+  });
+  if (childOrders.length === 0) {
+    throw new Error("At least one TP or SL order is required.");
+  }
+  return placeHyperliquidOrder({
+    wallet: options.wallet,
+    orders: childOrders,
+    grouping: options.grouping ?? "positionTpsl",
+    environment: env,
+    ...options.vaultAddress ? { vaultAddress: options.vaultAddress } : {},
+    ...typeof options.expiresAfter === "number" ? { expiresAfter: options.expiresAfter } : {},
+    ...typeof options.nonce === "number" ? { nonce: options.nonce } : {},
+    ...options.nonceSource ? { nonceSource: options.nonceSource } : {}
+  });
+}
+
+// src/adapters/hyperliquid/risk-utils.ts
+function toFinitePositive(value) {
+  return Number.isFinite(value) && value > 0 ? value : null;
+}
+function estimateMaintenanceLeverage(maxLeverage) {
+  const normalized = toFinitePositive(maxLeverage);
+  if (!normalized) return null;
+  return normalized * 2;
+}
+function estimateHyperliquidLiquidationPrice(params) {
+  const entryPrice = toFinitePositive(params.entryPrice);
+  const notionalUsd = toFinitePositive(params.notionalUsd);
+  const leverage = toFinitePositive(params.leverage);
+  const maintenanceLeverage = estimateMaintenanceLeverage(params.maxLeverage);
+  if (!entryPrice || !notionalUsd || !leverage || !maintenanceLeverage) {
+    return null;
+  }
+  const size = notionalUsd / entryPrice;
+  if (!Number.isFinite(size) || size <= 0) {
+    return null;
+  }
+  const isolatedMargin = notionalUsd / leverage;
+  const marginAvailable = params.marginMode === "cross" ? Math.max(
+    toFinitePositive(params.availableCollateralUsd ?? 0) ?? isolatedMargin,
+    isolatedMargin
+  ) : isolatedMargin;
+  const sideSign = params.side === "buy" ? 1 : -1;
+  const maintenanceFactor = 1 / maintenanceLeverage;
+  const denominator = 1 - maintenanceFactor * sideSign;
+  if (!Number.isFinite(denominator) || denominator <= 0) {
+    return null;
+  }
+  const liquidationPrice = entryPrice - sideSign * (marginAvailable / size) / denominator;
+  if (!Number.isFinite(liquidationPrice) || liquidationPrice <= 0) {
+    return null;
+  }
+  return liquidationPrice;
+}
+
+export { DEFAULT_HYPERLIQUID_MARKET_SLIPPAGE_BPS, DEFAULT_HYPERLIQUID_TPSL_MARKET_SLIPPAGE_BPS, HyperliquidApiError, HyperliquidBuilderApprovalError, HyperliquidExchangeClient, HyperliquidGuardError, HyperliquidInfoClient, HyperliquidTermsError, approveHyperliquidBuilderFee, batchModifyHyperliquidOrders, buildHyperliquidMarketIdentity, buildHyperliquidProfileAssets, cancelAllHyperliquidOrders, cancelHyperliquidOrders, cancelHyperliquidOrdersByCloid, cancelHyperliquidTwapOrder, computeHyperliquidMarketIocLimitPrice, createHyperliquidActionHash, createHyperliquidSubAccount, createMonotonicNonceFactory, depositToHyperliquidBridge, estimateHyperliquidLiquidationPrice, extractHyperliquidDex, fetchHyperliquidAssetCtxs, fetchHyperliquidClearinghouseState, fetchHyperliquidFrontendOpenOrders, fetchHyperliquidHistoricalOrders, fetchHyperliquidMeta, fetchHyperliquidMetaAndAssetCtxs, fetchHyperliquidOpenOrders, fetchHyperliquidOrderStatus, fetchHyperliquidPreTransferCheck, fetchHyperliquidSizeDecimals, fetchHyperliquidSpotAssetCtxs, fetchHyperliquidSpotClearinghouseState, fetchHyperliquidSpotMeta, fetchHyperliquidSpotMetaAndAssetCtxs, fetchHyperliquidTickSize, fetchHyperliquidUserFills, fetchHyperliquidUserFillsByTime, fetchHyperliquidUserRateLimit, formatHyperliquidMarketablePrice, formatHyperliquidPrice, formatHyperliquidSize, getHyperliquidMaxBuilderFee, isHyperliquidSpotSymbol, modifyHyperliquidOrder, normalizeHyperliquidBaseSymbol, normalizeHyperliquidMetaSymbol, normalizeSpotTokenName2 as normalizeSpotTokenName, parseHyperliquidSymbol, parseSpotPairSymbol, placeHyperliquidOrder, placeHyperliquidOrderWithTpSl, placeHyperliquidPositionTpSl, placeHyperliquidTwapOrder, reserveHyperliquidRequestWeight, resolveHyperliquidAbstractionFromMode, resolveHyperliquidLeverageMode, resolveHyperliquidOrderSymbol, resolveHyperliquidPair, resolveHyperliquidPerpSymbol, resolveHyperliquidProfileChain, resolveHyperliquidSpotSymbol, resolveHyperliquidSymbol, resolveSpotMidCandidates, resolveSpotTokenCandidates, scheduleHyperliquidCancel, sendHyperliquidSpot, setHyperliquidAccountAbstractionMode, setHyperliquidDexAbstraction, setHyperliquidPortfolioMargin, transferHyperliquidSubAccount, updateHyperliquidIsolatedMargin, updateHyperliquidLeverage, withdrawFromHyperliquid };
 //# sourceMappingURL=browser.js.map
 //# sourceMappingURL=browser.js.map