@123456btc/123456btc-cli 1.0.5 → 1.0.7

package/dist/exchange/v2/adapters/hyperliquid.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Hyperliquid Exchange Adapter — Institutional v2
+ * Supports: USDC perpetuals (all markets are cross-margin)
+ * Auth: EIP-712 secp256k1 signing (NOT HMAC)
+ * Note: Hyperliquid uses a custom signing scheme compatible with Ethereum wallets.
+ *       Because Cloudflare Workers does not have Node.js `crypto` or `ethers.js` natively,
+ *       we expose a `signerFn` hook — callers provide their own signing function.
+ *       A default `rawPrivateKeySignerFactory` is provided for environments that
+ *       support SubtleCrypto P-256 as a proxy (see caveat below).
+ *
+ * IMPORTANT: For production use with real private keys, inject a signer via
+ *   `HyperliquidAdapter.signerFn` that calls an ethers.js / viem signer,
+ *   or use the Hyperliquid Agent wallet pattern.
+ */
+import { BaseExchangeAdapter } from './base';
+import type { ExchangeId, MarketType, TickerInfo, SymbolInfo, OHLCVBar, OrderBook, FundingInfo, AccountSnapshot, PositionInfo, OrderResponse, RawOrderParams, ExchangeCredentials } from '../types';
+interface HlOrderWire {
+    a: number;
+    b: boolean;
+    p: string;
+    s: string;
+    r: boolean;
+    t: {
+        limit?: {
+            tif: string;
+        };
+    } | {
+        trigger?: {
+            isMarket: boolean;
+            tpsl: string;
+            triggerPx: string;
+        };
+    };
+    c: string;
+}
+interface HlAction {
+    type: string;
+    orders?: HlOrderWire[];
+    cancels?: Array<{
+        a: number;
+        o: number;
+    }>;
+    [key: string]: unknown;
+}
+/**
+ * Signer function type — accepts the EIP-712 action hash payload and returns
+ * { r, s, v } as a hex signature string (65 bytes = 130 hex chars).
+ * Callers must inject this in environments where secp256k1 is available.
+ */
+export type HyperliquidSignerFn = (action: HlAction, nonce: number, vaultAddress?: string) => Promise<string>;
+export declare class HyperliquidAdapter extends BaseExchangeAdapter {
+    readonly exchangeId: ExchangeId;
+    private readonly walletAddress;
+    private readonly signerFn;
+    /** Asset name → index cache (populated on first use) */
+    private assetCache;
+    private assetInfoCache;
+    constructor(creds: ExchangeCredentials, 
+    /** Inject your signer here. See HyperliquidSignerFn. */
+    signerFn?: HyperliquidSignerFn);
+    /**
+     * Fallback signer: uses HMAC-SHA256 as a PLACEHOLDER.
+     * This will NOT be accepted by Hyperliquid for real orders.
+     * Replace with a real EIP-712 secp256k1 signer in production.
+     */
+    private fallbackSigner;
+    private hlInfo;
+    private hlExchange;
+    private ensureAssetCache;
+    private getAssetIndex;
+    private normalizeCoin;
+    /** Format Hyperliquid coin to unified symbol. */
+    private formatHlSymbol;
+    /** Map Hyperliquid raw status to unified OrderStatus. */
+    private mapHlStatus;
+    /** Map Hyperliquid open-order / historical-order item to OrderResponse. */
+    private mapHlOrderResponse;
+    /** Map Hyperliquid fill to unified Fill. */
+    private mapHlFillResponse;
+    /** Format price for Hyperliquid wire. HL uses 6 decimals for most assets. */
+    private formatHlPrice;
+    /** Format size for Hyperliquid wire based on asset szDecimals. */
+    private formatHlSize;
+    getTicker(symbol: string): Promise<TickerInfo>;
+    getSymbolInfo(symbol: string): Promise<SymbolInfo>;
+    getOHLCV(symbol: string, timeframe: string, limit?: number): Promise<OHLCVBar[]>;
+    getOrderBook(symbol: string, _depth?: number): Promise<OrderBook>;
+    getFundingInfo(symbol: string): Promise<FundingInfo | null>;
+    listSymbols(_marketType: MarketType): Promise<string[]>;
+    getAccount(): Promise<AccountSnapshot>;
+    getPositions(symbol?: string): Promise<PositionInfo[]>;
+    setLeverage(symbol: string, leverage: number, marginMode?: 'cross' | 'isolated'): Promise<void>;
+    placeOrder(params: RawOrderParams): Promise<OrderResponse>;
+    cancelOrder(orderId: string, symbol: string): Promise<boolean>;
+    cancelAllOrders(_request?: import('../types').CancelAllOrdersRequest): Promise<boolean>;
+    getOrderStatus(orderId: string, symbol: string): Promise<OrderResponse>;
+    getOpenOrders(symbol?: string): Promise<OrderResponse[]>;
+    getOrderHistory(_query: import('../types').OrderHistoryQuery): Promise<import('../types').OrderHistoryResponse>;
+    getFills(query: import('../types').TradeHistoryQuery): Promise<import('../types').TradeHistoryResponse>;
+}
+export {};
+//# sourceMappingURL=hyperliquid.d.ts.map

