pmxt-core 2.37.14 → 2.38.0

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();

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

@@ -0,0 +1,140 @@
+import { MarketFilterParams, EventFetchParams, OHLCVParams, TradesParams } from '../../BaseExchange';
+import { IExchangeFetcher, FetcherContext } from '../interfaces';
+export interface HyperliquidRawSideSpec {
+    name: string;
+    token?: number;
+}
+export interface HyperliquidRawOutcome {
+    outcome: number;
+    name: string;
+    description: string;
+    sideSpecs: HyperliquidRawSideSpec[];
+}
+export interface HyperliquidRawQuestion {
+    question: number;
+    name: string;
+    description: string;
+    fallbackOutcome: number;
+    namedOutcomes: number[];
+    settledNamedOutcomes: number[];
+}
+export interface HyperliquidRawOutcomeMeta {
+    outcomes: HyperliquidRawOutcome[];
+    questions: HyperliquidRawQuestion[];
+}
+export interface HyperliquidRawL2Level {
+    px: string;
+    sz: string;
+    n: number;
+}
+export interface HyperliquidRawL2Book {
+    coin: string;
+    levels: [HyperliquidRawL2Level[], HyperliquidRawL2Level[]];
+    time: number;
+}
+export interface HyperliquidRawCandle {
+    t: number;
+    T: number;
+    s: string;
+    i: string;
+    o: string;
+    c: string;
+    h: string;
+    l: string;
+    v: string;
+    n: number;
+}
+export interface HyperliquidRawTrade {
+    coin: string;
+    side: string;
+    px: string;
+    sz: string;
+    hash: string;
+    time: number;
+    tid: number;
+}
+export interface HyperliquidRawMid {
+    [coin: string]: string;
+}
+export interface HyperliquidRawFill {
+    coin: string;
+    px: string;
+    sz: string;
+    side: string;
+    time: number;
+    startPosition: string;
+    dir: string;
+    closedPnl: string;
+    hash: string;
+    oid: number;
+    crossed: boolean;
+    fee: string;
+    tid: number;
+    feeToken: string;
+}
+export interface HyperliquidRawOpenOrder {
+    coin: string;
+    limitPx: string;
+    oid: number;
+    side: string;
+    sz: string;
+    timestamp: number;
+    origSz: string;
+    cloid?: string;
+}
+export interface HyperliquidRawPosition {
+    coin: string;
+    entryPx: string | null;
+    leverage: {
+        type: string;
+        value: number;
+    };
+    liquidationPx: string | null;
+    marginUsed: string;
+    maxTradeSzs: [string, string];
+    positionValue: string;
+    returnOnEquity: string;
+    szi: string;
+    unrealizedPnl: string;
+}
+export interface HyperliquidRawUserState {
+    assetPositions: Array<{
+        position: HyperliquidRawPosition;
+        type: string;
+    }>;
+    crossMarginSummary: {
+        accountValue: string;
+        totalMarginUsed: string;
+        totalNtlPos: string;
+        totalRawUsd: string;
+    };
+    marginSummary: {
+        accountValue: string;
+        totalMarginUsed: string;
+        totalNtlPos: string;
+        totalRawUsd: string;
+    };
+    withdrawable: string;
+}
+export interface HyperliquidRawOutcomeWithQuestion {
+    outcome: HyperliquidRawOutcome;
+    question: HyperliquidRawQuestion | undefined;
+    midPrice: string | undefined;
+}
+export declare class HyperliquidFetcher implements IExchangeFetcher<HyperliquidRawOutcomeWithQuestion, HyperliquidRawQuestion> {
+    private readonly ctx;
+    private readonly baseUrl;
+    constructor(ctx: FetcherContext, baseUrl: string);
+    private postInfo;
+    fetchRawMarkets(params?: MarketFilterParams): Promise<HyperliquidRawOutcomeWithQuestion[]>;
+    fetchRawEvents(params: EventFetchParams): Promise<HyperliquidRawQuestion[]>;
+    fetchRawOrderBook(marketId: string): Promise<HyperliquidRawL2Book>;
+    fetchRawOHLCV(marketId: string, params: OHLCVParams): Promise<HyperliquidRawCandle[]>;
+    fetchRawTrades(marketId: string, _params: TradesParams): Promise<HyperliquidRawTrade[]>;
+    fetchRawUserFills(walletAddress: string): Promise<HyperliquidRawFill[]>;
+    fetchRawOpenOrders(walletAddress: string): Promise<HyperliquidRawOpenOrder[]>;
+    fetchRawUserState(walletAddress: string): Promise<HyperliquidRawUserState>;
+    fetchOutcomeMeta(): Promise<HyperliquidRawOutcomeMeta>;
+    fetchAllMids(): Promise<HyperliquidRawMid>;
+    private getMidForOutcome;
+}

