@raintree-technology/perps 0.1.0

package/dist/adapters/hyperliquid.js

@@ -0,0 +1,797 @@
+/**
+ * Hyperliquid Adapter
+ * Implements PerpDEXAdapter interface for Hyperliquid DEX
+ */
+import { privateKeyToAccount } from "viem/accounts";
+import { HttpTransport, InfoClient, ExchangeClient, } from "@nktkas/hyperliquid";
+import { registerAdapter, } from "./interface.js";
+export class HyperliquidAdapter {
+    info = {
+        id: "hyperliquid",
+        name: "Hyperliquid",
+        type: "dex",
+        chains: ["arbitrum"],
+        features: {
+            spot: true,
+            perp: true,
+            margin: true,
+            crossMargin: true,
+            isolatedMargin: true,
+            stopOrders: true,
+            takeProfitOrders: true,
+            postOnly: true,
+            reduceOnly: true,
+            subaccounts: true,
+            modifyOrders: true,
+            batchOrders: true,
+            cancelAllAfter: true,
+            publicTrades: true,
+            fundingHistory: false,
+            orderHistory: true,
+            mmp: false,
+            twapOrders: true,
+        },
+        urls: {
+            app: "https://app.hyperliquid.xyz",
+            api: "https://api.hyperliquid.xyz",
+            docs: "https://hyperliquid.gitbook.io/hyperliquid-docs",
+            testnet: "https://app.hyperliquid-testnet.xyz",
+        },
+        implementation: {
+            marketData: "full",
+            authenticatedReads: "full",
+            orderLifecycle: "full",
+            orderCancellation: "full",
+            subscriptions: "full",
+            advancedTrading: "full",
+        },
+    };
+    httpTransport = null;
+    wsTransport = null;
+    infoClient = null;
+    exchangeClient = null;
+    config = null;
+    walletAddress = null;
+    connected = false;
+    meta = null;
+    latestMarkPrices = new Map();
+    async connect(config) {
+        this.config = config;
+        const credentialNetwork = config.credentials?.network;
+        const isTestnet = credentialNetwork === "testnet"
+            ? true
+            : credentialNetwork === "mainnet"
+                ? false
+                : (config.testnet ?? false);
+        this.httpTransport = new HttpTransport({ isTestnet });
+        this.infoClient = new InfoClient({ transport: this.httpTransport });
+        if (config.credentials?.privateKey) {
+            const account = privateKeyToAccount(config.credentials.privateKey);
+            this.walletAddress = config.credentials.walletAddress || account.address;
+            this.exchangeClient = new ExchangeClient({
+                transport: this.httpTransport,
+                wallet: account,
+            });
+        }
+        else if (config.credentials?.walletAddress) {
+            this.walletAddress = config.credentials.walletAddress;
+        }
+        // Fetch metadata
+        this.meta = await this.infoClient.meta();
+        this.connected = true;
+    }
+    async disconnect() {
+        if (this.wsTransport) {
+            try {
+                await this.wsTransport.close();
+            }
+            catch {
+                // Best effort close for transport cleanup.
+            }
+            this.wsTransport = null;
+        }
+        this.config = null;
+        this.walletAddress = null;
+        this.meta = null;
+        this.httpTransport = null;
+        this.infoClient = null;
+        this.exchangeClient = null;
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    // --------------------------------------------------------------------------
+    // Public Market Data
+    // --------------------------------------------------------------------------
+    async getMarkets() {
+        this.ensureConnected();
+        if (!this.meta) {
+            this.meta = await this.infoClient.meta();
+        }
+        return this.meta.universe.map((asset) => ({
+            symbol: `${asset.name}-PERP`,
+            baseAsset: asset.name,
+            quoteAsset: "USD",
+            type: "perp",
+            maxLeverage: asset.maxLeverage,
+            minSize: Math.pow(10, -asset.szDecimals).toString(),
+            tickSize: "0.01", // Hyperliquid uses dynamic tick sizes
+            fundingInterval: 1, // Hourly
+            isActive: true,
+        }));
+    }
+    async getMarket(symbol) {
+        const markets = await this.getMarkets();
+        const normalized = symbol.toUpperCase().replace("-PERP", "");
+        return markets.find((m) => m.baseAsset === normalized) ?? null;
+    }
+    async getTicker(market) {
+        this.ensureConnected();
+        const coin = market.toUpperCase().replace("-PERP", "");
+        const ctxs = await this.infoClient.metaAndAssetCtxs();
+        const meta = ctxs[0];
+        const assetCtxs = ctxs[1];
+        const idx = meta.universe.findIndex((u) => u.name === coin);
+        if (idx === -1)
+            throw new Error(`Market ${market} not found`);
+        const ctx = assetCtxs[idx];
+        const prevDayPx = parseFloat(ctx.prevDayPx);
+        const change = prevDayPx > 0
+            ? ((parseFloat(ctx.markPx) - prevDayPx) / prevDayPx) * 100
+            : 0;
+        // Cache mark price for position enrichment
+        this.latestMarkPrices.set(coin, ctx.markPx);
+        // Fetch 24h candle for high/low
+        let high24h = "0";
+        let low24h = "0";
+        try {
+            const now = Date.now();
+            const oneDayAgo = now - 86_400_000;
+            const candles = await this.infoClient.candleSnapshot({
+                coin,
+                interval: "1d",
+                startTime: oneDayAgo,
+                endTime: now,
+            });
+            if (candles && candles.length > 0) {
+                high24h = candles[candles.length - 1].h;
+                low24h = candles[candles.length - 1].l;
+            }
+        }
+        catch {
+            // candleSnapshot may not be available for all coins
+        }
+        return {
+            market: `${coin}-PERP`,
+            lastPrice: ctx.markPx,
+            markPrice: ctx.markPx,
+            indexPrice: ctx.oraclePx,
+            bid: ctx.impactPxs?.[0] ?? ctx.markPx,
+            ask: ctx.impactPxs?.[1] ?? ctx.markPx,
+            volume24h: ctx.dayNtlVlm,
+            change24h: change.toFixed(2),
+            high24h,
+            low24h,
+            openInterest: ctx.openInterest,
+            fundingRate: ctx.funding,
+            timestamp: Date.now(),
+        };
+    }
+    async getTickers() {
+        this.ensureConnected();
+        const ctxs = await this.infoClient.metaAndAssetCtxs();
+        const meta = ctxs[0];
+        const assetCtxs = ctxs[1];
+        return meta.universe.map((asset, idx) => {
+            const ctx = assetCtxs[idx];
+            const prevDayPx = parseFloat(ctx.prevDayPx);
+            const change = prevDayPx > 0
+                ? ((parseFloat(ctx.markPx) - prevDayPx) / prevDayPx) * 100
+                : 0;
+            // Cache mark prices for position enrichment
+            this.latestMarkPrices.set(asset.name, ctx.markPx);
+            return {
+                market: `${asset.name}-PERP`,
+                lastPrice: ctx.markPx,
+                markPrice: ctx.markPx,
+                indexPrice: ctx.oraclePx,
+                bid: ctx.impactPxs?.[0] ?? ctx.markPx,
+                ask: ctx.impactPxs?.[1] ?? ctx.markPx,
+                volume24h: ctx.dayNtlVlm,
+                change24h: change.toFixed(2),
+                high24h: "0",
+                low24h: "0",
+                openInterest: ctx.openInterest,
+                fundingRate: ctx.funding,
+                timestamp: Date.now(),
+            };
+        });
+    }
+    async getOrderBook(market, depth = 20) {
+        this.ensureConnected();
+        const coin = market.toUpperCase().replace("-PERP", "");
+        const book = await this.infoClient.l2Book({ coin, nSigFigs: 5 });
+        const bids = book?.levels?.[0] ?? [];
+        const asks = book?.levels?.[1] ?? [];
+        return {
+            market: `${coin}-PERP`,
+            bids: bids.slice(0, depth).map((l) => ({ price: l.px, size: l.sz })),
+            asks: asks.slice(0, depth).map((l) => ({ price: l.px, size: l.sz })),
+            timestamp: Date.now(),
+        };
+    }
+    async getFundingRate(market) {
+        const ticker = await this.getTicker(market);
+        return {
+            market: ticker.market,
+            rate: ticker.fundingRate,
+            nextFundingTime: Date.now() + 3600000, // Approximate
+            timestamp: ticker.timestamp,
+        };
+    }
+    async getFundingRates() {
+        const tickers = await this.getTickers();
+        return tickers.map((t) => ({
+            market: t.market,
+            rate: t.fundingRate,
+            nextFundingTime: Date.now() + 3600000,
+            timestamp: t.timestamp,
+        }));
+    }
+    // --------------------------------------------------------------------------
+    // Account Data (requires auth)
+    // --------------------------------------------------------------------------
+    async getPositions() {
+        this.ensureAuth();
+        // Refresh mark prices from metaAndAssetCtxs for position enrichment
+        try {
+            const ctxs = await this.infoClient.metaAndAssetCtxs();
+            const meta = ctxs[0];
+            const assetCtxs = ctxs[1];
+            for (let i = 0; i < meta.universe.length; i++) {
+                this.latestMarkPrices.set(meta.universe[i].name, assetCtxs[i].markPx);
+            }
+        }
+        catch {
+            // Best effort - positions will still work with cached or entry prices
+        }
+        const state = await this.infoClient.clearinghouseState({ user: this.walletAddress });
+        const positions = state.assetPositions;
+        return positions
+            .filter((p) => parseFloat(p.position.szi) !== 0)
+            .map((p) => this.mapPosition(p.position));
+    }
+    async getPosition(market) {
+        const positions = await this.getPositions();
+        const coin = market.toUpperCase().replace("-PERP", "");
+        return positions.find((p) => p.market === `${coin}-PERP`) ?? null;
+    }
+    async getOrders(market) {
+        this.ensureAuth();
+        const orders = await this.infoClient.openOrders({ user: this.walletAddress });
+        const mapped = orders.map((o) => this.mapOrder(o));
+        if (market) {
+            const coin = market.toUpperCase().replace("-PERP", "");
+            return mapped.filter((o) => o.market === `${coin}-PERP`);
+        }
+        return mapped;
+    }
+    async getOrder(orderId) {
+        this.ensureAuth();
+        // Try direct orderStatus lookup first
+        try {
+            const status = await this.infoClient.orderStatus({
+                user: this.walletAddress,
+                oid: parseInt(orderId),
+            });
+            if (status.order) {
+                return this.mapOrder(status.order);
+            }
+        }
+        catch {
+            // Fall through to open orders scan
+        }
+        const orders = await this.getOrders();
+        return orders.find((o) => o.id === orderId) ?? null;
+    }
+    async getBalances() {
+        this.ensureAuth();
+        const state = await this.infoClient.clearinghouseState({ user: this.walletAddress });
+        // Calculate totals
+        const accountValue = parseFloat(state.marginSummary.accountValue);
+        const totalMarginUsed = parseFloat(state.marginSummary.totalMarginUsed);
+        // Unrealized PnL from positions
+        const positions = state.assetPositions;
+        const unrealizedPnl = positions.reduce((sum, p) => sum + parseFloat(p.position.unrealizedPnl || "0"), 0);
+        return [
+            {
+                asset: "USD",
+                total: accountValue.toString(),
+                available: (accountValue - totalMarginUsed).toString(),
+                locked: totalMarginUsed.toString(),
+                unrealizedPnl: unrealizedPnl.toString(),
+                marginUsed: totalMarginUsed.toString(),
+            },
+        ];
+    }
+    async getTrades(market, limit = 100) {
+        this.ensureAuth();
+        const fills = await this.infoClient.userFills({ user: this.walletAddress });
+        let mapped = fills.slice(0, limit).map((f) => this.mapFill(f));
+        if (market) {
+            const coin = market.toUpperCase().replace("-PERP", "");
+            mapped = mapped.filter((t) => t.market === `${coin}-PERP`);
+        }
+        return mapped;
+    }
+    // --------------------------------------------------------------------------
+    // Trading
+    // --------------------------------------------------------------------------
+    async placeOrder(params) {
+        this.ensureExchangeClient();
+        const coin = params.market.toUpperCase().replace("-PERP", "");
+        const isBuy = params.side === "long";
+        const isMarket = params.type === "market";
+        let orderType = isMarket
+            ? { market: {} }
+            : { limit: { tif: params.postOnly ? "Alo" : "Gtc" } };
+        if (params.type === "stop" || params.type === "stop_limit") {
+            if (!params.triggerPrice) {
+                throw new Error("triggerPrice is required for stop orders");
+            }
+            orderType = {
+                trigger: {
+                    isMarket: params.type === "stop",
+                    triggerPx: params.triggerPrice,
+                    tpsl: "sl",
+                },
+            };
+        }
+        else if (params.type === "take_profit") {
+            if (!params.triggerPrice) {
+                throw new Error("triggerPrice is required for take_profit orders");
+            }
+            orderType = {
+                trigger: {
+                    isMarket: true,
+                    triggerPx: params.triggerPrice,
+                    tpsl: "tp",
+                },
+            };
+        }
+        const orderRequest = {
+            coin,
+            is_buy: isBuy,
+            sz: parseFloat(params.size),
+            limit_px: isMarket ? null : parseFloat(params.price),
+            order_type: orderType,
+            reduce_only: params.reduceOnly ?? false,
+        };
+        await this.exchangeClient.order(orderRequest);
+        // Return the order (fetch it back for full details)
+        const orders = await this.getOrders(params.market);
+        return orders[0] || {
+            id: "pending",
+            market: `${coin}-PERP`,
+            side: params.side,
+            type: params.type,
+            size: params.size,
+            price: params.price ?? null,
+            filled: "0",
+            remaining: params.size,
+            status: "open",
+            reduceOnly: params.reduceOnly ?? false,
+            postOnly: params.postOnly ?? false,
+            timestamp: Date.now(),
+        };
+    }
+    async cancelOrder(params) {
+        this.ensureExchangeClient();
+        if (!params.orderId) {
+            throw new Error("orderId is required for Hyperliquid cancelOrder");
+        }
+        let coin;
+        if (params.market) {
+            coin = params.market.toUpperCase().replace("-PERP", "");
+        }
+        else {
+            // Look up the order's market from open orders
+            const orders = await this.getOrders();
+            const match = orders.find((o) => o.id === params.orderId);
+            if (match) {
+                coin = match.market.replace("-PERP", "");
+            }
+        }
+        if (!coin) {
+            throw new Error(`Could not resolve market for order ${params.orderId}`);
+        }
+        const assetIndex = this.getAssetIndex(coin);
+        try {
+            await this.exchangeClient.cancel({
+                cancels: [{
+                        a: assetIndex,
+                        o: parseInt(params.orderId),
+                    }],
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async cancelAllOrders(market) {
+        this.ensureExchangeClient();
+        const orders = await this.getOrders(market);
+        let cancelled = 0;
+        for (const order of orders) {
+            const success = await this.cancelOrder({
+                orderId: order.id,
+                market: order.market,
+            });
+            if (success)
+                cancelled++;
+        }
+        return cancelled;
+    }
+    async setLeverage(market, leverage) {
+        this.ensureExchangeClient();
+        const coin = market.toUpperCase().replace("-PERP", "");
+        await this.exchangeClient.updateLeverage({
+            asset: this.getAssetIndex(coin),
+            isCross: true,
+            leverage,
+        });
+    }
+    async setMarginType(market, type) {
+        this.ensureExchangeClient();
+        const coin = market.toUpperCase().replace("-PERP", "");
+        const position = await this.getPosition(market);
+        await this.exchangeClient.updateLeverage({
+            asset: this.getAssetIndex(coin),
+            isCross: type === "cross",
+            leverage: position?.leverage ?? 1,
+        });
+    }
+    // --------------------------------------------------------------------------
+    // Advanced Trading
+    // --------------------------------------------------------------------------
+    async modifyOrder(params) {
+        this.ensureExchangeClient();
+        const coin = params.market.toUpperCase().replace("-PERP", "");
+        const oid = parseInt(params.orderId);
+        // Fetch existing order to get current values
+        const existing = await this.getOrder(params.orderId);
+        if (!existing) {
+            throw new Error(`Order ${params.orderId} not found`);
+        }
+        const isBuy = existing.side === "long";
+        const newPrice = params.price ? parseFloat(params.price) : parseFloat(existing.price ?? "0");
+        const newSize = params.size ? parseFloat(params.size) : parseFloat(existing.size);
+        await this.exchangeClient.modify({
+            oid,
+            order: {
+                a: this.getAssetIndex(coin),
+                b: isBuy,
+                p: newPrice.toString(),
+                s: newSize.toString(),
+                r: existing.reduceOnly,
+                t: { limit: { tif: existing.postOnly ? "Alo" : "Gtc" } },
+            },
+        });
+        // Fetch back the modified order
+        const orders = await this.getOrders(params.market);
+        return orders[0] || { ...existing, price: newPrice.toString(), size: newSize.toString() };
+    }
+    async batchPlaceOrders(paramsList) {
+        // Sequential: HL's batch endpoint is for modifications, not new orders
+        const results = [];
+        for (const params of paramsList) {
+            results.push(await this.placeOrder(params));
+        }
+        return results;
+    }
+    async batchCancelOrders(paramsList) {
+        this.ensureExchangeClient();
+        // Build batch cancel request
+        const cancels = [];
+        for (const params of paramsList) {
+            if (!params.orderId)
+                continue;
+            let coin;
+            if (params.market) {
+                coin = params.market.toUpperCase().replace("-PERP", "");
+            }
+            else {
+                const orders = await this.getOrders();
+                const match = orders.find((o) => o.id === params.orderId);
+                if (match)
+                    coin = match.market.replace("-PERP", "");
+            }
+            if (!coin)
+                continue;
+            cancels.push({ a: this.getAssetIndex(coin), o: parseInt(params.orderId) });
+        }
+        if (cancels.length === 0)
+            return paramsList.map(() => false);
+        try {
+            await this.exchangeClient.cancel({ cancels });
+            return paramsList.map(() => true);
+        }
+        catch {
+            // Fallback to individual cancels
+            const results = [];
+            for (const params of paramsList) {
+                try {
+                    results.push(await this.cancelOrder(params));
+                }
+                catch {
+                    results.push(false);
+                }
+            }
+            return results;
+        }
+    }
+    async cancelAllAfter(timeoutMs) {
+        this.ensureExchangeClient();
+        // Hyperliquid scheduleCancel: timeout in seconds
+        const timeoutSec = Math.max(0, Math.floor(timeoutMs / 1000));
+        await this.exchangeClient.scheduleCancel({
+            time: timeoutSec > 0 ? Date.now() + timeoutMs : null,
+        });
+    }
+    async getOrderHistory(_market, limit = 100) {
+        this.ensureAuth();
+        // Hyperliquid historicalOrders endpoint
+        const response = await this.infoClient.historicalOrders({
+            user: this.walletAddress,
+        });
+        let orders = response.slice(0, limit)
+            .map((entry) => entry.order ? this.mapOrder(entry.order) : null)
+            .filter((o) => o !== null);
+        if (_market) {
+            const coin = _market.toUpperCase().replace("-PERP", "");
+            orders = orders.filter((o) => o.market === `${coin}-PERP`);
+        }
+        return orders;
+    }
+    async getFundingHistory(_market, _limit) {
+        throw new Error("Hyperliquid does not expose a per-user funding history endpoint");
+    }
+    async getPublicTrades(market, limit = 100) {
+        this.ensureConnected();
+        const coin = market.toUpperCase().replace("-PERP", "");
+        const trades = await this.infoClient.recentTrades({ coin });
+        return trades.slice(0, limit).map((t) => ({
+            id: t.tid?.toString() ?? `${t.time}`,
+            market: `${coin}-PERP`,
+            side: t.side === "B" ? "long" : "short",
+            price: t.px,
+            size: t.sz,
+            timestamp: t.time,
+        }));
+    }
+    // --------------------------------------------------------------------------
+    // Market Maker Protection
+    // --------------------------------------------------------------------------
+    async setMMP(_config) {
+        throw new Error("Hyperliquid does not support Market Maker Protection (MMP)");
+    }
+    async getMMP(_market) {
+        throw new Error("Hyperliquid does not support Market Maker Protection (MMP)");
+    }
+    async resetMMP(_market) {
+        throw new Error("Hyperliquid does not support Market Maker Protection (MMP)");
+    }
+    // --------------------------------------------------------------------------
+    // TWAP Orders
+    // --------------------------------------------------------------------------
+    async placeTWAP(params) {
+        this.ensureExchangeClient();
+        const coin = params.market.toUpperCase().replace("-PERP", "");
+        const isBuy = params.side === "long";
+        const durationSec = Math.floor(params.durationMs / 1000);
+        await this.exchangeClient.twapOrder({
+            coin,
+            is_buy: isBuy,
+            sz: parseFloat(params.size),
+            duration_s: durationSec,
+            randomize: params.randomize ?? false,
+        });
+        return {
+            id: `twap-${Date.now()}`,
+            market: `${coin}-PERP`,
+            side: params.side,
+            totalSize: params.size,
+            executedSize: "0",
+            remainingSize: params.size,
+            status: "active",
+            startTime: Date.now(),
+            endTime: Date.now() + params.durationMs,
+        };
+    }
+    async cancelTWAP(twapId) {
+        this.ensureExchangeClient();
+        try {
+            await this.exchangeClient.twapCancel({
+                token_id: parseInt(twapId.replace("twap-", "")),
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getTWAPStatus(_twapId) {
+        throw new Error("Hyperliquid does not expose a TWAP status query endpoint");
+    }
+    // --------------------------------------------------------------------------
+    // Margin Management
+    // --------------------------------------------------------------------------
+    async updateIsolatedMargin(market, amount) {
+        this.ensureExchangeClient();
+        const coin = market.toUpperCase().replace("-PERP", "");
+        const isBuy = true; // For margin update, direction is based on position side
+        await this.exchangeClient.updateIsolatedMargin({
+            asset: this.getAssetIndex(coin),
+            isBuy,
+            ntli: parseFloat(amount),
+        });
+    }
+    subscribe(callbacks) {
+        this.ensureConnected();
+        let closed = false;
+        const emit = async () => {
+            if (closed)
+                return;
+            try {
+                if (callbacks.onTicker) {
+                    const tickers = await this.getTickers();
+                    for (const ticker of tickers) {
+                        callbacks.onTicker(ticker);
+                    }
+                }
+                if (callbacks.onPositions && this.walletAddress) {
+                    callbacks.onPositions(await this.getPositions());
+                }
+                if (callbacks.onOrders && this.walletAddress) {
+                    callbacks.onOrders(await this.getOrders());
+                }
+                if (callbacks.onBalances && this.walletAddress) {
+                    callbacks.onBalances(await this.getBalances());
+                }
+            }
+            catch (err) {
+                callbacks.onError?.(err instanceof Error ? err : new Error(String(err)));
+            }
+        };
+        void emit();
+        const timer = setInterval(() => {
+            void emit();
+        }, 1_000);
+        return () => {
+            closed = true;
+            clearInterval(timer);
+        };
+    }
+    subscribeOrderBook(market, callback) {
+        this.ensureConnected();
+        let closed = false;
+        const normalizedMarket = market.toUpperCase().endsWith("-PERP")
+            ? market.toUpperCase()
+            : `${market.toUpperCase()}-PERP`;
+        const emit = async () => {
+            if (closed)
+                return;
+            callback(await this.getOrderBook(normalizedMarket));
+        };
+        void emit().catch(() => { });
+        const timer = setInterval(() => {
+            void emit().catch(() => { });
+        }, 500);
+        return () => {
+            closed = true;
+            clearInterval(timer);
+        };
+    }
+    subscribeTicker(market, callback) {
+        this.ensureConnected();
+        let closed = false;
+        const normalizedMarket = market.toUpperCase().endsWith("-PERP")
+            ? market.toUpperCase()
+            : `${market.toUpperCase()}-PERP`;
+        const emit = async () => {
+            if (closed)
+                return;
+            callback(await this.getTicker(normalizedMarket));
+        };
+        void emit().catch(() => { });
+        const timer = setInterval(() => {
+            void emit().catch(() => { });
+        }, 1_000);
+        return () => {
+            closed = true;
+            clearInterval(timer);
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Private Helpers
+    // --------------------------------------------------------------------------
+    ensureConnected() {
+        if (!this.connected || !this.infoClient) {
+            throw new Error("Not connected. Call connect() first.");
+        }
+    }
+    ensureAuth() {
+        this.ensureConnected();
+        if (!this.walletAddress) {
+            throw new Error("Wallet address required. Provide credentials in connect().");
+        }
+    }
+    ensureExchangeClient() {
+        this.ensureConnected();
+        if (!this.exchangeClient) {
+            throw new Error("Exchange client not available. Provide privateKey in credentials.");
+        }
+    }
+    getAssetIndex(coin) {
+        if (!this.meta)
+            throw new Error("Meta not loaded");
+        const idx = this.meta.universe.findIndex((u) => u.name === coin);
+        if (idx === -1)
+            throw new Error(`Asset ${coin} not found`);
+        return idx;
+    }
+    mapPosition(p) {
+        const size = parseFloat(p.szi);
+        const markPrice = this.latestMarkPrices.get(p.coin) ?? p.entryPx;
+        return {
+            market: `${p.coin}-PERP`,
+            side: size > 0 ? "long" : "short",
+            size: Math.abs(size).toString(),
+            entryPrice: p.entryPx,
+            markPrice,
+            liquidationPrice: p.liquidationPx,
+            unrealizedPnl: p.unrealizedPnl,
+            realizedPnl: "0",
+            leverage: p.leverage.value,
+            marginType: p.leverage.type === "cross" ? "cross" : "isolated",
+            margin: p.marginUsed,
+            timestamp: Date.now(),
+        };
+    }
+    mapOrder(o) {
+        const filled = parseFloat(o.origSz) - parseFloat(o.sz);
+        return {
+            id: o.oid.toString(),
+            market: `${o.coin}-PERP`,
+            side: o.side === "B" ? "long" : "short",
+            type: o.triggerPx ? "stop" : "limit",
+            size: o.origSz,
+            price: o.limitPx,
+            filled: filled.toString(),
+            remaining: o.sz,
+            status: "open",
+            reduceOnly: o.reduceOnly,
+            postOnly: false,
+            timestamp: o.timestamp,
+            triggerPrice: o.triggerPx,
+        };
+    }
+    mapFill(f) {
+        return {
+            id: `${f.oid}-${f.time}`,
+            market: `${f.coin}-PERP`,
+            side: f.side === "B" ? "long" : "short",
+            price: f.px,
+            size: f.sz,
+            fee: f.fee,
+            feeAsset: f.feeToken,
+            timestamp: f.time,
+            orderId: f.oid.toString(),
+        };
+    }
+}
+// Register the adapter
+registerAdapter("hyperliquid", () => new HyperliquidAdapter());
+export default HyperliquidAdapter;