pmxt-core 2.37.14 → 2.39.0

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>;
+}

package/dist/exchanges/hyperliquid/index.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperliquidExchange = void 0;
+const BaseExchange_1 = require("../../BaseExchange");
+const errors_1 = require("../../errors");
+const config_1 = require("./config");
+const fetcher_1 = require("./fetcher");
+const normalizer_1 = require("./normalizer");
+const auth_1 = require("./auth");
+const errors_2 = require("./errors");
+class HyperliquidExchange extends BaseExchange_1.PredictionMarketExchange {
+    config;
+    fetcher;
+    normalizer;
+    walletAddress;
+    auth;
+    constructor(credentials) {
+        const opts = credentials && 'credentials' in credentials
+            ? credentials
+            : { credentials: credentials };
+        super(opts.credentials);
+        this.rateLimit = 200;
+        const testnet = 'testnet' in opts ? opts.testnet : false;
+        this.config = (0, config_1.getHyperliquidConfig)(opts.credentials?.baseUrl, testnet);
+        // Initialize auth if privateKey is provided (needed for trading)
+        if (opts.credentials?.privateKey) {
+            this.auth = new auth_1.HyperliquidAuth(opts.credentials, this.config.testnet);
+            this.walletAddress = this.auth.getAddress();
+        }
+        else {
+            // For read-only usage, users can pass walletAddress as apiKey
+            this.walletAddress = opts.credentials?.apiKey || undefined;
+        }
+        const ctx = {
+            http: this.http,
+            callApi: this.callApi.bind(this),
+            getHeaders: () => ({}),
+        };
+        this.fetcher = new fetcher_1.HyperliquidFetcher(ctx, this.config.baseUrl);
+        this.normalizer = new normalizer_1.HyperliquidNormalizer();
+    }
+    get name() {
+        return 'Hyperliquid';
+    }
+    // -------------------------------------------------------------------------
+    // Auth helpers
+    // -------------------------------------------------------------------------
+    requireWallet() {
+        if (!this.walletAddress) {
+            throw new errors_1.AuthenticationError('This operation requires a wallet address. ' +
+                'Initialize HyperliquidExchange with credentials (apiKey = wallet address, or privateKey for trading).', 'Hyperliquid');
+        }
+        return this.walletAddress;
+    }
+    requireAuth() {
+        if (!this.auth) {
+            throw new errors_1.AuthenticationError('Trading requires a privateKey for EIP-712 signing. ' +
+                'Initialize HyperliquidExchange with credentials including privateKey.', 'Hyperliquid');
+        }
+        return this.auth;
+    }
+    // -------------------------------------------------------------------------
+    // Market Data
+    // -------------------------------------------------------------------------
+    async fetchMarketsImpl(params) {
+        const rawOutcomes = await this.fetcher.fetchRawMarkets(params);
+        return rawOutcomes
+            .map(r => this.normalizer.normalizeMarket(r))
+            .filter((m) => m !== null);
+    }
+    async fetchEventsImpl(params) {
+        const [rawQuestions, meta, mids] = await Promise.all([
+            this.fetcher.fetchRawEvents(params),
+            this.fetcher.fetchOutcomeMeta(),
+            this.fetcher.fetchAllMids(),
+        ]);
+        return rawQuestions
+            .map(q => this.normalizer.normalizeEventWithMarkets(q, meta, mids))
+            .filter((e) => e !== null);
+    }
+    async fetchOrderBook(outcomeId) {
+        const raw = await this.fetcher.fetchRawOrderBook(outcomeId);
+        return this.normalizer.normalizeOrderBook(raw, outcomeId);
+    }
+    async fetchOHLCV(outcomeId, params) {
+        const raw = await this.fetcher.fetchRawOHLCV(outcomeId, params);
+        return this.normalizer.normalizeOHLCV(raw, params);
+    }
+    async fetchTrades(outcomeId, params) {
+        const raw = await this.fetcher.fetchRawTrades(outcomeId, params || {});
+        return raw.map((r, i) => this.normalizer.normalizeTrade(r, i));
+    }
+    // -------------------------------------------------------------------------
+    // User Data
+    // -------------------------------------------------------------------------
+    async fetchBalance() {
+        const wallet = this.requireWallet();
+        const raw = await this.fetcher.fetchRawUserState(wallet);
+        return this.normalizer.normalizeBalance(raw);
+    }
+    async fetchPositions() {
+        const wallet = this.requireWallet();
+        const raw = await this.fetcher.fetchRawUserState(wallet);
+        return raw.assetPositions
+            .filter(ap => ap.position.coin.startsWith('#'))
+            .map(ap => this.normalizer.normalizePosition(ap.position));
+    }
+    async fetchOpenOrders() {
+        const wallet = this.requireWallet();
+        const raw = await this.fetcher.fetchRawOpenOrders(wallet);
+        return raw
+            .filter(o => o.coin.startsWith('#'))
+            .map(o => this.normalizer.normalizeOpenOrder(o));
+    }
+    async fetchMyTrades(params) {
+        const wallet = this.requireWallet();
+        const raw = await this.fetcher.fetchRawUserFills(wallet);
+        return raw
+            .filter(f => f.coin.startsWith('#'))
+            .map((f, i) => this.normalizer.normalizeUserTrade(f, i));
+    }
+    // -------------------------------------------------------------------------
+    // Trading (EIP-712 signing required)
+    // -------------------------------------------------------------------------
+    async buildOrder(params) {
+        const assetId = parseInt(params.outcomeId, 10);
+        // Key order matters for msgpack hash: a, b, p, s, r, t, c
+        const orderWire = {
+            a: assetId,
+            b: params.side === 'buy',
+            p: params.price !== undefined ? (0, auth_1.floatToWire)(params.price) : '0.5',
+            s: (0, auth_1.floatToWire)(params.amount),
+            r: false,
+            t: params.type === 'market'
+                ? { limit: { tif: 'Ioc' } }
+                : { limit: { tif: 'Gtc' } },
+        };
+        // Key order matters for msgpack hash: type, orders, grouping
+        const action = {
+            type: 'order',
+            orders: [orderWire],
+            grouping: 'na',
+        };
+        return {
+            exchange: this.name,
+            params,
+            raw: action,
+        };
+    }
+    async submitOrder(built) {
+        const auth = this.requireAuth();
+        const action = built.raw;
+        try {
+            const requestBody = await auth.signExchangeRequest(action);
+            const response = await this.http.post(`${this.config.baseUrl}/exchange`, requestBody);
+            const data = response.data;
+            if (data.status === 'err') {
+                throw errors_2.hyperliquidErrorMapper.mapError(new Error(data.response || 'Order submission failed'));
+            }
+            const resting = data.response?.data?.statuses?.[0];
+            return {
+                id: resting?.resting?.oid ? String(resting.resting.oid) : 'unknown',
+                marketId: built.params.marketId,
+                outcomeId: built.params.outcomeId,
+                side: built.params.side,
+                type: built.params.type,
+                price: built.params.price,
+                amount: built.params.amount,
+                status: resting?.resting ? 'open' : 'filled',
+                filled: resting?.filled?.totalSz ? parseFloat(resting.filled.totalSz) : 0,
+                remaining: built.params.amount - (resting?.filled?.totalSz ? parseFloat(resting.filled.totalSz) : 0),
+                timestamp: Date.now(),
+            };
+        }
+        catch (error) {
+            throw errors_2.hyperliquidErrorMapper.mapError(error);
+        }
+    }
+    async createOrder(params) {
+        const built = await this.buildOrder(params);
+        return this.submitOrder(built);
+    }
+    async cancelOrder(orderId) {
+        const auth = this.requireAuth();
+        // Key order matters for msgpack hash: type, cancels
+        // Each cancel entry: a (asset), o (order id)
+        const action = {
+            type: 'cancel',
+            cancels: [{ a: 0, o: parseInt(orderId, 10) }],
+        };
+        try {
+            const requestBody = await auth.signExchangeRequest(action);
+            const response = await this.http.post(`${this.config.baseUrl}/exchange`, requestBody);
+            const data = response.data;
+            if (data.status === 'err') {
+                throw new Error(data.response || 'Cancel failed');
+            }
+            return {
+                id: orderId,
+                marketId: '',
+                outcomeId: '',
+                side: 'buy',
+                type: 'limit',
+                amount: 0,
+                status: 'cancelled',
+                filled: 0,
+                remaining: 0,
+                timestamp: Date.now(),
+            };
+        }
+        catch (error) {
+            throw errors_2.hyperliquidErrorMapper.mapError(error);
+        }
+    }
+    async close() {
+        // No persistent connections to clean up
+    }
+}
+exports.HyperliquidExchange = HyperliquidExchange;

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

