@reefclaw/connect 0.1.10 → 0.1.12

package/assets/plugin/venues/hyperliquid/hl-precision.js

@@ -1,176 +0,0 @@
-// Hyperliquid price/size precision — the rule, implemented HERE, on strings.
-//
-// ★ WHY NOT CCXT: `priceToPrecision` has a known rounding bug in the [1,10)
-// range (ccxt#26132) and the whole point of a safety floor is that the stop
-// price we compute is the stop price the exchange gets. Plan §5.5: own the math.
-//
-// ★ WHY NOT decimal.js: it would become a runtime dependency of the PUBLISHED
-// plugin package. The rule below only needs exact DECIMAL-STRING manipulation
-// (truncate / count significant figures) — no arithmetic on values — so strings
-// are both exact and dependency-free. Every function takes and returns numbers at
-// the boundary but never rounds through binary floating point.
-//
-// THE RULE (docs, verified 2026-07-11; re-verified live 2026-07-12):
-//   PRICE is valid iff
-//     - it is an INTEGER (always allowed, regardless of sig figs), OR
-//     - it has ≤ 5 significant figures AND ≤ (MAX_DECIMALS − szDecimals) decimals
-//       where MAX_DECIMALS = 6 for perps.
-//   SIZE is rounded DOWN to szDecimals (from `meta.universe`).
-//   MIN NOTIONAL is $10 (observed live: "Order must have minimum value of $10").
-//
-// Rounding direction is explicit at every call site — never "nearest" by default
-// on a protective leg. `passive` semantics: a BUY rounds DOWN, a SELL rounds UP,
-// so a rounded limit never crosses further into the book than intended.
-const MAX_DECIMALS_PERP = 6;
-/** HL minimum order value in USDC. Observed live 2026-07-12 (a $6 order was
- *  rejected: "Order must have minimum value of $10"). */
-export const HL_MIN_NOTIONAL_USD = 10;
-/** Split a finite number into its exact decimal string parts, expanding any
- *  exponent form ("1e-7") that JS produces for small/large magnitudes — the
- *  string rule below must never see an "e". */
-function toPlainDecimalString(value) {
-    if (!Number.isFinite(value))
-        throw new Error(`not finite: ${value}`);
-    // toPrecision(17) is lossless for a double, and never yields exponent form for
-    // the magnitudes we trade; Number() re-parses to drop trailing zeros.
-    const s = String(value);
-    if (!s.includes('e') && !s.includes('E'))
-        return s;
-    // Exponent form → expand via toFixed with enough decimals (bounded: HL prices
-    // never need more than 20 decimals, and sizes are capped by szDecimals).
-    return value.toFixed(20).replace(/0+$/, '').replace(/\.$/, '');
-}
-/** Count significant figures of a decimal string (leading zeros are not
- *  significant; trailing zeros AFTER a decimal point are, but we always emit
- *  trimmed strings so they never appear). */
-export function countSignificantFigures(value) {
-    const s = toPlainDecimalString(Math.abs(value));
-    const digits = s.replace('.', '').replace(/^0+/, '').replace(/0+$/, '');
-    // An integer like 1200 has 2 sig figs by this measure — which is the
-    // conservative reading, and integers are unconditionally allowed anyway.
-    return digits.length === 0 ? 1 : digits.length;
-}
-/** Decimal places of a value (0 for integers). */
-export function decimalPlaces(value) {
-    const s = toPlainDecimalString(Math.abs(value));
-    const dot = s.indexOf('.');
-    return dot === -1 ? 0 : s.length - dot - 1;
-}
-/** Truncate a decimal string to N decimals, rounding in the requested direction.
- *  Exact — no binary float rounding anywhere. */
-function roundDecimals(value, decimals, dir) {
-    if (decimals < 0)
-        decimals = 0;
-    const factor = 10 ** decimals;
-    // Work in an integer domain scaled by `factor`; the +/- 1e-9 nudge absorbs the
-    // classic 0.1*3 = 0.30000000000000004 representation error WITHOUT changing a
-    // value that is genuinely on the boundary.
-    const scaled = value * factor;
-    const eps = 1e-9;
-    const out = dir === 'down' ? Math.floor(scaled + eps) : Math.ceil(scaled - eps);
-    return out / factor;
-}
-/** Round a value to at most `sig` significant figures, in the given direction. */
-function roundToSignificantFigures(value, sig, dir) {
-    if (value === 0)
-        return 0;
-    const magnitude = Math.floor(Math.log10(Math.abs(value)));
-    // decimals needed so that the value carries exactly `sig` significant figures
-    const decimals = sig - 1 - magnitude;
-    return roundDecimals(value, Math.max(decimals, 0), dir);
-}
-/** Is this price acceptable to Hyperliquid as-is? (The exact documented rule —
- *  used by tests and as a post-round assertion, never as a substitute for
- *  rounding.) */
-export function isValidHlPrice(price, szDecimals) {
-    if (!Number.isFinite(price) || price <= 0)
-        return false;
-    if (Number.isInteger(price))
-        return true; // integers always allowed
-    const maxDecimals = MAX_DECIMALS_PERP - szDecimals;
-    return countSignificantFigures(price) <= 5 && decimalPlaces(price) <= maxDecimals;
-}
-/** Round a price to the nearest HL-legal value in the requested direction.
- *
- *  Applies BOTH constraints (≤5 sig figs AND ≤ MAX_DECIMALS−szDecimals decimals),
- *  tightest-wins. An integer result is always legal, so the decimal cap can never
- *  push a price to an illegal value. */
-export function roundHlPrice(price, szDecimals, dir) {
-    if (!Number.isFinite(price) || price <= 0) {
-        throw new Error(`Invalid HL price: ${price}`);
-    }
-    const maxDecimals = Math.max(MAX_DECIMALS_PERP - szDecimals, 0);
-    // 1) cap significant figures
-    let out = roundToSignificantFigures(price, 5, dir);
-    // 2) cap decimals (may reduce sig figs further — that stays legal)
-    if (decimalPlaces(out) > maxDecimals) {
-        out = roundDecimals(out, maxDecimals, dir);
-    }
-    // A rounded-to-zero price is never legal — fall back to the smallest legal tick.
-    if (out <= 0)
-        out = 1 / 10 ** maxDecimals;
-    return out;
-}
-/** Round an order size DOWN to szDecimals. Always DOWN: rounding a size up can
- *  overshoot the position (a reduce-only leg sized above the position is rejected)
- *  or exceed the intended risk. */
-export function roundHlSize(size, szDecimals) {
-    if (!Number.isFinite(size) || size < 0) {
-        throw new Error(`Invalid HL size: ${size}`);
-    }
-    return roundDecimals(size, szDecimals, 'down');
-}
-/** Pre-flight validation mirroring `ExchangeInfoCache.validate`'s contract
- *  (same shape, same "round then check" order, same dollar-hint error copy) so
- *  the adapter's call sites are venue-symmetric.
- *
- *  @param side  drives passive rounding of a limit price (buy → down, sell → up).
- *  @param referencePrice mark/mid — used for the notional check when no limit
- *    price is given (market orders). */
-export function validateHlOrder(args) {
-    const { amount, price, referencePrice, rules, side } = args;
-    const { szDecimals } = rules;
-    const roundedAmount = roundHlSize(amount, szDecimals);
-    if (roundedAmount <= 0) {
-        return {
-            valid: false,
-            error: `Amount ${amount} rounds to zero at ${szDecimals} decimals — increase the size`,
-            roundedAmount: 0,
-        };
-    }
-    let roundedPrice;
-    if (price !== undefined) {
-        roundedPrice = roundHlPrice(price, szDecimals, side === 'buy' ? 'down' : 'up');
-    }
-    const notionalPrice = roundedPrice ?? referencePrice;
-    if (notionalPrice !== undefined && notionalPrice > 0) {
-        const notional = roundedAmount * notionalPrice;
-        if (notional < HL_MIN_NOTIONAL_USD) {
-            const minAmount = HL_MIN_NOTIONAL_USD / notionalPrice;
-            return {
-                valid: false,
-                // Same dollar-hint shape the Binance path uses — the agent gets an
-                // actionable number, not a rule citation.
-                error: `Order value $${notional.toFixed(2)} is below Hyperliquid's $${HL_MIN_NOTIONAL_USD} minimum. ` +
-                    `Increase size to at least ${minAmount.toFixed(szDecimals + 1)} (≈$${HL_MIN_NOTIONAL_USD}).`,
-                roundedAmount,
-                roundedPrice,
-            };
-        }
-    }
-    return { valid: true, roundedAmount, roundedPrice };
-}
-/** The IOC price bound that emulates a market order (HL has no native market
- *  order — plan §3.4). Explicit slippage ALWAYS — ccxt's `defaultSlippage: 0.05`
- *  (5%!) is never relied upon. */
-export function marketIocPrice(args) {
-    const { referencePrice, side, slippagePct, szDecimals } = args;
-    if (!Number.isFinite(referencePrice) || referencePrice <= 0) {
-        throw new Error(`marketIocPrice needs a positive reference price, got ${referencePrice}`);
-    }
-    const slip = Math.min(Math.max(slippagePct, 0), 0.02); // hard clamp ≤2%
-    const raw = side === 'buy' ? referencePrice * (1 + slip) : referencePrice * (1 - slip);
-    // Round the bound OUTWARD (buy up / sell down) so rounding never makes the
-    // order less marketable than intended.
-    return roundHlPrice(raw, szDecimals, side === 'buy' ? 'up' : 'down');
-}

