@reefclaw/connect 0.1.10 → 0.1.12

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

@@ -1,79 +0,0 @@
-import type { CcxtTicker, CcxtOHLCV } from '../../types.js';
-import type { OrderBookDepth } from '../../simulator/types.js';
-import type { PublicMarketDataApi } from '../../ccxt/public-market-data-api.js';
-export interface HyperliquidPublicApiOptions {
-    testnet?: boolean;
-    /** Test seam — injected ccxt exchange instance. */
-    exchange?: any;
-    fetchImpl?: typeof fetch;
-}
-export declare class HyperliquidPublicApi implements PublicMarketDataApi {
-    private exchange;
-    private readonly testnet;
-    private readonly fetchImpl;
-    private readonly tickerTtlMs;
-    /** One upstream fetchTickers call serves every symbol within the TTL. */
-    private tickersCache;
-    private tickersInflight;
-    /** Coin → mid from one weight-2 allMids call (fetchTicker's price source). */
-    private midsCache;
-    private midsInflight;
-    constructor(opts?: HyperliquidPublicApiOptions);
-    private baseUrl;
-    /** Canonical/ccxt symbol → this venue's ccxt symbol, or null (logged) when
-     *  the symbol isn't a Hyperliquid USDC perp — a caller bug we surface
-     *  loudly rather than silently translating quote assets. */
-    private venueSymbol;
-    /** Fetch-all-tickers with a short TTL + inflight dedup. Returns a map keyed
-     *  by ccxt symbol, or null on failure. */
-    private getTickers;
-    /** Coin → mid price from one weight-2 `allMids` call (TTL-cached, inflight-
-     *  deduped; docs: hyperliquid.gitbook.io → Info endpoint → "Retrieve mids
-     *  for all coins"). Null on ANY failure — callers fall back to the full
-     *  snapshot path. Spot entries (`@<idx>` keys) parse fine and are simply
-     *  never looked up (we key by perp coin name). */
-    private getMids;
-    /** Fire-and-forget full-snapshot refresh once it ages past
-     *  FULL_SNAPSHOT_REFRESH_MS — fetchTicker must never block on the heavy
-     *  fetchTickers call when a fresh mid is available. getTickers' own
-     *  inflight dedup + error handling make this safe to kick repeatedly. */
-    private maybeRefreshSnapshot;
-    fetchTickerRaw(symbol: string): Promise<Record<string, any> | null>;
-    /** Price from the weight-2 allMids fast path; volume/change context from
-     *  the last full snapshot (background-refreshed). Hyperliquid's asset
-     *  contexts carry mark/mid rather than a trade-tape bid/ask; absent fields
-     *  fall back to `last` with zero modeled spread — the paper fill engine
-     *  models slippage itself (same convention as IntelPublicApi). Falls back
-     *  to the original blocking full-snapshot path when allMids fails. */
-    fetchTicker(symbol: string): Promise<CcxtTicker | null>;
-    fetchFundingRate(symbol: string): Promise<Record<string, any> | null>;
-    fetchOpenInterest(symbol: string): Promise<Record<string, any> | null>;
-    /** l2Book — Hyperliquid serves at most 20 levels/side (plan §3.6). */
-    fetchOrderBook(symbol: string, limit?: number): Promise<OrderBookDepth | null>;
-    /** candleSnapshot — only the most recent 5000 candles exist per (coin,
-     *  interval) (plan §3.6); requests inside that window behave like Binance. */
-    fetchOHLCV(symbol: string, timeframe?: string, limit?: number): Promise<CcxtOHLCV[] | null>;
-    /** Probe Hyperliquid reachability from this host — the readiness gate's
-     *  venue signal, mirroring BinancePublicApi.probeReachability's outcome
-     *  shape. Hand-rolled POST /info `exchangeStatus` (weight 2) so the probe
-     *  has zero ccxt-method-shape dependence; the response's `time` field
-     *  (verified live 2026-07-11: `{"specialStatuses":null,"time":…}`) doubles
-     *  as the clock-drift source. Geo classification is best-effort — HL's
-     *  API-level geo behavior is UNVERIFIED (plan §3.9); a 403/451 maps to
-     *  geo_blocked, anything else non-2xx/network maps to unreachable. */
-    probeReachability(): Promise<{
-        outcome: 'reachable' | 'geo_blocked' | 'unreachable' | 'unknown';
-        driftMs: number | null;
-    }>;
-    /** `meta` — the asset universe (szDecimals, maxLeverage, positional assetIndex).
-     *  Keyless info read, weight 20. Feeds HyperliquidInfoCache. Returns null on any
-     *  failure (never a partial universe — a half-loaded rules table would silently
-     *  reject orders). */
-    fetchMeta(): Promise<any | null>;
-    /** ★ MARK price — the price HL trigger orders fire on (there is no workingType
-     *  choice on this venue). Stop-distance validation and every trigger MUST use
-     *  this, never `last`: the mark is a CEX-composite median that can diverge from
-     *  HL's own last trade. Sourced from `metaAndAssetCtxs` (one weight-20 call
-     *  covers every asset). Returns null on failure — never a stale guess. */
-    fetchMarkPrice(symbol: string): Promise<number | null>;
-}

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

