opentool 0.8.23 → 0.8.25

package/dist/adapters/hyperliquid/index.js

@@ -6,6 +6,29 @@ import { hexToBytes, concatBytes, bytesToHex } from '@noble/hashes/utils';
 // src/adapters/hyperliquid/index.ts
 
 // src/store/index.ts
+var STORE_EVENT_LEVELS = [
+  "decision",
+  "execution",
+  "lifecycle"
+];
+var STORE_EVENT_LEVEL_SET = new Set(STORE_EVENT_LEVELS);
+var MARKET_REQUIRED_ACTIONS = [
+  "swap",
+  "bridge",
+  "order",
+  "trade",
+  "lend",
+  "borrow",
+  "repay",
+  "stake",
+  "unstake",
+  "withdraw",
+  "provide_liquidity",
+  "remove_liquidity",
+  "claim"
+];
+var MARKET_REQUIRED_ACTIONS_SET = new Set(MARKET_REQUIRED_ACTIONS);
+var EXECUTION_ACTIONS_SET = new Set(MARKET_REQUIRED_ACTIONS);
 var StoreError = class extends Error {
   constructor(message, status, causeData) {
     super(message);
@@ -14,13 +37,57 @@ var StoreError = class extends Error {
     this.name = "StoreError";
   }
 };
+var normalizeAction = (action) => {
+  const normalized = action?.trim().toLowerCase();
+  return normalized ? normalized : null;
+};
+var coerceEventLevel = (value) => {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase();
+  if (!normalized || !STORE_EVENT_LEVEL_SET.has(normalized)) return null;
+  return normalized;
+};
 var requiresMarketIdentity = (input) => {
-  const action = (input.action ?? "").toLowerCase();
-  if (action === "order" || action === "swap" || action === "trade") return true;
-  return false;
+  const action = normalizeAction(input.action);
+  if (!action) return false;
+  return MARKET_REQUIRED_ACTIONS_SET.has(action);
 };
 var hasMarketIdentity = (value) => {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  const requiredKeys = ["market_type", "venue", "environment", "canonical_symbol"];
+  return requiredKeys.every((key) => {
+    const field = record[key];
+    return typeof field === "string" && field.trim().length > 0;
+  });
+};
+var resolveEventLevel = (input) => {
+  const direct = coerceEventLevel(input.eventLevel);
+  if (direct) return direct;
+  const metadataLevel = coerceEventLevel(input.metadata?.eventLevel);
+  if (metadataLevel) return metadataLevel;
+  const action = normalizeAction(input.action);
+  if (action && EXECUTION_ACTIONS_SET.has(action) && (input.metadata?.lifecycle === true || typeof input.metadata?.executionRef === "string" || typeof input.metadata?.parentExecutionRef === "string")) {
+    return "lifecycle";
+  }
+  if (action && EXECUTION_ACTIONS_SET.has(action) || hasMarketIdentity(input.market)) {
+    return "execution";
+  }
+  if (action) return "decision";
+  return null;
+};
+var normalizeStoreInput = (input) => {
+  const metadata = { ...input.metadata ?? {} };
+  const eventLevel = resolveEventLevel({ ...input, metadata });
+  if (eventLevel) {
+    metadata.eventLevel = eventLevel;
+  }
+  const hasMetadata = Object.keys(metadata).length > 0;
+  return {
+    ...input,
+    ...eventLevel ? { eventLevel } : {},
+    ...hasMetadata ? { metadata } : {}
+  };
 };
 function resolveConfig(options) {
   const baseUrl = options?.baseUrl ?? process.env.BASE_URL ?? "https://api.openpond.ai";
@@ -41,8 +108,26 @@ function resolveConfig(options) {
   return { baseUrl: normalizedBaseUrl, apiKey, fetchFn };
 }
 async function store(input, options) {
-  if (requiresMarketIdentity(input) && !hasMarketIdentity(input.market)) {
-    throw new StoreError("market is required for trade events");
+  const normalizedInput = normalizeStoreInput(input);
+  const eventLevel = normalizedInput.eventLevel;
+  const normalizedAction = normalizeAction(normalizedInput.action);
+  if (eventLevel === "execution" || eventLevel === "lifecycle") {
+    if (!normalizedAction || !EXECUTION_ACTIONS_SET.has(normalizedAction)) {
+      throw new StoreError(
+        `eventLevel "${eventLevel}" requires an execution action`
+      );
+    }
+  }
+  if (eventLevel === "execution" && !hasMarketIdentity(normalizedInput.market)) {
+    throw new StoreError(
+      `market is required for execution events. market must include market_type, venue, environment, canonical_symbol`
+    );
+  }
+  const shouldApplyLegacyMarketRule = eventLevel == null || eventLevel === "execution";
+  if (shouldApplyLegacyMarketRule && requiresMarketIdentity(normalizedInput) && !hasMarketIdentity(normalizedInput.market)) {
+    throw new StoreError(
+      `market is required for action "${normalizedInput.action}". market must include market_type, venue, environment, canonical_symbol`
+    );
   }
   const { baseUrl, apiKey, fetchFn } = resolveConfig(options);
   const url = `${baseUrl}/apps/positions/tx`;
@@ -54,7 +139,7 @@ async function store(input, options) {
         "content-type": "application/json",
         "openpond-api-key": apiKey
       },
-      body: JSON.stringify(input)
+      body: JSON.stringify(normalizedInput)
     });
   } catch (error) {
     throw new StoreError("Failed to reach store endpoint", void 0, error);
@@ -493,12 +578,29 @@ function toApiDecimal(value) {
   }
   return asString;
 }
+var NORMALIZED_HEX_PATTERN = /^0x[0-9a-f]+$/;
+var ADDRESS_HEX_LENGTH = 42;
+var CLOID_HEX_LENGTH = 34;
 function normalizeHex(value) {
-  const lower = value.toLowerCase();
-  return lower.replace(/^0x0+/, "0x") || "0x0";
+  const lower = value.trim().toLowerCase();
+  if (!NORMALIZED_HEX_PATTERN.test(lower)) {
+    throw new Error(`Invalid hex value: ${value}`);
+  }
+  return lower;
 }
 function normalizeAddress(value) {
-  return normalizeHex(value);
+  const normalized = normalizeHex(value);
+  if (normalized.length !== ADDRESS_HEX_LENGTH) {
+    throw new Error(`Invalid address length: ${normalized}`);
+  }
+  return normalized;
+}
+function normalizeCloid(value) {
+  const normalized = normalizeHex(value);
+  if (normalized.length !== CLOID_HEX_LENGTH) {
+    throw new Error(`Invalid cloid length: ${normalized}`);
+  }
+  return normalized;
 }
 async function signL1Action(args) {
   const { wallet, action, nonce, vaultAddress, expiresAfter, isTestnet } = args;
@@ -1241,8 +1343,8 @@ async function cancelHyperliquidOrdersByCloid(options) {
       options,
       options.cancels,
       (idx, entry) => ({
-        a: idx,
-        c: normalizeAddress(entry.cloid)
+        asset: idx,
+        cloid: normalizeCloid(entry.cloid)
       })
     )
   };
@@ -1253,10 +1355,10 @@ async function cancelAllHyperliquidOrders(options) {
   return submitExchangeAction(options, action);
 }
 async function scheduleHyperliquidCancel(options) {
-  if (options.time !== null) {
+  if (options.time != null) {
     assertPositiveNumber(options.time, "time");
   }
-  const action = { type: "scheduleCancel", time: options.time };
+  const action = options.time == null ? { type: "scheduleCancel" } : { type: "scheduleCancel", time: options.time };
   return submitExchangeAction(options, action);
 }
 async function modifyHyperliquidOrder(options) {
@@ -1490,7 +1592,7 @@ async function buildOrder(intent, options) {
     r: intent.reduceOnly ?? false,
     t: limitOrTrigger,
     ...intent.clientId ? {
-      c: normalizeAddress(intent.clientId)
+      c: normalizeCloid(intent.clientId)
     } : {}
   };
 }
@@ -1537,6 +1639,32 @@ function assertPositiveDecimal(value, label) {
     return;
   }
   assertString(value, label);
+  if (!/^(?:\d+\.?\d*|\.\d+)$/.test(value.trim())) {
+    throw new Error(`${label} must be a positive decimal string.`);
+  }
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric) || numeric <= 0) {
+    throw new Error(`${label} must be positive.`);
+  }
+}
+function collectExchangeErrorMessages(payload) {
+  if (!payload || typeof payload !== "object") return [];
+  const root = payload;
+  const messages = [];
+  const statuses = root.response?.data?.statuses;
+  if (Array.isArray(statuses)) {
+    statuses.forEach((status, index) => {
+      if (status && typeof status === "object" && "error" in status && typeof status.error === "string") {
+        const errorText = status.error;
+        messages.push(`status[${index}]: ${errorText}`);
+      }
+    });
+  }
+  const singleStatus = root.response?.data?.status;
+  if (singleStatus && typeof singleStatus === "object" && "error" in singleStatus && typeof singleStatus.error === "string") {
+    messages.push(singleStatus.error);
+  }
+  return messages;
 }
 async function postExchange(env, body) {
   const response = await fetch(`${API_BASES[env]}/exchange`, {
@@ -1574,10 +1702,886 @@ async function postExchange(env, body) {
       body: json
     });
   }
+  const nestedErrors = collectExchangeErrorMessages(json);
+  if (nestedErrors.length > 0) {
+    throw new HyperliquidApiError("Hyperliquid exchange returned action errors.", {
+      status: response.status,
+      statusText: response.statusText,
+      body: json,
+      errors: nestedErrors
+    });
+  }
   return json;
 }
 