package/dist/exchanges/hyperliquid/fetcher.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperliquidFetcher = void 0;
+const errors_1 = require("./errors");
+const utils_1 = require("./utils");
+// ----------------------------------------------------------------------------
+// Fetcher
+// ----------------------------------------------------------------------------
+class HyperliquidFetcher {
+    ctx;
+    baseUrl;
+    constructor(ctx, baseUrl) {
+        this.ctx = ctx;
+        this.baseUrl = baseUrl;
+    }
+    // -- Info endpoint helper --------------------------------------------------
+    async postInfo(body) {
+        try {
+            const response = await this.ctx.http.post(`${this.baseUrl}/info`, body);
+            return response.data;
+        }
+        catch (error) {
+            throw errors_1.hyperliquidErrorMapper.mapError(error);
+        }
+    }
+    // -- Markets (outcomes) ----------------------------------------------------
+    async fetchRawMarkets(params) {
+        const [meta, mids] = await Promise.all([
+            this.fetchOutcomeMeta(),
+            this.fetchAllMids(),
+        ]);
+        const questionMap = new Map();
+        for (const q of meta.questions) {
+            for (const outcomeId of q.namedOutcomes) {
+                questionMap.set(outcomeId, q);
+            }
+        }
+        let results = meta.outcomes.map(outcome => ({
+            outcome,
+            question: questionMap.get(outcome.outcome),
+            midPrice: this.getMidForOutcome(mids, outcome.outcome),
+        }));
+        // Filter settled outcomes out by default (active only)
+        if (!params?.status || params.status === 'active') {
+            const settledSet = new Set();
+            for (const q of meta.questions) {
+                for (const settled of q.settledNamedOutcomes) {
+                    settledSet.add(settled);
+                }
+            }
+            results = results.filter(r => !settledSet.has(r.outcome.outcome));
+        }
+        // Client-side search
+        if (params?.query) {
+            const lowerQuery = params.query.toLowerCase();
+            results = results.filter(r => r.outcome.name.toLowerCase().includes(lowerQuery) ||
+                r.outcome.description.toLowerCase().includes(lowerQuery));
+        }
+        // Limit
+        const limit = params?.limit || 250000;
+        const offset = params?.offset || 0;
+        return results.slice(offset, offset + limit);
+    }
+    // -- Events (questions) ----------------------------------------------------
+    async fetchRawEvents(params) {
+        const meta = await this.fetchOutcomeMeta();
+        let results = [...meta.questions];
+        // Filter by query
+        if (params?.query) {
+            const lowerQuery = params.query.toLowerCase();
+            results = results.filter(q => q.name.toLowerCase().includes(lowerQuery) ||
+                q.description.toLowerCase().includes(lowerQuery));
+        }
+        // Filter settled
+        if (!params?.status || params.status === 'active') {
+            results = results.filter(q => q.namedOutcomes.length > q.settledNamedOutcomes.length);
+        }
+        const limit = params?.limit || 250000;
+        const offset = params?.offset || 0;
+        return results.slice(offset, offset + limit);
+    }
+    // -- OrderBook -------------------------------------------------------------
+    async fetchRawOrderBook(marketId) {
+        const outcomeId = (0, utils_1.fromMarketId)(marketId);
+        const coin = (0, utils_1.toCoinNotation)(outcomeId, 'yes');
+        return this.postInfo({ type: 'l2Book', coin });
+    }
+    // -- OHLCV (candles) -------------------------------------------------------
+    async fetchRawOHLCV(marketId, params) {
+        const outcomeId = (0, utils_1.fromMarketId)(marketId);
+        const coin = (0, utils_1.toCoinNotation)(outcomeId, 'yes');
+        const now = Date.now();
+        const startTime = params.start ? params.start.getTime() : now - 24 * 60 * 60 * 1000;
+        const endTime = params.end ? params.end.getTime() : now;
+        return this.postInfo({
+            type: 'candleSnapshot',
+            req: { coin, interval: params.resolution || '1h', startTime, endTime },
+        });
+    }
+    // -- Trades ----------------------------------------------------------------
+    async fetchRawTrades(marketId, _params) {
+        const outcomeId = (0, utils_1.fromMarketId)(marketId);
+        const coin = (0, utils_1.toCoinNotation)(outcomeId, 'yes');
+        return this.postInfo({ type: 'recentTrades', coin });
+    }
+    // -- User data -------------------------------------------------------------
+    async fetchRawUserFills(walletAddress) {
+        return this.postInfo({
+            type: 'userFills',
+            user: walletAddress,
+        });
+    }
+    async fetchRawOpenOrders(walletAddress) {
+        return this.postInfo({
+            type: 'openOrders',
+            user: walletAddress,
+        });
+    }
+    async fetchRawUserState(walletAddress) {
+        return this.postInfo({
+            type: 'clearinghouseState',
+            user: walletAddress,
+        });
+    }
+    // -- Shared helpers --------------------------------------------------------
+    async fetchOutcomeMeta() {
+        return this.postInfo({ type: 'outcomeMeta' });
+    }
+    async fetchAllMids() {
+        return this.postInfo({ type: 'allMids' });
+    }
+    getMidForOutcome(mids, outcomeId) {
+        const yesCoin = (0, utils_1.toCoinNotation)(outcomeId, 'yes');
+        return mids[yesCoin];
+    }
+}
+exports.HyperliquidFetcher = HyperliquidFetcher;

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

