pmxt-core 2.37.14 → 2.39.0

package/dist/BaseExchange.d.ts

@@ -449,7 +449,7 @@ export declare abstract class PredictionMarketExchange {
     /**
      * Fetch historical OHLCV (candlestick) price data for a specific market outcome.
      *
-     * @param id - The Outcome ID (outcomeId). Use outcome.outcomeId, NOT market.marketId
+     * @param outcomeId - The Outcome ID (outcomeId). Use outcome.outcomeId, NOT market.marketId
      * @param params - OHLCV parameters including resolution (required)
      * @returns Array of price candles
      *
@@ -457,29 +457,29 @@ export declare abstract class PredictionMarketExchange {
      * @notes Polymarket: outcomeId is the CLOB Token ID. Kalshi: outcomeId is the Market Ticker.
      * @notes Common resolutions: '1m' | '5m' | '15m' | '1h' | '6h' | '1d'. Arbitrary intervals (e.g. '30s', '120s', '3h') accepted by venues that support them.
      */
-    fetchOHLCV(id: string, params: OHLCVParams): Promise<PriceCandle[]>;
+    fetchOHLCV(outcomeId: string, params: OHLCVParams): Promise<PriceCandle[]>;
     /**
      * Fetch the current order book (bids/asks) for a specific outcome.
      * Essential for calculating spread, depth, and execution prices.
      *
-     * @param id - The Outcome ID (outcomeId) or market slug
+     * @param outcomeId - The Outcome ID (outcomeId) or market slug
      * @param side - Optional 'yes' or 'no' to explicitly indicate the
      *   outcome side. Required for exchanges where the API returns a
      *   single orderbook per market (e.g. Limitless) and the caller
      *   passes a slug instead of a token ID.
      * @returns Current order book with bids and asks
      */
-    fetchOrderBook(id: string, side?: 'yes' | 'no'): Promise<OrderBook>;
+    fetchOrderBook(outcomeId: string, side?: 'yes' | 'no'): Promise<OrderBook>;
     /**
      * Fetch raw trade history for a specific outcome.
      *
-     * @param id - The Outcome ID (outcomeId)
+     * @param outcomeId - The Outcome ID (outcomeId)
      * @param params - Trade filter parameters
      * @returns Array of recent trades
      *
      * @notes Polymarket requires an API key for trade history. Use fetchOHLCV for public historical data.
      */
-    fetchTrades(id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
+    fetchTrades(outcomeId: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
     /**
      * Place a new order on the exchange.
      *
@@ -582,39 +582,39 @@ export declare abstract class PredictionMarketExchange {
      * Watch order book updates in real-time via WebSocket.
      * Returns a promise that resolves with the next order book update. Call repeatedly in a loop to stream updates (CCXT Pro pattern).
      *
-     * @param id - The Outcome ID to watch
+     * @param outcomeId - The Outcome ID to watch
      * @param limit - Optional limit for orderbook depth
      * @returns Promise that resolves with the current orderbook state
      */
-    watchOrderBook(id: string, limit?: number): Promise<OrderBook>;
+    watchOrderBook(outcomeId: string, limit?: number): Promise<OrderBook>;
     /**
      * Watch multiple order books simultaneously via WebSocket.
      * Returns a promise that resolves with a record of order book snapshots keyed by ID.
      * Exchanges with native batch support (e.g. Kalshi) send a single subscribe message
      * for all tickers; others fall back to individual watchOrderBook calls.
      *
-     * @param ids - Array of Outcome IDs to watch
+     * @param outcomeIds - Array of Outcome IDs to watch
      * @param limit - Optional limit for orderbook depth
      * @returns Promise that resolves with order books keyed by ID
      */
-    watchOrderBooks(ids: string[], limit?: number): Promise<Record<string, OrderBook>>;
+    watchOrderBooks(outcomeIds: string[], limit?: number): Promise<Record<string, OrderBook>>;
     /**
      * Unsubscribe from a previously watched order book stream.
      *
-     * @param id - The Outcome ID to stop watching
+     * @param outcomeId - The Outcome ID to stop watching
      */
-    unwatchOrderBook(id: string): Promise<void>;
+    unwatchOrderBook(outcomeId: string): Promise<void>;
     /**
      * Watch trade executions in real-time via WebSocket.
      * Returns a promise that resolves with the next trade(s). Call repeatedly in a loop to stream updates (CCXT Pro pattern).
      *
-     * @param id - The Outcome ID to watch
+     * @param outcomeId - The Outcome ID to watch
      * @param address - Public wallet address
      * @param since - Optional timestamp to filter trades from
      * @param limit - Optional limit for number of trades
      * @returns Promise that resolves with recent trades
      */
-    watchTrades(id: string, address?: string, since?: number, limit?: number): Promise<Trade[]>;
+    watchTrades(outcomeId: string, address?: string, since?: number, limit?: number): Promise<Trade[]>;
     /**
      * Stream activity for a public wallet address
      * Returns a promise that resolves with the next activity snapshot whenever a change

package/dist/BaseExchange.js

@@ -391,7 +391,7 @@ class PredictionMarketExchange {
     /**
      * Fetch historical OHLCV (candlestick) price data for a specific market outcome.
      *
-     * @param id - The Outcome ID (outcomeId). Use outcome.outcomeId, NOT market.marketId
+     * @param outcomeId - The Outcome ID (outcomeId). Use outcome.outcomeId, NOT market.marketId
      * @param params - OHLCV parameters including resolution (required)
      * @returns Array of price candles
      *
@@ -399,33 +399,33 @@ class PredictionMarketExchange {
      * @notes Polymarket: outcomeId is the CLOB Token ID. Kalshi: outcomeId is the Market Ticker.
      * @notes Common resolutions: '1m' | '5m' | '15m' | '1h' | '6h' | '1d'. Arbitrary intervals (e.g. '30s', '120s', '3h') accepted by venues that support them.
      */
-    async fetchOHLCV(id, params) {
+    async fetchOHLCV(outcomeId, params) {
         throw new Error("Method fetchOHLCV not implemented.");
     }
     /**
      * Fetch the current order book (bids/asks) for a specific outcome.
      * Essential for calculating spread, depth, and execution prices.
      *
-     * @param id - The Outcome ID (outcomeId) or market slug
+     * @param outcomeId - The Outcome ID (outcomeId) or market slug
      * @param side - Optional 'yes' or 'no' to explicitly indicate the
      *   outcome side. Required for exchanges where the API returns a
      *   single orderbook per market (e.g. Limitless) and the caller
      *   passes a slug instead of a token ID.
      * @returns Current order book with bids and asks
      */
-    async fetchOrderBook(id, side) {
+    async fetchOrderBook(outcomeId, side) {
         throw new Error("Method fetchOrderBook not implemented.");
     }
     /**
      * Fetch raw trade history for a specific outcome.
      *
-     * @param id - The Outcome ID (outcomeId)
+     * @param outcomeId - The Outcome ID (outcomeId)
      * @param params - Trade filter parameters
      * @returns Array of recent trades
      *
      * @notes Polymarket requires an API key for trade history. Use fetchOHLCV for public historical data.
      */
-    async fetchTrades(id, params) {
+    async fetchTrades(outcomeId, params) {
         // Deprecation warning for resolution parameter
         if ('resolution' in params && params.resolution !== undefined) {
             console.warn('[pmxt] Warning: The "resolution" parameter is deprecated for fetchTrades() and will be ignored. ' +
@@ -761,11 +761,11 @@ class PredictionMarketExchange {
      * Watch order book updates in real-time via WebSocket.
      * Returns a promise that resolves with the next order book update. Call repeatedly in a loop to stream updates (CCXT Pro pattern).
      *
-     * @param id - The Outcome ID to watch
+     * @param outcomeId - The Outcome ID to watch
      * @param limit - Optional limit for orderbook depth
      * @returns Promise that resolves with the current orderbook state
      */
-    async watchOrderBook(id, limit) {
+    async watchOrderBook(outcomeId, limit) {
         throw new Error(`watchOrderBook() is not supported by ${this.name}`);
     }
     /**
@@ -774,30 +774,30 @@ class PredictionMarketExchange {
      * Exchanges with native batch support (e.g. Kalshi) send a single subscribe message
      * for all tickers; others fall back to individual watchOrderBook calls.
      *
-     * @param ids - Array of Outcome IDs to watch
+     * @param outcomeIds - Array of Outcome IDs to watch
      * @param limit - Optional limit for orderbook depth
      * @returns Promise that resolves with order books keyed by ID
      */
-    async watchOrderBooks(ids, limit) {
+    async watchOrderBooks(outcomeIds, limit) {
         // Default implementation: subscribe to each ID individually.
         // Exchanges with native batch support (e.g. Kalshi) override this
         // to send a single subscribe message for all tickers.
-        const entries = await Promise.all(ids.map(async (id) => {
-            const book = await this.watchOrderBook(id, limit);
-            return [id, book];
+        const entries = await Promise.all(outcomeIds.map(async (oid) => {
+            const book = await this.watchOrderBook(oid, limit);
+            return [oid, book];
         }));
         const result = {};
-        for (const [id, book] of entries) {
-            result[id] = book;
+        for (const [oid, book] of entries) {
+            result[oid] = book;
         }
         return result;
     }
     /**
      * Unsubscribe from a previously watched order book stream.
      *
-     * @param id - The Outcome ID to stop watching
+     * @param outcomeId - The Outcome ID to stop watching
      */
-    async unwatchOrderBook(id) {
+    async unwatchOrderBook(outcomeId) {
         throw new Error(`unwatchOrderBook() is not supported by ${this.name}`);
     }
     // ----------------------------------------------------------------------------
@@ -807,13 +807,13 @@ class PredictionMarketExchange {
      * Watch trade executions in real-time via WebSocket.
      * Returns a promise that resolves with the next trade(s). Call repeatedly in a loop to stream updates (CCXT Pro pattern).
      *
-     * @param id - The Outcome ID to watch
+     * @param outcomeId - The Outcome ID to watch
      * @param address - Public wallet address
      * @param since - Optional timestamp to filter trades from
      * @param limit - Optional limit for number of trades
      * @returns Promise that resolves with recent trades
      */
-    async watchTrades(id, address, since, limit) {
+    async watchTrades(outcomeId, address, since, limit) {
         throw new Error(`watchTrades() is not supported by ${this.name}`);
     }
     /**

package/dist/exchanges/baozi/index.d.ts

@@ -23,7 +23,7 @@ export declare class BaoziExchange extends PredictionMarketExchange {
     protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
     fetchOHLCV(): Promise<PriceCandle[]>;
-    fetchOrderBook(id: string): Promise<OrderBook>;
+    fetchOrderBook(outcomeId: string): Promise<OrderBook>;
     fetchTrades(): Promise<Trade[]>;
     fetchBalance(): Promise<Balance[]>;
     fetchPositions(): Promise<Position[]>;
@@ -31,7 +31,7 @@ export declare class BaoziExchange extends PredictionMarketExchange {
     cancelOrder(): Promise<Order>;
     fetchOrder(orderId: string): Promise<Order>;
     fetchOpenOrders(): Promise<Order[]>;
-    watchOrderBook(id: string): Promise<OrderBook>;
+    watchOrderBook(outcomeId: string): Promise<OrderBook>;
     watchTrades(): Promise<Trade[]>;
     close(): Promise<void>;
     private ensureAuth;

package/dist/exchanges/baozi/index.js

@@ -71,9 +71,9 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
         // Baozi has no historical price/trade API without a custom indexer
         return [];
     }
-    async fetchOrderBook(id) {
-        const rawMarket = await this.fetcher.fetchRawOrderBook(id);
-        return this.normalizer.normalizeOrderBook(rawMarket, id);
+    async fetchOrderBook(outcomeId) {
+        const rawMarket = await this.fetcher.fetchRawOrderBook(outcomeId);
+        return this.normalizer.normalizeOrderBook(rawMarket, outcomeId);
     }
     async fetchTrades() {
         // Baozi has no trade history API without a custom indexer
@@ -313,11 +313,11 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
     // -----------------------------------------------------------------------
     // WebSocket
     // -----------------------------------------------------------------------
-    async watchOrderBook(id) {
+    async watchOrderBook(outcomeId) {
         if (!this.ws) {
             this.ws = new websocket_1.BaoziWebSocket();
         }
-        return this.ws.watchOrderBook(this.connection, id);
+        return this.ws.watchOrderBook(this.connection, outcomeId);
     }
     async watchTrades() {
         throw new errors_1.ExchangeNotAvailable('Trade streaming is not available for Baozi', 'Baozi');

package/dist/exchanges/hyperliquid/auth.d.ts

@@ -0,0 +1,30 @@
+import { ExchangeCredentials } from '../../BaseExchange';
+export interface HyperliquidSignature {
+    r: string;
+    s: string;
+    v: number;
+}
+export declare function floatToWire(x: number): string;
+export declare class HyperliquidAuth {
+    private readonly wallet;
+    private readonly isMainnet;
+    constructor(credentials: ExchangeCredentials, testnet: boolean);
+    getAddress(): string;
+    /**
+     * Sign an L1 action using the phantom agent EIP-712 scheme.
+     *
+     * Flow:
+     *   1. msgpack-encode the action
+     *   2. Append nonce (8 bytes BE) + vault marker
+     *   3. keccak256 -> connectionId
+     *   4. EIP-712 sign {source, connectionId} with domain "Exchange"
+     */
+    signL1Action(action: Record<string, unknown>, vaultAddress?: string | null, nonce?: number): Promise<{
+        signature: HyperliquidSignature;
+        nonce: number;
+    }>;
+    /**
+     * Build and sign a complete exchange request body.
+     */
+    signExchangeRequest(action: Record<string, unknown>, vaultAddress?: string | null): Promise<Record<string, unknown>>;
+}

package/dist/exchanges/hyperliquid/auth.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperliquidAuth = void 0;
+exports.floatToWire = floatToWire;
+const ethers_1 = require("ethers");
+const msgpackr_1 = require("msgpackr");
+const errors_1 = require("../../errors");
+const config_1 = require("./config");
+// Standard msgpack encoder — variableMapSize ensures fixmap/fixarray encoding
+// which matches the Python/Rust msgpack libraries that Hyperliquid's server uses.
+const packr = new msgpackr_1.Packr({ useRecords: false, variableMapSize: true });
+// ----------------------------------------------------------------------------
+// EIP-712 domain and types for Hyperliquid L1 action signing
+// ----------------------------------------------------------------------------
+const EIP712_DOMAIN = {
+    name: 'Exchange',
+    version: '1',
+    chainId: config_1.EXCHANGE_CHAIN_ID,
+    verifyingContract: '0x0000000000000000000000000000000000000000',
+};
+const AGENT_TYPES = {
+    Agent: [
+        { name: 'source', type: 'string' },
+        { name: 'connectionId', type: 'bytes32' },
+    ],
+};
+// ----------------------------------------------------------------------------
+// msgpack helpers -- Hyperliquid requires int64 encoding for large integers
+// ----------------------------------------------------------------------------
+function convertLargeInts(obj) {
+    if (typeof obj === 'number' && Number.isInteger(obj) &&
+        (obj >= 0x100000000 || obj < -0x80000000)) {
+        return BigInt(obj);
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(convertLargeInts);
+    }
+    if (typeof obj === 'object' && obj !== null) {
+        const result = {};
+        for (const [key, val] of Object.entries(obj)) {
+            if (val !== undefined) {
+                result[key] = convertLargeInts(val);
+            }
+        }
+        return result;
+    }
+    return obj;
+}
+// ----------------------------------------------------------------------------
+// Action hash -- constructs the connectionId for the phantom agent
+// ----------------------------------------------------------------------------
+function computeActionHash(action, vaultAddress, nonce) {
+    // 1. msgpack-encode the action (large ints as int64)
+    const actionBytes = packr.pack(convertLargeInts(action));
+    // 2. nonce as 8 bytes big-endian
+    const nonceBytes = Buffer.alloc(8);
+    nonceBytes.writeBigUInt64BE(BigInt(nonce));
+    // 3. vault address marker
+    const parts = [Buffer.from(actionBytes), nonceBytes];
+    if (vaultAddress) {
+        parts.push(Buffer.from([0x01]));
+        parts.push(Buffer.from(vaultAddress.replace('0x', ''), 'hex'));
+    }
+    else {
+        parts.push(Buffer.from([0x00]));
+    }
+    // 4. keccak256 of concatenated bytes
+    return ethers_1.utils.keccak256(Buffer.concat(parts));
+}
+// ----------------------------------------------------------------------------
+// Price/size formatting -- must match Hyperliquid's wire format
+// ----------------------------------------------------------------------------
+function floatToWire(x) {
+    const rounded = x.toFixed(8);
+    if (Math.abs(parseFloat(rounded) - x) >= 1e-12) {
+        throw new Error(`floatToWire causes rounding: ${x}`);
+    }
+    return parseFloat(rounded).toString();
+}
+// ----------------------------------------------------------------------------
+// Auth class
+// ----------------------------------------------------------------------------
+class HyperliquidAuth {
+    wallet;
+    isMainnet;
+    constructor(credentials, testnet) {
+        if (!credentials.privateKey) {
+            throw new errors_1.AuthenticationError('Hyperliquid trading requires a privateKey for EIP-712 signing.', 'Hyperliquid');
+        }
+        let privateKey = credentials.privateKey;
+        if (privateKey.includes('\\n')) {
+            privateKey = privateKey.replace(/\\n/g, '\n');
+        }
+        const stripped = privateKey.startsWith('0x') ? privateKey.slice(2) : privateKey;
+        if (!/^[0-9a-fA-F]{64}$/.test(stripped)) {
+            throw new errors_1.AuthenticationError('Invalid private key format. Hyperliquid requires a 32-byte hex EVM private key (e.g. 0xabc123...).', 'Hyperliquid');
+        }
+        this.wallet = new ethers_1.Wallet(privateKey);
+        this.isMainnet = !testnet;
+    }
+    getAddress() {
+        return this.wallet.address;
+    }
+    /**
+     * Sign an L1 action using the phantom agent EIP-712 scheme.
+     *
+     * Flow:
+     *   1. msgpack-encode the action
+     *   2. Append nonce (8 bytes BE) + vault marker
+     *   3. keccak256 -> connectionId
+     *   4. EIP-712 sign {source, connectionId} with domain "Exchange"
+     */
+    async signL1Action(action, vaultAddress = null, nonce = Date.now()) {
+        const connectionId = computeActionHash(action, vaultAddress, nonce);
+        const message = {
+            source: this.isMainnet ? 'a' : 'b',
+            connectionId,
+        };
+        // ethers v5 uses _signTypedData (underscore prefix)
+        const sig = await this.wallet._signTypedData(EIP712_DOMAIN, AGENT_TYPES, message);
+        const split = ethers_1.utils.splitSignature(sig);
+        return {
+            signature: {
+                r: split.r,
+                s: split.s,
+                v: split.v,
+            },
+            nonce,
+        };
+    }
+    /**
+     * Build and sign a complete exchange request body.
+     */
+    async signExchangeRequest(action, vaultAddress = null) {
+        const nonce = Date.now();
+        const { signature } = await this.signL1Action(action, vaultAddress, nonce);
+        return {
+            action,
+            nonce,
+            signature,
+            vaultAddress,
+        };
+    }
+}
+exports.HyperliquidAuth = HyperliquidAuth;

package/dist/exchanges/hyperliquid/config.d.ts

@@ -0,0 +1,17 @@
+export declare const DEFAULT_HYPERLIQUID_BASE_URL = "https://api.hyperliquid.xyz";
+export declare const HYPERLIQUID_TESTNET_BASE_URL = "https://api.hyperliquid-testnet.xyz";
+export declare const HYPERLIQUID_WS_URL = "wss://api.hyperliquid.xyz/ws";
+export declare const HYPERLIQUID_TESTNET_WS_URL = "wss://api.hyperliquid-testnet.xyz/ws";
+export declare const OUTCOME_ASSET_BASE = 100000000;
+export declare const OUTCOME_MULTIPLIER = 10;
+export declare const SIDE_YES = 0;
+export declare const SIDE_NO = 1;
+export declare const EXCHANGE_DOMAIN = "Exchange";
+export declare const EXCHANGE_CHAIN_ID = 1337;
+export declare const MIN_ORDER_VALUE = 10;
+export interface HyperliquidApiConfig {
+    baseUrl: string;
+    wsUrl: string;
+    testnet: boolean;
+}
+export declare function getHyperliquidConfig(baseUrlOverride?: string, testnet?: boolean): HyperliquidApiConfig;

package/dist/exchanges/hyperliquid/config.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIN_ORDER_VALUE = exports.EXCHANGE_CHAIN_ID = exports.EXCHANGE_DOMAIN = exports.SIDE_NO = exports.SIDE_YES = exports.OUTCOME_MULTIPLIER = exports.OUTCOME_ASSET_BASE = exports.HYPERLIQUID_TESTNET_WS_URL = exports.HYPERLIQUID_WS_URL = exports.HYPERLIQUID_TESTNET_BASE_URL = exports.DEFAULT_HYPERLIQUID_BASE_URL = void 0;
+exports.getHyperliquidConfig = getHyperliquidConfig;
+exports.DEFAULT_HYPERLIQUID_BASE_URL = 'https://api.hyperliquid.xyz';
+exports.HYPERLIQUID_TESTNET_BASE_URL = 'https://api.hyperliquid-testnet.xyz';
+exports.HYPERLIQUID_WS_URL = 'wss://api.hyperliquid.xyz/ws';
+exports.HYPERLIQUID_TESTNET_WS_URL = 'wss://api.hyperliquid-testnet.xyz/ws';
+// HIP-4 Outcome Markets asset ID encoding
+// Asset ID = 100_000_000 + (10 * outcome_id) + side
+// side: 0 = Yes, 1 = No
+exports.OUTCOME_ASSET_BASE = 100_000_000;
+exports.OUTCOME_MULTIPLIER = 10;
+exports.SIDE_YES = 0;
+exports.SIDE_NO = 1;
+// EIP-712 signing constants
+exports.EXCHANGE_DOMAIN = 'Exchange';
+exports.EXCHANGE_CHAIN_ID = 1337;
+// Minimum order value in USDH
+exports.MIN_ORDER_VALUE = 10;
+function getHyperliquidConfig(baseUrlOverride, testnet) {
+    const isTestnet = testnet ?? false;
+    return {
+        baseUrl: baseUrlOverride ?? (isTestnet ? exports.HYPERLIQUID_TESTNET_BASE_URL : exports.DEFAULT_HYPERLIQUID_BASE_URL),
+        wsUrl: isTestnet ? exports.HYPERLIQUID_TESTNET_WS_URL : exports.HYPERLIQUID_WS_URL,
+        testnet: isTestnet,
+    };
+}

package/dist/exchanges/hyperliquid/errors.d.ts

@@ -0,0 +1,18 @@
+import { ErrorMapper } from '../../utils/error-mapper';
+import { BadRequest } from '../../errors';
+/**
+ * Maps Hyperliquid API errors to PMXT unified error classes.
+ *
+ * Hyperliquid returns errors as plain strings or JSON objects in
+ * the response body. Common patterns:
+ *   - "User has no account" -> AuthenticationError
+ *   - "Insufficient margin" -> InsufficientFunds
+ *   - "Invalid order" -> InvalidOrder
+ */
+export declare class HyperliquidErrorMapper extends ErrorMapper {
+    constructor();
+    protected extractErrorMessage(error: any): string;
+    protected mapBadRequestError(message: string, data: any): BadRequest;
+    mapError(error: any): ReturnType<ErrorMapper['mapError']>;
+}
+export declare const hyperliquidErrorMapper: HyperliquidErrorMapper;

package/dist/exchanges/hyperliquid/errors.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hyperliquidErrorMapper = exports.HyperliquidErrorMapper = void 0;
+const axios_1 = __importDefault(require("axios"));
+const error_mapper_1 = require("../../utils/error-mapper");
+const errors_1 = require("../../errors");
+/**
+ * Maps Hyperliquid API errors to PMXT unified error classes.
+ *
+ * Hyperliquid returns errors as plain strings or JSON objects in
+ * the response body. Common patterns:
+ *   - "User has no account" -> AuthenticationError
+ *   - "Insufficient margin" -> InsufficientFunds
+ *   - "Invalid order" -> InvalidOrder
+ */
+class HyperliquidErrorMapper extends error_mapper_1.ErrorMapper {
+    constructor() {
+        super('Hyperliquid');
+    }
+    extractErrorMessage(error) {
+        if (axios_1.default.isAxiosError(error) && error.response?.data) {
+            const data = error.response.data;
+            if (typeof data === 'string') {
+                return `[${error.response.status}] ${data}`;
+            }
+            if (data.status === 'err' && data.response) {
+                return `[${error.response.status}] ${data.response}`;
+            }
+        }
+        return super.extractErrorMessage(error);
+    }
+    mapBadRequestError(message, data) {
+        const lowerMessage = message.toLowerCase();
+        const responseStr = typeof data === 'object' && data?.response
+            ? String(data.response).toLowerCase()
+            : lowerMessage;
+        if (responseStr.includes('insufficient margin') || responseStr.includes('not enough')) {
+            return new errors_1.InsufficientFunds(message, this.exchangeName);
+        }
+        if (responseStr.includes('invalid order') || responseStr.includes('price out of range')) {
+            return new errors_1.InvalidOrder(message, this.exchangeName);
+        }
+        if (responseStr.includes('no account') || responseStr.includes('not authorized')) {
+            return new errors_1.AuthenticationError(message, this.exchangeName);
+        }
+        return super.mapBadRequestError(message, data);
+    }
+    mapError(error) {
+        if (axios_1.default.isAxiosError(error) && error.response?.status === 429) {
+            const retryAfter = error.response.headers?.['retry-after'];
+            const retryAfterSeconds = retryAfter ? parseInt(retryAfter, 10) : undefined;
+            return new errors_1.RateLimitExceeded(this.extractErrorMessage(error), retryAfterSeconds, this.exchangeName);
+        }
+        return super.mapError(error);
+    }
+}
+exports.HyperliquidErrorMapper = HyperliquidErrorMapper;
+exports.hyperliquidErrorMapper = new HyperliquidErrorMapper();