package/assets/plugin/venues/hyperliquid/hl-private.d.ts

@@ -1,88 +0,0 @@
-import type { CcxtOrder, CcxtPosition, CcxtBalance } from '../../types.js';
-export interface HlCredentials {
-    /** MASTER account address (0x…). Queries always use this — an agent wallet
-     *  holds no balance and no positions (learned the hard way 2026-07-12). */
-    walletAddress: string;
-    /** AGENT (API) wallet private key — signs, never holds funds. */
-    agentPrivateKey: string;
-    testnet?: boolean;
-}
-/** The CCXT options that MUST be present on every authed HL client. Exported so
- *  `hl-private.test.ts` can assert them — if a future ccxt bump changes the
- *  option names, the test fails rather than the users paying a silent 1bp. */
-export declare const HL_REQUIRED_OPTIONS: {
-    readonly builderFee: false;
-    readonly refSet: true;
-};
-export interface HlTriggerParams {
-    /** Trigger price (fires on MARK — HL has no workingType choice). */
-    triggerPrice: number;
-    /** 'sl' | 'tp' — HL's own naming. */
-    tpsl: 'sl' | 'tp';
-    reduceOnly: true;
-    cloid?: string;
-}
-export interface HlOrderRequest {
-    symbol: string;
-    side: 'buy' | 'sell';
-    /** 'market' is emulated: an IOC limit at `price` (the caller must have applied
-     *  the slippage bound via hl-precision.marketIocPrice). */
-    type: 'market' | 'limit';
-    amount: number;
-    price: number;
-    reduceOnly?: boolean;
-    postOnly?: boolean;
-    cloid?: string;
-    trigger?: {
-        triggerPrice: number;
-        tpsl: 'sl' | 'tp';
-    };
-}
-export declare class HyperliquidPrivateApi {
-    private readonly creds;
-    private readonly exchange;
-    private readonly mutex;
-    private marketsLoaded;
-    constructor(creds: HlCredentials);
-    /** Exposed for the options-pin test + diagnostics. */
-    getExchange(): any;
-    loadMarkets(): Promise<boolean>;
-    /** Positions for the MASTER account. `null` = fetch failed (state unknown);
-     *  `[]` = the exchange confirmed flat. */
-    fetchPositions(symbol?: string): Promise<CcxtPosition[] | null>;
-    /** Open orders INCLUDING trigger/TPSL legs. CCXT's HL `fetchOpenOrders`
-     *  defaults to `frontendOpenOrders`, which is the only endpoint that returns
-     *  trigger orders (plan §3.6) — the analog of Binance's merged algo endpoints. */
-    fetchOpenOrders(symbol?: string): Promise<CcxtOrder[] | null>;
-    fetchBalance(): Promise<CcxtBalance | null>;
-    /** Per-order status — the liveness resolver's REST tier (Tier 2 of the
-     *  3-tier rule). Weight 2. `null` = lookup FAILED (unknown), which callers
-     *  must treat as "do not act", NOT as "gone". */
-    fetchOrder(orderId: string, symbol?: string): Promise<CcxtOrder | null>;
-    /** Own fills. WS is the authoritative ingress (plan + the audit-trail rule);
-     *  this is the gap-fill/truth-check path. NOTE: only the 10,000 most recent
-     *  fills exist server-side — deep history is NOT queryable on HL, which is why
-     *  the `trades` table must be WS-first. */
-    fetchMyTrades(symbol?: string, since?: number, limit?: number): Promise<unknown[] | null>;
-    /** Refresh the ADDRESS action budget (the starvation guard). Weight 20 — call
-     *  every ~5 min, never per-heartbeat. */
-    refreshAddressBudget(): Promise<void>;
-    /** Raw `POST /info` — for the handful of reads CCXT doesn't expose
-     *  (userRateLimit, userNonFundingLedgerUpdates, portfolio). Never used for
-     *  signed actions. */
-    rawInfo(body: Record<string, unknown>): Promise<any>;
-    /** Submit one order. Market orders are IOC-limit emulated — `price` is
-     *  MANDATORY (ccxt throws without it) and the caller must already have applied
-     *  the slippage bound + HL rounding (hl-precision). */
-    submitOrder(req: HlOrderRequest): Promise<CcxtOrder | null>;
-    /** Submit N orders as ONE signed action (one nonce, one `/exchange` call).
-     *  This is how a bracket pair (SL+TP) is placed: atomic-ish, and it costs 1 IP
-     *  weight unit but N address actions. */
-    submitOrders(reqs: HlOrderRequest[]): Promise<CcxtOrder[] | null>;
-    cancelOrder(orderId: string, symbol: string): Promise<CcxtOrder | null>;
-    /** Cancel by cloid — the bracket path's cancel (we always know our own cloid,
-     *  and it survives a restart because it is derived, not stored). */
-    cancelOrderByCloid(cloid: string, symbol: string): Promise<CcxtOrder | null>;
-    private buildParams;
-    get isMarketsLoaded(): boolean;
-}