@@ -1,429 +0,0 @@
-// Hyperliquid public market-data source (keyless) — Phase 1 of
-// docs/HYPERLIQUID_INTEGRATION_PLAN.md. Implements PublicMarketDataApi so
-// PAPER mode on venue='hyperliquid' prices the simulator, the stop-watcher,
-// and every market-data tool from Hyperliquid instead of Binance. Live
-// trading does NOT use this class (the Phase 3 adapter owns its own reads).
-//
-// Protocol facts (verified 2026-07-11, plan §3 + live probe):
-//   - REST is POST-only: /info on api.hyperliquid.xyz (testnet:
-//     api.hyperliquid-testnet.xyz). CCXT@4.5.37 wraps everything we need.
-//   - `exchangeStatus` (weight 2) returns `{specialStatuses, time}` — the
-//     reachability probe AND a clock-drift source in one call.
-//   - `allMids` (weight 2) returns the mid price for EVERY coin in one call —
-//     the docs' recommended price read (plan §3: ccxt fetchTicker is
-//     'emulated' — prefer allMids). fetchTicker serves its PRICE from one
-//     TTL-cached allMids call; volume/change context rides the last full
-//     fetchTickers snapshot, refreshed in the background at most every
-//     FULL_SNAPSHOT_REFRESH_MS. Why the split: ccxt@4.5.37's hyperliquid
-//     fetchTickers() literally calls fetchMarkets() — the full perp+spot
-//     meta/ctx pipeline — measured ~13s on the first HL soak box, which
-//     starved every 10s-timeout skill-poller call 100% of the time. allMids
-//     measured ~1.4s on the same box. The full address/IP rate gate is a
-//     Phase 3 concern (live cadences); paper-mode cadence here is bounded by
-//     the caches: ≤ (60s/TTL) weight-2 calls/min + ≤ weight-20 every 5 min.
-//   - CCXT auto-monetization landmine (plan §3.8): initializeClient() only
-//     fires on AUTHENTICATED clients, and this class is keyless — but we pin
-//     `builderFee:false, refSet:true` in options anyway so a future
-//     credentialed refactor can never silently enroll CCXT's builder fee or
-//     referral code. hl-public.test.ts asserts these options forever.
-//
-// Error contract mirrors BinancePublicApi/IntelPublicApi: null on ANY failure,
-// never throw to consumers. Binance-shaped symbols (…/USDT) are a caller bug
-// on this venue — logged clearly, null returned (never silently translated).
-import { createRequire } from 'node:module';
-import { logger } from '../../logger.js';
-import { toCcxtSymbol, toHyperliquidCoin } from '../symbols.js';
-const TAG = 'hl-public';
-// Load ccxt via CJS require — OpenClaw's ESM loader gives wrong module shape
-// (same pattern as binance-public.ts / binance-private.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');
-}
-/** Base URLs verified against the official docs + pinned ccxt source (plan §3.1). */
-const HL_MAINNET_API = 'https://api.hyperliquid.xyz';
-const HL_TESTNET_API = 'https://api.hyperliquid-testnet.xyz';
-const DEFAULT_TICKER_TTL_MS = 4_000;
-/** How stale the full fetchTickers snapshot (volume/change context) may get
- *  before fetchTicker kicks a background refresh. Deliberately long: the
- *  snapshot's ccxt call re-runs the whole fetchMarkets pipeline (weight ~60,
- *  ~13s on a slow host) and nothing price-critical reads these fields. */
-const FULL_SNAPSHOT_REFRESH_MS = 300_000;
-function resolveTickerTtlMs() {
-    const raw = Number(process.env.RC_HL_TICKER_TTL_MS);
-    if (!Number.isFinite(raw) || raw < 500)
-        return DEFAULT_TICKER_TTL_MS;
-    return raw;
-}
-export class HyperliquidPublicApi {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    exchange;
-    testnet;
-    fetchImpl;
-    tickerTtlMs = resolveTickerTtlMs();
-    /** One upstream fetchTickers call serves every symbol within the TTL. */
-    tickersCache = null;
-    tickersInflight = null;
-    /** Coin → mid from one weight-2 allMids call (fetchTicker's price source). */
-    midsCache = null;
-    midsInflight = null;
-    constructor(opts = {}) {
-        this.testnet = opts.testnet === true;
-        this.fetchImpl = opts.fetchImpl ?? fetch;
-        if (opts.exchange) {
-            this.exchange = opts.exchange;
-        }
-        else {
-            const HlClass = ccxtCjs.hyperliquid ?? ccxtCjs.default?.hyperliquid;
-            if (!HlClass) {
-                throw new Error('CCXT hyperliquid class not found — check ccxt version');
-            }
-            this.exchange = new HlClass({
-                enableRateLimit: true,
-                options: {
-                    // ★ Never let CCXT enroll its own builder fee / referral code —
-                    // plan §3.8. Keyless clients can't sign those actions anyway, but
-                    // the pin is deliberate defense-in-depth for future refactors.
-                    builderFee: false,
-                    refSet: true,
-                },
-            });
-            if (this.testnet) {
-                this.exchange.setSandboxMode(true);
-            }
-        }
-        logger.info(TAG, `Hyperliquid public API initialized (no auth${this.testnet ? ', TESTNET' : ''})`);
-    }
-    baseUrl() {
-        return this.testnet ? HL_TESTNET_API : HL_MAINNET_API;
-    }
-    /** Canonical/ccxt symbol → this venue's ccxt symbol, or null (logged) when
-     *  the symbol isn't a Hyperliquid USDC perp — a caller bug we surface
-     *  loudly rather than silently translating quote assets. */
-    venueSymbol(symbol, ctx) {
-        try {
-            return toCcxtSymbol('hyperliquid', symbol);
-        }
-        catch (err) {
-            logger.warn(TAG, `${ctx}(${symbol}) — not a Hyperliquid symbol (${err instanceof Error ? err.message : String(err)}); use USDC pairs like BTC/USDC`);
-            return null;
-        }
-    }
-    /** Fetch-all-tickers with a short TTL + inflight dedup. Returns a map keyed
-     *  by ccxt symbol, or null on failure. */
-    async getTickers() {
-        const now = Date.now();
-        if (this.tickersCache && now - this.tickersCache.at < this.tickerTtlMs) {
-            return this.tickersCache.bySymbol;
-        }
-        if (this.tickersInflight)
-            return this.tickersInflight;
-        this.tickersInflight = (async () => {
-            try {
-                const raw = await this.exchange.fetchTickers();
-                const bySymbol = new Map(Object.entries(raw ?? {}));
-                this.tickersCache = { at: Date.now(), bySymbol };
-                return bySymbol;
-            }
-            catch (err) {
-                logger.error(TAG, `fetchTickers failed: ${err instanceof Error ? err.message : String(err)}`);
-                return null;
-            }
-            finally {
-                this.tickersInflight = null;
-            }
-        })();
-        return this.tickersInflight;
-    }
-    /** Coin → mid price from one weight-2 `allMids` call (TTL-cached, inflight-
-     *  deduped; docs: hyperliquid.gitbook.io → Info endpoint → "Retrieve mids
-     *  for all coins"). Null on ANY failure — callers fall back to the full
-     *  snapshot path. Spot entries (`@<idx>` keys) parse fine and are simply
-     *  never looked up (we key by perp coin name). */
-    async getMids() {
-        const now = Date.now();
-        if (this.midsCache && now - this.midsCache.at < this.tickerTtlMs) {
-            return this.midsCache.byCoin;
-        }
-        if (this.midsInflight)
-            return this.midsInflight;
-        this.midsInflight = (async () => {
-            try {
-                const raw = await this.exchange.publicPostInfo({ type: 'allMids' });
-                const byCoin = new Map();
-                for (const [coin, mid] of Object.entries(raw ?? {})) {
-                    const n = Number(mid);
-                    if (Number.isFinite(n) && n > 0)
-                        byCoin.set(coin, n);
-                }
-                if (byCoin.size === 0) {
-                    logger.warn(TAG, 'allMids returned no parseable mids');
-                    return null;
-                }
-                this.midsCache = { at: Date.now(), byCoin };
-                return byCoin;
-            }
-            catch (err) {
-                logger.error(TAG, `allMids failed: ${err instanceof Error ? err.message : String(err)}`);
-                return null;
-            }
-            finally {
-                this.midsInflight = null;
-            }
-        })();
-        return this.midsInflight;
-    }
-    /** Fire-and-forget full-snapshot refresh once it ages past
-     *  FULL_SNAPSHOT_REFRESH_MS — fetchTicker must never block on the heavy
-     *  fetchTickers call when a fresh mid is available. getTickers' own
-     *  inflight dedup + error handling make this safe to kick repeatedly. */
-    maybeRefreshSnapshot() {
-        const at = this.tickersCache?.at ?? 0;
-        if (Date.now() - at < FULL_SNAPSHOT_REFRESH_MS)
-            return;
-        if (this.tickersInflight)
-            return;
-        void this.getTickers();
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async fetchTickerRaw(symbol) {
-        const vs = this.venueSymbol(symbol, 'fetchTickerRaw');
-        if (!vs)
-            return null;
-        const tickers = await this.getTickers();
-        return tickers?.get(vs) ?? null;
-    }
-    /** Price from the weight-2 allMids fast path; volume/change context from
-     *  the last full snapshot (background-refreshed). Hyperliquid's asset
-     *  contexts carry mark/mid rather than a trade-tape bid/ask; absent fields
-     *  fall back to `last` with zero modeled spread — the paper fill engine
-     *  models slippage itself (same convention as IntelPublicApi). Falls back
-     *  to the original blocking full-snapshot path when allMids fails. */
-    async fetchTicker(symbol) {
-        const vs = this.venueSymbol(symbol, 'fetchTicker');
-        if (!vs)
-            return null;
-        const coin = toHyperliquidCoin(symbol);
-        const mids = await this.getMids();
-        const mid = mids?.get(coin);
-        if (mid !== undefined) {
-            this.maybeRefreshSnapshot();
-            const base = this.tickersCache?.bySymbol.get(vs);
-            const timestamp = this.midsCache?.at ?? Date.now();
-            return {
-                symbol,
-                last: mid,
-                bid: mid,
-                ask: mid,
-                baseVolume: Number(base?.baseVolume ?? 0) || 0,
-                quoteVolume: Number(base?.quoteVolume ?? 0) || 0,
-                change: Number(base?.change ?? 0) || 0,
-                percentage: Number(base?.percentage ?? 0) || 0,
-                timestamp,
-                datetime: new Date(timestamp).toISOString(),
-            };
-        }
-        const tickers = await this.getTickers();
-        const raw = tickers?.get(vs);
-        if (!raw) {
-            if (tickers)
-                logger.warn(TAG, `fetchTicker(${symbol}) — ${vs} not in Hyperliquid universe`);
-            return null;
-        }
-        const last = Number(raw.last ?? raw.close ?? raw.markPrice ?? NaN);
-        if (!Number.isFinite(last) || last <= 0) {
-            logger.warn(TAG, `fetchTicker(${symbol}) — no usable price on ticker`);
-            return null;
-        }
-        const timestamp = Number.isFinite(raw.timestamp) ? Number(raw.timestamp) : Date.now();
-        return {
-            // Key on the symbol the CALLER used so per-symbol maps line up.
-            symbol,
-            last,
-            bid: Number(raw.bid ?? NaN) > 0 ? Number(raw.bid) : last,
-            ask: Number(raw.ask ?? NaN) > 0 ? Number(raw.ask) : last,
-            baseVolume: Number(raw.baseVolume ?? 0) || 0,
-            quoteVolume: Number(raw.quoteVolume ?? 0) || 0,
-            change: Number(raw.change ?? 0) || 0,
-            percentage: Number(raw.percentage ?? 0) || 0,
-            timestamp,
-            datetime: raw.datetime ?? new Date(timestamp).toISOString(),
-        };
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async fetchFundingRate(symbol) {
-        const vs = this.venueSymbol(symbol, 'fetchFundingRate');
-        if (!vs)
-            return null;
-        try {
-            const r = await this.exchange.fetchFundingRate(vs);
-            return r ?? null;
-        }
-        catch (err) {
-            logger.error(TAG, `fetchFundingRate(${symbol}) failed: ${err instanceof Error ? err.message : String(err)}`);
-            return null;
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async fetchOpenInterest(symbol) {
-        const vs = this.venueSymbol(symbol, 'fetchOpenInterest');
-        if (!vs)
-            return null;
-        try {
-            const r = await this.exchange.fetchOpenInterest(vs);
-            return r ?? null;
-        }
-        catch (err) {
-            logger.error(TAG, `fetchOpenInterest(${symbol}) failed: ${err instanceof Error ? err.message : String(err)}`);
-            return null;
-        }
-    }
-    /** l2Book — Hyperliquid serves at most 20 levels/side (plan §3.6). */
-    async fetchOrderBook(symbol, limit = 20) {
-        const vs = this.venueSymbol(symbol, 'fetchOrderBook');
-        if (!vs)
-            return null;
-        try {
-            const raw = await this.exchange.fetchOrderBook(vs, Math.min(limit, 20));
-            return {
-                bids: (raw.bids ?? []).map((l) => [l[0], l[1]]),
-                asks: (raw.asks ?? []).map((l) => [l[0], l[1]]),
-                timestamp: raw.timestamp ?? Date.now(),
-            };
-        }
-        catch (err) {
-            logger.error(TAG, `fetchOrderBook(${symbol}) failed: ${err instanceof Error ? err.message : String(err)}`);
-            return null;
-        }
-    }
-    /** candleSnapshot — only the most recent 5000 candles exist per (coin,
-     *  interval) (plan §3.6); requests inside that window behave like Binance. */
-    async fetchOHLCV(symbol, timeframe = '1h', limit = 100) {
-        const vs = this.venueSymbol(symbol, 'fetchOHLCV');
-        if (!vs)
-            return null;
-        try {
-            const raw = await this.exchange.fetchOHLCV(vs, timeframe, undefined, limit);
-            const valid = [];
-            for (const candle of raw) {
-                if (candle.length >= 6 &&
-                    typeof candle[0] === 'number' &&
-                    typeof candle[1] === 'number' &&
-                    typeof candle[2] === 'number' &&
-                    typeof candle[3] === 'number' &&
-                    typeof candle[4] === 'number' &&
-                    typeof candle[5] === 'number') {
-                    valid.push(candle);
-                }
-            }
-            return valid;
-        }
-        catch (err) {
-            logger.error(TAG, `fetchOHLCV(${symbol}, ${timeframe}) failed: ${err instanceof Error ? err.message : String(err)}`);
-            return null;
-        }
-    }
-    /** Probe Hyperliquid reachability from this host — the readiness gate's
-     *  venue signal, mirroring BinancePublicApi.probeReachability's outcome
-     *  shape. Hand-rolled POST /info `exchangeStatus` (weight 2) so the probe
-     *  has zero ccxt-method-shape dependence; the response's `time` field
-     *  (verified live 2026-07-11: `{"specialStatuses":null,"time":…}`) doubles
-     *  as the clock-drift source. Geo classification is best-effort — HL's
-     *  API-level geo behavior is UNVERIFIED (plan §3.9); a 403/451 maps to
-     *  geo_blocked, anything else non-2xx/network maps to unreachable. */
-    async probeReachability() {
-        const ac = new AbortController();
-        const tid = setTimeout(() => ac.abort(), 10_000);
-        try {
-            const res = await this.fetchImpl(`${this.baseUrl()}/info`, {
-                method: 'POST',
-                headers: { 'content-type': 'application/json' },
-                body: JSON.stringify({ type: 'exchangeStatus' }),
-                signal: ac.signal,
-            });
-            if (res.status === 451 || res.status === 403) {
-                logger.warn(TAG, `probeReachability: HTTP ${res.status} (geo/policy block)`);
-                return { outcome: 'geo_blocked', driftMs: null };
-            }
-            if (res.status < 200 || res.status >= 300) {
-                logger.warn(TAG, `probeReachability: HTTP ${res.status}`);
-                return { outcome: 'unreachable', driftMs: null };
-            }
-            const body = (await res.json());
-            const serverTime = Number(body?.time);
-            const driftMs = Number.isFinite(serverTime) ? serverTime - Date.now() : null;
-            return { outcome: 'reachable', driftMs };
-        }
-        catch (err) {
-            logger.warn(TAG, `probeReachability failed: ${err instanceof Error ? err.message : String(err)}`);
-            return { outcome: 'unreachable', driftMs: null };
-        }
-        finally {
-            clearTimeout(tid);
-        }
-    }
-    /** `meta` — the asset universe (szDecimals, maxLeverage, positional assetIndex).
-     *  Keyless info read, weight 20. Feeds HyperliquidInfoCache. Returns null on any
-     *  failure (never a partial universe — a half-loaded rules table would silently
-     *  reject orders). */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async fetchMeta() {
-        try {
-            const res = await this.fetchImpl(`${this.baseUrl()}/info`, {
-                method: 'POST',
-                headers: { 'content-type': 'application/json' },
-                body: JSON.stringify({ type: 'meta' }),
-                signal: AbortSignal.timeout(15_000),
-            });
-            if (!res.ok) {
-                logger.warn(TAG, `fetchMeta: HTTP ${res.status}`);
-                return null;
-            }
-            return await res.json();
-        }
-        catch (err) {
-            logger.warn(TAG, `fetchMeta failed: ${err instanceof Error ? err.message : String(err)}`);
-            return null;
-        }
-    }
-    /** ★ MARK price — the price HL trigger orders fire on (there is no workingType
-     *  choice on this venue). Stop-distance validation and every trigger MUST use
-     *  this, never `last`: the mark is a CEX-composite median that can diverge from
-     *  HL's own last trade. Sourced from `metaAndAssetCtxs` (one weight-20 call
-     *  covers every asset). Returns null on failure — never a stale guess. */
-    async fetchMarkPrice(symbol) {
-        try {
-            const res = await this.fetchImpl(`${this.baseUrl()}/info`, {
-                method: 'POST',
-                headers: { 'content-type': 'application/json' },
-                body: JSON.stringify({ type: 'metaAndAssetCtxs' }),
-                signal: AbortSignal.timeout(15_000),
-            });
-            if (!res.ok) {
-                logger.warn(TAG, `fetchMarkPrice: HTTP ${res.status}`);
-                return null;
-            }
-            const body = (await res.json());
-            const universe = body?.[0]?.universe ?? [];
-            const ctxs = body?.[1] ?? [];
-            const coin = toHyperliquidCoin(symbol);
-            const idx = universe.findIndex((u) => u?.name === coin);
-            if (idx < 0) {
-                logger.warn(TAG, `fetchMarkPrice: ${coin} not in meta.universe`);
-                return null;
-            }
-            const mark = Number(ctxs[idx]?.markPx);
-            return Number.isFinite(mark) && mark > 0 ? mark : null;
-        }
-        catch (err) {
-            logger.warn(TAG, `fetchMarkPrice failed: ${err instanceof Error ? err.message : String(err)}`);
-            return null;
-        }
-    }
-}

package/assets/plugin/venues/hyperliquid/hl-rate-gate.d.ts

@@ -1,57 +0,0 @@
-/** Info-request weights, from the docs (§3.3). Anything unlisted defaults to 20 —
- *  the conservative side. `/exchange` actions are `1 + floor(batch/40)`. */
-export declare const HL_INFO_WEIGHTS: Record<string, number>;
-export declare class HyperliquidRateLimitedError extends Error {
-    constructor(message: string);
-}
-/** Thrown by the proactive pacer BEFORE a call goes out. Subclass so every
- *  existing `catch (HyperliquidRateLimitedError)` absorbs it — the same
- *  relationship `BinanceWeightPacedError` has to `BinanceBannedError`. */
-export declare class HyperliquidPacedError extends HyperliquidRateLimitedError {
-    constructor(message: string);
-}
-/** Current 60s IP-weight estimate. */
-export declare function currentIpWeight(now?: number): number;
-/** Weight for an info context (defaults to the conservative 20). */
-export declare function infoWeight(ctx: string): number;
-/** `/exchange` IP weight for a batch of n actions: 1 + floor(n/40). */
-export declare function exchangeIpWeight(batchLen: number): number;
-/** FIRST LINE of every gated read's try-block.
- *
- *  Throws when:
- *   - a 429 backoff is active (hard stop — like an active Binance ban), or
- *   - the IP weight window is over its soft ceiling (proactive pacing), or
- *   - the address budget is below the floor AND this context is shed-able.
- *
- *  Order/cancel/close paths must NOT call this — they arm the gate via
- *  `noteError` only, so a limit can never block an exit. */
-export declare function assertNotLimited(ctx: string): void;
-/** Record a successful call's cost. `addressActions` is 0 for pure info reads
- *  (they cost IP weight only) and n for an `/exchange` batch of n actions. */
-export declare function noteSuccess(ctx: string, cost?: {
-    ipWeight?: number;
-    addressActions?: number;
-}): void;
-/** Arm the gate from a caught error. Called in EVERY catch — including on the
- *  order/cancel paths that are never pre-gated (so a burst of rejects still
- *  backs the gate off). */
-export declare function noteError(err: unknown, ctx?: string): void;
-/** HL surfaces rate limiting as HTTP 429 and/or a text body; match on shape, not
- *  on a venue flag, so the skill-side breaker can reuse this predicate. */
-export declare function isRateLimitError(err: unknown): boolean;
-/** Feed the address budget from info `userRateLimit` (`nRequestsCap −
- *  nRequestsUsed`). Poll it every ~5 min — it costs weight 20. */
-export declare function updateAddressBudget(args: {
-    nRequestsUsed: number;
-    nRequestsCap: number;
-}): void;
-/** Snapshot for tests + the readiness/diagnostic surfaces. */
-export declare function getGateState(): {
-    ipWeight60s: number;
-    weightCeiling: number;
-    addressRemaining?: number;
-    limited: boolean;
-    limitedForMs: number;
-};
-/** Test-only reset. */
-export declare function __resetGateForTests(): void;