+// src/adapters/hyperliquid/env.ts
+function resolveHyperliquidChain(environment) {
+  return environment === "mainnet" ? "arbitrum" : "arbitrum-sepolia";
+}
+function resolveHyperliquidRpcEnvVar(environment) {
+  return environment === "mainnet" ? "ARBITRUM_RPC_URL" : "ARBITRUM_SEPOLIA_RPC_URL";
+}
+function resolveHyperliquidChainConfig(environment, env = process.env) {
+  const rpcVar = resolveHyperliquidRpcEnvVar(environment);
+  const rpcUrl = env[rpcVar];
+  return {
+    chain: resolveHyperliquidChain(environment),
+    ...rpcUrl ? { rpcUrl } : {}
+  };
+}
+function resolveHyperliquidStoreNetwork(environment) {
+  return environment === "mainnet" ? "hyperliquid" : "hyperliquid-testnet";
+}
+
+// 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 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 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();
+}
+
+// src/adapters/hyperliquid/order-utils.ts
+var MAX_HYPERLIQUID_PRICE_DECIMALS = 8;
+function countDecimals(value) {
+  if (!Number.isFinite(value)) return 0;
+  const s = value.toString();
+  const [, dec = ""] = s.split(".");
+  return dec.length;
+}
+function clampPriceDecimals(value) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error("Price must be positive.");
+  }
+  const fixed = value.toFixed(MAX_HYPERLIQUID_PRICE_DECIMALS);
+  return fixed.replace(/\.?0+$/, "");
+}
+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";
+  },
+  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 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 formatHyperliquidOrderSize(value, szDecimals) {
+  if (!Number.isFinite(value) || value <= 0) return "0";
+  try {
+    return formatHyperliquidSize(value, szDecimals);
+  } catch {
+    return "0";
+  }
+}
+function roundHyperliquidPriceToTick(price, tick, side) {
+  if (!Number.isFinite(price) || price <= 0) {
+    throw new Error("Price must be positive.");
+  }
+  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 scale = 10 ** tick.tickDecimals;
+  const scaled = BigInt(Math.round(price * scale));
+  const tickSize = tick.tickSizeInt;
+  const rounded = side === "sell" ? scaled / tickSize * tickSize : (scaled + tickSize - 1n) / tickSize * tickSize;
+  const integer = Number(rounded) / scale;
+  return clampPriceDecimals(integer);
+}
+function formatHyperliquidMarketablePrice(params) {
+  const { mid, side, slippageBps, tick } = params;
+  const decimals = countDecimals(mid);
+  const factor = 10 ** decimals;
+  const adjusted = mid * (side === "buy" ? 1 + slippageBps / 1e4 : 1 - slippageBps / 1e4);
+  if (tick) {
+    return roundHyperliquidPriceToTick(adjusted, tick, side);
+  }
+  const scaled = adjusted * factor;
+  const rounded = side === "buy" ? Math.ceil(scaled) / factor : Math.floor(scaled) / factor;
+  return clampPriceDecimals(rounded);
+}
+function extractHyperliquidOrderIds(responses) {
+  const cloids = /* @__PURE__ */ new Set();
+  const oids = /* @__PURE__ */ new Set();
+  const push = (val, target) => {
+    if (val === null || val === void 0) return;
+    const str = String(val);
+    if (str.length) target.add(str);
+  };
+  for (const res of responses) {
+    const statuses = res?.response?.data?.statuses;
+    if (!Array.isArray(statuses)) continue;
+    for (const status of statuses) {
+      const resting = status.resting;
+      const filled = status.filled;
+      push(resting?.cloid, cloids);
+      push(resting?.oid, oids);
+      push(filled?.cloid, cloids);
+      push(filled?.oid, oids);
+    }
+  }
+  return {
+    cloids: Array.from(cloids),
+    oids: Array.from(oids)
+  };
+}
+function resolveHyperliquidOrderRef(params) {
+  const { response, fallbackCloid, fallbackOid, prefix = "hl-order", index = 0 } = params;
+  const statuses = response?.response?.data?.statuses ?? [];
+  if (Array.isArray(statuses)) {
+    for (const status of statuses) {
+      const filled = status && typeof status.filled === "object" ? status.filled : null;
+      if (filled) {
+        if (typeof filled.cloid === "string" && filled.cloid.trim().length > 0) {
+          return filled.cloid;
+        }
+        if (typeof filled.oid === "number" || typeof filled.oid === "string" && filled.oid.trim().length > 0) {
+          return String(filled.oid);
+        }
+      }
+      const resting = status && typeof status.resting === "object" ? status.resting : null;
+      if (resting) {
+        if (typeof resting.cloid === "string" && resting.cloid.trim().length > 0) {
+          return resting.cloid;
+        }
+        if (typeof resting.oid === "number" || typeof resting.oid === "string" && resting.oid.trim().length > 0) {
+          return String(resting.oid);
+        }
+      }
+    }
+  }
+  if (fallbackCloid && fallbackCloid.trim().length > 0) {
+    return fallbackCloid;
+  }
+  if (fallbackOid && fallbackOid.trim().length > 0) {
+    return fallbackOid;
+  }
+  return `${prefix}-${Date.now()}-${index}`;
+}
+function resolveHyperliquidErrorDetail(error) {
+  if (error instanceof HyperliquidApiError) {
+    return error.response ?? null;
+  }
+  if (error && typeof error === "object" && "response" in error) {
+    return error.response ?? null;
+  }
+  return null;
+}
+
+// src/adapters/hyperliquid/state-readers.ts
+function unwrapData(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  if ("data" in payload) {
+    const data = payload.data;
+    if (data && typeof data === "object") {
+      return data;
+    }
+  }
+  return payload;
+}
+function readHyperliquidNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function readHyperliquidAccountValue(payload) {
+  const data = unwrapData(payload);
+  if (!data) return null;
+  const candidates = [
+    data?.marginSummary?.accountValue,
+    data?.crossMarginSummary?.accountValue,
+    data?.accountValue,
+    data?.equity,
+    data?.totalAccountValue,
+    data?.marginSummary?.totalAccountValue
+  ];
+  for (const value of candidates) {
+    const parsed = readHyperliquidNumber(value);
+    if (parsed !== null) return parsed;
+  }
+  return null;
+}
+function matchPerpCoin(params) {
+  const coin = params.coin.toUpperCase();
+  const target = params.target.toUpperCase();
+  if (params.prefixMatch) return coin.startsWith(target);
+  return coin === target;
+}
+function readHyperliquidPerpPositionSize(payload, symbol, options) {
+  const data = unwrapData(payload);
+  const rows = Array.isArray(data?.assetPositions) ? data.assetPositions : [];
+  const base = symbol.split("-")[0]?.toUpperCase() ?? symbol.toUpperCase();
+  const prefixMatch = options?.prefixMatch ?? false;
+  for (const row of rows) {
+    const position = row.position ?? row;
+    const coin = typeof position?.coin === "string" ? position.coin : typeof row.coin === "string" ? row.coin : "";
+    if (!matchPerpCoin({ coin, target: base, prefixMatch })) continue;
+    const size = position.szi ?? row.szi;
+    const parsed = readHyperliquidNumber(size);
+    return parsed ?? 0;
+  }
+  return 0;
+}
+function readHyperliquidPerpPosition(payload, symbol, options) {
+  const data = unwrapData(payload);
+  const rows = Array.isArray(data?.assetPositions) ? data.assetPositions : [];
+  const target = symbol.split("-")[0]?.toUpperCase() ?? symbol.toUpperCase();
+  const prefixMatch = options?.prefixMatch ?? false;
+  for (const row of rows) {
+    const position = row?.position ?? row;
+    const coin = typeof position?.coin === "string" ? position.coin : typeof row?.coin === "string" ? row.coin : "";
+    if (!matchPerpCoin({ coin, target, prefixMatch })) continue;
+    const size = readHyperliquidNumber(position?.szi ?? row.szi) ?? 0;
+    const positionValue = Math.abs(
+      readHyperliquidNumber(position?.positionValue ?? row.positionValue) ?? 0
+    );
+    const unrealizedPnl = readHyperliquidNumber(
+      position?.unrealizedPnl ?? row.unrealizedPnl
+    );
+    return { size, positionValue, unrealizedPnl };
+  }
+  return { size: 0, positionValue: 0, unrealizedPnl: null };
+}
+function readHyperliquidSpotBalanceSize(payload, symbol) {
+  const data = unwrapData(payload);
+  const rows = Array.isArray(data?.balances) ? data.balances : [];
+  const base = symbol.split("/")[0]?.split("-")[0]?.toUpperCase() ?? symbol.toUpperCase();
+  for (const row of rows) {
+    const coin = typeof row?.coin === "string" ? row.coin : typeof row?.asset === "string" ? row.asset : "";
+    if (coin.toUpperCase() !== base) continue;
+    const total = row.total ?? row.balance ?? row.szi;
+    const parsed = readHyperliquidNumber(total);
+    return parsed ?? 0;
+  }
+  return 0;
+}
+function readHyperliquidSpotBalance(payload, base) {
+  const data = unwrapData(payload);
+  const balances = Array.isArray(data?.balances) ? data.balances : [];
+  const target = base.toUpperCase();
+  for (const row of balances) {
+    const coin = typeof row?.coin === "string" ? row.coin : "";
+    if (coin.toUpperCase() !== target) continue;
+    const total = readHyperliquidNumber(row?.total) ?? 0;
+    const entryNtl = readHyperliquidNumber(row?.entryNtl);
+    return { total, entryNtl };
+  }
+  return { total: 0, entryNtl: null };
+}
+function readHyperliquidSpotAccountValue(params) {
+  const rows = Array.isArray(params.balances) ? params.balances : [];
+  if (rows.length === 0) return null;
+  let total = 0;
+  let hasValue = false;
+  for (const row of rows) {
+    const coin = typeof row?.coin === "string" ? row.coin : typeof row?.asset === "string" ? row.asset : "";
+    if (!coin) continue;
+    const amount = readHyperliquidNumber(
+      row.total ?? row.balance ?? row.szi
+    );
+    if (amount == null || amount === 0) continue;
+    const price = params.pricesUsd.get(coin.toUpperCase());
+    if (price == null || !Number.isFinite(price) || price <= 0) continue;
+    total += amount * price;
+    hasValue = true;
+  }
+  return hasValue ? total : null;
+}
+
+// src/adapters/hyperliquid/market-data.ts
+var META_CACHE_TTL_MS = 5 * 60 * 1e3;
+var allMidsCache = /* @__PURE__ */ new Map();
+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 pow10(decimals) {
+  let result = 1n;
+  for (let i = 0; i < decimals; i += 1) {
+    result *= 10n;
+  }
+  return result;
+}
+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 formatScaledInt(value, decimals) {
+  const negative = value < 0n;
+  const absValue = negative ? -value : value;
+  const scale = pow10(decimals);
+  const integer = absValue / scale;
+  const fraction = absValue % scale;
+  if (decimals === 0) {
+    return `${negative ? "-" : ""}${integer.toString()}`;
+  }
+  const fractionStr = fraction.toString().padStart(decimals, "0");
+  return `${negative ? "-" : ""}${integer.toString()}.${fractionStr}`.replace(
+    /\.?0+$/,
+    ""
+  );
+}
+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 fetchHyperliquidAllMids(environment) {
+  const cacheKey = environment;
+  const cached = allMidsCache.get(cacheKey);
+  if (cached && Date.now() - cached.fetchedAt < META_CACHE_TTL_MS) {
+    return cached.mids;
+  }
+  const baseUrl = API_BASES[environment];
+  const res = await fetch(`${baseUrl}/info`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ type: "allMids" })
+  });
+  const json = await res.json().catch(() => null);
+  if (!res.ok || !json || typeof json !== "object") {
+    throw new Error(`Failed to load Hyperliquid mid prices (${res.status}).`);
+  }
+  allMidsCache.set(cacheKey, { fetchedAt: Date.now(), mids: json });
+  return json;
+}
+async function fetchHyperliquidTickSize(params) {
+  return fetchHyperliquidTickSizeForCoin(params.environment, params.symbol);
+}
+async function fetchHyperliquidSpotTickSize(params) {
+  if (!Number.isFinite(params.marketIndex)) {
+    throw new Error("Hyperliquid spot market index is invalid.");
+  }
+  return fetchHyperliquidTickSizeForCoin(
+    params.environment,
+    `@${params.marketIndex}`
+  );
+}
+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 fetchHyperliquidPerpMarketInfo(params) {
+  const data = await fetchHyperliquidMetaAndAssetCtxs(params.environment);
+  const universe = data?.[0]?.universe ?? [];
+  const contexts = data?.[1] ?? [];
+  const target = normalizeHyperliquidMetaSymbol(params.symbol).toUpperCase();
+  const idx = universe.findIndex(
+    (entry) => normalizeHyperliquidMetaSymbol(entry?.name ?? "").toUpperCase() === target
+  );
+  if (idx < 0) {
+    throw new Error(`Unknown Hyperliquid perp asset: ${params.symbol}`);
+  }
+  const ctx = contexts[idx] ?? null;
+  const price = readHyperliquidNumber(ctx?.markPx ?? ctx?.midPx ?? ctx?.oraclePx);
+  if (!price || price <= 0) {
+    throw new Error(`No perp price available for ${params.symbol}`);
+  }
+  const fundingRate = readHyperliquidNumber(ctx?.funding);
+  const szDecimals = readHyperliquidNumber(universe[idx]?.szDecimals);
+  if (szDecimals == null) {
+    throw new Error(`No size decimals available for ${params.symbol}`);
+  }
+  return {
+    symbol: params.symbol,
+    price,
+    fundingRate,
+    szDecimals
+  };
+}
+async function fetchHyperliquidSpotMarketInfo(params) {
+  const mids = params.mids === void 0 ? await fetchHyperliquidAllMids(params.environment).catch(() => null) : params.mids;
+  const data = await fetchHyperliquidSpotMetaAndAssetCtxs(params.environment);
+  const universe = data?.[0]?.universe ?? [];
+  const tokens = data?.[0]?.tokens ?? [];
+  const contexts = data?.[1] ?? [];
+  const tokenMap = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    const index = token?.index;
+    const szDecimals = readHyperliquidNumber(token?.szDecimals);
+    if (typeof index !== "number" || szDecimals == null) continue;
+    tokenMap.set(index, {
+      name: normalizeSpotTokenName2(token?.name),
+      szDecimals
+    });
+  }
+  const baseCandidates = resolveSpotTokenCandidates(params.base);
+  const quoteCandidates = resolveSpotTokenCandidates(params.quote);
+  const normalizedBase = normalizeSpotTokenName2(params.base).toUpperCase();
+  const normalizedQuote = normalizeSpotTokenName2(params.quote).toUpperCase();
+  for (let idx = 0; idx < universe.length; idx += 1) {
+    const market = universe[idx];
+    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;
+    const marketBaseCandidates = resolveSpotTokenCandidates(baseToken.name);
+    const marketQuoteCandidates = resolveSpotTokenCandidates(quoteToken.name);
+    if (baseCandidates.some((candidate) => marketBaseCandidates.includes(candidate)) && quoteCandidates.some((candidate) => marketQuoteCandidates.includes(candidate))) {
+      const contextIndex = typeof market?.index === "number" ? market.index : idx;
+      const ctx = (contextIndex >= 0 && contextIndex < contexts.length ? contexts[contextIndex] : null) ?? contexts[idx] ?? null;
+      let price = null;
+      if (mids) {
+        for (const candidate of resolveSpotMidCandidates(baseToken.name)) {
+          const mid = readHyperliquidNumber(mids[candidate]);
+          if (mid != null && mid > 0) {
+            price = mid;
+            break;
+          }
+        }
+      }
+      if (!price || price <= 0) {
+        price = readHyperliquidNumber(ctx?.markPx ?? ctx?.midPx ?? ctx?.oraclePx);
+      }
+      if (!price || price <= 0) {
+        throw new Error(
+          `No spot price available for ${normalizedBase}/${normalizedQuote}`
+        );
+      }
+      const marketIndex = typeof market?.index === "number" ? market.index : idx;
+      return {
+        symbol: `${baseToken.name.toUpperCase()}/${quoteToken.name.toUpperCase()}`,
+        base: baseToken.name.toUpperCase(),
+        quote: quoteToken.name.toUpperCase(),
+        assetId: 1e4 + marketIndex,
+        marketIndex,
+        price,
+        szDecimals: baseToken.szDecimals
+      };
+    }
+  }
+  throw new Error(`Unknown Hyperliquid spot market: ${normalizedBase}/${normalizedQuote}`);
+}
+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;
+}
+function buildHyperliquidSpotUsdPriceMap(params) {
+  const universe = params.meta.universe ?? [];
+  const tokens = params.meta.tokens ?? [];
+  const tokenMap = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    const index = token?.index;
+    if (typeof index !== "number") continue;
+    tokenMap.set(index, normalizeSpotTokenName2(token?.name).toUpperCase());
+  }
+  const prices = /* @__PURE__ */ new Map();
+  prices.set("USDC", 1);
+  for (let idx = 0; idx < universe.length; idx += 1) {
+    const market = universe[idx];
+    const [baseIndex, quoteIndex] = Array.isArray(market?.tokens) ? market.tokens : [];
+    const base = tokenMap.get(baseIndex ?? -1);
+    const quote = tokenMap.get(quoteIndex ?? -1);
+    if (!base || !quote) continue;
+    if (quote !== "USDC") continue;
+    const contextIndex = typeof market?.index === "number" ? market.index : idx;
+    const ctx = (contextIndex >= 0 && contextIndex < params.ctxs.length ? params.ctxs[contextIndex] : null) ?? params.ctxs[idx] ?? null;
+    let price = null;
+    if (params.mids) {
+      for (const candidate of resolveSpotMidCandidates(base)) {
+        const mid = readHyperliquidNumber(params.mids[candidate]);
+        if (mid != null && mid > 0) {
+          price = mid;
+          break;
+        }
+      }
+    }
+    if (!price || price <= 0) {
+      price = readHyperliquidNumber(ctx?.markPx ?? ctx?.midPx ?? ctx?.oraclePx);
+    }
+    if (!price || price <= 0) continue;
+    prices.set(base, price);
+  }
+  return prices;
+}
+async function fetchHyperliquidSpotUsdPriceMap(environment) {
+  const [spotMetaAndCtxs, mids] = await Promise.all([
+    fetchHyperliquidSpotMetaAndAssetCtxs(environment),
+    fetchHyperliquidAllMids(environment).catch(() => null)
+  ]);
+  const [metaRaw, ctxsRaw] = spotMetaAndCtxs;
+  const meta = {
+    universe: Array.isArray(metaRaw?.universe) ? metaRaw.universe : [],
+    tokens: Array.isArray(metaRaw?.tokens) ? metaRaw.tokens : []
+  };
+  const ctxs = Array.isArray(ctxsRaw) ? ctxsRaw : [];
+  return buildHyperliquidSpotUsdPriceMap({ meta, ctxs, mids });
+}
+async function fetchHyperliquidSpotAccountValue(params) {
+  const pricesUsd = await fetchHyperliquidSpotUsdPriceMap(params.environment);
+  return readHyperliquidSpotAccountValue({
+    balances: params.balances,
+    pricesUsd
+  });
+}
+var __hyperliquidMarketDataInternals = {
+  maxDecimals,
+  toScaledInt,
+  formatScaledInt
+};
+
 // src/adapters/hyperliquid/index.ts