@@ -0,0 +1,18 @@
+import { UnifiedMarket, UnifiedEvent, OrderBook, PriceCandle, Trade, UserTrade, Position, Balance, Order } from '../../types';
+import { IExchangeNormalizer } from '../interfaces';
+import { OHLCVParams } from '../../BaseExchange';
+import { HyperliquidRawOutcomeWithQuestion, HyperliquidRawQuestion, HyperliquidRawL2Book, HyperliquidRawCandle, HyperliquidRawTrade, HyperliquidRawFill, HyperliquidRawOpenOrder, HyperliquidRawPosition, HyperliquidRawUserState, HyperliquidRawOutcomeMeta, HyperliquidRawMid } from './fetcher';
+export declare class HyperliquidNormalizer implements IExchangeNormalizer<HyperliquidRawOutcomeWithQuestion, HyperliquidRawQuestion> {
+    normalizeMarket(raw: HyperliquidRawOutcomeWithQuestion): UnifiedMarket | null;
+    normalizeEvent(raw: HyperliquidRawQuestion): UnifiedEvent | null;
+    normalizeEventWithMarkets(raw: HyperliquidRawQuestion, outcomeMeta: HyperliquidRawOutcomeMeta, mids: HyperliquidRawMid): UnifiedEvent | null;
+    normalizeOrderBook(raw: HyperliquidRawL2Book, _id: string): OrderBook;
+    normalizeOHLCV(raw: HyperliquidRawCandle[], _params: OHLCVParams): PriceCandle[];
+    normalizeTrade(raw: HyperliquidRawTrade, _index: number): Trade;
+    normalizeUserTrade(raw: HyperliquidRawFill, _index: number): UserTrade;
+    normalizeOpenOrder(raw: HyperliquidRawOpenOrder): Order;
+    normalizePosition(raw: HyperliquidRawPosition): Position;
+    normalizeBalance(raw: HyperliquidRawUserState): Balance[];
+    private coinToMarketId;
+    private coinToOutcomeId;
+}