@@ -0,0 +1,31 @@
+import { PredictionMarketExchange, MarketFilterParams, EventFetchParams, OHLCVParams, TradesParams, ExchangeCredentials, MyTradesParams } from '../../BaseExchange';
+import { UnifiedMarket, UnifiedEvent, OrderBook, PriceCandle, Trade, UserTrade, Balance, Position, Order, CreateOrderParams, BuiltOrder } from '../../types';
+export interface HyperliquidExchangeOptions {
+    credentials?: ExchangeCredentials;
+    testnet?: boolean;
+}
+export declare class HyperliquidExchange extends PredictionMarketExchange {
+    private readonly config;
+    private readonly fetcher;
+    private readonly normalizer;
+    private readonly walletAddress?;
+    private readonly auth?;
+    constructor(credentials?: ExchangeCredentials | HyperliquidExchangeOptions);
+    get name(): string;
+    private requireWallet;
+    private requireAuth;
+    protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
+    protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
+    fetchOrderBook(outcomeId: string): Promise<OrderBook>;
+    fetchOHLCV(outcomeId: string, params: OHLCVParams): Promise<PriceCandle[]>;
+    fetchTrades(outcomeId: string, params?: TradesParams): Promise<Trade[]>;
+    fetchBalance(): Promise<Balance[]>;
+    fetchPositions(): Promise<Position[]>;
+    fetchOpenOrders(): Promise<Order[]>;
+    fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
+    buildOrder(params: CreateOrderParams): Promise<BuiltOrder>;
+    submitOrder(built: BuiltOrder): Promise<Order>;
+    createOrder(params: CreateOrderParams): Promise<Order>;
+    cancelOrder(orderId: string): Promise<Order>;
+    close(): Promise<void>;
+}