+function assertPositiveDecimalInput(value, label) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new Error(`${label} must be a positive number.`);
+    }
+    return;
+  }
+  if (typeof value === "bigint") {
+    if (value <= 0n) {
+      throw new Error(`${label} must be positive.`);
+    }
+    return;
+  }
+  const trimmed = value.trim();
+  if (!trimmed.length) {
+    throw new Error(`${label} must be a non-empty string.`);
+  }
+  if (!/^(?:\d+\.?\d*|\.\d+)$/.test(trimmed)) {
+    throw new Error(`${label} must be a positive decimal string.`);
+  }
+  const numeric = Number(trimmed);
+  if (!Number.isFinite(numeric) || numeric <= 0) {
+    throw new Error(`${label} must be positive.`);
+  }
+}
+function normalizePositiveDecimalString(raw, label) {
+  const trimmed = raw.trim();
+  if (!trimmed.length) {
+    throw new Error(`${label} must be a non-empty decimal string.`);
+  }
+  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 numeric = Number(normalized);
+  if (!Number.isFinite(numeric) || numeric <= 0) {
+    throw new Error(`${label} must be positive.`);
+  }
+  return normalized;
+}
 async function placeHyperliquidOrder(options) {
   const {
     wallet,
@@ -1601,6 +2605,11 @@ async function placeHyperliquidOrder(options) {
   const resolvedBaseUrl = API_BASES[inferredEnvironment];
   const preparedOrders = await Promise.all(
     orders.map(async (intent) => {
+      assertPositiveDecimalInput(intent.price, "price");
+      assertPositiveDecimalInput(intent.size, "size");
+      if (intent.trigger) {
+        assertPositiveDecimalInput(intent.trigger.triggerPx, "triggerPx");
+      }
       const assetIndex = await resolveHyperliquidAssetIndex({
         symbol: intent.symbol,
         baseUrl: resolvedBaseUrl,
@@ -1626,7 +2635,7 @@ async function placeHyperliquidOrder(options) {
         r: intent.reduceOnly ?? false,
         t: limitOrTrigger,
         ...intent.clientId ? {
-          c: normalizeHex(intent.clientId)
+          c: normalizeCloid(intent.clientId)
         } : {}
       };
       return order;
@@ -1695,7 +2704,9 @@ async function placeHyperliquidOrder(options) {
   }
   const statuses = json.response?.data?.statuses ?? [];
   const errorStatuses = statuses.filter(
-    (entry) => "error" in entry
+    (entry) => Boolean(
+      entry && typeof entry === "object" && "error" in entry && typeof entry.error === "string"
+    )
   );
   if (errorStatuses.length) {
     const message = errorStatuses.map((entry) => entry.error).join(", ");
@@ -1749,10 +2760,11 @@ async function depositToHyperliquidBridge(options) {
 }
 async function withdrawFromHyperliquid(options) {
   const { environment, amount, destination, wallet } = options;
-  const parsedAmount = Number(amount);
-  if (!Number.isFinite(parsedAmount) || parsedAmount <= 0) {
-    throw new Error("Withdraw amount must be a positive number.");
-  }
+  const normalizedAmount = normalizePositiveDecimalString(
+    amount,
+    "Withdraw amount"
+  );
+  const parsedAmount = Number.parseFloat(normalizedAmount);
   if (!wallet.account || !wallet.walletClient || !wallet.publicClient) {
     throw new Error(
       "Wallet client and public client are required for withdraw."
@@ -1772,7 +2784,7 @@ async function withdrawFromHyperliquid(options) {
   const message = {
     hyperliquidChain,
     destination: normalizedDestination,
-    amount: parsedAmount.toString(),
+    amount: normalizedAmount,
     time
   };
   const types = {
@@ -1797,7 +2809,7 @@ async function withdrawFromHyperliquid(options) {
       signatureChainId,
       hyperliquidChain,
       destination: normalizedDestination,
-      amount: parsedAmount.toString(),
+      amount: normalizedAmount,
       time: nonce
     },
     nonce,
@@ -1967,6 +2979,6 @@ var __hyperliquidInternals = {
   splitSignature
 };
 
-export { DEFAULT_HYPERLIQUID_MARKET_SLIPPAGE_BPS, HyperliquidApiError, HyperliquidBuilderApprovalError, HyperliquidExchangeClient, HyperliquidGuardError, HyperliquidInfoClient, HyperliquidTermsError, __hyperliquidInternals, approveHyperliquidBuilderFee, batchModifyHyperliquidOrders, buildHyperliquidMarketIdentity, cancelAllHyperliquidOrders, cancelHyperliquidOrders, cancelHyperliquidOrdersByCloid, cancelHyperliquidTwapOrder, computeHyperliquidMarketIocLimitPrice, createHyperliquidSubAccount, createMonotonicNonceFactory, depositToHyperliquidBridge, fetchHyperliquidAssetCtxs, fetchHyperliquidClearinghouseState, fetchHyperliquidFrontendOpenOrders, fetchHyperliquidHistoricalOrders, fetchHyperliquidMeta, fetchHyperliquidMetaAndAssetCtxs, fetchHyperliquidOpenOrders, fetchHyperliquidOrderStatus, fetchHyperliquidPreTransferCheck, fetchHyperliquidSpotAssetCtxs, fetchHyperliquidSpotClearinghouseState, fetchHyperliquidSpotMeta, fetchHyperliquidSpotMetaAndAssetCtxs, fetchHyperliquidUserFills, fetchHyperliquidUserFillsByTime, fetchHyperliquidUserRateLimit, getHyperliquidMaxBuilderFee, modifyHyperliquidOrder, placeHyperliquidOrder, placeHyperliquidTwapOrder, recordHyperliquidBuilderApproval, recordHyperliquidTermsAcceptance, reserveHyperliquidRequestWeight, resolveHyperliquidAbstractionFromMode, scheduleHyperliquidCancel, sendHyperliquidSpot, setHyperliquidAccountAbstractionMode, setHyperliquidDexAbstraction, setHyperliquidPortfolioMargin, transferHyperliquidSubAccount, updateHyperliquidIsolatedMargin, updateHyperliquidLeverage, withdrawFromHyperliquid };
+export { DEFAULT_HYPERLIQUID_MARKET_SLIPPAGE_BPS, HyperliquidApiError, HyperliquidBuilderApprovalError, HyperliquidExchangeClient, HyperliquidGuardError, HyperliquidInfoClient, HyperliquidTermsError, __hyperliquidInternals, __hyperliquidMarketDataInternals, approveHyperliquidBuilderFee, batchModifyHyperliquidOrders, buildHyperliquidMarketIdentity, buildHyperliquidSpotUsdPriceMap, cancelAllHyperliquidOrders, cancelHyperliquidOrders, cancelHyperliquidOrdersByCloid, cancelHyperliquidTwapOrder, computeHyperliquidMarketIocLimitPrice, createHyperliquidSubAccount, createMonotonicNonceFactory, depositToHyperliquidBridge, extractHyperliquidDex, extractHyperliquidOrderIds, fetchHyperliquidAllMids, fetchHyperliquidAssetCtxs, fetchHyperliquidClearinghouseState, fetchHyperliquidFrontendOpenOrders, fetchHyperliquidHistoricalOrders, fetchHyperliquidMeta, fetchHyperliquidMetaAndAssetCtxs, fetchHyperliquidOpenOrders, fetchHyperliquidOrderStatus, fetchHyperliquidPerpMarketInfo, fetchHyperliquidPreTransferCheck, fetchHyperliquidSizeDecimals, fetchHyperliquidSpotAccountValue, fetchHyperliquidSpotAssetCtxs, fetchHyperliquidSpotClearinghouseState, fetchHyperliquidSpotMarketInfo, fetchHyperliquidSpotMeta, fetchHyperliquidSpotMetaAndAssetCtxs, fetchHyperliquidSpotTickSize, fetchHyperliquidSpotUsdPriceMap, fetchHyperliquidTickSize, fetchHyperliquidUserFills, fetchHyperliquidUserFillsByTime, fetchHyperliquidUserRateLimit, formatHyperliquidMarketablePrice, formatHyperliquidOrderSize, formatHyperliquidPrice, formatHyperliquidSize, getHyperliquidMaxBuilderFee, isHyperliquidSpotSymbol, modifyHyperliquidOrder, normalizeHyperliquidBaseSymbol, normalizeHyperliquidMetaSymbol, normalizeSpotTokenName2 as normalizeSpotTokenName, parseSpotPairSymbol, placeHyperliquidOrder, placeHyperliquidTwapOrder, readHyperliquidAccountValue, readHyperliquidNumber, readHyperliquidPerpPosition, readHyperliquidPerpPositionSize, readHyperliquidSpotAccountValue, readHyperliquidSpotBalance, readHyperliquidSpotBalanceSize, recordHyperliquidBuilderApproval, recordHyperliquidTermsAcceptance, reserveHyperliquidRequestWeight, resolveHyperliquidAbstractionFromMode, resolveHyperliquidChain, resolveHyperliquidChainConfig, resolveHyperliquidErrorDetail, resolveHyperliquidOrderRef, resolveHyperliquidOrderSymbol, resolveHyperliquidPair, resolveHyperliquidRpcEnvVar, resolveHyperliquidStoreNetwork, resolveHyperliquidSymbol, resolveSpotMidCandidates, resolveSpotTokenCandidates, roundHyperliquidPriceToTick, scheduleHyperliquidCancel, sendHyperliquidSpot, setHyperliquidAccountAbstractionMode, setHyperliquidDexAbstraction, setHyperliquidPortfolioMargin, transferHyperliquidSubAccount, updateHyperliquidIsolatedMargin, updateHyperliquidLeverage, withdrawFromHyperliquid };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map