@outcome.xyz/hip4 1.0.0-beta

package/dist/index.cjs

@@ -0,0 +1,4244 @@
+'use strict';
+
+// src/lib/precision/primitives/_decimal-impl.ts
+var PRECISION = 28;
+var TO_EXP_NEG = -7;
+var TO_EXP_POS = 21;
+var ROUND_UP = 0;
+var ROUND_DOWN = 1;
+var ROUND_HALF_UP = 4;
+var POW10_CACHE = [1n];
+function pow10(n) {
+  if (n < 0) throw new Error(`pow10: negative n (${n})`);
+  if (n < POW10_CACHE.length) return POW10_CACHE[n];
+  let last = POW10_CACHE[POW10_CACHE.length - 1];
+  for (let i = POW10_CACHE.length; i <= n; i++) {
+    last = last * 10n;
+    POW10_CACHE.push(last);
+  }
+  return POW10_CACHE[n];
+}
+function digitCount(n) {
+  if (n === 0n) return 0;
+  return n.toString().length;
+}
+function trimTrailingZeros(m, e) {
+  if (m === 0n) return { m: 0n, e: 0 };
+  let mantissa = m;
+  let exp = e;
+  while (mantissa % 10n === 0n) {
+    mantissa /= 10n;
+    exp += 1;
+  }
+  return { m: mantissa, e: exp };
+}
+function parseString(input) {
+  const s = input.trim();
+  if (s === "") throw new Error("Invalid decimal: empty string");
+  const m = s.match(
+    /^([+-]?)(?:(\d+)(?:\.(\d*))?|\.(\d+))(?:[eE]([+-]?\d+))?$/
+  );
+  if (!m) throw new Error(`Invalid decimal: "${input}"`);
+  const sign = m[1];
+  const intPart = m[2] ?? "";
+  const fracPart = m[3] ?? m[4] ?? "";
+  const expPart = m[5] ?? "0";
+  let digits = intPart + fracPart;
+  digits = digits.replace(/^0+/, "");
+  let exp = parseInt(expPart, 10) - fracPart.length;
+  if (digits === "") {
+    return { neg: sign === "-", mantissa: 0n, exp: 0 };
+  }
+  const mantissa0 = BigInt(digits);
+  const trimmed = trimTrailingZeros(mantissa0, exp);
+  return {
+    neg: sign === "-",
+    mantissa: trimmed.m,
+    exp: trimmed.e
+  };
+}
+function fromParts(neg2, mantissa, exp) {
+  const t = trimTrailingZeros(mantissa, exp);
+  const sign = t.m === 0n ? false : neg2;
+  return new Decimal(_INTERNAL, sign, t.m, t.e);
+}
+var _INTERNAL = /* @__PURE__ */ Symbol("DecimalInternal");
+function cmpAbs(a, b) {
+  if (a.mantissa === 0n && b.mantissa === 0n) return 0;
+  if (a.mantissa === 0n) return -1;
+  if (b.mantissa === 0n) return 1;
+  const ea = digitCount(a.mantissa) - 1 + a.exp;
+  const eb = digitCount(b.mantissa) - 1 + b.exp;
+  if (ea !== eb) return ea < eb ? -1 : 1;
+  if (a.exp === b.exp) {
+    return a.mantissa === b.mantissa ? 0 : a.mantissa < b.mantissa ? -1 : 1;
+  }
+  if (a.exp > b.exp) {
+    const aScaled = a.mantissa * pow10(a.exp - b.exp);
+    return aScaled === b.mantissa ? 0 : aScaled < b.mantissa ? -1 : 1;
+  }
+  const bScaled = b.mantissa * pow10(b.exp - a.exp);
+  return a.mantissa === bScaled ? 0 : a.mantissa < bScaled ? -1 : 1;
+}
+function roundToSigFigs(mantissa, exp, sigFigs, hasMoreNonZeroBeyond = false) {
+  if (mantissa === 0n) return { m: 0n, e: 0 };
+  const d = digitCount(mantissa);
+  if (d <= sigFigs) return trimTrailingZeros(mantissa, exp);
+  const trim = d - sigFigs;
+  const divisor = pow10(trim);
+  const trunc = mantissa / divisor;
+  const rem = mantissa % divisor;
+  const half = pow10(trim - 1) * 5n;
+  let rounded;
+  if (rem > half || rem === half && hasMoreNonZeroBeyond) {
+    rounded = trunc + 1n;
+  } else if (rem < half) {
+    rounded = trunc;
+  } else {
+    rounded = trunc + 1n;
+  }
+  return trimTrailingZeros(rounded, exp + trim);
+}
+var Decimal = class _Decimal {
+  static ROUND_UP = ROUND_UP;
+  static ROUND_DOWN = ROUND_DOWN;
+  static ROUND_HALF_UP = ROUND_HALF_UP;
+  neg;
+  mantissa;
+  exp;
+  constructor(a, b, c, d) {
+    if (a === _INTERNAL) {
+      this.neg = b;
+      this.mantissa = c;
+      this.exp = d;
+      return;
+    }
+    if (a instanceof _Decimal) {
+      this.neg = a.neg;
+      this.mantissa = a.mantissa;
+      this.exp = a.exp;
+      return;
+    }
+    let s;
+    if (typeof a === "number") {
+      if (!Number.isFinite(a)) throw new Error(`Invalid number: ${a}`);
+      s = String(a);
+    } else if (typeof a === "string") {
+      s = a;
+    } else {
+      throw new Error(`Unsupported input type: ${typeof a}`);
+    }
+    const parsed = parseString(s);
+    this.neg = parsed.neg;
+    this.mantissa = parsed.mantissa;
+    this.exp = parsed.exp;
+  }
+  // -- predicates -----------------------------------------------------------
+  isZero() {
+    return this.mantissa === 0n;
+  }
+  isNegative() {
+    return this.neg;
+  }
+  isNeg() {
+    return this.neg;
+  }
+  isPositive() {
+    return !this.neg;
+  }
+  isPos() {
+    return this.isPositive();
+  }
+  isInteger() {
+    if (this.mantissa === 0n) return true;
+    return this.exp >= 0;
+  }
+  // -- comparisons ----------------------------------------------------------
+  comparedTo(other) {
+    const b = toDec(other);
+    if (this.mantissa === 0n && b.mantissa === 0n) return 0;
+    if (this.neg && !b.neg) return -1;
+    if (!this.neg && b.neg) return 1;
+    if (this.mantissa === 0n) return b.neg ? 1 : -1;
+    if (b.mantissa === 0n) return this.neg ? -1 : 1;
+    const c = cmpAbs(this, b);
+    return this.neg ? -c : c;
+  }
+  cmp(other) {
+    return this.comparedTo(other);
+  }
+  equals(other) {
+    return this.comparedTo(other) === 0;
+  }
+  eq(other) {
+    return this.equals(other);
+  }
+  greaterThan(other) {
+    return this.comparedTo(other) > 0;
+  }
+  gt(other) {
+    return this.greaterThan(other);
+  }
+  greaterThanOrEqualTo(other) {
+    return this.comparedTo(other) >= 0;
+  }
+  gte(other) {
+    return this.greaterThanOrEqualTo(other);
+  }
+  lessThan(other) {
+    return this.comparedTo(other) < 0;
+  }
+  lt(other) {
+    return this.lessThan(other);
+  }
+  lessThanOrEqualTo(other) {
+    return this.comparedTo(other) <= 0;
+  }
+  lte(other) {
+    return this.lessThanOrEqualTo(other);
+  }
+  // -- unary ----------------------------------------------------------------
+  abs() {
+    if (!this.neg) return this;
+    return fromParts(false, this.mantissa, this.exp);
+  }
+  negated() {
+    if (this.mantissa === 0n) return this;
+    return fromParts(!this.neg, this.mantissa, this.exp);
+  }
+  neg_() {
+    return this.negated();
+  }
+  // -- arithmetic -----------------------------------------------------------
+  plus(other) {
+    const b = toDec(other);
+    if (this.mantissa === 0n) {
+      const r = roundToSigFigs(b.mantissa, b.exp, PRECISION);
+      return fromParts(r.m === 0n ? false : b.neg, r.m, r.e);
+    }
+    if (b.mantissa === 0n) {
+      const r = roundToSigFigs(this.mantissa, this.exp, PRECISION);
+      return fromParts(r.m === 0n ? false : this.neg, r.m, r.e);
+    }
+    const minExp = Math.min(this.exp, b.exp);
+    const aM = this.mantissa * pow10(this.exp - minExp);
+    const bM = b.mantissa * pow10(b.exp - minExp);
+    let resNeg;
+    let resM;
+    if (this.neg === b.neg) {
+      resNeg = this.neg;
+      resM = aM + bM;
+    } else if (aM === bM) {
+      return ZERO;
+    } else if (aM > bM) {
+      resNeg = this.neg;
+      resM = aM - bM;
+    } else {
+      resNeg = b.neg;
+      resM = bM - aM;
+    }
+    const rounded = roundToSigFigs(resM, minExp, PRECISION);
+    return fromParts(resNeg, rounded.m, rounded.e);
+  }
+  minus(other) {
+    const b = toDec(other);
+    return this.plus(fromParts(!b.neg, b.mantissa, b.exp));
+  }
+  times(other) {
+    const b = toDec(other);
+    if (this.mantissa === 0n || b.mantissa === 0n) return ZERO;
+    const m = this.mantissa * b.mantissa;
+    const e = this.exp + b.exp;
+    const sign = this.neg !== b.neg;
+    const rounded = roundToSigFigs(m, e, PRECISION);
+    return fromParts(sign, rounded.m, rounded.e);
+  }
+  dividedBy(other) {
+    const b = toDec(other);
+    if (b.mantissa === 0n) throw new Error("Division by zero");
+    if (this.mantissa === 0n) return ZERO;
+    const sign = this.neg !== b.neg;
+    const aDigits = digitCount(this.mantissa);
+    const bDigits = digitCount(b.mantissa);
+    const wantDigits = PRECISION + 2;
+    const haveDigits = aDigits - bDigits + (this.mantissa >= b.mantissa ? 1 : 0);
+    const shift = Math.max(0, wantDigits - haveDigits);
+    const scaledNum = this.mantissa * pow10(shift);
+    const q = scaledNum / b.mantissa;
+    const rem = scaledNum % b.mantissa;
+    const newExp = this.exp - b.exp - shift;
+    const rounded = roundToSigFigs(q, newExp, PRECISION, rem !== 0n);
+    return fromParts(sign, rounded.m, rounded.e);
+  }
+  div(other) {
+    return this.dividedBy(other);
+  }
+  // Integer-exponent power. Throws on non-integer exponent.
+  pow(exponent) {
+    const e = toDec(exponent);
+    if (!e.isInteger()) {
+      throw new Error("pow: only integer exponents are supported");
+    }
+    let n;
+    if (e.mantissa === 0n) {
+      return ONE;
+    }
+    if (e.exp === 0) {
+      if (e.mantissa > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error("pow: exponent too large");
+      }
+      n = Number(e.mantissa) * (e.neg ? -1 : 1);
+    } else {
+      const full = e.mantissa * pow10(e.exp);
+      if (full > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error("pow: exponent too large");
+      }
+      n = Number(full) * (e.neg ? -1 : 1);
+    }
+    if (n === 0) return ONE;
+    if (this.mantissa === 0n) {
+      if (n < 0)
+        throw new Error("pow: 0 cannot be raised to a negative exponent");
+      return ZERO;
+    }
+    const negResult = this.neg && n % 2 !== 0;
+    const absExp = Math.abs(n);
+    let baseM = this.mantissa;
+    let baseE = this.exp;
+    let resM = 1n;
+    let resE = 0;
+    let k = absExp;
+    while (k > 0) {
+      if (k & 1) {
+        resM = resM * baseM;
+        resE = resE + baseE;
+        const r = roundToSigFigs(resM, resE, PRECISION);
+        resM = r.m;
+        resE = r.e;
+      }
+      k >>>= 1;
+      if (k > 0) {
+        baseM = baseM * baseM;
+        baseE = baseE + baseE;
+        const r = roundToSigFigs(baseM, baseE, PRECISION);
+        baseM = r.m;
+        baseE = r.e;
+      }
+    }
+    if (n < 0) {
+      return fromParts(negResult, 1n, 0).dividedBy(
+        fromParts(false, resM, resE)
+      );
+    }
+    return fromParts(negResult, resM, resE);
+  }
+  // -- rounding to integer using global mode (HALF_UP) ----------------------
+  round() {
+    return roundDp(this, 0, ROUND_HALF_UP);
+  }
+  floor() {
+    return roundDp(this, 0, ROUND_FLOOR_INTERNAL);
+  }
+  ceil() {
+    return roundDp(this, 0, ROUND_CEIL_INTERNAL);
+  }
+  // -- toFixed --------------------------------------------------------------
+  toFixed(dp, mode = ROUND_HALF_UP) {
+    if (dp === void 0) {
+      return this.toFixedFlat();
+    }
+    if (!Number.isInteger(dp) || dp < 0) {
+      throw new RangeError(
+        `toFixed: dp must be a non-negative integer (got ${dp})`
+      );
+    }
+    if (this.mantissa === 0n) {
+      return dp === 0 ? "0" : "0." + "0".repeat(dp);
+    }
+    const targetExp = -dp;
+    let m;
+    if (this.exp >= targetExp) {
+      m = this.mantissa * pow10(this.exp - targetExp);
+    } else {
+      const trim = targetExp - this.exp;
+      const divisor = pow10(trim);
+      const trunc = this.mantissa / divisor;
+      const rem = this.mantissa % divisor;
+      const half = pow10(trim - 1) * 5n;
+      switch (mode) {
+        case ROUND_DOWN:
+          m = trunc;
+          break;
+        case ROUND_UP:
+          m = rem === 0n ? trunc : trunc + 1n;
+          break;
+        case ROUND_HALF_UP:
+          if (rem > half) m = trunc + 1n;
+          else if (rem < half) m = trunc;
+          else m = trunc + 1n;
+          break;
+        default:
+          throw new Error(`toFixed: unsupported rounding mode (${mode})`);
+      }
+    }
+    const sign = this.neg ? "-" : "";
+    const s = m.toString();
+    if (dp === 0) return sign + s;
+    if (s.length <= dp) {
+      return sign + "0." + "0".repeat(dp - s.length) + s;
+    }
+    return sign + s.slice(0, s.length - dp) + "." + s.slice(s.length - dp);
+  }
+  // toString without exponential notation, full precision (matches decimal.js
+  // toFixed() with no args for the values produced in this codebase).
+  toFixedFlat() {
+    if (this.mantissa === 0n) return "0";
+    return formatPlain(this);
+  }
+  // -- toString -------------------------------------------------------------
+  toString() {
+    if (this.mantissa === 0n) return "0";
+    const valExp = digitCount(this.mantissa) - 1 + this.exp;
+    if (valExp <= TO_EXP_NEG || valExp >= TO_EXP_POS) {
+      return formatExponential(this, valExp);
+    }
+    return formatPlain(this);
+  }
+  valueOf() {
+    return this.toString();
+  }
+  // -- toNumber -------------------------------------------------------------
+  toNumber() {
+    if (this.mantissa === 0n) return 0;
+    return parseFloat(this.toString());
+  }
+  // -- floor of log10(|this|) - used internally; not on decimal.js's API ----
+  //
+  // Returns floor(log10(|value|)) as a Decimal integer. Throws on zero.
+  // Equivalent to (digitCount(mantissa) - 1 + exp).
+  floorLog10() {
+    if (this.mantissa === 0n) {
+      throw new RangeError("floorLog10: log of zero is undefined");
+    }
+    const v = digitCount(this.mantissa) - 1 + this.exp;
+    return fromInt(v);
+  }
+  // -- significant digits ---------------------------------------------------
+  toSignificantDigits(sigFigs) {
+    if (!Number.isInteger(sigFigs) || sigFigs < 1) {
+      throw new RangeError(
+        `toSignificantDigits: sigFigs must be >= 1 (got ${sigFigs})`
+      );
+    }
+    if (this.mantissa === 0n) return this;
+    const r = roundToSigFigs(this.mantissa, this.exp, sigFigs);
+    return fromParts(this.neg, r.m, r.e);
+  }
+  // -- statics --------------------------------------------------------------
+  static min(...values) {
+    if (values.length === 0)
+      throw new Error("min: at least one argument required");
+    let best = toDec(values[0]);
+    for (let i = 1; i < values.length; i++) {
+      const v = toDec(values[i]);
+      if (v.lt(best)) best = v;
+    }
+    return best;
+  }
+  static max(...values) {
+    if (values.length === 0)
+      throw new Error("max: at least one argument required");
+    let best = toDec(values[0]);
+    for (let i = 1; i < values.length; i++) {
+      const v = toDec(values[i]);
+      if (v.gt(best)) best = v;
+    }
+    return best;
+  }
+  static sum(...values) {
+    let acc = ZERO;
+    for (const v of values) acc = acc.plus(toDec(v));
+    return acc;
+  }
+};
+var ROUND_FLOOR_INTERNAL = 100;
+var ROUND_CEIL_INTERNAL = 101;
+function roundDp(d, dp, mode) {
+  if (d.mantissa === 0n) return ZERO;
+  const targetExp = -0;
+  if (d.exp >= targetExp) {
+    return d;
+  }
+  const trim = targetExp - d.exp;
+  const divisor = pow10(trim);
+  const trunc = d.mantissa / divisor;
+  const rem = d.mantissa % divisor;
+  const half = pow10(trim - 1) * 5n;
+  let rounded;
+  switch (mode) {
+    case ROUND_DOWN:
+      rounded = trunc;
+      break;
+    case ROUND_UP:
+      rounded = rem === 0n ? trunc : trunc + 1n;
+      break;
+    case ROUND_HALF_UP:
+      if (rem > half) rounded = trunc + 1n;
+      else if (rem < half) rounded = trunc;
+      else rounded = trunc + 1n;
+      break;
+    case ROUND_FLOOR_INTERNAL:
+      if (d.neg) rounded = rem === 0n ? trunc : trunc + 1n;
+      else rounded = trunc;
+      break;
+    case ROUND_CEIL_INTERNAL:
+      if (d.neg) rounded = trunc;
+      else rounded = rem === 0n ? trunc : trunc + 1n;
+      break;
+    default:
+      throw new Error(`Unsupported rounding mode: ${mode}`);
+  }
+  if (rounded === 0n) return ZERO;
+  return fromParts(d.neg, rounded, targetExp);
+}
+function formatPlain(d) {
+  if (d.mantissa === 0n) return "0";
+  const digits = d.mantissa.toString();
+  const sign = d.neg ? "-" : "";
+  if (d.exp >= 0) {
+    return sign + digits + "0".repeat(d.exp);
+  }
+  const fracLen = -d.exp;
+  if (fracLen >= digits.length) {
+    return sign + "0." + "0".repeat(fracLen - digits.length) + digits;
+  }
+  const intPart = digits.slice(0, digits.length - fracLen);
+  const fracPart = digits.slice(digits.length - fracLen);
+  return sign + intPart + "." + fracPart;
+}
+function formatExponential(d, valExp) {
+  const digits = d.mantissa.toString();
+  const sign = d.neg ? "-" : "";
+  const head = digits[0];
+  const tail = digits.slice(1);
+  const mant = tail.length === 0 ? head : `${head}.${tail}`;
+  const expPart = valExp >= 0 ? `e+${valExp}` : `e${valExp}`;
+  return sign + mant + expPart;
+}
+function toDec(x) {
+  return x instanceof Decimal ? x : new Decimal(x);
+}
+function fromInt(n) {
+  if (!Number.isInteger(n)) throw new Error("fromInt: not an integer");
+  if (n === 0) return ZERO;
+  const neg2 = n < 0;
+  const abs3 = Math.abs(n);
+  return fromParts(neg2, BigInt(abs3), 0);
+}
+var ZERO = new Decimal(_INTERNAL, false, 0n, 0);
+var ONE = new Decimal(_INTERNAL, false, 1n, 0);
+
+// src/lib/precision/primitives/core.ts
+function toDecimal(value) {
+  if (value instanceof Decimal) return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error(`Invalid numeric input: ${value}`);
+    }
+    return new Decimal(value);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "") {
+      throw new Error("Empty string is not a valid decimal input");
+    }
+    return new Decimal(trimmed);
+  }
+  throw new Error(`Unsupported input type: ${typeof value}`);
+}
+function toNum(value) {
+  return toDecimal(value).toNumber();
+}
+function sub(a, b) {
+  return toDecimal(a).minus(toDecimal(b)).toString();
+}
+function mul(a, b) {
+  return toDecimal(a).times(toDecimal(b)).toString();
+}
+function div(a, b, dp) {
+  const divisor = toDecimal(b);
+  if (divisor.isZero()) throw new Error("Division by zero");
+  const result = toDecimal(a).dividedBy(divisor);
+  return result.toString();
+}
+function pow(base, exp) {
+  return toDecimal(base).pow(toDecimal(exp)).toString();
+}
+
+// src/lib/precision/primitives/compare.ts
+function lt(a, b) {
+  return toDecimal(a).lessThan(toDecimal(b));
+}
+function isZero(value) {
+  return toDecimal(value).isZero();
+}
+function min(...values) {
+  if (values.length === 0) throw new Error("min requires at least one argument");
+  return Decimal.min(...values.map(toDecimal)).toString();
+}
+
+// src/lib/precision/primitives/clamp.ts
+function clamp(value, lo, hi) {
+  const dLo = toDecimal(lo);
+  const dHi = toDecimal(hi);
+  if (dLo.gt(dHi))
+    throw new RangeError(`clamp: lo (${dLo}) must be <= hi (${dHi})`);
+  return Decimal.max(dLo, Decimal.min(dHi, toDecimal(value))).toString();
+}
+
+// src/lib/precision/io/format.ts
+new Decimal(1e3);
+new Decimal(1e6);
+new Decimal(1e9);
+function fixed(value, dp) {
+  return toDecimal(value).toFixed(dp);
+}
+
+// src/adapter/hyperliquid/client.ts
+var HLApiError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "HLApiError";
+  }
+  status;
+};
+var MAINNET_INFO_URL = "https://api.hyperliquid.xyz/info";
+var MAINNET_EXCHANGE_URL = "https://api.hyperliquid.xyz/exchange";
+var TESTNET_INFO_URL = "https://api-ui.hyperliquid-testnet.xyz/info";
+var TESTNET_EXCHANGE_URL = "https://api-ui.hyperliquid-testnet.xyz/exchange";
+var TESTNET_WS_URL = "wss://api-ui.hyperliquid-testnet.xyz/ws";
+var MAINNET_WS_URL = "wss://api.hyperliquid.xyz/ws";
+var ALL_DEXS = "ALL_DEXS";
+function isUsdClassTransferRequired(abstraction) {
+  return abstraction === "default" || abstraction === "disabled" || abstraction === "dexAbstraction";
+}
+function outcomeCoin(outcomeId) {
+  return `@${outcomeId}`;
+}
+function sideCoin(outcomeId, sideIndex) {
+  return `#${outcomeId}${sideIndex}`;
+}
+function sideAssetId(outcomeId, sideIndex) {
+  return 1e8 + outcomeId * 10 + sideIndex;
+}
+function parseSideCoin(coin) {
+  if (!coin.startsWith("#") && !coin.startsWith("+")) return null;
+  const num = coin.slice(1);
+  if (num.length < 2) return null;
+  const sideIndex = parseInt(num.slice(-1), 10);
+  const outcomeId = parseInt(num.slice(0, -1), 10);
+  if (isNaN(sideIndex) || isNaN(outcomeId)) return null;
+  if (sideIndex > 1) return null;
+  return { outcomeId, sideIndex };
+}
+function parseOutcomeCoin(coin) {
+  if (!coin.startsWith("@")) return null;
+  const outcomeId = parseInt(coin.slice(1), 10);
+  if (isNaN(outcomeId)) return null;
+  return { outcomeId };
+}
+function coinOutcomeId(coin) {
+  if (coin.startsWith("#") || coin.startsWith("+")) {
+    const parsed = parseSideCoin(coin);
+    return parsed ? parsed.outcomeId : null;
+  }
+  if (coin.startsWith("@")) {
+    const parsed = parseOutcomeCoin(coin);
+    return parsed ? parsed.outcomeId : null;
+  }
+  return null;
+}
+function isOutcomeCoin(coin) {
+  return coin.startsWith("@") || coin.startsWith("#") || coin.startsWith("+");
+}
+var HIP4Client = class {
+  infoUrl;
+  exchangeUrl;
+  wsUrl;
+  testnet;
+  log;
+  constructor(config = {}) {
+    this.testnet = config.testnet ?? true;
+    this.infoUrl = config.infoUrl ?? (this.testnet ? TESTNET_INFO_URL : MAINNET_INFO_URL);
+    this.exchangeUrl = config.exchangeUrl ?? (this.testnet ? TESTNET_EXCHANGE_URL : MAINNET_EXCHANGE_URL);
+    this.wsUrl = this.testnet ? TESTNET_WS_URL : MAINNET_WS_URL;
+    this.log = config.logger ?? (() => {
+    });
+  }
+  // -- Info endpoints -------------------------------------------------------
+  async fetchOutcomeMeta() {
+    return this.infoPost({ type: "outcomeMeta" });
+  }
+  async fetchSettledOutcome(outcome) {
+    return this.infoPost({
+      type: "settledOutcome",
+      outcome
+    });
+  }
+  async fetchL2Book(coin) {
+    return this.infoPost({ type: "l2Book", coin });
+  }
+  async fetchRecentTrades(coin) {
+    return this.infoPost({ type: "recentTrades", coin });
+  }
+  async fetchAllMids() {
+    return this.infoPost({ type: "allMids" });
+  }
+  async fetchCandleSnapshot(coin, interval, startTime, endTime) {
+    return this.infoPost({
+      type: "candleSnapshot",
+      req: { coin, interval, startTime, endTime }
+    });
+  }
+  async fetchClearinghouseState(user) {
+    return this.infoPost({
+      type: "clearinghouseState",
+      user
+    });
+  }
+  async fetchUserFills(user) {
+    return this.infoPost({ type: "userFills", user });
+  }
+  /** Spot meta + asset contexts (includes markPx / oracle price for each spot asset) */
+  async fetchSpotAssetCtx(spotIndex) {
+    const data = await this.infoPost({
+      type: "spotMetaAndAssetCtxs"
+    });
+    const ctx = data[1]?.[spotIndex];
+    if (!ctx?.markPx) return null;
+    return { markPx: ctx.markPx, midPx: ctx.midPx ?? "0" };
+  }
+  /** Spot balances - HIP-4 prediction market positions live here (USDH, outcome tokens) */
+  async fetchSpotClearinghouseState(user) {
+    return this.infoPost({
+      type: "spotClearinghouseState",
+      user
+    });
+  }
+  /** Trade fills with time range filtering */
+  async fetchUserFillsByTime(user, startTime, endTime) {
+    return this.infoPost({
+      type: "userFillsByTime",
+      user,
+      startTime,
+      endTime,
+      aggregateByTime: true,
+      reversed: true,
+      dex: ALL_DEXS
+    });
+  }
+  /** Approved extra agents for a user */
+  async fetchExtraAgents(user) {
+    return this.infoPost({ type: "extraAgents", user });
+  }
+  /**
+   * Check the maximum builder fee a user has approved for a given builder.
+   * Returns the approved fee in tenths of a basis point (e.g. 100 = 0.1%).
+   * Returns 0 if no approval exists.
+   */
+  async fetchMaxBuilderFee(user, builder) {
+    const result = await this.infoPost({
+      type: "maxBuilderFee",
+      user,
+      builder: builder.toLowerCase()
+    });
+    return result ? Number(result) : 0;
+  }
+  /**
+   * Fetch all approved builder addresses for a user.
+   * Hyperliquid limits each address to a maximum of 3 approved builders.
+   */
+  async fetchApprovedBuilders(user) {
+    return this.infoPost({ type: "approvedBuilders", user });
+  }
+  /**
+   * Fetch a user's referral state from Hyperliquid.
+   * Returns the referral state object, or null if no referrer is set.
+   */
+  async fetchReferralState(user) {
+    return this.infoPost({ type: "referral", user });
+  }
+  /**
+   * Fetch the role assigned to a user by Hyperliquid.
+   * `role === "missing"` indicates the wallet has never interacted with HL.
+   */
+  async fetchUserRole(user) {
+    return this.infoPost({ type: "userRole", user });
+  }
+  /**
+   * Fetch the user's effective fee schedule (post-discount).
+   * Spot rates (`userSpotCrossRate` / `userSpotAddRate`) are what apply to
+   * HIP-4 outcome closes; opens are 0-fee.
+   */
+  async fetchUserFees(user) {
+    return this.infoPost({ type: "userFees", user });
+  }
+  /**
+   * Fetch the user's account abstraction mode.
+   *
+   * Returns one of `"default" | "disabled" | "dexAbstraction" |
+   * "unifiedAccount" | "portfolioMargin"`. Standard accounts return
+   * `"default"` (or `"disabled"`); both keep spot and perp as separate
+   * silos and require a `usdClassTransfer` before `withdraw3`. Only
+   * `"unifiedAccount"` / `"portfolioMargin"` merge the balances and reject
+   * `usdClassTransfer`. Use {@link isUsdClassTransferRequired} to gate the
+   * spot↔perp transfer step in deposit/withdraw flows.
+   *
+   * Endpoint: `POST /info` body `{ type: "userAbstraction", user }`.
+   */
+  async fetchUserAbstraction(user) {
+    return this.infoPost({ type: "userAbstraction", user });
+  }
+  /** Frontend-formatted open orders */
+  async fetchFrontendOpenOrders(user) {
+    return this.infoPost({
+      type: "frontendOpenOrders",
+      user,
+      dex: ALL_DEXS
+    });
+  }
+  // -- Exchange endpoints ---------------------------------------------------
+  async placeOrder(action, nonce, signature, vaultAddress = null) {
+    return this.exchangePost({
+      action,
+      nonce,
+      signature,
+      vaultAddress
+    });
+  }
+  async cancelOrder(action, nonce, signature, vaultAddress = null) {
+    return this.exchangePost({
+      action,
+      nonce,
+      signature,
+      vaultAddress
+    });
+  }
+  async modifyOrder(action, nonce, signature, vaultAddress = null) {
+    return this.exchangePost({
+      action,
+      nonce,
+      signature,
+      vaultAddress
+    });
+  }
+  async batchModifyOrders(action, nonce, signature, vaultAddress = null) {
+    return this.exchangePost({
+      action,
+      nonce,
+      signature,
+      vaultAddress
+    });
+  }
+  /** Submit a user-signed action (withdraw, usdClassTransfer, etc.) */
+  async submitUserSignedAction(action, nonce, signature) {
+    return this.exchangePost({
+      action,
+      nonce,
+      signature
+    });
+  }
+  // -- WebSocket subscriptions -----------------------------------------------
+  ws = null;
+  wsPendingMessages = [];
+  /** Callbacks keyed by response channel (for message routing). */
+  wsCallbacks = /* @__PURE__ */ new Map();
+  /** Active subscribe messages as JSON strings (for reconnection). */
+  wsActiveSubs = /* @__PURE__ */ new Set();
+  /**
+   * Subscribe to a Hyperliquid WebSocket channel.
+   * Returns an unsubscribe function.
+   *
+   * @param options.responseChannel  Channel name HL uses in response messages
+   *   when it differs from `subscription.type` (e.g. subscribe as
+   *   "activeAssetCtx" but receive on "activeSpotAssetCtx").
+   */
+  subscribe(subscription, onData, options) {
+    const responseChannel = options?.responseChannel ?? subscription.type;
+    this.ensureWs();
+    const subMsg = JSON.stringify({ method: "subscribe", subscription });
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(subMsg);
+    } else {
+      this.wsPendingMessages.push(subMsg);
+    }
+    this.wsActiveSubs.add(subMsg);
+    if (!this.wsCallbacks.has(responseChannel)) {
+      this.wsCallbacks.set(responseChannel, /* @__PURE__ */ new Set());
+    }
+    this.wsCallbacks.get(responseChannel)?.add(onData);
+    return () => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify({ method: "unsubscribe", subscription }));
+      }
+      this.wsActiveSubs.delete(subMsg);
+      const cbs = this.wsCallbacks.get(responseChannel);
+      if (cbs) {
+        cbs.delete(onData);
+        if (cbs.size === 0) this.wsCallbacks.delete(responseChannel);
+      }
+      if (this.wsCallbacks.size === 0 && this.ws) {
+        this.ws.close();
+        this.ws = null;
+      }
+    };
+  }
+  /** Tear down WebSocket and clear all subscriptions. */
+  closeWs() {
+    if (this.wsReconnectTimer) {
+      clearTimeout(this.wsReconnectTimer);
+      this.wsReconnectTimer = null;
+    }
+    this.wsReconnectAttempts = 0;
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.wsCallbacks.clear();
+    this.wsActiveSubs.clear();
+    this.wsPendingMessages = [];
+  }
+  ensureWs() {
+    if (this.ws) return;
+    const ws = new WebSocket(this.wsUrl);
+    this.ws = ws;
+    ws.onopen = () => {
+      this.wsReconnectAttempts = 0;
+      for (const msg of this.wsPendingMessages) {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(msg);
+        }
+      }
+      this.wsPendingMessages = [];
+    };
+    ws.onmessage = (event) => {
+      try {
+        const parsed = JSON.parse(event.data);
+        if (!parsed.channel) return;
+        const cbs = this.wsCallbacks.get(parsed.channel);
+        if (cbs) {
+          for (const cb of cbs) cb(parsed.data);
+        }
+      } catch {
+      }
+    };
+    ws.onclose = () => {
+      if (this.ws === ws) {
+        this.ws = null;
+        if (this.wsActiveSubs.size > 0) {
+          this.scheduleReconnect();
+        }
+      }
+    };
+  }
+  wsReconnectAttempts = 0;
+  wsReconnectTimer = null;
+  wsDestroyed = false;
+  scheduleReconnect() {
+    if (this.wsDestroyed) return;
+    if (this.wsReconnectAttempts >= 10) {
+      this.log("warn", "WS max reconnect attempts reached");
+      return;
+    }
+    const delay = Math.min(1e3 * 2 ** this.wsReconnectAttempts, 3e4);
+    this.wsReconnectAttempts++;
+    this.wsReconnectTimer = setTimeout(() => {
+      if (this.wsDestroyed || this.wsActiveSubs.size === 0) return;
+      this.ensureWs();
+      for (const msg of this.wsActiveSubs) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+          this.ws.send(msg);
+        } else {
+          this.wsPendingMessages.push(msg);
+        }
+      }
+    }, delay);
+  }
+  // -- Internal -------------------------------------------------------------
+  async infoPost(body) {
+    try {
+      return await this.doInfoPost(body);
+    } catch (err) {
+      if (err instanceof HLApiError && err.status >= 400 && err.status < 500)
+        throw err;
+      this.log("warn", "Info request failed, retrying once", {
+        type: body.type,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      await new Promise((r) => setTimeout(r, 1e3));
+      return this.doInfoPost(body);
+    }
+  }
+  async doInfoPost(body) {
+    const res = await fetch(this.infoUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!res.ok) {
+      throw new HLApiError(
+        res.status,
+        `HL info API responded with ${res.status}: ${res.statusText}`
+      );
+    }
+    try {
+      return await res.json();
+    } catch {
+      throw new HLApiError(res.status, "Exchange returned non-JSON response");
+    }
+  }
+  async exchangePost(body) {
+    const res = await fetch(this.exchangeUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!res.ok) {
+      throw new HLApiError(
+        res.status,
+        `HL exchange API responded with ${res.status}: ${res.statusText}`
+      );
+    }
+    try {
+      return await res.json();
+    } catch {
+      throw new HLApiError(res.status, "Exchange returned non-JSON response");
+    }
+  }
+};
+
+// src/adapter/hyperliquid/account.ts
+var POLL_INTERVAL_MS = 1e4;
+function mapSpotBalance(bal, allMids, nameMap, resolveSideNames) {
+  const coin = bal.coin;
+  if (!isOutcomeCoin(coin)) return null;
+  const total = toDecimal(bal.total);
+  if (total.isZero()) return null;
+  const outcomeId = coinOutcomeId(coin);
+  const marketId = outcomeId !== null ? String(outcomeId) : coin;
+  const outcome = coin;
+  const parsed = parseSideCoin(coin);
+  let outcomeName;
+  if (parsed && resolveSideNames) {
+    const names2 = resolveSideNames(parsed.outcomeId);
+    outcomeName = names2 ? names2[parsed.sideIndex] : `Side ${parsed.sideIndex}`;
+  } else {
+    outcomeName = parsed ? `Side ${parsed.sideIndex}` : coin;
+  }
+  toDecimal(bal.entryNtl);
+  const avgCost = isZero(bal.total) ? "0" : div(bal.entryNtl, bal.total);
+  const mid = allMids[coin];
+  const currentPrice = mid ?? "0";
+  const unrealizedPnl = mul(sub(currentPrice, avgCost), bal.total);
+  const potentialPayout = bal.total;
+  const names = nameMap.get(marketId);
+  return {
+    marketId,
+    eventTitle: names?.eventTitle ?? "",
+    marketQuestion: names?.marketQuestion ?? "",
+    outcome,
+    outcomeName,
+    shares: fixed(bal.total, 6),
+    avgCost: fixed(avgCost, 6),
+    currentPrice,
+    unrealizedPnl: fixed(unrealizedPnl, 6),
+    potentialPayout: fixed(potentialPayout, 6),
+    eventStatus: "active"
+  };
+}
+function mapFill(raw) {
+  if (!isOutcomeCoin(raw.coin)) return null;
+  const outcomeId = coinOutcomeId(raw.coin);
+  const marketId = outcomeId !== null ? String(outcomeId) : raw.coin;
+  return {
+    id: String(raw.tid),
+    type: "trade",
+    marketId,
+    outcome: raw.coin,
+    side: raw.side === "B" ? "buy" : "sell",
+    price: raw.px,
+    size: raw.sz,
+    timestamp: raw.time
+  };
+}
+var HIP4AccountAdapter = class {
+  constructor(client, events, resolveSideNames) {
+    this.client = client;
+    this.events = events;
+    this.resolveSideNames = resolveSideNames;
+  }
+  client;
+  events;
+  resolveSideNames;
+  async fetchPositions(address) {
+    if (this.events?.ensureSideNames) {
+      await this.events.ensureSideNames();
+    }
+    const [state, allMids, eventList] = await Promise.all([
+      this.client.fetchSpotClearinghouseState(address),
+      this.client.fetchAllMids(),
+      this.events?.fetchEvents({ limit: 200 }).catch(() => []) ?? Promise.resolve([])
+    ]);
+    const nameMap = /* @__PURE__ */ new Map();
+    for (const event of eventList) {
+      for (const market of event.markets) {
+        nameMap.set(market.id, { eventTitle: event.title, marketQuestion: market.question });
+      }
+    }
+    const positions = [];
+    for (const bal of state.balances) {
+      if (!isOutcomeCoin(bal.coin)) continue;
+      if (isZero(bal.total)) continue;
+      const mapped = mapSpotBalance(bal, allMids, nameMap, this.resolveSideNames);
+      if (mapped) positions.push(mapped);
+    }
+    return positions;
+  }
+  async fetchActivity(address) {
+    const now = Date.now();
+    const thirtyDaysMs = 30 * 24 * 60 * 60 * 1e3;
+    const startTime = now - thirtyDaysMs;
+    const fills = await this.client.fetchUserFillsByTime(
+      address,
+      startTime,
+      now
+    );
+    const activities = [];
+    for (const fill of fills) {
+      const mapped = mapFill(fill);
+      if (mapped) activities.push(mapped);
+    }
+    return activities;
+  }
+  async fetchBalance(address) {
+    const state = await this.client.fetchSpotClearinghouseState(address);
+    return state.balances.map((b) => ({
+      coin: b.coin,
+      total: b.total,
+      hold: b.hold
+    }));
+  }
+  async fetchOpenOrders(address) {
+    const orders = await this.client.fetchFrontendOpenOrders(address);
+    return orders.map((o) => ({
+      coin: o.coin,
+      side: o.side,
+      limitPx: o.limitPx,
+      sz: o.sz,
+      oid: o.oid,
+      timestamp: o.timestamp
+    }));
+  }
+  subscribePositions(address, onData) {
+    let active = true;
+    const poll = async () => {
+      while (active) {
+        try {
+          const positions = await this.fetchPositions(address);
+          if (active) onData(positions);
+        } catch {
+        }
+        if (active) {
+          await sleep(POLL_INTERVAL_MS);
+        }
+      }
+    };
+    void poll();
+    return () => {
+      active = false;
+    };
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/adapter/hyperliquid/auth.ts
+function isEthersSigner(val) {
+  return typeof val.getAddress === "function" && typeof val.signTypedData === "function";
+}
+function isViemAccount(val) {
+  return typeof val.address === "string" && typeof val.signTypedData === "function";
+}
+function wrapViemAccount(account) {
+  return {
+    getAddress: () => account.address,
+    signTypedData: (domain, types, value) => account.signTypedData({
+      domain,
+      types: { ...types },
+      primaryType: Object.keys(types)[0],
+      message: value
+    })
+  };
+}
+var HIP4Auth = class {
+  state = { status: "disconnected" };
+  signer = null;
+  async initAuth(walletAddress, signer) {
+    if (typeof signer !== "object" || signer === null) {
+      this.state = { status: "disconnected" };
+      throw new Error(
+        "HIP-4 auth requires a signer. Pass a viem PrivateKeyAccount, ethers Wallet, or compatible signer."
+      );
+    }
+    const obj = signer;
+    let resolved;
+    if (isEthersSigner(obj)) {
+      resolved = signer;
+    } else if (isViemAccount(obj)) {
+      resolved = wrapViemAccount(obj);
+    } else {
+      this.state = { status: "disconnected" };
+      throw new Error(
+        "HIP-4 auth requires a signer with signTypedData(). Pass a viem PrivateKeyAccount, ethers Wallet, or compatible signer."
+      );
+    }
+    this.state = { status: "pending_approval", address: walletAddress };
+    this.signer = resolved;
+    this.state = {
+      status: "ready",
+      address: walletAddress
+    };
+    return this.state;
+  }
+  getAuthStatus() {
+    return this.state;
+  }
+  clearAuth() {
+    this.signer = null;
+    this.state = { status: "disconnected" };
+  }
+  /** Internal - used by the trading adapter to get the active signer */
+  getSigner() {
+    return this.signer;
+  }
+};
+
+// src/adapter/hyperliquid/market-discovery.ts
+var PREDICTION_ASSET_OFFSET = 1e8;
+function parseDescription(desc) {
+  if (!desc || !desc.includes("|")) return null;
+  const fields = {};
+  for (const pair of desc.split("|")) {
+    const idx = pair.indexOf(":");
+    if (idx > 0) {
+      fields[pair.slice(0, idx)] = pair.slice(idx + 1);
+    }
+  }
+  if (fields.class !== "priceBinary") return null;
+  if (!fields.underlying || !fields.expiry || !fields.targetPrice || !fields.period) {
+    return null;
+  }
+  return {
+    class: "priceBinary",
+    underlying: fields.underlying,
+    expiry: parseExpiry(fields.expiry),
+    targetPrice: parseFloat(fields.targetPrice),
+    period: fields.period
+  };
+}
+function parsePriceBucketDescription(desc) {
+  if (!desc || !desc.includes("|")) return null;
+  const fields = {};
+  for (const pair of desc.split("|")) {
+    const idx = pair.indexOf(":");
+    if (idx > 0) {
+      fields[pair.slice(0, idx)] = pair.slice(idx + 1);
+    }
+  }
+  if (fields.class !== "priceBucket") return null;
+  if (!fields.underlying || !fields.expiry || !fields.priceThresholds || !fields.period) {
+    return null;
+  }
+  const priceThresholds = fields.priceThresholds.split(",").map((s) => parseFloat(s.trim())).filter((n) => Number.isFinite(n)).sort((a, b) => a - b);
+  if (priceThresholds.length === 0) return null;
+  return {
+    class: "priceBucket",
+    underlying: fields.underlying,
+    expiry: parseExpiry(fields.expiry),
+    priceThresholds,
+    period: fields.period
+  };
+}
+function parseExpiry(s) {
+  const year = parseInt(s.slice(0, 4));
+  const month = parseInt(s.slice(4, 6)) - 1;
+  const day = parseInt(s.slice(6, 8));
+  const hour = parseInt(s.slice(9, 11));
+  const min2 = parseInt(s.slice(11, 13));
+  return new Date(Date.UTC(year, month, day, hour, min2));
+}
+function discoverPriceBinaryMarkets(meta, mids) {
+  const markets = [];
+  for (const outcome of meta.outcomes) {
+    const parsed = parseDescription(outcome.description);
+    if (!parsed) continue;
+    if (!mids[parsed.underlying]) continue;
+    if (parsed.expiry.getTime() <= Date.now()) continue;
+    const yesCoinNum = outcome.outcome * 10;
+    const noCoinNum = outcome.outcome * 10 + 1;
+    markets.push({
+      outcomeId: outcome.outcome,
+      underlying: parsed.underlying,
+      targetPrice: parsed.targetPrice,
+      expiry: parsed.expiry,
+      period: parsed.period,
+      yesCoinNum,
+      noCoinNum,
+      yesCoin: `#${yesCoinNum}`,
+      noCoin: `#${noCoinNum}`,
+      yesAsset: PREDICTION_ASSET_OFFSET + yesCoinNum,
+      noAsset: PREDICTION_ASSET_OFFSET + noCoinNum
+    });
+  }
+  return markets;
+}
+function timeToExpiry(market) {
+  return (market.expiry.getTime() - Date.now()) / 6e4;
+}
+function periodMinutes(period) {
+  const match = period.match(/^(\d+)(m|h|d)$/);
+  if (!match) return 15;
+  const value = parseInt(match[1]);
+  switch (match[2]) {
+    case "m":
+      return value;
+    case "h":
+      return value * 60;
+    case "d":
+      return value * 1440;
+    default:
+      return 15;
+  }
+}
+function formatMarketLabel(market) {
+  return `${market.underlying}-${market.period}`;
+}
+
+// src/adapter/hyperliquid/market-classification.ts
+var PREDICTION_ASSET_OFFSET2 = 1e8;
+function buildSides(outcome) {
+  return [
+    {
+      name: outcome.sideSpecs[0]?.name ?? "Side 0",
+      coinNum: outcome.outcome * 10,
+      coin: `#${outcome.outcome * 10}`,
+      asset: PREDICTION_ASSET_OFFSET2 + outcome.outcome * 10
+    },
+    {
+      name: outcome.sideSpecs[1]?.name ?? "Side 1",
+      coinNum: outcome.outcome * 10 + 1,
+      coin: `#${outcome.outcome * 10 + 1}`,
+      asset: PREDICTION_ASSET_OFFSET2 + outcome.outcome * 10 + 1
+    }
+  ];
+}
+function buildQuestionIndex(questions) {
+  const byOutcome = /* @__PURE__ */ new Map();
+  for (const q of questions) {
+    const bucket = parsePriceBucketDescription(q.description);
+    q.namedOutcomes.forEach((id, bucketIndex) => {
+      byOutcome.set(id, {
+        question: q,
+        isFallback: false,
+        bucketIndex,
+        bucket
+      });
+    });
+    byOutcome.set(q.fallbackOutcome, {
+      question: q,
+      isFallback: true,
+      bucketIndex: -1,
+      bucket
+    });
+  }
+  return { byOutcome };
+}
+function getPriceBucketBounds(thresholds, bucketIndex) {
+  if (bucketIndex < 0) return { lowerBound: null, upperBound: null };
+  const lowerBound = bucketIndex === 0 ? null : thresholds[bucketIndex - 1] ?? null;
+  const upperBound = bucketIndex >= thresholds.length ? null : thresholds[bucketIndex] ?? null;
+  return { lowerBound, upperBound };
+}
+function buildPriceBucketMarket(outcome, sides, entry, bucket) {
+  const { lowerBound, upperBound } = getPriceBucketBounds(
+    bucket.priceThresholds,
+    entry.bucketIndex
+  );
+  return {
+    type: "priceBucket",
+    outcomeId: outcome.outcome,
+    name: outcome.name,
+    description: outcome.description,
+    sides,
+    raw: outcome,
+    underlying: bucket.underlying,
+    expiry: bucket.expiry,
+    priceThresholds: bucket.priceThresholds,
+    period: bucket.period,
+    questionId: entry.question.question,
+    questionName: entry.question.name,
+    questionDescription: entry.question.description,
+    isFallback: entry.isFallback,
+    bucketIndex: entry.bucketIndex,
+    lowerBound,
+    upperBound,
+    rawQuestion: entry.question
+  };
+}
+function classifyOutcome(outcome, questions, precomputedIndex) {
+  const sides = buildSides(outcome);
+  const index = precomputedIndex ?? buildQuestionIndex(questions);
+  const parsed = parseDescription(outcome.description);
+  if (parsed) {
+    const market2 = {
+      type: "defaultBinary",
+      outcomeId: outcome.outcome,
+      name: `${parsed.underlying} > $${parsed.targetPrice} (${parsed.period})`,
+      description: `Will ${parsed.underlying} be above $${parsed.targetPrice} by expiry?`,
+      sides,
+      raw: outcome,
+      underlying: parsed.underlying,
+      targetPrice: parsed.targetPrice,
+      expiry: parsed.expiry,
+      period: parsed.period
+    };
+    return market2;
+  }
+  const questionEntry = index.byOutcome.get(outcome.outcome);
+  if (questionEntry) {
+    if (questionEntry.bucket) {
+      return buildPriceBucketMarket(
+        outcome,
+        sides,
+        questionEntry,
+        questionEntry.bucket
+      );
+    }
+    const market2 = {
+      type: "multiOutcome",
+      outcomeId: outcome.outcome,
+      name: outcome.name,
+      description: outcome.description,
+      sides,
+      raw: outcome,
+      questionId: questionEntry.question.question,
+      questionName: questionEntry.question.name,
+      questionDescription: questionEntry.question.description,
+      isFallback: questionEntry.isFallback,
+      rawQuestion: questionEntry.question
+    };
+    return market2;
+  }
+  const market = {
+    type: "labelledBinary",
+    outcomeId: outcome.outcome,
+    name: outcome.name,
+    description: outcome.description,
+    sides,
+    raw: outcome
+  };
+  return market;
+}
+function classifyAllOutcomes(outcomes, questions) {
+  const index = buildQuestionIndex(questions);
+  return outcomes.map((outcome) => {
+    const sides = buildSides(outcome);
+    const parsed = parseDescription(outcome.description);
+    if (parsed) {
+      return {
+        type: "defaultBinary",
+        outcomeId: outcome.outcome,
+        name: `${parsed.underlying} > $${parsed.targetPrice} (${parsed.period})`,
+        description: `Will ${parsed.underlying} be above $${parsed.targetPrice} by expiry?`,
+        sides,
+        raw: outcome,
+        underlying: parsed.underlying,
+        targetPrice: parsed.targetPrice,
+        expiry: parsed.expiry,
+        period: parsed.period
+      };
+    }
+    const questionEntry = index.byOutcome.get(outcome.outcome);
+    if (questionEntry) {
+      if (questionEntry.bucket) {
+        return buildPriceBucketMarket(
+          outcome,
+          sides,
+          questionEntry,
+          questionEntry.bucket
+        );
+      }
+      return {
+        type: "multiOutcome",
+        outcomeId: outcome.outcome,
+        name: outcome.name,
+        description: outcome.description,
+        sides,
+        raw: outcome,
+        questionId: questionEntry.question.question,
+        questionName: questionEntry.question.name,
+        questionDescription: questionEntry.question.description,
+        isFallback: questionEntry.isFallback,
+        rawQuestion: questionEntry.question
+      };
+    }
+    return {
+      type: "labelledBinary",
+      outcomeId: outcome.outcome,
+      name: outcome.name,
+      description: outcome.description,
+      sides,
+      raw: outcome
+    };
+  });
+}
+
+// src/adapter/hyperliquid/events.ts
+var CATEGORIES = [
+  { id: "custom", name: "Custom", slug: "custom" },
+  { id: "recurring", name: "Recurring", slug: "recurring" }
+];
+function isRecurring(outcome) {
+  return outcome.name === "Recurring";
+}
+function parseRecurringDescription(desc) {
+  if (!desc.includes("|")) return null;
+  const result = {};
+  for (const segment of desc.split("|")) {
+    const [key, ...rest] = segment.split(":");
+    if (key && rest.length > 0) {
+      result[key] = rest.join(":");
+    }
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}
+function recurringTitle(outcome) {
+  const parsed = parseRecurringDescription(outcome.description);
+  if (!parsed) return `Outcome #${outcome.outcome}`;
+  const underlying = parsed.underlying ?? "???";
+  const target = parsed.targetPrice ?? "???";
+  const period = parsed.period ?? "";
+  if (parsed.class === "priceBinary") {
+    return `${underlying} > $${target} (${period})`;
+  }
+  return `${underlying} ${parsed.class ?? "outcome"} (${period})`;
+}
+function recurringDescription(outcome) {
+  const parsed = parseRecurringDescription(outcome.description);
+  if (!parsed) return outcome.description;
+  const expiry = parsed.expiry ?? "unknown";
+  return `Will ${parsed.underlying ?? "asset"} be above $${parsed.targetPrice ?? "?"} by ${expiry}?`;
+}
+function mapOutcomeToMarket(outcome, eventId) {
+  const outcomes = outcome.sideSpecs.map(
+    (spec, sideIndex) => ({
+      name: spec.name,
+      tokenId: sideCoin(outcome.outcome, sideIndex),
+      price: "0"
+    })
+  );
+  return {
+    id: String(outcome.outcome),
+    eventId,
+    question: isRecurring(outcome) ? recurringDescription(outcome) : outcome.name,
+    outcomes,
+    volume: "0",
+    liquidity: "0"
+  };
+}
+function mapQuestionToEvent(question, outcomeMap) {
+  const eventId = `q${question.question}`;
+  const allOutcomeIds = [
+    ...question.namedOutcomes,
+    question.fallbackOutcome
+  ].filter((id) => outcomeMap.has(id));
+  const markets = allOutcomeIds.map((id) => outcomeMap.get(id)).map((o) => mapOutcomeToMarket(o, eventId));
+  const settled = new Set(question.settledNamedOutcomes);
+  const hasUnsettled = question.namedOutcomes.some((id) => !settled.has(id));
+  return {
+    id: eventId,
+    title: question.name,
+    description: question.description,
+    category: "custom",
+    markets,
+    totalVolume: "0",
+    endDate: "",
+    status: hasUnsettled ? "active" : "resolved"
+  };
+}
+function mapStandaloneOutcomeToEvent(outcome) {
+  const eventId = `o${outcome.outcome}`;
+  const recurring = isRecurring(outcome);
+  return {
+    id: eventId,
+    title: recurring ? recurringTitle(outcome) : outcome.name,
+    description: recurring ? recurringDescription(outcome) : outcome.description,
+    category: recurring ? "recurring" : "custom",
+    markets: [mapOutcomeToMarket(outcome, eventId)],
+    totalVolume: "0",
+    endDate: recurring ? parseRecurringDescription(outcome.description)?.expiry ?? "" : "",
+    status: "active"
+  };
+}
+var HIP4EventAdapter = class _HIP4EventAdapter {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  cache = null;
+  metaCache = null;
+  static CACHE_TTL_MS = 3e4;
+  /** Side names from outcomeMeta. Populated once, never cleared (sideSpecs don't change). */
+  sideNames = null;
+  /** Returns a resolver function that looks up side names by outcome ID. */
+  getSideNameResolver() {
+    return (outcomeId) => this.sideNames?.get(outcomeId) ?? null;
+  }
+  /** Ensure sideNames are loaded. Call before using the resolver if data may not be cached yet. */
+  async ensureSideNames() {
+    if (this.sideNames) return;
+    const meta = await this.client.fetchOutcomeMeta();
+    this.populateSideNames(meta);
+  }
+  /**
+   * Subscribe to live outcome-meta updates (HIP-4 catalog changes).
+   *
+   * Each frame is an array of one or more updates. The handler is invoked
+   * once per update with the discriminated payload. Internally we also:
+   *   - extend `sideNames` for newly created outcomes (so `getSideNameResolver`
+   *     returns real names instead of falling back to "Side 0/1")
+   *   - invalidate the events + markets caches so the next read refetches
+   *     and reflects the change
+   *
+   * Returns an unsubscribe callback.
+   */
+  subscribeOutcomeMetaUpdates(onData) {
+    return this.client.subscribe(
+      { type: "outcomeMetaUpdates" },
+      (raw) => {
+        if (!Array.isArray(raw)) return;
+        const updates = raw;
+        for (const update of updates) {
+          this.applyMetaUpdate(update);
+          onData(update);
+        }
+      }
+    );
+  }
+  applyMetaUpdate(update) {
+    if ("outcomeCreated" in update) {
+      const spec = update.outcomeCreated;
+      if (this.sideNames && spec.sideSpecs.length >= 2) {
+        this.sideNames.set(spec.outcome, [
+          spec.sideSpecs[0].name,
+          spec.sideSpecs[1].name
+        ]);
+      }
+    }
+    this.cache = null;
+    this.metaCache = null;
+  }
+  populateSideNames(meta) {
+    if (this.sideNames) return;
+    this.sideNames = /* @__PURE__ */ new Map();
+    for (const o of meta.outcomes) {
+      if (o.sideSpecs.length >= 2) {
+        this.sideNames.set(o.outcome, [
+          o.sideSpecs[0].name,
+          o.sideSpecs[1].name
+        ]);
+      }
+    }
+  }
+  async fetchEvents(params = {}) {
+    let events = await this.loadEvents();
+    if (params.category && params.category !== "all") {
+      events = events.filter((e) => e.category === params.category);
+    }
+    if (params.active) {
+      events = events.filter((e) => e.status === "active");
+    }
+    if (params.query) {
+      const q = params.query.toLowerCase();
+      events = events.filter(
+        (e) => e.title.toLowerCase().includes(q) || e.description.toLowerCase().includes(q)
+      );
+    }
+    const offset = params.offset ?? 0;
+    const limit = params.limit ?? 50;
+    return events.slice(offset, offset + limit);
+  }
+  async fetchEvent(eventId) {
+    const events = await this.loadEvents();
+    const event = events.find((e) => e.id === eventId);
+    if (!event) {
+      throw new Error(`HIP-4 event not found: ${eventId}`);
+    }
+    return event;
+  }
+  async fetchCategories() {
+    return CATEGORIES;
+  }
+  async fetchMarkets(params = {}) {
+    const allMarkets = await this.loadMarkets();
+    let filtered = params.type ? allMarkets.filter((m) => m.type === params.type) : allMarkets;
+    if (params.groupBy === "type") {
+      const grouped = {};
+      for (const m of filtered) {
+        (grouped[m.type] ??= []).push(m);
+      }
+      return grouped;
+    }
+    if (params.groupBy === "question") {
+      const grouped = {};
+      for (const m of filtered) {
+        const key = m.type === "multiOutcome" ? String(m.questionId) : "standalone";
+        (grouped[key] ??= []).push(m);
+      }
+      return grouped;
+    }
+    const offset = params.offset ?? 0;
+    const limit = params.limit ?? filtered.length;
+    return filtered.slice(offset, offset + limit);
+  }
+  async loadMarkets() {
+    const now = Date.now();
+    if (this.metaCache && now - this.metaCache.timestamp < _HIP4EventAdapter.CACHE_TTL_MS) {
+      return this.metaCache.markets;
+    }
+    const [meta, mids] = await Promise.all([
+      this.client.fetchOutcomeMeta(),
+      this.client.fetchAllMids().catch(() => ({}))
+    ]);
+    this.populateSideNames(meta);
+    const markets = classifyAllOutcomes(meta.outcomes, meta.questions);
+    this.metaCache = { meta, mids, markets, timestamp: now };
+    return markets;
+  }
+  // -------------------------------------------------------------------------
+  // loadEvents  - legacy PredictionEvent API
+  // -------------------------------------------------------------------------
+  async loadEvents() {
+    const now = Date.now();
+    if (this.cache && now - this.cache.timestamp < _HIP4EventAdapter.CACHE_TTL_MS) {
+      return this.cache.events;
+    }
+    const [meta, mids] = await Promise.all([
+      this.client.fetchOutcomeMeta(),
+      this.client.fetchAllMids().catch(() => ({}))
+    ]);
+    this.populateSideNames(meta);
+    const events = buildEventsFromMeta(meta);
+    for (const event of events) {
+      for (const market of event.markets) {
+        for (const outcome of market.outcomes) {
+          const mid = mids[outcome.tokenId];
+          if (mid) {
+            outcome.price = mid;
+          }
+        }
+      }
+    }
+    this.cache = { events, timestamp: now };
+    return events;
+  }
+};
+function buildEventsFromMeta(meta) {
+  const outcomeMap = /* @__PURE__ */ new Map();
+  for (const o of meta.outcomes) {
+    outcomeMap.set(o.outcome, o);
+  }
+  const claimedOutcomes = /* @__PURE__ */ new Set();
+  const events = [];
+  for (const q of meta.questions) {
+    for (const id of q.namedOutcomes) claimedOutcomes.add(id);
+    claimedOutcomes.add(q.fallbackOutcome);
+    events.push(mapQuestionToEvent(q, outcomeMap));
+  }
+  for (const o of meta.outcomes) {
+    if (!claimedOutcomes.has(o.outcome)) {
+      events.push(mapStandaloneOutcomeToEvent(o));
+    }
+  }
+  return events;
+}
+
+// src/adapter/hyperliquid/market-data.ts
+function mapBook(raw, marketId) {
+  const [bids, asks] = raw.levels;
+  return {
+    marketId,
+    bids: bids.map((l) => ({ price: l.px, size: l.sz })),
+    asks: asks.map((l) => ({ price: l.px, size: l.sz })),
+    timestamp: raw.time
+  };
+}
+function mapWsBook(raw, marketId) {
+  const [bids, asks] = raw.levels;
+  return {
+    marketId,
+    bids: bids.map((l) => ({ price: l.px, size: l.sz })),
+    asks: asks.map((l) => ({ price: l.px, size: l.sz })),
+    timestamp: raw.time
+  };
+}
+function mapTrade(raw, marketId) {
+  return {
+    id: String(raw.tid),
+    marketId,
+    outcome: raw.coin,
+    side: raw.side === "B" ? "buy" : "sell",
+    price: raw.px,
+    size: raw.sz,
+    timestamp: raw.time
+  };
+}
+var HIP4MarketDataAdapter = class _HIP4MarketDataAdapter {
+  constructor(client, resolveSideNames, ensureSideNames) {
+    this.client = client;
+    this.resolveSideNames = resolveSideNames ?? (() => null);
+    this.ensureSideNames = ensureSideNames;
+  }
+  client;
+  midsCache = null;
+  static MIDS_CACHE_TTL = 5e3;
+  resolveSideNames;
+  ensureSideNames;
+  async fetchOrderBook(marketId, sideIndex = 0) {
+    const outcomeId = parseInt(marketId, 10);
+    const coin = sideCoin(outcomeId, sideIndex);
+    const raw = await this.client.fetchL2Book(coin);
+    return mapBook(raw, marketId);
+  }
+  sideNamesFor(marketId) {
+    const outcomeId = parseInt(marketId, 10);
+    return this.resolveSideNames(outcomeId) ?? ["Side 0", "Side 1"];
+  }
+  async fetchPrice(marketId) {
+    await this.ensureSideNames?.();
+    const outcomeId = parseInt(marketId, 10);
+    const mids = await this.getMids();
+    const [name0, name1] = this.sideNamesFor(marketId);
+    const side0Coin = sideCoin(outcomeId, 0);
+    const side1Coin = sideCoin(outcomeId, 1);
+    const side0Mid = mids[side0Coin] ?? "0";
+    const side1Mid = mids[side1Coin] ?? "0";
+    return {
+      marketId,
+      outcomes: [
+        { name: name0, price: side0Mid, midpoint: side0Mid },
+        { name: name1, price: side1Mid, midpoint: side1Mid }
+      ],
+      timestamp: Date.now()
+    };
+  }
+  async fetchTrades(marketId, limit = 50, sideIndex = 0) {
+    const outcomeId = parseInt(marketId, 10);
+    const coin = sideCoin(outcomeId, sideIndex);
+    const raw = await this.client.fetchRecentTrades(coin);
+    return raw.slice(0, limit).map((t) => mapTrade(t, marketId));
+  }
+  async fetchCandles(marketId, interval = "1h", startTime, endTime) {
+    const outcomeId = parseInt(marketId, 10);
+    const coin = sideCoin(outcomeId, 0);
+    const now = Date.now();
+    const start = startTime ?? now - 14 * 24 * 60 * 60 * 1e3;
+    const end = endTime ?? now;
+    const raw = await this.client.fetchCandleSnapshot(
+      coin,
+      interval,
+      start,
+      end
+    );
+    return raw.map((c) => ({
+      time: c.t / 1e3,
+      open: parseFloat(c.o),
+      high: parseFloat(c.h),
+      low: parseFloat(c.l),
+      close: parseFloat(c.c),
+      volume: parseFloat(c.v)
+    }));
+  }
+  // -- WebSocket subscriptions --------------------------------------------
+  subscribeOrderBook(marketId, onData) {
+    const outcomeId = parseInt(marketId, 10);
+    const coin = sideCoin(outcomeId, 0);
+    return this.subscribeWs("l2Book", coin, (data) => {
+      if (isL2BookData(data) && data.coin === coin) {
+        onData(mapWsBook(data, marketId));
+      }
+    });
+  }
+  subscribePrice(marketId, onData) {
+    const outcomeId = parseInt(marketId, 10);
+    const coin0 = sideCoin(outcomeId, 0);
+    const coin1 = sideCoin(outcomeId, 1);
+    return this.subscribeWs("allMids", "*", (data) => {
+      if (!isAllMidsData(data)) return;
+      const mids = data.mids;
+      const side0Mid = mids[coin0];
+      const side1Mid = mids[coin1];
+      if (side0Mid === void 0 && side1Mid === void 0) return;
+      const [n0, n1] = this.sideNamesFor(marketId);
+      onData({
+        marketId,
+        outcomes: [
+          {
+            name: n0,
+            price: side0Mid ?? "0",
+            midpoint: side0Mid ?? "0"
+          },
+          {
+            name: n1,
+            price: side1Mid ?? "0",
+            midpoint: side1Mid ?? "0"
+          }
+        ],
+        timestamp: Date.now()
+      });
+    });
+  }
+  subscribeTrades(marketId, onData) {
+    const outcomeId = parseInt(marketId, 10);
+    const coin = sideCoin(outcomeId, 0);
+    return this.subscribeWs("trades", coin, (data) => {
+      if (!isTradesData(data)) return;
+      for (const t of data) {
+        const trade = t;
+        if (trade.coin === coin) {
+          onData(mapTrade(trade, marketId));
+        }
+      }
+    });
+  }
+  subscribeAllMids(onData) {
+    return this.subscribeWs("allMids", "*", (data) => {
+      if (isAllMidsData(data)) {
+        onData(data);
+      }
+    });
+  }
+  /**
+   * Subscribe to real-time asset context (volume, mark price, OI) for a spot coin.
+   *
+   * HL subscription type is "activeAssetCtx" but the response channel for spot
+   * assets is "activeSpotAssetCtx" (perps use "activeAssetCtx" instead).
+   * We only handle spot here since HIP-4 prediction tokens are spot assets.
+   * If perps support is added, a separate method or channel-aware routing is needed.
+   */
+  subscribeActiveAssetCtx(coin, onData) {
+    return this.subscribeWs(
+      "activeSpotAssetCtx",
+      coin,
+      (data) => {
+        if (isActiveAssetCtxData(data) && data.coin === coin) {
+          onData(data);
+        }
+      },
+      "activeAssetCtx"
+    );
+  }
+  /**
+   * Subscribe to bulk spot asset context updates for ALL spot coins.
+   * Undocumented HL subscription type "spotAssetCtxs" - streams an array
+   * of SpotAssetCtx entries on each update.
+   */
+  subscribeSpotAssetCtxs(onData) {
+    return this.subscribeWs("spotAssetCtxs", "*", (data) => {
+      if (isSpotAssetCtxsData(data)) {
+        onData(data);
+      }
+    });
+  }
+  /**
+   * Subscribe to real-time perp asset context (mark price, oracle, funding).
+   * For perps, both subscription type and response channel are "activeAssetCtx".
+   */
+  subscribePerpAssetCtx(coin, onData) {
+    return this.subscribeWs("activeAssetCtx", coin, (data) => {
+      if (isActivePerpAssetCtxData(data) && data.coin === coin) {
+        onData(data);
+      }
+    });
+  }
+  /** No-op - WebSocket lifecycle is managed by the shared HIP4Client. */
+  destroy() {
+  }
+  // -- Internal helpers ---------------------------------------------------
+  async getMids() {
+    const now = Date.now();
+    if (this.midsCache && now - this.midsCache.time < _HIP4MarketDataAdapter.MIDS_CACHE_TTL) {
+      return this.midsCache.data;
+    }
+    const data = await this.client.fetchAllMids();
+    this.midsCache = { data, time: now };
+    return data;
+  }
+  /**
+   * Subscribe to a WebSocket channel via the shared HIP4Client.
+   *
+   * @param channel   Response channel name used for message routing (e.g. "l2Book").
+   * @param coin      Coin filter ("*" for channel-only subscriptions).
+   * @param onData    Callback fired on each matching message.
+   * @param subscriptionType  Wire type sent in the subscribe message. Defaults
+   *   to `channel`. Needed when HL uses a different name in the subscribe
+   *   request vs the response channel (e.g. send "activeAssetCtx" but receive
+   *   on "activeSpotAssetCtx" for spot assets).
+   */
+  subscribeWs(channel, coin, onData, subscriptionType) {
+    const wireType = subscriptionType ?? channel;
+    const subscription = { type: wireType };
+    if (coin !== "*") {
+      subscription.coin = coin;
+    }
+    return this.client.subscribe(
+      subscription,
+      onData,
+      wireType !== channel ? { responseChannel: channel } : void 0
+    );
+  }
+};
+function isL2BookData(data) {
+  return typeof data === "object" && data !== null && "coin" in data && "levels" in data;
+}
+function isAllMidsData(data) {
+  return typeof data === "object" && data !== null && "mids" in data;
+}
+function isTradesData(data) {
+  return Array.isArray(data);
+}
+function isActiveAssetCtxData(data) {
+  return typeof data === "object" && data !== null && "coin" in data && "ctx" in data;
+}
+function isActivePerpAssetCtxData(data) {
+  return typeof data === "object" && data !== null && "coin" in data && "ctx" in data;
+}
+function isSpotAssetCtxsData(data) {
+  return Array.isArray(data) && data.length > 0 && typeof data[0] === "object" && data[0] !== null && "coin" in data[0] && "markPx" in data[0];
+}
+
+// src/adapter/hyperliquid/pricing.ts
+var MIN_NOTIONAL = 10;
+function computeTickSize(price) {
+  if (price <= 0) return 1e-5;
+  const d = toDecimal(price);
+  const magnitude = d.floorLog10();
+  return toNum(pow("10", magnitude.minus(4).toString()));
+}
+function roundToTick(price) {
+  const tick = computeTickSize(price);
+  const d = toDecimal(price);
+  const t = toDecimal(tick);
+  return toNum(d.dividedBy(t).round().times(t).toString());
+}
+function formatPrice(price) {
+  if (price <= 0) return "0";
+  const rounded = roundToTick(price);
+  const tick = computeTickSize(rounded);
+  const decimals = Math.max(0, -toNum(toDecimal(tick).floorLog10().toString()));
+  let s = fixed(rounded, decimals);
+  if (s.includes(".")) {
+    s = s.replace(/\.?0+$/, "");
+  }
+  return s;
+}
+function stripZeros(s) {
+  if (!s.includes(".")) return s;
+  return s.replace(/\.?0+$/, "");
+}
+function getMinShares(markPx) {
+  const effective = toNum(clamp(
+    toDecimal(Math.min(markPx, 1 - markPx)).toString(),
+    "0.01",
+    "1"
+  ));
+  return Math.ceil(MIN_NOTIONAL / effective);
+}
+
+// src/adapter/hyperliquid/types.ts
+function splitHexSignature(hex) {
+  const raw = hex.startsWith("0x") ? hex.slice(2) : hex;
+  return {
+    r: "0x" + raw.slice(0, 64),
+    s: "0x" + raw.slice(64, 128),
+    v: parseInt(raw.slice(128, 130), 16)
+  };
+}
+function normalizeSignature(sig) {
+  if (typeof sig === "string") {
+    return splitHexSignature(sig);
+  }
+  return sig;
+}
+
+// src/adapter/hyperliquid/signing.ts
+function encodeMsgpack(value) {
+  const parts = [];
+  encodeValue(value, parts);
+  let totalLen = 0;
+  for (const p of parts) totalLen += p.length;
+  const result = new Uint8Array(totalLen);
+  let offset = 0;
+  for (const p of parts) {
+    result.set(p, offset);
+    offset += p.length;
+  }
+  return result;
+}
+function encodeValue(value, parts) {
+  if (value === null || value === void 0) {
+    parts.push(new Uint8Array([192]));
+    return;
+  }
+  if (typeof value === "boolean") {
+    parts.push(new Uint8Array([value ? 195 : 194]));
+    return;
+  }
+  if (typeof value === "number") {
+    encodeNumber(value, parts);
+    return;
+  }
+  if (typeof value === "string") {
+    encodeString(value, parts);
+    return;
+  }
+  if (Array.isArray(value)) {
+    encodeArray(value, parts);
+    return;
+  }
+  if (typeof value === "object") {
+    encodeMap(value, parts);
+    return;
+  }
+  throw new Error(`msgpack: unsupported type ${typeof value}`);
+}
+function encodeNumber(n, parts) {
+  if (!Number.isInteger(n)) {
+    const buf = new ArrayBuffer(9);
+    const view = new DataView(buf);
+    view.setUint8(0, 203);
+    view.setFloat64(1, n);
+    parts.push(new Uint8Array(buf));
+    return;
+  }
+  if (n >= 0) {
+    if (n <= 127) {
+      parts.push(new Uint8Array([n]));
+    } else if (n <= 255) {
+      parts.push(new Uint8Array([204, n]));
+    } else if (n <= 65535) {
+      const buf = new Uint8Array(3);
+      buf[0] = 205;
+      buf[1] = n >> 8 & 255;
+      buf[2] = n & 255;
+      parts.push(buf);
+    } else if (n <= 4294967295) {
+      const buf = new Uint8Array(5);
+      buf[0] = 206;
+      buf[1] = n >> 24 & 255;
+      buf[2] = n >> 16 & 255;
+      buf[3] = n >> 8 & 255;
+      buf[4] = n & 255;
+      parts.push(buf);
+    } else {
+      const buf = new Uint8Array(9);
+      buf[0] = 207;
+      const big = BigInt(n);
+      const view = new DataView(buf.buffer);
+      view.setBigUint64(1, big);
+      parts.push(buf);
+    }
+  } else {
+    if (n >= -32) {
+      parts.push(new Uint8Array([256 + n & 255]));
+    } else if (n >= -128) {
+      const buf = new Uint8Array(2);
+      buf[0] = 208;
+      buf[1] = 256 + n & 255;
+      parts.push(buf);
+    } else if (n >= -32768) {
+      const buf = new Uint8Array(3);
+      buf[0] = 209;
+      const view = new DataView(buf.buffer);
+      view.setInt16(1, n);
+      parts.push(buf);
+    } else if (n >= -2147483648) {
+      const buf = new Uint8Array(5);
+      buf[0] = 210;
+      const view = new DataView(buf.buffer);
+      view.setInt32(1, n);
+      parts.push(buf);
+    } else {
+      const buf = new Uint8Array(9);
+      buf[0] = 211;
+      const view = new DataView(buf.buffer);
+      view.setBigInt64(1, BigInt(n));
+      parts.push(buf);
+    }
+  }
+}
+function encodeString(s, parts) {
+  const encoded = new TextEncoder().encode(s);
+  const len = encoded.length;
+  if (len <= 31) {
+    parts.push(new Uint8Array([160 | len]));
+  } else if (len <= 255) {
+    parts.push(new Uint8Array([217, len]));
+  } else if (len <= 65535) {
+    parts.push(new Uint8Array([218, len >> 8 & 255, len & 255]));
+  } else {
+    parts.push(
+      new Uint8Array([
+        219,
+        len >> 24 & 255,
+        len >> 16 & 255,
+        len >> 8 & 255,
+        len & 255
+      ])
+    );
+  }
+  parts.push(encoded);
+}
+function encodeArray(arr, parts) {
+  const len = arr.length;
+  if (len <= 15) {
+    parts.push(new Uint8Array([144 | len]));
+  } else if (len <= 65535) {
+    parts.push(new Uint8Array([220, len >> 8 & 255, len & 255]));
+  } else {
+    parts.push(
+      new Uint8Array([
+        221,
+        len >> 24 & 255,
+        len >> 16 & 255,
+        len >> 8 & 255,
+        len & 255
+      ])
+    );
+  }
+  for (const item of arr) {
+    encodeValue(item, parts);
+  }
+}
+function encodeMap(obj, parts) {
+  const keys = Object.keys(obj);
+  const len = keys.length;
+  if (len <= 15) {
+    parts.push(new Uint8Array([128 | len]));
+  } else if (len <= 65535) {
+    parts.push(new Uint8Array([222, len >> 8 & 255, len & 255]));
+  } else {
+    parts.push(
+      new Uint8Array([
+        223,
+        len >> 24 & 255,
+        len >> 16 & 255,
+        len >> 8 & 255,
+        len & 255
+      ])
+    );
+  }
+  for (const key of keys) {
+    encodeString(key, parts);
+    encodeValue(obj[key], parts);
+  }
+}
+var KECCAK_ROUND_CONSTANTS = [
+  0x0000000000000001n,
+  0x0000000000008082n,
+  0x800000000000808an,
+  0x8000000080008000n,
+  0x000000000000808bn,
+  0x0000000080000001n,
+  0x8000000080008081n,
+  0x8000000000008009n,
+  0x000000000000008an,
+  0x0000000000000088n,
+  0x0000000080008009n,
+  0x000000008000000an,
+  0x000000008000808bn,
+  0x800000000000008bn,
+  0x8000000000008089n,
+  0x8000000000008003n,
+  0x8000000000008002n,
+  0x8000000000000080n,
+  0x000000000000800an,
+  0x800000008000000an,
+  0x8000000080008081n,
+  0x8000000000008080n,
+  0x0000000080000001n,
+  0x8000000080008008n
+];
+var ROTATION_OFFSETS = [
+  0,
+  1,
+  62,
+  28,
+  27,
+  36,
+  44,
+  6,
+  55,
+  20,
+  3,
+  10,
+  43,
+  25,
+  39,
+  41,
+  45,
+  15,
+  21,
+  8,
+  18,
+  2,
+  61,
+  56,
+  14
+];
+var PI_PERMUTATION = new Array(25);
+for (let x = 0; x < 5; x++) {
+  for (let y = 0; y < 5; y++) {
+    const fromIdx = x + 5 * y;
+    const newX = y;
+    const newY = (2 * x + 3 * y) % 5;
+    PI_PERMUTATION[fromIdx] = newX + 5 * newY;
+  }
+}
+var MASK64 = 0xffffffffffffffffn;
+function rotl64(x, n) {
+  if (n === 0) return x;
+  return (x << BigInt(n) | x >> BigInt(64 - n)) & MASK64;
+}
+function keccakF1600(state) {
+  for (let round = 0; round < 24; round++) {
+    const c = new Array(5);
+    for (let x = 0; x < 5; x++) {
+      c[x] = state[x] ^ state[x + 5] ^ state[x + 10] ^ state[x + 15] ^ state[x + 20];
+    }
+    for (let x = 0; x < 5; x++) {
+      const d = c[(x + 4) % 5] ^ rotl64(c[(x + 1) % 5], 1);
+      for (let y = 0; y < 5; y++) {
+        state[x + 5 * y] = (state[x + 5 * y] ^ d) & MASK64;
+      }
+    }
+    const temp = new Array(25);
+    for (let i = 0; i < 25; i++) {
+      temp[PI_PERMUTATION[i]] = rotl64(state[i], ROTATION_OFFSETS[i]);
+    }
+    for (let y = 0; y < 5; y++) {
+      const base = 5 * y;
+      const t0 = temp[base];
+      const t1 = temp[base + 1];
+      const t2 = temp[base + 2];
+      const t3 = temp[base + 3];
+      const t4 = temp[base + 4];
+      state[base] = (t0 ^ ~t1 & MASK64 & t2) & MASK64;
+      state[base + 1] = (t1 ^ ~t2 & MASK64 & t3) & MASK64;
+      state[base + 2] = (t2 ^ ~t3 & MASK64 & t4) & MASK64;
+      state[base + 3] = (t3 ^ ~t4 & MASK64 & t0) & MASK64;
+      state[base + 4] = (t4 ^ ~t0 & MASK64 & t1) & MASK64;
+    }
+    state[0] = (state[0] ^ KECCAK_ROUND_CONSTANTS[round]) & MASK64;
+  }
+}
+function keccak256(data) {
+  const rate = 136;
+  const state = new Array(25).fill(0n);
+  let offset = 0;
+  while (offset + rate <= data.length) {
+    xorBlock(state, data, offset, rate);
+    keccakF1600(state);
+    offset += rate;
+  }
+  const remaining = data.length - offset;
+  const lastBlock = new Uint8Array(rate);
+  lastBlock.set(data.subarray(offset, offset + remaining));
+  lastBlock[remaining] = 1;
+  lastBlock[rate - 1] |= 128;
+  xorBlock(state, lastBlock, 0, rate);
+  keccakF1600(state);
+  const output = new Uint8Array(32);
+  for (let i = 0; i < 4; i++) {
+    const word = state[i];
+    for (let b = 0; b < 8; b++) {
+      output[i * 8 + b] = Number(word >> BigInt(b * 8) & 0xffn);
+    }
+  }
+  return output;
+}
+function xorBlock(state, data, offset, len) {
+  const words = len / 8;
+  for (let i = 0; i < words; i++) {
+    let word = 0n;
+    const base = offset + i * 8;
+    for (let b = 0; b < 8; b++) {
+      word |= BigInt(data[base + b]) << BigInt(b * 8);
+    }
+    state[i] = (state[i] ^ word) & MASK64;
+  }
+}
+function bytesToHex(bytes) {
+  let hex = "0x";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += bytes[i].toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function hexToBytes(hex) {
+  const raw = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(raw.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(raw.substring(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function formatDecimal(numStr) {
+  if (numStr.includes("e") || numStr.includes("E")) {
+    numStr = Number(numStr).toFixed(20);
+  }
+  if (!numStr.includes(".")) return numStr;
+  const [intPart, fracPart] = numStr.split(".");
+  const trimmed = fracPart.replace(/0+$/, "");
+  return trimmed ? `${intPart}.${trimmed}` : intPart;
+}
+function sortOrderAction(action) {
+  const sortedOrders = action.orders.map((o) => {
+    let t = o.t;
+    if ("trigger" in t) {
+      t = {
+        trigger: {
+          isMarket: t.trigger.isMarket,
+          triggerPx: formatDecimal(t.trigger.triggerPx),
+          tpsl: t.trigger.tpsl
+        }
+      };
+    }
+    const wire = {
+      a: o.a,
+      b: o.b,
+      p: formatDecimal(o.p),
+      s: formatDecimal(o.s),
+      r: o.r,
+      t
+    };
+    if (o.c !== void 0) {
+      wire.c = o.c;
+    }
+    return wire;
+  });
+  const sorted = {
+    type: action.type,
+    orders: sortedOrders,
+    grouping: action.grouping
+  };
+  if (action.builder !== void 0) {
+    sorted.builder = {
+      b: action.builder.b.toLowerCase(),
+      f: action.builder.f
+    };
+  }
+  return sorted;
+}
+function sortCancelAction(action) {
+  const sortedCancels = action.cancels.map((c) => ({
+    a: c.a,
+    o: c.o
+  }));
+  return {
+    type: action.type,
+    cancels: sortedCancels
+  };
+}
+function sortOrderWire(o) {
+  let t = o.t;
+  if ("trigger" in t) {
+    t = {
+      trigger: {
+        isMarket: t.trigger.isMarket,
+        triggerPx: formatDecimal(t.trigger.triggerPx),
+        tpsl: t.trigger.tpsl
+      }
+    };
+  }
+  const wire = {
+    a: o.a,
+    b: o.b,
+    p: formatDecimal(o.p),
+    s: formatDecimal(o.s),
+    r: o.r,
+    t
+  };
+  if (o.c !== void 0) {
+    wire.c = o.c;
+  }
+  return wire;
+}
+function sortModifyAction(action) {
+  return {
+    type: action.type,
+    oid: action.oid,
+    order: sortOrderWire(action.order)
+  };
+}
+function sortUserOutcomeAction(action) {
+  if ("splitOutcome" in action) {
+    const { outcome: outcome2, amount: amount2 } = action.splitOutcome;
+    return {
+      type: "userOutcome",
+      splitOutcome: { outcome: outcome2, amount: formatDecimal(amount2) }
+    };
+  }
+  if ("mergeOutcome" in action) {
+    const { outcome: outcome2, amount: amount2 } = action.mergeOutcome;
+    return {
+      type: "userOutcome",
+      mergeOutcome: {
+        outcome: outcome2,
+        amount: amount2 === null ? null : formatDecimal(amount2)
+      }
+    };
+  }
+  if ("mergeQuestion" in action) {
+    const { question: question2, amount: amount2 } = action.mergeQuestion;
+    return {
+      type: "userOutcome",
+      mergeQuestion: {
+        question: question2,
+        amount: amount2 === null ? null : formatDecimal(amount2)
+      }
+    };
+  }
+  const { question, outcome, amount } = action.negateOutcome;
+  return {
+    type: "userOutcome",
+    negateOutcome: { question, outcome, amount: formatDecimal(amount) }
+  };
+}
+function sortScheduleCancelAction(action) {
+  return { type: action.type, time: action.time };
+}
+function createL1ActionHash(params) {
+  const { action, nonce, vaultAddress } = params;
+  const msgpackBytes = encodeMsgpack(action);
+  const nonceBytes = new Uint8Array(8);
+  const nonceView = new DataView(nonceBytes.buffer);
+  nonceView.setBigUint64(0, BigInt(nonce));
+  let vaultBytes;
+  if (vaultAddress) {
+    const addrBytes = hexToBytes(vaultAddress);
+    vaultBytes = new Uint8Array(1 + 20);
+    vaultBytes[0] = 1;
+    vaultBytes.set(addrBytes.slice(0, 20), 1);
+  } else {
+    vaultBytes = new Uint8Array([0]);
+  }
+  const totalLen = msgpackBytes.length + nonceBytes.length + vaultBytes.length;
+  const combined = new Uint8Array(totalLen);
+  combined.set(msgpackBytes, 0);
+  combined.set(nonceBytes, msgpackBytes.length);
+  combined.set(vaultBytes, msgpackBytes.length + nonceBytes.length);
+  return keccak256(combined);
+}
+var AGENT_DOMAIN = {
+  name: "Exchange",
+  version: "1",
+  chainId: 1337,
+  verifyingContract: "0x0000000000000000000000000000000000000000"
+};
+var AGENT_TYPES = {
+  Agent: [
+    { name: "source", type: "string" },
+    { name: "connectionId", type: "bytes32" }
+  ]
+};
+async function signL1Action(params) {
+  const { signer, action, nonce, isTestnet, vaultAddress } = params;
+  const actionHash = createL1ActionHash({ action, nonce, vaultAddress });
+  const connectionId = bytesToHex(actionHash);
+  const message = {
+    source: isTestnet ? "b" : "a",
+    connectionId
+  };
+  const rawSig = await signer.signTypedData(
+    AGENT_DOMAIN,
+    AGENT_TYPES,
+    message
+  );
+  return normalizeSignature(rawSig);
+}
+var WITHDRAW_TYPES = {
+  "HyperliquidTransaction:Withdraw": [
+    { name: "hyperliquidChain", type: "string" },
+    { name: "destination", type: "string" },
+    { name: "amount", type: "string" },
+    { name: "time", type: "uint64" }
+  ]
+};
+var USD_CLASS_TRANSFER_TYPES = {
+  "HyperliquidTransaction:UsdClassTransfer": [
+    { name: "hyperliquidChain", type: "string" },
+    { name: "amount", type: "string" },
+    { name: "toPerp", type: "bool" },
+    { name: "nonce", type: "uint64" }
+  ]
+};
+var USD_SEND_TYPES = {
+  "HyperliquidTransaction:UsdSend": [
+    { name: "hyperliquidChain", type: "string" },
+    { name: "destination", type: "string" },
+    { name: "amount", type: "string" },
+    { name: "time", type: "uint64" }
+  ]
+};
+var SPOT_SEND_TYPES = {
+  "HyperliquidTransaction:SpotSend": [
+    { name: "hyperliquidChain", type: "string" },
+    { name: "destination", type: "string" },
+    { name: "token", type: "string" },
+    { name: "amount", type: "string" },
+    { name: "time", type: "uint64" }
+  ]
+};
+var SEND_ASSET_TYPES = {
+  "HyperliquidTransaction:SendAsset": [
+    { name: "hyperliquidChain", type: "string" },
+    { name: "destination", type: "string" },
+    { name: "sourceDex", type: "string" },
+    { name: "destinationDex", type: "string" },
+    { name: "token", type: "string" },
+    { name: "amount", type: "string" },
+    { name: "fromSubAccount", type: "string" },
+    { name: "nonce", type: "uint64" }
+  ]
+};
+var SEND_TO_EVM_WITH_DATA_TYPES = {
+  "HyperliquidTransaction:SendToEvmWithData": [
+    { name: "hyperliquidChain", type: "string" },
+    { name: "token", type: "string" },
+    { name: "amount", type: "string" },
+    { name: "sourceDex", type: "string" },
+    { name: "destinationRecipient", type: "string" },
+    { name: "addressEncoding", type: "string" },
+    { name: "destinationChainId", type: "uint32" },
+    { name: "gasLimit", type: "uint64" },
+    { name: "data", type: "bytes" },
+    { name: "nonce", type: "uint64" }
+  ]
+};
+async function signUserSignedAction(params) {
+  const { signer, action, types } = params;
+  const primaryType = Object.keys(types)[0];
+  if (!primaryType || !types[primaryType]) {
+    throw new Error("EIP-712 types object is empty");
+  }
+  const knownKeys = new Set(types[primaryType].map((f) => f.name));
+  const message = {};
+  for (const [k, v] of Object.entries(action)) {
+    if (knownKeys.has(k)) message[k] = v;
+  }
+  const chainId = parseInt(action.signatureChainId, 16);
+  if (isNaN(chainId)) {
+    throw new Error(`Invalid signatureChainId: "${action.signatureChainId}"`);
+  }
+  const domain = {
+    name: "HyperliquidSignTransaction",
+    version: "1",
+    chainId,
+    verifyingContract: "0x0000000000000000000000000000000000000000"
+  };
+  const rawSig = await signer.signTypedData(
+    domain,
+    types,
+    message
+  );
+  return normalizeSignature(rawSig);
+}
+
+// src/adapter/hyperliquid/trading.ts
+function formatPredictionPrice(price) {
+  if (price <= 0) return "0";
+  let formatted;
+  if (price >= 1e3) {
+    formatted = Math.round(price).toString();
+  } else if (price >= 10) {
+    formatted = price.toFixed(1);
+  } else if (price >= 1) {
+    formatted = price.toFixed(2);
+  } else {
+    formatted = price.toFixed(4);
+  }
+  return formatted.replace(/\.?0+$/, "");
+}
+function mapTif(type, tif) {
+  if (type === "market") {
+    return { limit: { tif: "FrontendMarket" } };
+  }
+  switch (tif) {
+    case "FOK":
+      throw new Error(
+        "FOK (Fill-or-Kill) is not supported by Hyperliquid. Use FAK (Fill-and-Kill / IoC) for immediate partial fills, or GTC for resting orders."
+      );
+    case "FAK":
+      return { limit: { tif: "Ioc" } };
+    case "ALO":
+      return { limit: { tif: "Alo" } };
+    case "GTD":
+      throw new Error(
+        "GTD (Good-til-Date) is not supported for prediction markets on Hyperliquid. Use GTC for resting orders."
+      );
+    case "GTC":
+    case void 0:
+    default:
+      return { limit: { tif: "Gtc" } };
+  }
+}
+function resolveAssetId(marketId, outcome) {
+  const outcomeId = parseInt(marketId, 10);
+  if (outcome.startsWith("#") || outcome.startsWith("+")) {
+    const num = outcome.slice(1);
+    const sideIndex = parseInt(num.slice(-1), 10);
+    if (sideIndex !== 0 && sideIndex !== 1) {
+      throw new Error(
+        `Invalid sideIndex ${sideIndex} in outcome "${outcome}". Must be 0 or 1.`
+      );
+    }
+    return sideAssetId(outcomeId, sideIndex);
+  }
+  const sideMatch = /(\d)$/.exec(outcome);
+  if (sideMatch?.[1]) {
+    const sideIndex = parseInt(sideMatch[1], 10);
+    if (sideIndex > 1) {
+      return sideAssetId(outcomeId, 0);
+    }
+    return sideAssetId(outcomeId, sideIndex);
+  }
+  return sideAssetId(outcomeId, 0);
+}
+function interpretStatus(status) {
+  if ("filled" in status) {
+    return {
+      orderId: String(status.filled.oid),
+      status: "filled",
+      shares: status.filled.totalSz
+    };
+  }
+  if ("resting" in status) {
+    return {
+      orderId: String(status.resting.oid),
+      status: "resting"
+    };
+  }
+  if ("error" in status) {
+    return {
+      error: status.error,
+      status: "error"
+    };
+  }
+  return { status: "unknown" };
+}
+var HIP4TradingAdapter = class {
+  constructor(client, auth, config) {
+    this.client = client;
+    this.auth = auth;
+    this.builderAddress = config?.builderAddress;
+    this.builderFee = config?.builderFee;
+  }
+  client;
+  auth;
+  builderAddress;
+  builderFee;
+  buildOrderWire(params) {
+    const assetId = resolveAssetId(params.marketId, params.outcome);
+    const isBuy = params.side === "buy";
+    const amount = stripZeros(params.amount);
+    let price;
+    if (params.type === "market") {
+      price = isBuy ? "0.99999" : "0.00001";
+      this.client.log(
+        "debug",
+        `Market order: side=${isBuy ? "buy" : "sell"}, price=${price} (FrontendMarket best-execution)`
+      );
+    } else {
+      const rawPrice = toNum(toDecimal(params.price ?? "0"));
+      price = formatPrice(rawPrice);
+      this.client.log("debug", `Limit order: price=${price}`);
+      const numericSize = toDecimal(amount);
+      if (params.markPx !== void 0 && !params.skipMinNotionalCheck) {
+        const minShares = getMinShares(params.markPx);
+        if (numericSize.lt(minShares)) {
+          return {
+            error: `Size ${numericSize} below minimum ${minShares} shares (markPx=${params.markPx})`
+          };
+        }
+      }
+      const effectiveNotional = params.markPx !== void 0 ? mul(
+        amount,
+        clamp(
+          min(String(params.markPx), sub("1", String(params.markPx))),
+          "0.01",
+          "1"
+        )
+      ) : mul(price, amount);
+      if (!params.skipMinNotionalCheck && lt(effectiveNotional, String(MIN_NOTIONAL))) {
+        return {
+          error: `Notional $${fixed(effectiveNotional, 2)} below minimum $${MIN_NOTIONAL}`
+        };
+      }
+    }
+    return {
+      wire: {
+        a: assetId,
+        b: isBuy,
+        p: price,
+        s: amount,
+        r: false,
+        t: mapTif(params.type, params.timeInForce)
+      }
+    };
+  }
+  async placeOrder(params) {
+    const signer = this.auth.getSigner();
+    if (!signer) {
+      return {
+        success: false,
+        error: "Not authenticated. Call auth.initAuth() first."
+      };
+    }
+    const wireResult = this.buildOrderWire(params);
+    if ("error" in wireResult) {
+      return { success: false, error: wireResult.error };
+    }
+    const action = {
+      type: "order",
+      orders: [wireResult.wire],
+      grouping: "na"
+    };
+    const effectiveBuilderAddress = params.builderAddress ?? this.builderAddress;
+    const effectiveBuilderFee = params.builderFee ?? this.builderFee;
+    if (effectiveBuilderAddress) {
+      action.builder = {
+        b: effectiveBuilderAddress.toLowerCase(),
+        f: effectiveBuilderFee ?? 0
+      };
+    }
+    const sortedAction = sortOrderAction(action);
+    this.client.log("debug", "Order wire", wireResult.wire);
+    try {
+      const nonce = Date.now();
+      const signature = await signL1Action({
+        signer,
+        action: sortedAction,
+        nonce,
+        isTestnet: this.client.testnet
+      });
+      const res = await this.client.placeOrder(
+        sortedAction,
+        nonce,
+        signature,
+        null
+      );
+      if (res.status !== "ok" || !res.response) {
+        return { success: false, error: "Exchange returned non-ok status" };
+      }
+      const firstStatus = res.response.data.statuses[0];
+      if (!firstStatus) {
+        return { success: false, error: "No order status returned" };
+      }
+      const result = interpretStatus(firstStatus);
+      return {
+        success: !result.error,
+        ...result
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown order error";
+      return { success: false, error: message };
+    }
+  }
+  async placeOrders(params) {
+    if (params.length === 0) {
+      return { success: true, results: [] };
+    }
+    const signer = this.auth.getSigner();
+    if (!signer) {
+      return {
+        success: false,
+        results: params.map(() => ({
+          success: false,
+          error: "Not authenticated. Call auth.initAuth() first."
+        }))
+      };
+    }
+    const results = new Array(params.length);
+    const validWires = [];
+    const wireToInputIndex = [];
+    for (let i = 0; i < params.length; i++) {
+      const wireResult = this.buildOrderWire(params[i]);
+      if ("error" in wireResult) {
+        results[i] = { success: false, error: wireResult.error };
+      } else {
+        wireToInputIndex.push(i);
+        validWires.push(wireResult.wire);
+      }
+    }
+    if (validWires.length === 0) {
+      return { success: false, results };
+    }
+    const action = {
+      type: "order",
+      orders: validWires,
+      grouping: "na"
+    };
+    if (this.builderAddress) {
+      action.builder = {
+        b: this.builderAddress.toLowerCase(),
+        f: this.builderFee ?? 0
+      };
+    }
+    const sortedAction = sortOrderAction(action);
+    this.client.log("debug", `Batch order: ${validWires.length} wires`);
+    try {
+      const nonce = Date.now();
+      const signature = await signL1Action({
+        signer,
+        action: sortedAction,
+        nonce,
+        isTestnet: this.client.testnet
+      });
+      const res = await this.client.placeOrder(
+        sortedAction,
+        nonce,
+        signature,
+        null
+      );
+      if (res.status !== "ok" || !res.response) {
+        for (const idx of wireToInputIndex) {
+          results[idx] = {
+            success: false,
+            error: "Exchange returned non-ok status"
+          };
+        }
+        return { success: false, results };
+      }
+      const statuses = res.response.data.statuses;
+      for (let j = 0; j < wireToInputIndex.length; j++) {
+        const inputIdx = wireToInputIndex[j];
+        const status = statuses[j];
+        if (!status) {
+          results[inputIdx] = {
+            success: false,
+            error: "No order status returned"
+          };
+        } else {
+          const interpreted = interpretStatus(status);
+          results[inputIdx] = { success: !interpreted.error, ...interpreted };
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown order error";
+      for (const idx of wireToInputIndex) {
+        results[idx] = { success: false, error: message };
+      }
+    }
+    const allSuccess = results.every((r) => r.success);
+    return { success: allSuccess, results };
+  }
+  async cancelOrder(params) {
+    const signer = this.auth.getSigner();
+    if (!signer) {
+      throw new Error("Not authenticated. Call auth.initAuth() first.");
+    }
+    if (params.length === 0) {
+      throw new Error("cancelOrder requires at least one order to cancel.");
+    }
+    const cancels = params.map((p) => {
+      const assetId = p.outcome ? resolveAssetId(p.marketId, p.outcome) : sideAssetId(parseInt(p.marketId, 10), 0);
+      return { a: assetId, o: parseInt(p.orderId, 10) };
+    });
+    const action = {
+      type: "cancel",
+      cancels
+    };
+    const sortedAction = sortCancelAction(action);
+    const nonce = Date.now();
+    const signature = await signL1Action({
+      signer,
+      action: sortedAction,
+      nonce,
+      isTestnet: this.client.testnet
+    });
+    return this.client.cancelOrder(sortedAction, nonce, signature, null);
+  }
+  async modifyOrder(params) {
+    const signer = this.auth.getSigner();
+    if (!signer) {
+      return {
+        success: false,
+        error: "Not authenticated. Call auth.initAuth() first."
+      };
+    }
+    const wireResult = this.buildOrderWire({
+      marketId: params.marketId,
+      outcome: params.outcome,
+      side: params.side,
+      type: params.type,
+      price: params.price,
+      amount: params.amount,
+      timeInForce: params.timeInForce,
+      markPx: params.markPx
+    });
+    if ("error" in wireResult) {
+      return { success: false, error: wireResult.error };
+    }
+    const oid = parseInt(params.orderId, 10);
+    if (!Number.isFinite(oid)) {
+      return { success: false, error: `Invalid orderId "${params.orderId}"` };
+    }
+    const action = {
+      type: "modify",
+      oid,
+      order: wireResult.wire
+    };
+    const sortedAction = sortModifyAction(action);
+    this.client.log("debug", "Modify wire", {
+      oid,
+      order: wireResult.wire
+    });
+    try {
+      const nonce = Date.now();
+      const signature = await signL1Action({
+        signer,
+        action: sortedAction,
+        nonce,
+        isTestnet: this.client.testnet
+      });
+      const res = await this.client.modifyOrder(
+        sortedAction,
+        nonce,
+        signature,
+        null
+      );
+      if (res.status !== "ok") {
+        const errorMsg = typeof res.response === "string" ? res.response : "Exchange returned non-ok status";
+        return { success: false, error: errorMsg };
+      }
+      const structured = res.response && typeof res.response !== "string" ? res.response : null;
+      const firstStatus = structured?.data?.statuses?.[0];
+      if (!firstStatus) {
+        return {
+          success: true,
+          orderId: String(oid),
+          status: "resting"
+        };
+      }
+      const result = interpretStatus(firstStatus);
+      return {
+        success: !result.error,
+        ...result
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown modify error";
+      return { success: false, error: message };
+    }
+  }
+  // -------------------------------------------------------------------------
+  // userOutcome share-conversion actions
+  //
+  // All four variants share the same envelope (`type: "userOutcome"`) and use
+  // L1 agent signing - same authority as orders, so an active agent is
+  // required. They affect the user's spot balances directly (no order book).
+  // -------------------------------------------------------------------------
+  /** Split X quote tokens into X Yes + X No shares of one outcome. */
+  async splitOutcome(params) {
+    return this.submitUserOutcomeAction({
+      type: "userOutcome",
+      splitOutcome: { outcome: params.outcome, amount: params.amount }
+    });
+  }
+  /** Merge X Yes + X No shares of one outcome back into X quote tokens. */
+  async mergeOutcome(params) {
+    return this.submitUserOutcomeAction({
+      type: "userOutcome",
+      mergeOutcome: { outcome: params.outcome, amount: params.amount }
+    });
+  }
+  /** Merge X Yes shares from every outcome of a question into X quote tokens. */
+  async mergeQuestion(params) {
+    return this.submitUserOutcomeAction({
+      type: "userOutcome",
+      mergeQuestion: { question: params.question, amount: params.amount }
+    });
+  }
+  /**
+   * Convert X No shares of one outcome into X Yes shares of every *other*
+   * outcome belonging to the same question (including the fallback). The
+   * wire sub-key is `negateOutcome` - confirmed against HL's own testnet
+   * "Convert Outcomes" UI; their docs body's `negateQuestion` is a typo.
+   */
+  async negateOutcome(params) {
+    return this.submitUserOutcomeAction({
+      type: "userOutcome",
+      negateOutcome: {
+        question: params.question,
+        outcome: params.outcome,
+        amount: params.amount
+      }
+    });
+  }
+  async submitUserOutcomeAction(action) {
+    const signer = this.auth.getSigner();
+    if (!signer) {
+      return {
+        success: false,
+        error: "Not authenticated. Call auth.initAuth() first."
+      };
+    }
+    try {
+      const sorted = sortUserOutcomeAction(action);
+      const nonce = Date.now();
+      this.client.log("debug", "userOutcome action wire", sorted);
+      const signature = await signL1Action({
+        signer,
+        action: sorted,
+        nonce,
+        isTestnet: this.client.testnet
+      });
+      const res = await this.client.submitUserSignedAction(
+        sorted,
+        nonce,
+        signature
+      );
+      if (res.status === "ok") return { success: true };
+      let errorMsg = "User outcome action failed";
+      if (typeof res.response === "string") {
+        errorMsg = res.response;
+      } else if (res.response && typeof res.response === "object" && !Array.isArray(res.response)) {
+        const obj = res.response;
+        if (typeof obj.error === "string") errorMsg = obj.error;
+      }
+      return { success: false, error: errorMsg };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown user outcome error";
+      return { success: false, error: message };
+    }
+  }
+  // -------------------------------------------------------------------------
+  // scheduleCancel - HL "dead-man's switch"
+  //
+  // Registers a future timestamp at which HL cancels every open order from
+  // this agent. Per-agent, not per-order: a new schedule replaces the
+  // previous one. Pass `null` to clear an existing schedule.
+  //
+  // Use case: arm 1h before a HIP-4 market's settlement so resting limits
+  // never sit through the auction unprotected.
+  // -------------------------------------------------------------------------
+  async scheduleCancel(time) {
+    const signer = this.auth.getSigner();
+    if (!signer) {
+      return {
+        success: false,
+        error: "Not authenticated. Call auth.initAuth() first."
+      };
+    }
+    try {
+      const action = {
+        type: "scheduleCancel",
+        time
+      };
+      const sorted = sortScheduleCancelAction(action);
+      const nonce = Date.now();
+      this.client.log("debug", "scheduleCancel action wire", sorted);
+      const signature = await signL1Action({
+        signer,
+        action: sorted,
+        nonce,
+        isTestnet: this.client.testnet
+      });
+      const res = await this.client.submitUserSignedAction(
+        sorted,
+        nonce,
+        signature
+      );
+      if (res.status === "ok") return { success: true };
+      let errorMsg = "scheduleCancel failed";
+      if (typeof res.response === "string") {
+        errorMsg = res.response;
+      } else if (res.response && typeof res.response === "object" && !Array.isArray(res.response)) {
+        const obj = res.response;
+        if (typeof obj.error === "string") errorMsg = obj.error;
+      }
+      return { success: false, error: errorMsg };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown scheduleCancel error";
+      return { success: false, error: message };
+    }
+  }
+};
+
+// src/lib/precision/financial/price.ts
+function applySlippage(mid, ratio, side) {
+  const m = toDecimal(mid);
+  const r = toDecimal(ratio);
+  return side === "buy" ? m.times(Decimal.sum(1, r)).toString() : m.times(new Decimal(1).minus(r)).toString();
+}
+
+// src/adapter/hyperliquid/core-evm-system-address.ts
+var HYPE_CORE_EVM_SYSTEM_ADDRESS = "0x2222222222222222222222222222222222222222";
+var MAX_CORE_EVM_TOKEN_INDEX = Number.MAX_SAFE_INTEGER;
+function deriveCoreEvmSystemAddress(tokenIndex) {
+  if (!Number.isInteger(tokenIndex)) {
+    throw new Error(
+      `Token index must be an integer, got ${String(tokenIndex)}`
+    );
+  }
+  if (tokenIndex < 0) {
+    throw new Error(`Token index must be non-negative, got ${tokenIndex}`);
+  }
+  if (tokenIndex > MAX_CORE_EVM_TOKEN_INDEX) {
+    throw new Error(
+      `Token index ${tokenIndex} exceeds safe-integer ceiling ${MAX_CORE_EVM_TOKEN_INDEX}`
+    );
+  }
+  const hex = BigInt(tokenIndex).toString(16).padStart(38, "0");
+  return `0x20${hex}`;
+}
+
+// src/adapter/hyperliquid/wallet.ts
+var USDH_SPOT_INDEX_TESTNET = 1338;
+var USDH_SPOT_INDEX_MAINNET = 230;
+var USDH_ASSET_ID_TESTNET = 1e4 + USDH_SPOT_INDEX_TESTNET;
+var USDH_ASSET_ID_MAINNET = 1e4 + USDH_SPOT_INDEX_MAINNET;
+var USDH_SPOT_PAIR_TESTNET = "@1338";
+var USDH_SPOT_PAIR_MAINNET = "@230";
+var USDH_TOKEN_INDEX_MAINNET = 360;
+var USDH_TOKEN_INDEX_TESTNET = 1452;
+var USDH_TOKEN_HASH_MAINNET = "0x54e00a5988577cb0b0c9ab0cb6ef7f4b";
+var USDH_TOKEN_HASH_TESTNET = "0x471fd4480bb9943a1fe080ab0d4ff36c";
+var USDH_HL_TOKEN_MAINNET = `USDH:${USDH_TOKEN_HASH_MAINNET}`;
+var USDH_HL_TOKEN_TESTNET = `USDH:${USDH_TOKEN_HASH_TESTNET}`;
+var USDH_EVM_ADDRESS_MAINNET = "0x111111a1a0667d36bD57c0A9f569b98057111111";
+var USDH_EVM_ADDRESS_TESTNET = "0x22222245c52c817F95b74664Ae8546B490222222";
+var USDH_CORE_DECIMALS = 8;
+var USDH_EVM_DECIMALS = 6;
+var USDC_HL_TOKEN_MAINNET = "USDC:0x6d1e7cde53ba9467b783cb7c530ce054";
+var USDC_HL_TOKEN_TESTNET = "USDC:0xeb62eee3685fc4c43992febcd9e75443";
+var USDH_ASSET_ID = USDH_ASSET_ID_TESTNET;
+var USDH_SPOT_PAIR = USDH_SPOT_PAIR_TESTNET;
+var SPOT_TOKEN_ID_PATTERN = /^[A-Z0-9]+:0x[0-9a-f]{32}$/;
+var HIP4WalletAdapter = class {
+  constructor(client, auth) {
+    this.client = client;
+    this.auth = auth;
+  }
+  client;
+  auth;
+  signer = null;
+  setSigner(signer) {
+    const obj = signer;
+    if (typeof obj.getAddress === "function" && typeof obj.signTypedData === "function") {
+      this.signer = signer;
+      return;
+    }
+    if (typeof obj.address === "string" && typeof obj.signTypedData === "function") {
+      const addr = obj.address;
+      const sign = obj.signTypedData;
+      this.signer = {
+        getAddress: () => addr,
+        signTypedData: (domain, types, value) => {
+          const primaryType = Object.keys(types)[0];
+          if (!primaryType) throw new Error("EIP-712 types object is empty");
+          return sign({
+            domain,
+            types: { ...types },
+            primaryType,
+            message: value
+          });
+        }
+      };
+      return;
+    }
+    throw new Error(
+      "Invalid signer: must have getAddress()+signTypedData() or address+signTypedData()"
+    );
+  }
+  async buyUsdh(amount) {
+    return this.executeSpotOrder(true, amount);
+  }
+  async sellUsdh(amount) {
+    return this.executeSpotOrder(false, amount);
+  }
+  async transferToSpot(amount) {
+    return this.usdClassTransfer({ amount, toPerp: false });
+  }
+  async transferToPerps(amount) {
+    return this.usdClassTransfer({ amount, toPerp: true });
+  }
+  async usdClassTransfer(params) {
+    return this.executeUserSigned(
+      "usdClassTransfer",
+      { amount: params.amount, toPerp: params.toPerp },
+      USD_CLASS_TRANSFER_TYPES,
+      "nonce"
+    );
+  }
+  async withdraw(params) {
+    return this.executeUserSigned(
+      "withdraw3",
+      { destination: params.destination, amount: params.amount },
+      WITHDRAW_TYPES,
+      "time"
+    );
+  }
+  async usdSend(params) {
+    return this.executeUserSigned(
+      "usdSend",
+      { destination: params.destination, amount: params.amount },
+      USD_SEND_TYPES,
+      "time"
+    );
+  }
+  async spotSend(params) {
+    return this.executeUserSigned(
+      "spotSend",
+      {
+        destination: params.destination,
+        token: params.token,
+        amount: params.amount
+      },
+      SPOT_SEND_TYPES,
+      "time"
+    );
+  }
+  /**
+   * Unified-account-compatible transfer primitive. Supersedes `spotSend`,
+   * `usdSend`, `usdClassTransfer`, and `subAccountSpotTransfer` when the
+   * account is in `unifiedAccount` or `portfolioMargin` abstraction mode
+   * (where silo-specific actions return "Action disabled when unified
+   * account is active").
+   *
+   * Use cases:
+   *   - User → user spot transfer: `sourceDex: "spot", destinationDex: "spot"`
+   *   - Core → HyperEVM bridge: `destination = systemAddress`, both dex = `""`
+   *   - Spot → perp silo move: `sourceDex: "spot", destinationDex: ""`
+   */
+  async sendAsset(params) {
+    return this.executeUserSigned(
+      "sendAsset",
+      {
+        destination: params.destination,
+        sourceDex: params.sourceDex ?? "spot",
+        destinationDex: params.destinationDex ?? "",
+        token: params.token,
+        amount: params.amount,
+        fromSubAccount: params.fromSubAccount ?? ""
+      },
+      SEND_ASSET_TYPES,
+      "nonce"
+    );
+  }
+  /**
+   * Move a spot token from HyperCore to HyperEVM.
+   *
+   * Mechanism: `sendAsset` to the token's system address, with
+   * `sourceDex = "spot"` and `destinationDex = ""`. HL credits the sender's
+   * HyperEVM address by calling `transfer(sender, amount)` on the token's
+   * linked ERC-20 contract. No hook data, no CCTP - the token stays as the
+   * same token on HyperEVM.
+   *
+   * Why `sendAsset` and not `spotSend`: `spotSend` is rejected under
+   * `unifiedAccount` / `portfolioMargin` abstraction modes with "Action
+   * disabled when unified account is active". Unified is the app default
+   * for new accounts, so `sendAsset` is the only flow that works for both
+   * modes.
+   *
+   * Use this for USDH (and any non-USDC spot token). For USDC destinations
+   * on other EVM chains, use `sendUsdcToEvm` instead (CCTP is strictly
+   * cheaper + faster than sendAsset-to-HyperEVM + bridge).
+   *
+   * HYPE is the documented exception: callers must set `isHype: true` so
+   * the destination resolves to the hardcoded `0x2222…2222` slot rather
+   * than the index-derived address.
+   */
+  async sendSpotTokenToEvm(params) {
+    if (!SPOT_TOKEN_ID_PATTERN.test(params.tokenId)) {
+      return {
+        success: false,
+        error: `Invalid token id ${params.tokenId}: expected "SYMBOL:0x<32-hex>"`
+      };
+    }
+    let destination;
+    try {
+      destination = params.isHype ? HYPE_CORE_EVM_SYSTEM_ADDRESS : deriveCoreEvmSystemAddress(params.tokenIndex);
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : "Invalid token index"
+      };
+    }
+    return this.sendAsset({
+      destination,
+      token: params.tokenId,
+      amount: params.amount,
+      sourceDex: "spot",
+      destinationDex: "spot"
+    });
+  }
+  /**
+   * Transfer a spot token from HyperCore to the EVM side, invoking the
+   * linked contract's `coreReceiveWithData` hook with user-provided data.
+   *
+   * For Circle-managed tokens (USDC), this bridges via CCTP directly to
+   * `destinationChainId` - `destinationRecipient` receives USDC there. No
+   * secondary `withdraw3` or Across hop needed to land on Arbitrum.
+   *
+   * Fee model: HyperEVM gas (`gasLimit × baseFee × HYPE/USDC_oracle`,
+   * deducted from L1 USDC) + Circle forwarder fee on destination (0.2 USDC
+   * flat, subtracted from amount). CCTP protocol fee is 0.
+   */
+  async sendToEvmWithData(params) {
+    return this.executeUserSigned(
+      "sendToEvmWithData",
+      {
+        token: params.token,
+        amount: params.amount,
+        sourceDex: params.sourceDex ?? "spot",
+        destinationRecipient: params.destinationRecipient,
+        addressEncoding: params.addressEncoding ?? "hex",
+        destinationChainId: params.destinationChainId,
+        gasLimit: params.gasLimit,
+        data: params.data ?? "0x"
+      },
+      SEND_TO_EVM_WITH_DATA_TYPES,
+      "nonce"
+    );
+  }
+  /**
+   * Convenience wrapper: `sendToEvmWithData` with the USDC token string
+   * for the current network auto-filled. Circle's CoreDepositWallet picks
+   * up the call and CCTPs USDC to `destinationChainId`.
+   */
+  async sendUsdcToEvm(params) {
+    const token = this.client.testnet ? USDC_HL_TOKEN_TESTNET : USDC_HL_TOKEN_MAINNET;
+    return this.sendToEvmWithData({ ...params, token });
+  }
+  // -------------------------------------------------------------------------
+  // Internal
+  // -------------------------------------------------------------------------
+  async executeSpotOrder(isBuy, amount) {
+    const agentSigner = this.auth.getSigner();
+    if (!agentSigner) {
+      return {
+        success: false,
+        error: "Not authenticated. Call auth.initAuth() first."
+      };
+    }
+    try {
+      const spotIndex = this.client.testnet ? USDH_SPOT_INDEX_TESTNET : USDH_SPOT_INDEX_MAINNET;
+      const assetId = 1e4 + spotIndex;
+      const ctx = await this.client.fetchSpotAssetCtx(spotIndex);
+      const oracle = ctx ? toDecimal(ctx.markPx) : null;
+      if (!oracle || oracle.lte(0)) {
+        return { success: false, error: "Could not fetch USDH oracle price" };
+      }
+      const slipped = applySlippage(ctx.markPx, "0.1", isBuy ? "buy" : "sell");
+      const price = formatPrice(Number(slipped));
+      const action = {
+        type: "order",
+        orders: [
+          {
+            a: assetId,
+            b: isBuy,
+            p: price,
+            s: amount,
+            r: false,
+            t: { limit: { tif: "Ioc" } }
+          }
+        ],
+        grouping: "na"
+      };
+      const sortedAction = sortOrderAction(action);
+      const nonce = Date.now();
+      const signature = await signL1Action({
+        signer: agentSigner,
+        action: sortedAction,
+        nonce,
+        isTestnet: this.client.testnet
+      });
+      const res = await this.client.placeOrder(
+        sortedAction,
+        nonce,
+        signature,
+        null
+      );
+      if (res.status !== "ok" || !res.response) {
+        return { success: false, error: "Exchange returned non-ok status" };
+      }
+      const firstStatus = res.response.data.statuses[0];
+      if (!firstStatus) {
+        return { success: false, error: "No order status returned" };
+      }
+      if ("error" in firstStatus) {
+        return { success: false, error: firstStatus.error };
+      }
+      const filled = "filled" in firstStatus ? firstStatus.filled : void 0;
+      return {
+        success: true,
+        filledSz: filled?.totalSz,
+        avgPx: filled?.avgPx,
+        oid: filled?.oid
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Set a referral code on Hyperliquid.
+   * Uses L1 agent signing (requires auth to be initialized).
+   */
+  async setReferrer(code) {
+    const signer = this.auth.getSigner();
+    if (!signer) {
+      return {
+        success: false,
+        error: "Not authenticated. Call auth.initAuth() first."
+      };
+    }
+    try {
+      const nonce = Date.now();
+      const action = { type: "setReferrer", code };
+      const signature = await signL1Action({
+        signer,
+        action,
+        nonce,
+        isTestnet: this.client.testnet
+      });
+      const res = await this.client.submitUserSignedAction(
+        action,
+        nonce,
+        signature
+      );
+      if (res.status === "ok") {
+        return { success: true };
+      }
+      let errorMsg = "Failed to set referrer";
+      if (typeof res.response === "string") {
+        errorMsg = res.response;
+      } else if (res.response && typeof res.response === "object" && !Array.isArray(res.response)) {
+        const obj = res.response;
+        if (typeof obj.error === "string") errorMsg = obj.error;
+      }
+      return { success: false, error: errorMsg };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      return { success: false, error: message };
+    }
+  }
+  async executeUserSigned(type, fields, types, nonceFieldName) {
+    if (!this.signer) {
+      return {
+        success: false,
+        error: "No wallet signer set. Call wallet.setSigner() first."
+      };
+    }
+    try {
+      const nonce = Date.now();
+      const action = {
+        type,
+        signatureChainId: this.client.testnet ? "0x66eee" : "0xa4b1",
+        hyperliquidChain: this.client.testnet ? "Testnet" : "Mainnet",
+        ...fields,
+        [nonceFieldName]: nonce
+      };
+      const signature = await signUserSignedAction({
+        signer: this.signer,
+        action,
+        types
+      });
+      const res = await this.client.submitUserSignedAction(
+        action,
+        nonce,
+        signature
+      );
+      if (res.status === "ok") {
+        return { success: true };
+      }
+      let errorMsg = "Action failed";
+      if (typeof res.response === "string") {
+        errorMsg = res.response;
+      } else if (res.response && typeof res.response === "object" && !Array.isArray(res.response)) {
+        const obj = res.response;
+        if (typeof obj.error === "string") errorMsg = obj.error;
+      }
+      return { success: false, error: errorMsg };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      return { success: false, error: message };
+    }
+  }
+};
+
+// src/adapter/hyperliquid/index.ts
+var HyperliquidHip4Adapter = class {
+  id = "hyperliquid";
+  name;
+  events;
+  marketData;
+  account;
+  trading;
+  auth;
+  wallet;
+  client;
+  _marketData;
+  constructor(config = {}) {
+    const testnet = config.testnet ?? true;
+    this.name = testnet ? "Hyperliquid HIP-4 (Testnet)" : "Hyperliquid HIP-4";
+    this.client = new HIP4Client({
+      testnet,
+      infoUrl: config.infoUrl,
+      exchangeUrl: config.exchangeUrl,
+      logger: config.logger
+    });
+    const auth = new HIP4Auth();
+    const eventAdapter = new HIP4EventAdapter(this.client);
+    this.events = eventAdapter;
+    const sideNameResolver = eventAdapter.getSideNameResolver();
+    const ensureSideNames = () => eventAdapter.ensureSideNames();
+    this._marketData = new HIP4MarketDataAdapter(this.client, sideNameResolver, ensureSideNames);
+    this.marketData = this._marketData;
+    this.account = new HIP4AccountAdapter(this.client, eventAdapter, sideNameResolver);
+    this.trading = new HIP4TradingAdapter(this.client, auth, {
+      builderAddress: config.builderAddress,
+      builderFee: config.builderFee
+    });
+    this.auth = auth;
+    this.wallet = new HIP4WalletAdapter(this.client, auth);
+  }
+  async initialize() {
+    await this.events.ensureSideNames();
+  }
+  destroy() {
+    this.client.closeWs();
+    this.auth.clearAuth();
+  }
+};
+
+// src/adapter/factory.ts
+function createHIP4Adapter(config = {}) {
+  return new HyperliquidHip4Adapter(config);
+}
+
+// src/adapter/hyperliquid/agent-wallet.ts
+var HL_MAINNET_CHAIN_ID = 42161;
+var HL_TESTNET_CHAIN_ID = 421614;
+function getEIP712Domain(isMainnet) {
+  return {
+    name: "HyperliquidSignTransaction",
+    version: "1",
+    chainId: isMainnet ? HL_MAINNET_CHAIN_ID : HL_TESTNET_CHAIN_ID,
+    verifyingContract: "0x0000000000000000000000000000000000000000"
+  };
+}
+var HL_MAINNET_API = "https://api.hyperliquid.xyz";
+var HL_TESTNET_API = "https://api.hyperliquid-testnet.xyz";
+function getAgentApprovalTypedData(agentAddress, agentName, nonce, isMainnet = true) {
+  return {
+    domain: getEIP712Domain(isMainnet),
+    types: {
+      "HyperliquidTransaction:ApproveAgent": [
+        { name: "hyperliquidChain", type: "string" },
+        { name: "agentAddress", type: "address" },
+        { name: "agentName", type: "string" },
+        { name: "nonce", type: "uint64" }
+      ]
+    },
+    primaryType: "HyperliquidTransaction:ApproveAgent",
+    message: {
+      hyperliquidChain: isMainnet ? "Mainnet" : "Testnet",
+      agentAddress: agentAddress.toLowerCase(),
+      agentName,
+      nonce: BigInt(nonce)
+    }
+  };
+}
+var APPROVE_BUILDER_FEE_TYPES = {
+  "HyperliquidTransaction:ApproveBuilderFee": [
+    { name: "hyperliquidChain", type: "string" },
+    { name: "maxFeeRate", type: "string" },
+    { name: "builder", type: "address" },
+    { name: "nonce", type: "uint64" }
+  ]
+};
+function getBuilderFeeApprovalTypedData(builderAddress, maxFeeRate, nonce, isMainnet = true) {
+  return {
+    domain: getEIP712Domain(isMainnet),
+    types: APPROVE_BUILDER_FEE_TYPES,
+    primaryType: "HyperliquidTransaction:ApproveBuilderFee",
+    message: {
+      hyperliquidChain: isMainnet ? "Mainnet" : "Testnet",
+      maxFeeRate,
+      builder: builderAddress.toLowerCase(),
+      nonce: BigInt(nonce)
+    }
+  };
+}
+async function submitBuilderFeeApproval(signature, builderAddress, maxFeeRate, nonce, isMainnet = true, exchangeUrl) {
+  const parsedSig = splitHexSignature(signature);
+  const action = {
+    type: "approveBuilderFee",
+    signatureChainId: isMainnet ? "0xa4b1" : "0x66eee",
+    hyperliquidChain: isMainnet ? "Mainnet" : "Testnet",
+    maxFeeRate,
+    builder: builderAddress.toLowerCase(),
+    nonce
+  };
+  try {
+    const url = exchangeUrl ?? `${isMainnet ? HL_MAINNET_API : HL_TESTNET_API}/exchange`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        action,
+        nonce,
+        signature: parsedSig
+      })
+    });
+    const result = await response.json();
+    if (result.status === "ok") {
+      return { success: true };
+    }
+    const errorMsg = typeof result.response === "string" ? result.response : result.response?.error ?? "Failed to approve builder fee";
+    return { success: false, error: errorMsg };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Network error"
+    };
+  }
+}
+async function submitAgentApproval(signature, agentAddress, agentName, nonce, isMainnet = true, exchangeUrl) {
+  const parsedSig = splitHexSignature(signature);
+  const action = {
+    type: "approveAgent",
+    signatureChainId: isMainnet ? "0xa4b1" : "0x66eee",
+    hyperliquidChain: isMainnet ? "Mainnet" : "Testnet",
+    agentAddress: agentAddress.toLowerCase(),
+    agentName,
+    nonce
+  };
+  try {
+    const url = exchangeUrl ?? `${isMainnet ? HL_MAINNET_API : HL_TESTNET_API}/exchange`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        action,
+        nonce,
+        signature: parsedSig
+      })
+    });
+    const result = await response.json();
+    if (result.status === "ok") {
+      return { success: true };
+    }
+    const error = typeof result.response === "string" ? result.response : result.response?.error ?? "Failed to approve agent";
+    return { success: false, error };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Network error"
+    };
+  }
+}
+
+// src/adapter/hyperliquid/core-to-evm-fees.ts
+var CORE_TO_EVM_GAS_LIMIT = 200000n;
+function estimateCoreToEvmFee(inputs) {
+  if (inputs.hypeCoreSpotBalance < 0) {
+    throw new Error(
+      `hypeCoreSpotBalance must be non-negative, got ${inputs.hypeCoreSpotBalance}`
+    );
+  }
+  if (inputs.sourceTokenPriceUsd <= 0) {
+    throw new Error(
+      `sourceTokenPriceUsd must be positive, got ${inputs.sourceTokenPriceUsd}`
+    );
+  }
+  if (inputs.hypeSpotMarkPxUsd <= 0) {
+    throw new Error(
+      `hypeSpotMarkPxUsd must be positive, got ${inputs.hypeSpotMarkPxUsd}`
+    );
+  }
+  const zeroBase = {
+    currency: "source",
+    amountHype: 0,
+    amountSourceToken: 0,
+    usd: 0,
+    gasLimit: CORE_TO_EVM_GAS_LIMIT,
+    baseFeeWei: inputs.baseFeeWei
+  };
+  if (inputs.baseFeeWei <= 0n) return zeroBase;
+  const gasWei = CORE_TO_EVM_GAS_LIMIT * inputs.baseFeeWei;
+  const gasGwei = Number(gasWei / 1000000000n);
+  const feeHype = gasGwei / 1e9;
+  const feeUsd = feeHype * inputs.hypeSpotMarkPxUsd;
+  if (inputs.hypeCoreSpotBalance >= feeHype) {
+    return {
+      currency: "HYPE",
+      amountHype: feeHype,
+      amountSourceToken: 0,
+      usd: feeUsd,
+      gasLimit: CORE_TO_EVM_GAS_LIMIT,
+      baseFeeWei: inputs.baseFeeWei
+    };
+  }
+  return {
+    currency: "source",
+    amountHype: 0,
+    amountSourceToken: feeUsd / inputs.sourceTokenPriceUsd,
+    usd: feeUsd,
+    gasLimit: CORE_TO_EVM_GAS_LIMIT,
+    baseFeeWei: inputs.baseFeeWei
+  };
+}
+function medianBaseFeeWei(samples) {
+  if (samples.length === 0) {
+    throw new Error("medianBaseFeeWei: empty sample array");
+  }
+  for (const s of samples) {
+    if (s < 0n) {
+      throw new Error(
+        `medianBaseFeeWei: non-negative values required, got ${s}`
+      );
+    }
+  }
+  const sorted = [...samples].sort((a2, b2) => a2 < b2 ? -1 : a2 > b2 ? 1 : 0);
+  const mid = sorted.length >> 1;
+  if (sorted.length % 2 === 1) {
+    return sorted[mid];
+  }
+  const a = sorted[mid - 1];
+  const b = sorted[mid];
+  return (a + b) / 2n;
+}
+
+// src/adapter/hyperliquid/hype-spot-mark-px.ts
+var HYPE_USDC_SPOT_PAIR_MAINNET = "@107";
+var HYPE_USDC_SPOT_PAIR_TESTNET = "@1035";
+function selectHypeSpotMarkPx(ctxs, options = {}) {
+  const coin = options.testnet ? HYPE_USDC_SPOT_PAIR_TESTNET : HYPE_USDC_SPOT_PAIR_MAINNET;
+  const ctx = ctxs[coin];
+  if (!ctx) return null;
+  const raw = ctx.markPx;
+  if (!raw) return null;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0) return null;
+  return parsed;
+}
+function findHypeUsdcSpotPairCoin(meta) {
+  const hype = meta.tokens.find((t) => t.name === "HYPE");
+  if (!hype) return null;
+  const pair = meta.universe.find(
+    (p) => p.tokens[0] === hype.index && p.tokens[1] === 0
+  );
+  if (!pair) return null;
+  return `@${pair.index}`;
+}
+
+// src/streams/candle-utils.ts
+var INTERVAL_REGEX = /^(\d+)([mhd])$/;
+function intervalToMs(interval) {
+  const match = interval.match(INTERVAL_REGEX);
+  if (!match) return 36e5;
+  const n = Number(match[1]);
+  switch (match[2]) {
+    case "m":
+      return n * 6e4;
+    case "h":
+      return n * 36e5;
+    case "d":
+      return n * 864e5;
+    default:
+      return 36e5;
+  }
+}
+function candleBoundaryMs(timestampMs, intervalMs) {
+  return Math.floor(timestampMs / intervalMs) * intervalMs;
+}
+function processTick(candles, price, timestampMs, intervalMs) {
+  if (candles.length === 0) {
+    const boundary = candleBoundaryMs(timestampMs, intervalMs);
+    candles.push({
+      time: boundary / 1e3,
+      open: price,
+      high: price,
+      low: price,
+      close: price,
+      volume: 0
+    });
+    return true;
+  }
+  const last = candles[candles.length - 1];
+  const lastBoundaryMs = last.time * 1e3;
+  const tickBoundaryMs = candleBoundaryMs(timestampMs, intervalMs);
+  if (tickBoundaryMs === lastBoundaryMs) {
+    last.close = price;
+    last.high = Math.max(last.high, price);
+    last.low = Math.min(last.low, price);
+    return true;
+  }
+  if (tickBoundaryMs > lastBoundaryMs) {
+    candles.push({
+      time: tickBoundaryMs / 1e3,
+      open: price,
+      high: price,
+      low: price,
+      close: price,
+      volume: 0
+    });
+    return true;
+  }
+  return false;
+}
+
+// src/streams/perp-price-feed.ts
+function parseWsCandle(raw) {
+  return {
+    time: raw.t / 1e3,
+    open: parseFloat(raw.o),
+    high: parseFloat(raw.h),
+    low: parseFloat(raw.l),
+    close: parseFloat(raw.c),
+    volume: parseFloat(raw.v)
+  };
+}
+function mergeCandle(candles, incoming) {
+  if (candles.length === 0) {
+    candles.push(incoming);
+    return;
+  }
+  const last = candles[candles.length - 1];
+  if (incoming.time === last.time) {
+    last.open = incoming.open;
+    last.high = incoming.high;
+    last.low = incoming.low;
+    last.close = incoming.close;
+    last.volume = incoming.volume;
+  } else if (incoming.time > last.time) {
+    candles.push(incoming);
+  }
+}
+function bridgeToNow(candles, intervalMs) {
+  if (candles.length === 0) return;
+  const last = candles[candles.length - 1];
+  const nowMs = Date.now();
+  const lastMs = last.time * 1e3;
+  if (nowMs - lastMs <= intervalMs * 2) return;
+  const boundary = Math.floor(nowMs / intervalMs) * intervalMs - intervalMs;
+  if (boundary <= lastMs) return;
+  candles.push({
+    time: boundary / 1e3,
+    open: last.close,
+    high: last.close,
+    low: last.close,
+    close: last.close,
+    volume: 0
+  });
+}
+function trimToWindow(candles, lookbackMs) {
+  if (candles.length === 0) return candles;
+  const windowStartSec = (Date.now() - lookbackMs) / 1e3;
+  const firstInWindow = candles.findIndex((c) => c.time >= windowStartSec);
+  if (firstInWindow === 0) return candles;
+  if (firstInWindow === -1) return candles.slice(-1);
+  return candles.slice(firstInWindow - 1);
+}
+function createPerpPriceFeed(client, coin, onSnapshot, options) {
+  const interval = options?.interval ?? "1h";
+  const lookbackMs = options?.lookbackMs ?? 14 * 24 * 60 * 60 * 1e3;
+  const intervalMs = intervalToMs(interval);
+  let destroyed = false;
+  let candles = [];
+  let currentMid = null;
+  let ready = false;
+  let bufferedCandles = [];
+  function emit() {
+    if (destroyed) return;
+    const trimmed = trimToWindow(candles, lookbackMs);
+    onSnapshot({
+      coin,
+      candles: trimmed.map((c) => ({ ...c })),
+      currentMid,
+      ready
+    });
+  }
+  const unsubMids = client.subscribe({ type: "allMids" }, (data) => {
+    if (destroyed) return;
+    const mids = data?.mids;
+    if (!mids) return;
+    const raw = mids[coin];
+    if (raw === void 0) return;
+    const mid = Number.parseFloat(raw);
+    if (Number.isNaN(mid)) return;
+    if (currentMid === null) {
+      currentMid = mid;
+      if (ready) emit();
+    }
+  });
+  const unsubCandle = client.subscribe(
+    { type: "candle", coin, interval },
+    (data) => {
+      if (destroyed) return;
+      const raw = data;
+      if (!raw?.t || !raw?.o) return;
+      if (raw.s !== void 0 && raw.s !== coin) return;
+      if (raw.i !== void 0 && raw.i !== interval) return;
+      if (!ready) {
+        bufferedCandles.push(raw);
+        return;
+      }
+      mergeCandle(candles, parseWsCandle(raw));
+      emit();
+    }
+  );
+  const unsubMarkPrice = client.subscribe(
+    { type: "activeAssetCtx", coin },
+    (data) => {
+      if (destroyed) return;
+      const msg = data;
+      if (!msg?.ctx?.markPx) return;
+      if (msg.coin !== coin) return;
+      const mark = Number.parseFloat(msg.ctx.markPx);
+      if (Number.isNaN(mark)) return;
+      currentMid = mark;
+      if (ready) emit();
+    }
+  );
+  const MIN_FETCH_LOOKBACK = 7 * 24 * 60 * 60 * 1e3;
+  const fetchLookback = Math.max(lookbackMs, MIN_FETCH_LOOKBACK);
+  const now = Date.now();
+  client.fetchCandleSnapshot(coin, interval, now - fetchLookback, now).then((historical) => {
+    if (destroyed) return;
+    candles = historical.map((c) => ({
+      time: c.t / 1e3,
+      open: parseFloat(c.o),
+      high: parseFloat(c.h),
+      low: parseFloat(c.l),
+      close: parseFloat(c.c),
+      volume: parseFloat(c.v)
+    }));
+    for (const raw of bufferedCandles) {
+      mergeCandle(candles, parseWsCandle(raw));
+    }
+    bufferedCandles = [];
+    bridgeToNow(candles, intervalMs);
+    ready = true;
+    emit();
+  }).catch((err) => {
+    console.warn("[perp-price-feed] candle fetch failed:", err);
+    if (destroyed) return;
+    for (const raw of bufferedCandles) {
+      mergeCandle(candles, parseWsCandle(raw));
+    }
+    bufferedCandles = [];
+    bridgeToNow(candles, intervalMs);
+    ready = true;
+    emit();
+  });
+  return () => {
+    destroyed = true;
+    unsubMids();
+    unsubCandle();
+    unsubMarkPrice();
+  };
+}
+
+// src/streams/price-feed.ts
+function createPriceFeed(marketData, marketId, onSnapshot, options) {
+  const interval = options?.interval ?? "1h";
+  const lookbackMs = options?.lookbackMs ?? 14 * 24 * 60 * 60 * 1e3;
+  const sideIndex = options?.sideIndex ?? 0;
+  const intervalMs = intervalToMs(interval);
+  let destroyed = false;
+  let candles = [];
+  let currentMid = null;
+  let ready = false;
+  let bufferedTicks = [];
+  function emit() {
+    if (destroyed) return;
+    onSnapshot({
+      marketId,
+      candles: candles.map((c) => ({ ...c })),
+      currentMid,
+      ready
+    });
+  }
+  function processTick2(price, timestampMs) {
+    currentMid = price;
+    processTick(candles, price, timestampMs, intervalMs);
+  }
+  const unsubPrice = marketData.subscribePrice(marketId, (priceData) => {
+    if (destroyed) return;
+    const outcome = priceData.outcomes[sideIndex];
+    if (!outcome) return;
+    const mid = parseFloat(outcome.midpoint);
+    if (Number.isNaN(mid)) return;
+    if (!ready) {
+      bufferedTicks.push({ price: mid, timestamp: priceData.timestamp });
+      return;
+    }
+    processTick2(mid, priceData.timestamp);
+    emit();
+  });
+  const now = Date.now();
+  marketData.fetchCandles(marketId, interval, now - lookbackMs, now).then((historical) => {
+    if (destroyed) return;
+    candles = historical.map((c) => ({
+      time: c.time,
+      open: c.open,
+      high: c.high,
+      low: c.low,
+      close: c.close,
+      volume: c.volume
+    }));
+    for (const tick of bufferedTicks) {
+      processTick2(tick.price, tick.timestamp);
+    }
+    bufferedTicks = [];
+    ready = true;
+    emit();
+  }).catch(() => {
+    if (destroyed) return;
+    for (const tick of bufferedTicks) {
+      processTick2(tick.price, tick.timestamp);
+    }
+    bufferedTicks = [];
+    ready = true;
+    emit();
+  });
+  return () => {
+    destroyed = true;
+    unsubPrice();
+  };
+}
+
+// src/utils/orderbook.ts
+function computeEstimatedCost(tokenAmount, orderType, limitPriceCents, marketPriceCents) {
+  if (tokenAmount <= 0) return 0;
+  if (orderType === "market") {
+    if (marketPriceCents !== void 0 && marketPriceCents > 0) {
+      return toNum(
+        toDecimal(tokenAmount).times(toDecimal(marketPriceCents)).dividedBy(100).toString()
+      );
+    }
+    return tokenAmount;
+  }
+  if (!limitPriceCents || limitPriceCents <= 0) return 0;
+  return toNum(
+    toDecimal(tokenAmount).times(toDecimal(limitPriceCents)).dividedBy(100).toString()
+  );
+}
+function computeTradeCost(params) {
+  const { tokenAmount, orderType, limitPriceCents, marketPriceCents } = params;
+  const estimatedCost = orderType === "limit" ? computeEstimatedCost(tokenAmount, "limit", limitPriceCents) : computeEstimatedCost(tokenAmount, "market", null, marketPriceCents);
+  const potentialReturn = computePotentialReturn(tokenAmount);
+  return {
+    estimatedCost,
+    potentialReturn,
+    displayShares: tokenAmount
+  };
+}
+function computePotentialReturn(tokenAmount) {
+  return Math.max(0, tokenAmount);
+}
+
+exports.ALL_DEXS = ALL_DEXS;
+exports.CORE_TO_EVM_GAS_LIMIT = CORE_TO_EVM_GAS_LIMIT;
+exports.HIP4Client = HIP4Client;
+exports.HIP4EventAdapter = HIP4EventAdapter;
+exports.HIP4TradingAdapter = HIP4TradingAdapter;
+exports.HIP4WalletAdapter = HIP4WalletAdapter;
+exports.HLApiError = HLApiError;
+exports.HYPE_CORE_EVM_SYSTEM_ADDRESS = HYPE_CORE_EVM_SYSTEM_ADDRESS;
+exports.HYPE_USDC_SPOT_PAIR_MAINNET = HYPE_USDC_SPOT_PAIR_MAINNET;
+exports.HYPE_USDC_SPOT_PAIR_TESTNET = HYPE_USDC_SPOT_PAIR_TESTNET;
+exports.MAX_CORE_EVM_TOKEN_INDEX = MAX_CORE_EVM_TOKEN_INDEX;
+exports.MIN_NOTIONAL = MIN_NOTIONAL;
+exports.USDC_HL_TOKEN_MAINNET = USDC_HL_TOKEN_MAINNET;
+exports.USDC_HL_TOKEN_TESTNET = USDC_HL_TOKEN_TESTNET;
+exports.USDH_ASSET_ID = USDH_ASSET_ID;
+exports.USDH_ASSET_ID_MAINNET = USDH_ASSET_ID_MAINNET;
+exports.USDH_ASSET_ID_TESTNET = USDH_ASSET_ID_TESTNET;
+exports.USDH_CORE_DECIMALS = USDH_CORE_DECIMALS;
+exports.USDH_EVM_ADDRESS_MAINNET = USDH_EVM_ADDRESS_MAINNET;
+exports.USDH_EVM_ADDRESS_TESTNET = USDH_EVM_ADDRESS_TESTNET;
+exports.USDH_EVM_DECIMALS = USDH_EVM_DECIMALS;
+exports.USDH_HL_TOKEN_MAINNET = USDH_HL_TOKEN_MAINNET;
+exports.USDH_HL_TOKEN_TESTNET = USDH_HL_TOKEN_TESTNET;
+exports.USDH_SPOT_INDEX_MAINNET = USDH_SPOT_INDEX_MAINNET;
+exports.USDH_SPOT_INDEX_TESTNET = USDH_SPOT_INDEX_TESTNET;
+exports.USDH_SPOT_PAIR = USDH_SPOT_PAIR;
+exports.USDH_SPOT_PAIR_MAINNET = USDH_SPOT_PAIR_MAINNET;
+exports.USDH_SPOT_PAIR_TESTNET = USDH_SPOT_PAIR_TESTNET;
+exports.USDH_TOKEN_HASH_MAINNET = USDH_TOKEN_HASH_MAINNET;
+exports.USDH_TOKEN_HASH_TESTNET = USDH_TOKEN_HASH_TESTNET;
+exports.USDH_TOKEN_INDEX_MAINNET = USDH_TOKEN_INDEX_MAINNET;
+exports.USDH_TOKEN_INDEX_TESTNET = USDH_TOKEN_INDEX_TESTNET;
+exports.buildQuestionIndex = buildQuestionIndex;
+exports.candleBoundaryMs = candleBoundaryMs;
+exports.classifyAllOutcomes = classifyAllOutcomes;
+exports.classifyOutcome = classifyOutcome;
+exports.computeEstimatedCost = computeEstimatedCost;
+exports.computePotentialReturn = computePotentialReturn;
+exports.computeTickSize = computeTickSize;
+exports.computeTradeCost = computeTradeCost;
+exports.createHIP4Adapter = createHIP4Adapter;
+exports.createPerpPriceFeed = createPerpPriceFeed;
+exports.createPriceFeed = createPriceFeed;
+exports.deriveCoreEvmSystemAddress = deriveCoreEvmSystemAddress;
+exports.discoverPriceBinaryMarkets = discoverPriceBinaryMarkets;
+exports.estimateCoreToEvmFee = estimateCoreToEvmFee;
+exports.findHypeUsdcSpotPairCoin = findHypeUsdcSpotPairCoin;
+exports.formatMarketLabel = formatMarketLabel;
+exports.formatPredictionPrice = formatPredictionPrice;
+exports.formatPrice = formatPrice;
+exports.getAgentApprovalTypedData = getAgentApprovalTypedData;
+exports.getBuilderFeeApprovalTypedData = getBuilderFeeApprovalTypedData;
+exports.getMinShares = getMinShares;
+exports.getPriceBucketBounds = getPriceBucketBounds;
+exports.intervalToMs = intervalToMs;
+exports.isUsdClassTransferRequired = isUsdClassTransferRequired;
+exports.medianBaseFeeWei = medianBaseFeeWei;
+exports.normalizeSignature = normalizeSignature;
+exports.outcomeCoin = outcomeCoin;
+exports.parseDescription = parseDescription;
+exports.parseOutcomeCoin = parseOutcomeCoin;
+exports.parsePriceBucketDescription = parsePriceBucketDescription;
+exports.parseSideCoin = parseSideCoin;
+exports.periodMinutes = periodMinutes;
+exports.processTick = processTick;
+exports.roundToTick = roundToTick;
+exports.selectHypeSpotMarkPx = selectHypeSpotMarkPx;
+exports.sideAssetId = sideAssetId;
+exports.sideCoin = sideCoin;
+exports.splitHexSignature = splitHexSignature;
+exports.stripZeros = stripZeros;
+exports.submitAgentApproval = submitAgentApproval;
+exports.submitBuilderFeeApproval = submitBuilderFeeApproval;
+exports.timeToExpiry = timeToExpiry;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map