package/dist/exchange/v2/adapters/hyperliquid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hyperliquid.d.ts","sourceRoot":"","sources":["../../../../src/exchange/v2/adapters/hyperliquid.ts"],"names":[],"mappings":"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"}

package/dist/exchange/v2/adapters/hyperliquid.js

@@ -0,0 +1,536 @@
+"use strict";
+/**
+ * Hyperliquid Exchange Adapter — Institutional v2
+ * Supports: USDC perpetuals (all markets are cross-margin)
+ * Auth: EIP-712 secp256k1 signing (NOT HMAC)
+ * Note: Hyperliquid uses a custom signing scheme compatible with Ethereum wallets.
+ *       Because Cloudflare Workers does not have Node.js `crypto` or `ethers.js` natively,
+ *       we expose a `signerFn` hook — callers provide their own signing function.
+ *       A default `rawPrivateKeySignerFactory` is provided for environments that
+ *       support SubtleCrypto P-256 as a proxy (see caveat below).
+ *
+ * IMPORTANT: For production use with real private keys, inject a signer via
+ *   `HyperliquidAdapter.signerFn` that calls an ethers.js / viem signer,
+ *   or use the Hyperliquid Agent wallet pattern.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperliquidAdapter = void 0;
+const base_1 = require("./base");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const HL_BASE = 'https://api.hyperliquid.xyz';
+const HL_TESTNET = 'https://api.hyperliquid-testnet.xyz';
+// ─── Adapter ──────────────────────────────────────────────────────────────
+class HyperliquidAdapter extends base_1.BaseExchangeAdapter {
+    exchangeId = 'hyperliquid';
+    walletAddress;
+    signerFn;
+    /** Asset name → index cache (populated on first use) */
+    assetCache = new Map();
+    assetInfoCache = new Map();
+    constructor(creds, 
+    /** Inject your signer here. See HyperliquidSignerFn. */
+    signerFn) {
+        super({
+            credentials: creds,
+            baseUrl: creds.testnet ? HL_TESTNET : HL_BASE,
+        });
+        // walletAddress = apiKey field (0x... Ethereum address)
+        this.walletAddress = (creds.apiKey ?? '').trim();
+        this.signerFn = signerFn ?? this.fallbackSigner.bind(this);
+    }
+    // ─── Signer ───────────────────────────────────────────────────────────────
+    /**
+     * Fallback signer: uses HMAC-SHA256 as a PLACEHOLDER.
+     * This will NOT be accepted by Hyperliquid for real orders.
+     * Replace with a real EIP-712 secp256k1 signer in production.
+     */
+    async fallbackSigner(action, nonce) {
+        // Build the EIP-712 phantom agent hash (Hyperliquid-specific)
+        const enc = new TextEncoder();
+        const payload = JSON.stringify({ action, nonce, vaultAddress: null });
+        const secret = this.creds.privateKey?.startsWith('0x')
+            ? this.creds.privateKey.slice(2)
+            : this.creds.privateKey ?? this.creds.apiSecret ?? '';
+        // Decode hex key
+        const keyBytes = secret.match(/.{1,2}/g)?.map(b => parseInt(b, 16));
+        if (!keyBytes || keyBytes.length < 32) {
+            throw new base_1.ExchangeError('Hyperliquid requires a valid 32-byte secp256k1 private key. ' +
+                'Please inject a real EIP-712 signer via the signerFn parameter.', 'hyperliquid');
+        }
+        const key = await crypto.subtle.importKey('raw', new Uint8Array(keyBytes), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+        const sig = await crypto.subtle.sign('HMAC', key, enc.encode(payload));
+        const hex = Array.from(new Uint8Array(sig)).map(b => b.toString(16).padStart(2, '0')).join('');
+        // Return as 65-byte placeholder (will fail on HL — this is intentional)
+        return `0x${hex.padEnd(130, '0')}`;
+    }
+    // ─── HTTP ─────────────────────────────────────────────────────────────────
+    async hlInfo(body) {
+        const res = await fetch(`${this.baseUrl}/info`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        const text = await res.text();
+        let json;
+        try {
+            json = JSON.parse(text);
+        }
+        catch {
+            json = text;
+        }
+        if (!res.ok || json?.status === 'err') {
+            throw new base_1.ExchangeError(JSON.stringify(json), 'hyperliquid');
+        }
+        return json;
+    }
+    async hlExchange(action) {
+        const nonce = Date.now();
+        const signature = await this.signerFn(action, nonce);
+        const res = await fetch(`${this.baseUrl}/exchange`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ action, nonce, signature }),
+        });
+        const text = await res.text();
+        let json;
+        try {
+            json = JSON.parse(text);
+        }
+        catch {
+            json = text;
+        }
+        if (!res.ok)
+            throw new base_1.ExchangeError(JSON.stringify(json), 'hyperliquid');
+        const r = json;
+        if (r.status === 'err')
+            throw new base_1.ExchangeError(JSON.stringify(json), 'hyperliquid');
+        return json;
+    }
+    // ─── Asset Registry ───────────────────────────────────────────────────────
+    async ensureAssetCache() {
+        if (this.assetCache.size > 0)
+            return;
+        const meta = await this.hlInfo({ type: 'meta' });
+        const universe = meta[0]?.universe ?? [];
+        universe.forEach((asset, idx) => {
+            this.assetCache.set(asset.name, idx);
+            this.assetCache.set(`${asset.name}-USDC`, idx);
+            this.assetCache.set(`${asset.name}USDT`, idx);
+            this.assetInfoCache.set(asset.name, { szDecimals: asset.szDecimals, maxLeverage: asset.maxLeverage });
+        });
+    }
+    async getAssetIndex(symbol) {
+        await this.ensureAssetCache();
+        const coin = symbol.replace(/[-/](USDC|USDT|USD|PERP)$/i, '');
+        const idx = this.assetCache.get(symbol) ?? this.assetCache.get(coin);
+        if (idx === undefined)
+            throw new base_1.ExchangeError(`Unknown symbol: ${symbol}`, 'hyperliquid');
+        return idx;
+    }
+    normalizeCoin(symbol) {
+        return symbol.replace(/[-/](USDC|USDT|USD|PERP)$/i, '');
+    }
+    /** Format Hyperliquid coin to unified symbol. */
+    formatHlSymbol(coin) {
+        if (coin.includes('/'))
+            return coin;
+        if (coin.startsWith('@'))
+            return coin;
+        return `${coin}-USDC`;
+    }
+    /** Map Hyperliquid raw status to unified OrderStatus. */
+    mapHlStatus(raw) {
+        const m = {
+            filled: 'filled',
+            canceled: 'cancelled',
+            open: 'open',
+            iocCancelRejected: 'rejected',
+            positionIncreaseAtOpenInterestCapRejected: 'rejected',
+            selfTradeCanceled: 'cancelled',
+        };
+        return m[raw] ?? this.normaliseStatus(raw);
+    }
+    /** Map Hyperliquid open-order / historical-order item to OrderResponse. */
+    mapHlOrderResponse(order, status, statusTimestamp) {
+        const origQty = parseFloat(order.origSz ?? order.sz ?? '0');
+        const remainingQty = parseFloat(order.sz ?? '0');
+        const filledQty = Math.max(0, origQty - remainingQty);
+        const price = parseFloat(order.limitPx ?? '0');
+        return {
+            orderId: String(order.oid),
+            clientOrderId: order.cloid ?? undefined,
+            symbol: this.formatHlSymbol(order.coin),
+            side: (order.side === 'B' ? 'buy' : 'sell'),
+            type: (order.orderType?.toLowerCase() ?? 'limit'),
+            quantity: origQty,
+            price: price > 0 ? price : undefined,
+            status: status ? this.mapHlStatus(status) : 'open',
+            filledQuantity: filledQty,
+            createdAt: order.timestamp,
+            updatedAt: statusTimestamp,
+            raw: { order, status, statusTimestamp },
+        };
+    }
+    /** Map Hyperliquid fill to unified Fill. */
+    mapHlFillResponse(f) {
+        return {
+            fillId: String(f.tid ?? ''),
+            orderId: String(f.oid ?? ''),
+            symbol: this.formatHlSymbol(f.coin),
+            side: (f.side === 'B' ? 'buy' : 'sell'),
+            quantity: parseFloat(f.sz ?? '0'),
+            price: parseFloat(f.px ?? '0'),
+            fee: parseFloat(f.fee ?? '0'),
+            feeCurrency: f.feeToken ?? 'USDC',
+            liquidity: f.crossed ? 'taker' : 'maker',
+            timestamp: typeof f.time === 'number' ? f.time : parseInt(`${f.time ?? Date.now()}`),
+            raw: f,
+        };
+    }
+    /** Format price for Hyperliquid wire. HL uses 6 decimals for most assets. */
+    formatHlPrice(price, symbol) {
+        // Try to infer price precision from szDecimals (price szDecimals relationship is not direct,
+        // but szDecimals gives us a lower bound on precision). Fallback to 6 decimals.
+        const coin = this.normalizeCoin(symbol);
+        const info = this.assetInfoCache.get(coin);
+        // szDecimals typically ranges 0-8; price precision is often max(6, 8 - szDecimals) on HL
+        const priceDecimals = info ? Math.max(6, 8 - info.szDecimals) : 6;
+        return price.toFixed(priceDecimals);
+    }
+    /** Format size for Hyperliquid wire based on asset szDecimals. */
+    formatHlSize(size, symbol) {
+        const coin = this.normalizeCoin(symbol);
+        const info = this.assetInfoCache.get(coin);
+        const decimals = info?.szDecimals ?? 6;
+        return size.toFixed(decimals);
+    }
+    // ─── Market Data ─────────────────────────────────────────────────────────
+    async getTicker(symbol) {
+        const coin = this.normalizeCoin(symbol);
+        const [metaAndCtxs, l2] = await Promise.all([
+            this.hlInfo({ type: 'metaAndAssetCtxs' }),
+            this.hlInfo({ type: 'l2Book', coin }),
+        ]);
+        const ctxs = metaAndCtxs[1] ?? [];
+        await this.ensureAssetCache();
+        const idx = this.assetCache.get(coin) ?? 0;
+        const ctx = ctxs[idx] ?? {};
+        const markPrice = +new decimal_js_1.default(String((ctx.markPx ?? ctx.oraclePx ?? '0') || '0'));
+        const levels = l2.levels ?? [[], []];
+        const bid = levels[0]?.[0] ? +new decimal_js_1.default(String(levels[0][0][0] || '0')) : markPrice * 0.999;
+        const ask = levels[1]?.[0] ? +new decimal_js_1.default(String(levels[1][0][0] || '0')) : markPrice * 1.001;
+        return {
+            symbol, bid, ask, last: markPrice,
+            volume24h: parseFloat(ctx.dayNtlVlm ?? '0'),
+            openInterest: parseFloat(ctx.openInterest ?? '0'),
+            markPrice, fundingRate: parseFloat(ctx.funding ?? '0'),
+        };
+    }
+    async getSymbolInfo(symbol) {
+        await this.ensureAssetCache();
+        const coin = this.normalizeCoin(symbol);
+        const info = this.assetInfoCache.get(coin);
+        const stepSize = info ? Math.pow(10, -info.szDecimals) : 0.001;
+        return {
+            symbol, base: coin, quote: 'USDC', marketType: 'swap',
+            minQty: stepSize, maxQty: 999999999, stepSize, tickSize: 0.01,
+            minNotional: 10, maxLeverage: info?.maxLeverage ?? 50,
+            settleCurrency: 'USDC',
+        };
+    }
+    async getOHLCV(symbol, timeframe, limit = 100) {
+        const coin = this.normalizeCoin(symbol);
+        const intervalMap = {
+            '1m': '1m', '3m': '3m', '5m': '5m', '15m': '15m', '30m': '30m',
+            '1h': '1h', '2h': '2h', '4h': '4h', '8h': '8h', '1d': '1d',
+        };
+        const interval = intervalMap[timeframe] ?? '1h';
+        const endTime = Date.now();
+        const intervalMs = {
+            '1m': 60_000, '3m': 180_000, '5m': 300_000, '15m': 900_000, '30m': 1_800_000,
+            '1h': 3_600_000, '2h': 7_200_000, '4h': 14_400_000, '8h': 28_800_000, '1d': 86_400_000,
+        };
+        const startTime = endTime - (intervalMs[interval] ?? 3_600_000) * limit;
+        const data = await this.hlInfo({ type: 'candleSnapshot', req: { coin, interval, startTime, endTime } });
+        return (data ?? []).map(c => ({
+            timestamp: c.t, open: parseFloat(c.o), high: parseFloat(c.h),
+            low: parseFloat(c.l), close: parseFloat(c.c), volume: parseFloat(c.v),
+        }));
+    }
+    async getOrderBook(symbol, _depth = 20) {
+        const coin = this.normalizeCoin(symbol);
+        const data = await this.hlInfo({ type: 'l2Book', coin });
+        const levels = data.levels ?? [[], []];
+        return {
+            symbol,
+            bids: (levels[0] ?? []).map(([p, q]) => ({ price: parseFloat(p), quantity: parseFloat(q) })),
+            asks: (levels[1] ?? []).map(([p, q]) => ({ price: parseFloat(p), quantity: parseFloat(q) })),
+            timestamp: Date.now(),
+        };
+    }
+    async getFundingInfo(symbol) {
+        const coin = this.normalizeCoin(symbol);
+        try {
+            const [metaCtxs, hist] = await Promise.all([
+                this.hlInfo({ type: 'metaAndAssetCtxs' }),
+                this.hlInfo({
+                    type: 'fundingHistory', coin,
+                    startTime: Date.now() - 7 * 24 * 60 * 60 * 1000, endTime: Date.now(),
+                }),
+            ]);
+            await this.ensureAssetCache();
+            const idx = this.assetCache.get(coin) ?? 0;
+            const ctx = metaCtxs[1]?.[idx] ?? {};
+            return {
+                symbol, fundingRate: parseFloat(ctx.funding ?? '0'),
+                nextFundingTime: 0, openInterest: parseFloat(ctx.openInterest ?? '0'),
+                historyRates: (hist ?? []).slice(-7).map(h => ({
+                    rate: parseFloat(h.fundingRate ?? '0'), timestamp: parseInt(h.time ?? '0'),
+                })),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async listSymbols(_marketType) {
+        const meta = await this.hlInfo({ type: 'meta' });
+        return (meta[0]?.universe ?? []).map(u => `${u.name}-USDC`);
+    }
+    // ─── Account ─────────────────────────────────────────────────────────────
+    async getAccount() {
+        if (!this.walletAddress)
+            throw new base_1.ExchangeError('Wallet address required', 'hyperliquid');
+        const data = await this.hlInfo({ type: 'clearinghouseState', user: this.walletAddress });
+        const ms = data.marginSummary ?? {};
+        const accountValue = +new decimal_js_1.default(String(ms.accountValue ?? '0'));
+        const withdrawable = +new decimal_js_1.default(String(data.withdrawable ?? '0'));
+        return {
+            balances: [{
+                    asset: 'USDC', free: withdrawable,
+                    locked: Math.max(0, accountValue - withdrawable), total: accountValue,
+                }],
+            totalEquity: accountValue,
+            availableMargin: withdrawable,
+            unrealizedPnl: parseFloat(ms.totalUnrealizedPnl ?? ms.totalRawUpl ?? '0'),
+        };
+    }
+    async getPositions(symbol) {
+        if (!this.walletAddress)
+            return [];
+        const data = await this.hlInfo({ type: 'clearinghouseState', user: this.walletAddress });
+        return (data.assetPositions ?? [])
+            .map(item => item.position)
+            .filter(p => {
+            const size = +new decimal_js_1.default(String(p.szi ?? '0'));
+            if (size === 0)
+                return false;
+            if (symbol) {
+                const coin = this.normalizeCoin(symbol);
+                return p.coin === coin || p.coin === symbol;
+            }
+            return true;
+        })
+            .map(p => {
+            const size = +new decimal_js_1.default(String(p.szi ?? '0'));
+            const entry = +new decimal_js_1.default(String(p.entryPx ?? '0'));
+            const mark = +new decimal_js_1.default(String(p.markPx ?? entry));
+            return {
+                symbol: this.formatHlSymbol(p.coin), side: size > 0 ? 'long' : 'short',
+                size: Math.abs(size), entryPrice: entry, markPrice: mark,
+                notional: Math.abs(size) * mark,
+                leverage: parseFloat((p.leverage && typeof p.leverage === 'object' ? p.leverage.value : p.leverage) ?? '1'),
+                marginMode: 'cross',
+                unrealizedPnl: parseFloat(p.unrealizedPnl ?? '0'),
+                liquidationPrice: p.liquidationPx ? parseFloat(p.liquidationPx) : undefined,
+                margin: parseFloat(p.marginUsed ?? '0'),
+                openedAt: Date.now(),
+            };
+        });
+    }
+    // ─── Leverage ────────────────────────────────────────────────────────────
+    async setLeverage(symbol, leverage, marginMode = 'cross') {
+        const assetIdx = await this.getAssetIndex(symbol);
+        await this.hlExchange({
+            type: 'updateLeverage',
+            asset: assetIdx,
+            isCross: marginMode === 'cross',
+            leverage,
+        });
+    }
+    // ─── Order Placement ──────────────────────────────────────────────────────
+    async placeOrder(params) {
+        const assetIdx = await this.getAssetIndex(params.symbol);
+        const isBuy = params.side === 'buy';
+        const clientOid = params.clientOrderId ?? (0, base_1.genClientOrderId)('hl');
+        // Convert clientOrderId to 16-byte hex cloid
+        const cloid = '0x' + Array.from(new TextEncoder().encode(clientOid.padEnd(16, '0').slice(0, 16)))
+            .map(b => b.toString(16).padStart(2, '0')).join('');
+        let orderType;
+        switch (params.type) {
+            case 'market':
+                // Market on Hyperliquid = IOC limit far from market
+                orderType = { limit: { tif: 'Ioc' } };
+                break;
+            case 'limit':
+                orderType = { limit: { tif: params.timeInForce === 'IOC' ? 'Ioc' : params.postOnly ? 'Alo' : 'Gtc' } };
+                break;
+            case 'stop_market':
+                orderType = { trigger: { isMarket: true, tpsl: 'sl', triggerPx: String(params.stopPrice ?? params.price ?? '0') } };
+                break;
+            case 'stop_limit':
+                orderType = { trigger: { isMarket: false, tpsl: 'sl', triggerPx: String(params.stopPrice ?? '0') } };
+                break;
+            case 'take_profit_market':
+                orderType = { trigger: { isMarket: true, tpsl: 'tp', triggerPx: String(params.stopPrice ?? params.price ?? '0') } };
+                break;
+            case 'take_profit_limit':
+                orderType = { trigger: { isMarket: false, tpsl: 'tp', triggerPx: String(params.stopPrice ?? '0') } };
+                break;
+            default:
+                orderType = { limit: { tif: 'Gtc' } };
+        }
+        // For market orders, use a wide price to ensure fill
+        let price = params.price ?? 0;
+        if (params.type === 'market' && price === 0) {
+            const ticker = await this.getTicker(params.symbol);
+            price = isBuy ? ticker.ask * 1.05 : ticker.bid * 0.95;
+        }
+        const orderWire = {
+            a: assetIdx, b: isBuy,
+            p: this.formatHlPrice(price, params.symbol),
+            s: this.formatHlSize(params.quantity ?? 0, params.symbol),
+            r: params.reduceOnly ?? false,
+            t: orderType, c: cloid,
+        };
+        const result = await this.hlExchange({ type: 'order', orders: [orderWire], grouping: 'na' });
+        const status = result.response?.data?.statuses?.[0];
+        if (status?.error)
+            throw new base_1.ExchangeError(status.error, 'hyperliquid');
+        const oid = String(status?.resting?.oid ?? status?.filled?.oid ?? Date.now());
+        const filledQty = status?.filled ? parseFloat(status.filled.totalSz) : 0;
+        const avgPrice = status?.filled ? parseFloat(status.filled.avgPx) : undefined;
+        return {
+            orderId: oid, clientOrderId: clientOid, symbol: params.symbol,
+            side: params.side, type: params.type,
+            quantity: params.quantity ?? 0, price: params.price,
+            status: filledQty >= (params.quantity ?? 0) ? 'filled' : filledQty > 0 ? 'partially_filled' : 'open',
+            filledQuantity: filledQty, avgFillPrice: avgPrice,
+            createdAt: Date.now(), raw: result,
+        };
+    }
+    async cancelOrder(orderId, symbol) {
+        const assetIdx = await this.getAssetIndex(symbol);
+        try {
+            await this.hlExchange({
+                type: 'cancel',
+                cancels: [{ a: assetIdx, o: parseInt(orderId) }],
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async cancelAllOrders(_request) {
+        try {
+            await this.hlExchange({ type: 'cancelAll' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getOrderStatus(orderId, symbol) {
+        if (!this.walletAddress)
+            throw new base_1.ExchangeError('Wallet address required', 'hyperliquid');
+        const orders = await this.hlInfo({ type: 'openOrders', user: this.walletAddress });
+        const order = orders.find(o => String(o.oid) === orderId);
+        if (!order) {
+            // Order not in open orders — could be filled, cancelled, or unknown
+            return {
+                orderId, symbol, side: 'buy', type: 'limit', quantity: 0,
+                status: 'unknown',
+                filledQuantity: 0, createdAt: Date.now(),
+            };
+        }
+        return {
+            orderId, symbol: `${order.coin}-USDC`,
+            side: order.side?.toLowerCase() === 'b' || order.side === 'buy' ? 'buy' : 'sell',
+            type: 'limit', quantity: +new decimal_js_1.default(String(order.sz ?? '0')),
+            price: +new decimal_js_1.default(String(order.limitPx ?? '0')),
+            status: +new decimal_js_1.default(String(order.filledSz ?? '0')) >= +new decimal_js_1.default(String(order.sz ?? '0')) ? 'filled'
+                : +new decimal_js_1.default(String(order.filledSz ?? '0')) > 0 ? 'partially_filled' : 'open',
+            filledQuantity: +new decimal_js_1.default(String(order.filledSz ?? '0')),
+            avgFillPrice: order.avgFillPx ? +new decimal_js_1.default(String(order.avgFillPx)) : undefined,
+            createdAt: parseInt(order.timestamp ?? `${Date.now()}`),
+        };
+    }
+    async getOpenOrders(symbol) {
+        if (!this.walletAddress)
+            return [];
+        const orders = await this.hlInfo({ type: 'openOrders', user: this.walletAddress });
+        return orders
+            .filter(o => !symbol || o.coin === this.normalizeCoin(symbol))
+            .map(o => this.mapHlOrderResponse(o));
+    }
+    async getOrderHistory(_query) {
+        if (!this.walletAddress)
+            return { orders: [], hasMore: false };
+        const endTime = _query.endTime ?? Date.now();
+        const startTime = _query.startTime ?? endTime - 30 * 24 * 60 * 60 * 1000;
+        const data = await this.hlInfo({
+            type: 'historicalOrders',
+            user: this.walletAddress,
+            startTime: Math.floor(startTime),
+            endTime: Math.floor(endTime),
+        });
+        // Group by oid and keep the latest status per order
+        const statusPriority = {
+            filled: 3, canceled: 3, selfTradeCanceled: 3,
+            iocCancelRejected: 2, positionIncreaseAtOpenInterestCapRejected: 2,
+            open: 1,
+        };
+        const latestByOid = new Map();
+        for (const item of (data ?? [])) {
+            const existing = latestByOid.get(item.order.oid);
+            if (!existing) {
+                latestByOid.set(item.order.oid, item);
+                continue;
+            }
+            const existingP = statusPriority[existing.status] ?? 0;
+            const newP = statusPriority[item.status] ?? 0;
+            if (item.statusTimestamp > existing.statusTimestamp ||
+                (item.statusTimestamp === existing.statusTimestamp && newP > existingP)) {
+                latestByOid.set(item.order.oid, item);
+            }
+        }
+        const orders = Array.from(latestByOid.values())
+            .filter(item => !_query.symbol || item.order.coin === this.normalizeCoin(_query.symbol))
+            .slice(0, _query.limit ?? 50)
+            .map(item => this.mapHlOrderResponse(item.order, item.status, item.statusTimestamp));
+        return { orders, hasMore: false };
+    }
+    async getFills(query) {
+        if (!this.walletAddress)
+            return { fills: [], hasMore: false };
+        const endTime = query.endTime ?? Date.now();
+        const startTime = query.startTime ?? endTime - 30 * 24 * 60 * 60 * 1000;
+        const data = await this.hlInfo({
+            type: 'userFillsByTime',
+            user: this.walletAddress,
+            startTime: Math.floor(startTime),
+            endTime: Math.floor(endTime),
+        });
+        const fills = (data ?? [])
+            .filter(f => !query.symbol || f.coin === this.normalizeCoin(query.symbol))
+            .slice(0, query.limit ?? 50)
+            .map(f => this.mapHlFillResponse(f));
+        return { fills, hasMore: false };
+    }
+}
+exports.HyperliquidAdapter = HyperliquidAdapter;
+//# sourceMappingURL=hyperliquid.js.map