package/assets/plugin/venues/hyperliquid/hl-private.js

@@ -1,357 +0,0 @@
-// Hyperliquid signed-action client — the HL mirror of `ccxt/binance-private.ts`.
-//
-// CONTRACTS THIS FILE INHERITS FROM THE BINANCE SIDE (non-negotiable — the shared
-// adapter-contract suite runs against both):
-//   ★ null ≠ empty. EVERY read returns `null` on a FAILED fetch, never `[]`.
-//     `[]` means "the exchange said: nothing". Callers make destructive decisions
-//     (cancel a bracket, close a position, trust a snapshot) on that difference.
-//   ★ Reads are pre-gated (`assertNotLimited`), order/cancel paths are NOT (an
-//     exit must never be blocked by our own pacer) but every path arms the gate
-//     via `noteError`.
-//
-// HYPERLIQUID-SPECIFIC LANDMINES (all verified live on testnet 2026-07-12):
-//   ★ ccxt AUTO-MONETIZES an authed HL client — `initializeClient()` enrolls
-//     CCXT's own builder fee (1bp/order) + referral code on the first signed call.
-//     `options.{builderFee:false, refSet:true}` disables both. A test pins this.
-//   ★ Market orders REQUIRE a reference price (ccxt derives the slippage cap from
-//     it) — `createOrder(sym,'market',side,size)` with no price THROWS client-side.
-//     There is no native market order on HL: it is an IOC limit at a bounded price.
-//   ★ Signed actions carry a NONCE (epoch ms) and HL keeps only the 100 highest
-//     per signer. Two actions signed in the same millisecond can collide → every
-//     signed action goes through a monotonic-nonce MUTEX (one in-flight at a time,
-//     strictly increasing ms). This is why `submitOrders` batches a bracket pair
-//     into ONE action rather than firing two.
-//   ★ Agent (API) wallets can only TRADE. `usdClassTransfer`/withdraw are
-//     user-signed actions and fail with "Must deposit before performing actions"
-//     when signed by an agent. We never call them.
-import { createRequire } from 'node:module';
-import { logger } from '../../logger.js';
-import { toCcxtSymbol } from '../symbols.js';
-import { assertNotLimited, noteError, noteSuccess, exchangeIpWeight, updateAddressBudget, } from './hl-rate-gate.js';
-import { isValidHlCloid } from './hl-cloid.js';
-// ccxt via CJS require — OpenClaw's ESM loader yields the wrong module shape
-// (same rationale as binance-private.ts / hl-public.ts).
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let ccxtCjs;
-try {
-    const _require = createRequire(import.meta.url);
-    ccxtCjs = _require('ccxt');
-}
-catch {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    ccxtCjs = require('ccxt');
-}
-const TAG = 'hl-private';
-/** The CCXT options that MUST be present on every authed HL client. Exported so
- *  `hl-private.test.ts` can assert them — if a future ccxt bump changes the
- *  option names, the test fails rather than the users paying a silent 1bp. */
-export const HL_REQUIRED_OPTIONS = {
-    builderFee: false,
-    refSet: true,
-};
-/**
- * Serializes every signed action behind a monotonic nonce.
- *
- * HL keeps the 100 highest nonces per signer and rejects repeats; two actions
- * signed inside the same millisecond can therefore collide and one is silently
- * lost. Rather than hand-rolling nonces (ccxt owns that), we guarantee that no
- * two signed actions are ever *issued* in the same millisecond from this process:
- * each waits for the previous to settle AND for the clock to advance.
- */
-class NonceMutex {
-    chain = Promise.resolve();
-    lastIssuedMs = 0;
-    run(fn) {
-        const next = this.chain.then(async () => {
-            const now = Date.now();
-            if (now <= this.lastIssuedMs) {
-                // Same-ms collision guard: wait out the millisecond.
-                await new Promise((r) => setTimeout(r, this.lastIssuedMs - now + 1));
-            }
-            this.lastIssuedMs = Date.now();
-            return fn();
-        });
-        // Keep the chain alive even when a link rejects (otherwise one failed action
-        // would poison every later one).
-        this.chain = next.then(() => undefined, () => undefined);
-        return next;
-    }
-}
-export class HyperliquidPrivateApi {
-    creds;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    exchange;
-    mutex = new NonceMutex();
-    marketsLoaded = false;
-    constructor(creds) {
-        this.creds = creds;
-        if (!creds.walletAddress || !creds.agentPrivateKey) {
-            throw new Error('HyperliquidPrivateApi requires walletAddress + agentPrivateKey');
-        }
-        this.exchange = new ccxtCjs.hyperliquid({
-            walletAddress: creds.walletAddress,
-            privateKey: creds.agentPrivateKey,
-            options: { ...HL_REQUIRED_OPTIONS },
-            enableRateLimit: true,
-        });
-        if (creds.testnet) {
-            this.exchange.setSandboxMode(true);
-            const url = JSON.stringify(this.exchange.urls?.api ?? '');
-            if (!url.includes('testnet')) {
-                throw new Error(`HL testnet requested but sandbox URL is not testnet: ${url.slice(0, 80)}`);
-            }
-        }
-        logger.info(TAG, `Hyperliquid private API initialized (${creds.testnet ? 'TESTNET' : 'MAINNET'}, master ${creds.walletAddress.slice(0, 8)}…)`);
-    }
-    /** Exposed for the options-pin test + diagnostics. */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    getExchange() {
-        return this.exchange;
-    }
-    async loadMarkets() {
-        try {
-            assertNotLimited('meta');
-            await this.exchange.loadMarkets();
-            noteSuccess('meta');
-            this.marketsLoaded = true;
-            return true;
-        }
-        catch (err) {
-            noteError(err, 'loadMarkets');
-            logger.error(TAG, `loadMarkets failed: ${msg(err)}`);
-            return false;
-        }
-    }
-    // ---- Reads (null on failure — NEVER []) ----
-    /** Positions for the MASTER account. `null` = fetch failed (state unknown);
-     *  `[]` = the exchange confirmed flat. */
-    async fetchPositions(symbol) {
-        try {
-            assertNotLimited('clearinghouseState');
-            const symbols = symbol ? [toCcxtSymbol('hyperliquid', symbol)] : undefined;
-            const raw = await this.exchange.fetchPositions(symbols);
-            noteSuccess('clearinghouseState');
-            if (!Array.isArray(raw))
-                return null;
-            return raw.filter((p) => Math.abs(Number(p.contracts ?? 0)) > 0);
-        }
-        catch (err) {
-            noteError(err, 'fetchPositions');
-            logger.error(TAG, `fetchPositions failed: ${msg(err)}`);
-            return null;
-        }
-    }
-    /** Open orders INCLUDING trigger/TPSL legs. CCXT's HL `fetchOpenOrders`
-     *  defaults to `frontendOpenOrders`, which is the only endpoint that returns
-     *  trigger orders (plan §3.6) — the analog of Binance's merged algo endpoints. */
-    async fetchOpenOrders(symbol) {
-        try {
-            assertNotLimited('frontendOpenOrders');
-            const s = symbol ? toCcxtSymbol('hyperliquid', symbol) : undefined;
-            const raw = await this.exchange.fetchOpenOrders(s);
-            noteSuccess('frontendOpenOrders');
-            return Array.isArray(raw) ? raw : null;
-        }
-        catch (err) {
-            noteError(err, 'fetchOpenOrders');
-            logger.error(TAG, `fetchOpenOrders failed: ${msg(err)}`);
-            return null;
-        }
-    }
-    async fetchBalance() {
-        try {
-            assertNotLimited('clearinghouseState');
-            const raw = await this.exchange.fetchBalance();
-            noteSuccess('clearinghouseState');
-            return raw ?? null;
-        }
-        catch (err) {
-            noteError(err, 'fetchBalance');
-            logger.error(TAG, `fetchBalance failed: ${msg(err)}`);
-            return null;
-        }
-    }
-    /** Per-order status — the liveness resolver's REST tier (Tier 2 of the
-     *  3-tier rule). Weight 2. `null` = lookup FAILED (unknown), which callers
-     *  must treat as "do not act", NOT as "gone". */
-    async fetchOrder(orderId, symbol) {
-        try {
-            assertNotLimited('orderStatus');
-            const s = symbol ? toCcxtSymbol('hyperliquid', symbol) : undefined;
-            const raw = await this.exchange.fetchOrder(orderId, s);
-            noteSuccess('orderStatus');
-            return raw ?? null;
-        }
-        catch (err) {
-            noteError(err, 'fetchOrder');
-            logger.warn(TAG, `fetchOrder(${orderId}) failed: ${msg(err)}`);
-            return null;
-        }
-    }
-    /** Own fills. WS is the authoritative ingress (plan + the audit-trail rule);
-     *  this is the gap-fill/truth-check path. NOTE: only the 10,000 most recent
-     *  fills exist server-side — deep history is NOT queryable on HL, which is why
-     *  the `trades` table must be WS-first. */
-    async fetchMyTrades(symbol, since, limit = 100) {
-        try {
-            assertNotLimited('userFills');
-            const s = symbol ? toCcxtSymbol('hyperliquid', symbol) : undefined;
-            const raw = await this.exchange.fetchMyTrades(s, since, limit);
-            noteSuccess('userFills');
-            return Array.isArray(raw) ? raw : null;
-        }
-        catch (err) {
-            noteError(err, 'fetchMyTrades');
-            logger.error(TAG, `fetchMyTrades failed: ${msg(err)}`);
-            return null;
-        }
-    }
-    /** Refresh the ADDRESS action budget (the starvation guard). Weight 20 — call
-     *  every ~5 min, never per-heartbeat. */
-    async refreshAddressBudget() {
-        try {
-            assertNotLimited('userRateLimit');
-            const res = await this.rawInfo({ type: 'userRateLimit', user: this.creds.walletAddress });
-            noteSuccess('userRateLimit');
-            const used = Number(res?.nRequestsUsed);
-            const cap = Number(res?.nRequestsCap);
-            if (Number.isFinite(used) && Number.isFinite(cap)) {
-                updateAddressBudget({ nRequestsUsed: used, nRequestsCap: cap });
-            }
-        }
-        catch (err) {
-            noteError(err, 'userRateLimit');
-            logger.warn(TAG, `refreshAddressBudget failed: ${msg(err)}`);
-        }
-    }
-    /** Raw `POST /info` — for the handful of reads CCXT doesn't expose
-     *  (userRateLimit, userNonFundingLedgerUpdates, portfolio). Never used for
-     *  signed actions. */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async rawInfo(body) {
-        const base = this.creds.testnet
-            ? 'https://api.hyperliquid-testnet.xyz'
-            : 'https://api.hyperliquid.xyz';
-        const res = await fetch(`${base}/info`, {
-            method: 'POST',
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify(body),
-            signal: AbortSignal.timeout(15_000),
-        });
-        if (!res.ok)
-            throw new Error(`POST /info ${String(body.type)} → ${res.status}`);
-        return res.json();
-    }
-    // ---- Signed actions (NEVER pre-gated; always nonce-serialized) ----
-    /** Submit one order. Market orders are IOC-limit emulated — `price` is
-     *  MANDATORY (ccxt throws without it) and the caller must already have applied
-     *  the slippage bound + HL rounding (hl-precision). */
-    async submitOrder(req) {
-        if (req.cloid && !isValidHlCloid(req.cloid)) {
-            throw new Error(`Invalid HL cloid ${req.cloid} — must be 0x + 32 hex chars`);
-        }
-        return this.mutex.run(async () => {
-            try {
-                const params = this.buildParams(req);
-                const order = await this.exchange.createOrder(toCcxtSymbol('hyperliquid', req.symbol), req.type === 'market' ? 'market' : 'limit', req.side, req.amount, req.price, // ★ always passed — ccxt needs it even for 'market'
-                params);
-                noteSuccess('exchange', { ipWeight: exchangeIpWeight(1), addressActions: 1 });
-                return order ?? null;
-            }
-            catch (err) {
-                noteError(err, 'submitOrder');
-                // Order paths RETHROW (the caller must see a rejection) — unlike reads,
-                // which collapse to null.
-                throw err;
-            }
-        });
-    }
-    /** Submit N orders as ONE signed action (one nonce, one `/exchange` call).
-     *  This is how a bracket pair (SL+TP) is placed: atomic-ish, and it costs 1 IP
-     *  weight unit but N address actions. */
-    async submitOrders(reqs) {
-        if (reqs.length === 0)
-            return [];
-        for (const r of reqs) {
-            if (r.cloid && !isValidHlCloid(r.cloid)) {
-                throw new Error(`Invalid HL cloid ${r.cloid} — must be 0x + 32 hex chars`);
-            }
-        }
-        return this.mutex.run(async () => {
-            try {
-                const ccxtReqs = reqs.map((r) => ({
-                    symbol: toCcxtSymbol('hyperliquid', r.symbol),
-                    type: r.type === 'market' ? 'market' : 'limit',
-                    side: r.side,
-                    amount: r.amount,
-                    price: r.price,
-                    params: this.buildParams(r),
-                }));
-                const orders = await this.exchange.createOrders(ccxtReqs);
-                noteSuccess('exchange', {
-                    ipWeight: exchangeIpWeight(reqs.length),
-                    addressActions: reqs.length, // ★ batches cost n against the ADDRESS budget
-                });
-                return Array.isArray(orders) ? orders : null;
-            }
-            catch (err) {
-                noteError(err, 'submitOrders');
-                throw err;
-            }
-        });
-    }
-    async cancelOrder(orderId, symbol) {
-        return this.mutex.run(async () => {
-            try {
-                const res = await this.exchange.cancelOrder(orderId, toCcxtSymbol('hyperliquid', symbol));
-                noteSuccess('exchange', { ipWeight: exchangeIpWeight(1), addressActions: 1 });
-                return res ?? null;
-            }
-            catch (err) {
-                noteError(err, 'cancelOrder');
-                throw err;
-            }
-        });
-    }
-    /** Cancel by cloid — the bracket path's cancel (we always know our own cloid,
-     *  and it survives a restart because it is derived, not stored). */
-    async cancelOrderByCloid(cloid, symbol) {
-        return this.mutex.run(async () => {
-            try {
-                const res = await this.exchange.cancelOrder(cloid, toCcxtSymbol('hyperliquid', symbol), { clientOrderId: cloid });
-                noteSuccess('exchange', { ipWeight: exchangeIpWeight(1), addressActions: 1 });
-                return res ?? null;
-            }
-            catch (err) {
-                noteError(err, 'cancelOrderByCloid');
-                throw err;
-            }
-        });
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    buildParams(req) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const params = {};
-        if (req.reduceOnly)
-            params.reduceOnly = true;
-        if (req.postOnly)
-            params.postOnly = true; // → ALO
-        if (req.cloid)
-            params.clientOrderId = req.cloid;
-        if (req.trigger) {
-            // HL trigger orders fire on MARK price only (no workingType choice).
-            params.triggerPrice = req.trigger.triggerPrice;
-            if (req.trigger.tpsl === 'tp')
-                params.takeProfitPrice = req.trigger.triggerPrice;
-            else
-                params.stopLossPrice = req.trigger.triggerPrice;
-        }
-        return params;
-    }
-    get isMarketsLoaded() {
-        return this.marketsLoaded;
-    }
-}
-function msg(err) {
-    return err instanceof Error ? err.message : String(err);
-}