pmxt-core 2.37.14 → 2.38.0

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

package/dist/exchanges/hyperliquid/normalizer.js

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperliquidNormalizer = void 0;
+const market_utils_1 = require("../../utils/market-utils");
+const utils_1 = require("./utils");
+const config_1 = require("./config");
+function parseDescription(description) {
+    // Hyperliquid outcome descriptions use key:value pairs separated by |
+    // e.g. "class:priceBinary|underlying:BTC|expiry:20260509-0600|targetPrice:79583|period:1d"
+    // or simple values like "other", "index:0"
+    const result = { raw: description };
+    const parts = description.split('|');
+    for (const part of parts) {
+        const colonIdx = part.indexOf(':');
+        if (colonIdx === -1)
+            continue;
+        const key = part.slice(0, colonIdx);
+        const value = part.slice(colonIdx + 1);
+        switch (key) {
+            case 'class':
+                result.class = value;
+                break;
+            case 'underlying':
+                result.underlying = value;
+                break;
+            case 'expiry': {
+                result.expiry = value;
+                result.expiryDate = parseExpiryDate(value);
+                break;
+            }
+            case 'targetPrice':
+                result.targetPrice = value;
+                break;
+            case 'priceThresholds':
+                result.priceThresholds = value.split(',');
+                break;
+            case 'period':
+                result.period = value;
+                break;
+            case 'index':
+                result.index = value;
+                break;
+        }
+    }
+    return result;
+}
+/**
+ * Parse Hyperliquid's expiry format "YYYYMMDD-HHmm" into a Date.
+ * Example: "20260509-0600" -> 2026-05-09T06:00:00Z
+ */
+function parseExpiryDate(expiry) {
+    const match = expiry.match(/^(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})$/);
+    if (!match)
+        return undefined;
+    const [, year, month, day, hour, minute] = match;
+    return new Date(`${year}-${month}-${day}T${hour}:${minute}:00Z`);
+}
+/**
+ * Build a human-readable title from the parsed description.
+ */
+function buildTitle(rawName, parsed, questionParsed) {
+    // priceBinary: "BTC > $79,583 @ May 9, 2026"
+    if (parsed.class === 'priceBinary' && parsed.underlying && parsed.targetPrice) {
+        const price = Number(parsed.targetPrice).toLocaleString('en-US');
+        const dateStr = parsed.expiryDate
+            ? parsed.expiryDate.toISOString().replace('T', ' ').replace(':00.000Z', ' UTC')
+            : '';
+        return `${parsed.underlying} > $${price}${dateStr ? ` @ ${dateStr}` : ''}`;
+    }
+    // Named outcome in a priceBucket question: use thresholds from question
+    if (parsed.index !== undefined && questionParsed?.priceThresholds && questionParsed.underlying) {
+        const idx = parseInt(parsed.index, 10);
+        const thresholds = questionParsed.priceThresholds;
+        const underlying = questionParsed.underlying;
+        if (idx === 0 && thresholds.length > 0) {
+            return `${underlying} < $${Number(thresholds[0]).toLocaleString('en-US')}`;
+        }
+        if (idx === thresholds.length) {
+            return `${underlying} > $${Number(thresholds[thresholds.length - 1]).toLocaleString('en-US')}`;
+        }
+        if (idx > 0 && idx <= thresholds.length) {
+            const lo = Number(thresholds[idx - 1]).toLocaleString('en-US');
+            const hi = Number(thresholds[idx]).toLocaleString('en-US');
+            return `${underlying} $${lo} - $${hi}`;
+        }
+    }
+    return rawName;
+}
+function buildMarketUrl(outcomeId) {
+    return `https://app.hyperliquid.xyz/trade/${encodeURIComponent(`#${outcomeId * 10}`)}`;
+}
+function buildEventUrl(questionId) {
+    return `https://app.hyperliquid.xyz/trade/${encodeURIComponent(`#${questionId}`)}`;
+}
+function isOutcomeCoin(coin) {
+    return coin.startsWith('#');
+}
+// ----------------------------------------------------------------------------
+// Normalizer
+// ----------------------------------------------------------------------------
+class HyperliquidNormalizer {
+    normalizeMarket(raw) {
+        if (!raw || !raw.outcome)
+            return null;
+        const outcome = raw.outcome;
+        const outcomeId = outcome.outcome;
+        const parsed = parseDescription(outcome.description);
+        // Also parse the question description for context (e.g. priceThresholds)
+        const questionParsed = raw.question
+            ? parseDescription(raw.question.description)
+            : undefined;
+        const midPrice = raw.midPrice ? parseFloat(raw.midPrice) : 0.5;
+        const yesPrice = Math.max(0, Math.min(1, midPrice));
+        const noPrice = Math.max(0, Math.min(1, 1 - midPrice));
+        const outcomes = [];
+        for (const side of outcome.sideSpecs) {
+            const sideKey = side.name.toLowerCase() === 'yes' ? 'yes' : 'no';
+            outcomes.push({
+                outcomeId: (0, utils_1.toOutcomeId)(outcomeId, sideKey),
+                marketId: (0, utils_1.toMarketId)(outcomeId),
+                label: side.name,
+                price: sideKey === 'yes' ? yesPrice : noPrice,
+            });
+        }
+        // If no sideSpecs provided, default to Yes/No
+        if (outcomes.length === 0) {
+            outcomes.push({
+                outcomeId: (0, utils_1.toOutcomeId)(outcomeId, 'yes'),
+                marketId: (0, utils_1.toMarketId)(outcomeId),
+                label: 'Yes',
+                price: yesPrice,
+            }, {
+                outcomeId: (0, utils_1.toOutcomeId)(outcomeId, 'no'),
+                marketId: (0, utils_1.toMarketId)(outcomeId),
+                label: 'No',
+                price: noPrice,
+            });
+        }
+        // Resolution date: prefer outcome-level expiry, fall back to question-level
+        const expiryDate = parsed.expiryDate
+            ?? questionParsed?.expiryDate
+            ?? undefined;
+        // Build a descriptive title from the parsed description
+        const title = buildTitle(outcome.name, parsed, questionParsed);
+        // Derive underlying from outcome or question
+        const underlying = parsed.underlying ?? questionParsed?.underlying;
+        const tags = [];
+        if (underlying) {
+            tags.push(underlying);
+        }
+        tags.push('Outcome Markets');
+        const category = underlying ? 'Crypto' : undefined;
+        const um = {
+            marketId: (0, utils_1.toMarketId)(outcomeId),
+            eventId: raw.question ? String(raw.question.question) : undefined,
+            title,
+            description: outcome.description,
+            slug: `hl-${outcomeId}`,
+            outcomes,
+            resolutionDate: expiryDate ?? new Date(0),
+            volume24h: 0,
+            liquidity: 0,
+            url: buildMarketUrl(outcomeId),
+            category,
+            tags,
+            tickSize: 0.001,
+            status: 'active',
+        };
+        (0, market_utils_1.addBinaryOutcomes)(um);
+        return um;
+    }
+    normalizeEvent(raw) {
+        if (!raw)
+            return null;
+        const parsed = parseDescription(raw.description);
+        const underlying = parsed.underlying;
+        // Build a more descriptive event title
+        let title = raw.name;
+        if (parsed.class === 'priceBucket' && underlying && parsed.priceThresholds) {
+            const thresholds = parsed.priceThresholds.map(t => `$${Number(t).toLocaleString('en-US')}`).join(', ');
+            const dateStr = parsed.expiryDate
+                ? parsed.expiryDate.toISOString().replace('T', ' ').replace(':00.000Z', ' UTC')
+                : '';
+            title = `${underlying} Price Bucket [${thresholds}]${dateStr ? ` @ ${dateStr}` : ''}`;
+        }
+        const tags = ['Outcome Markets'];
+        if (underlying)
+            tags.push(underlying);
+        return {
+            id: String(raw.question),
+            title,
+            description: raw.description,
+            slug: `hl-question-${raw.question}`,
+            markets: [],
+            volume24h: 0,
+            url: buildEventUrl(raw.question),
+            category: underlying ? 'Crypto' : undefined,
+            tags,
+        };
+    }
+    normalizeEventWithMarkets(raw, outcomeMeta, mids) {
+        const event = this.normalizeEvent(raw);
+        if (!event)
+            return null;
+        const markets = [];
+        for (const outcomeId of raw.namedOutcomes) {
+            if (raw.settledNamedOutcomes.includes(outcomeId))
+                continue;
+            const outcome = outcomeMeta.outcomes.find(o => o.outcome === outcomeId);
+            if (!outcome)
+                continue;
+            const yesCoin = (0, utils_1.toCoinNotation)(outcomeId, 'yes');
+            const midPrice = mids[yesCoin];
+            const market = this.normalizeMarket({
+                outcome,
+                question: raw,
+                midPrice,
+            });
+            if (market) {
+                markets.push(market);
+            }
+        }
+        return {
+            ...event,
+            markets,
+            volume24h: markets.reduce((sum, m) => sum + m.volume24h, 0),
+        };
+    }
+    normalizeOrderBook(raw, _id) {
+        const [rawBids, rawAsks] = raw.levels;
+        const bids = rawBids.map(level => ({
+            price: parseFloat(level.px),
+            size: parseFloat(level.sz),
+        }));
+        const asks = rawAsks.map(level => ({
+            price: parseFloat(level.px),
+            size: parseFloat(level.sz),
+        }));
+        return {
+            bids: [...bids].sort((a, b) => b.price - a.price),
+            asks: [...asks].sort((a, b) => a.price - b.price),
+            timestamp: raw.time,
+        };
+    }
+    normalizeOHLCV(raw, _params) {
+        return raw.map(candle => ({
+            timestamp: candle.t,
+            open: parseFloat(candle.o),
+            high: parseFloat(candle.h),
+            low: parseFloat(candle.l),
+            close: parseFloat(candle.c),
+            volume: parseFloat(candle.v),
+        }));
+    }
+    normalizeTrade(raw, _index) {
+        return {
+            id: String(raw.tid),
+            timestamp: raw.time,
+            price: parseFloat(raw.px),
+            amount: parseFloat(raw.sz),
+            side: raw.side === 'B' ? 'buy' : raw.side === 'A' ? 'sell' : 'unknown',
+        };
+    }
+    normalizeUserTrade(raw, _index) {
+        return {
+            id: String(raw.tid),
+            timestamp: raw.time,
+            price: parseFloat(raw.px),
+            amount: parseFloat(raw.sz),
+            side: raw.side === 'B' ? 'buy' : raw.side === 'A' ? 'sell' : 'unknown',
+            orderId: String(raw.oid),
+        };
+    }
+    normalizeOpenOrder(raw) {
+        const origSz = parseFloat(raw.origSz);
+        const currentSz = parseFloat(raw.sz);
+        return {
+            id: String(raw.oid),
+            marketId: this.coinToMarketId(raw.coin),
+            outcomeId: this.coinToOutcomeId(raw.coin),
+            side: raw.side === 'B' ? 'buy' : 'sell',
+            type: 'limit',
+            price: parseFloat(raw.limitPx),
+            amount: origSz,
+            status: currentSz < origSz ? 'open' : 'pending',
+            filled: origSz - currentSz,
+            remaining: currentSz,
+            timestamp: raw.timestamp,
+        };
+    }
+    normalizePosition(raw) {
+        if (!isOutcomeCoin(raw.coin)) {
+            return {
+                marketId: raw.coin,
+                outcomeId: raw.coin,
+                outcomeLabel: raw.coin,
+                size: parseFloat(raw.szi),
+                entryPrice: raw.entryPx ? parseFloat(raw.entryPx) : 0,
+                currentPrice: 0,
+                unrealizedPnL: parseFloat(raw.unrealizedPnl),
+            };
+        }
+        return {
+            marketId: this.coinToMarketId(raw.coin),
+            outcomeId: this.coinToOutcomeId(raw.coin),
+            outcomeLabel: raw.coin,
+            size: parseFloat(raw.szi),
+            entryPrice: raw.entryPx ? parseFloat(raw.entryPx) : 0,
+            currentPrice: 0,
+            unrealizedPnL: parseFloat(raw.unrealizedPnl),
+        };
+    }
+    normalizeBalance(raw) {
+        const summary = raw.crossMarginSummary;
+        const total = parseFloat(summary.accountValue);
+        const locked = parseFloat(summary.totalMarginUsed);
+        return [{
+                currency: 'USDH',
+                total,
+                available: total - locked,
+                locked,
+            }];
+    }
+    // -- Private helpers -------------------------------------------------------
+    coinToMarketId(coin) {
+        if (!coin.startsWith('#'))
+            return coin;
+        const encoding = parseInt(coin.slice(1), 10);
+        const { outcomeId } = (0, utils_1.decodeAssetId)(config_1.OUTCOME_ASSET_BASE + encoding);
+        return (0, utils_1.toMarketId)(outcomeId);
+    }
+    coinToOutcomeId(coin) {
+        if (!coin.startsWith('#'))
+            return coin;
+        const encoding = parseInt(coin.slice(1), 10);
+        return String(config_1.OUTCOME_ASSET_BASE + encoding);
+    }
+}
+exports.HyperliquidNormalizer = HyperliquidNormalizer;

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

@@ -0,0 +1,41 @@
+/**
+ * Encode an outcome ID and side into a Hyperliquid asset ID.
+ *
+ * Formula: 100_000_000 + (10 * outcomeId) + side
+ * where side = 0 (Yes) or 1 (No).
+ */
+export declare function encodeAssetId(outcomeId: number, side: 'yes' | 'no'): number;
+/**
+ * Decode a Hyperliquid asset ID back into outcome ID and side.
+ */
+export declare function decodeAssetId(assetId: number): {
+    outcomeId: number;
+    side: 'yes' | 'no';
+};
+/**
+ * Convert an outcome ID and side to the Hyperliquid coin notation (#encoding).
+ *
+ * Example: outcome 1, Yes -> "#10"
+ */
+export declare function toCoinNotation(outcomeId: number, side: 'yes' | 'no'): string;
+/**
+ * Convert an asset encoding (the number after #) to outcome ID and side.
+ */
+export declare function fromCoinEncoding(encoding: number): {
+    outcomeId: number;
+    side: 'yes' | 'no';
+};
+/**
+ * Build a unique market ID string from an outcome.
+ * We use "hl-outcome-{outcomeId}" as the market ID.
+ */
+export declare function toMarketId(outcomeId: number): string;
+/**
+ * Extract the numeric outcome ID from our market ID format.
+ */
+export declare function fromMarketId(marketId: string): number;
+/**
+ * Build an outcome ID string for the unified type.
+ * Format: "{assetId}" which is the full numeric asset ID.
+ */
+export declare function toOutcomeId(outcomeId: number, side: 'yes' | 'no'): string;

package/dist/exchanges/hyperliquid/utils.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeAssetId = encodeAssetId;
+exports.decodeAssetId = decodeAssetId;
+exports.toCoinNotation = toCoinNotation;
+exports.fromCoinEncoding = fromCoinEncoding;
+exports.toMarketId = toMarketId;
+exports.fromMarketId = fromMarketId;
+exports.toOutcomeId = toOutcomeId;
+const config_1 = require("./config");
+/**
+ * Encode an outcome ID and side into a Hyperliquid asset ID.
+ *
+ * Formula: 100_000_000 + (10 * outcomeId) + side
+ * where side = 0 (Yes) or 1 (No).
+ */
+function encodeAssetId(outcomeId, side) {
+    const sideValue = side === 'yes' ? config_1.SIDE_YES : config_1.SIDE_NO;
+    return config_1.OUTCOME_ASSET_BASE + (config_1.OUTCOME_MULTIPLIER * outcomeId) + sideValue;
+}
+/**
+ * Decode a Hyperliquid asset ID back into outcome ID and side.
+ */
+function decodeAssetId(assetId) {
+    const offset = assetId - config_1.OUTCOME_ASSET_BASE;
+    const sideValue = offset % config_1.OUTCOME_MULTIPLIER;
+    const outcomeId = (offset - sideValue) / config_1.OUTCOME_MULTIPLIER;
+    return {
+        outcomeId,
+        side: sideValue === config_1.SIDE_YES ? 'yes' : 'no',
+    };
+}
+/**
+ * Convert an outcome ID and side to the Hyperliquid coin notation (#encoding).
+ *
+ * Example: outcome 1, Yes -> "#10"
+ */
+function toCoinNotation(outcomeId, side) {
+    const encoding = config_1.OUTCOME_MULTIPLIER * outcomeId + (side === 'yes' ? config_1.SIDE_YES : config_1.SIDE_NO);
+    return `#${encoding}`;
+}
+/**
+ * Convert an asset encoding (the number after #) to outcome ID and side.
+ */
+function fromCoinEncoding(encoding) {
+    const sideValue = encoding % config_1.OUTCOME_MULTIPLIER;
+    const outcomeId = (encoding - sideValue) / config_1.OUTCOME_MULTIPLIER;
+    return {
+        outcomeId,
+        side: sideValue === config_1.SIDE_YES ? 'yes' : 'no',
+    };
+}
+/**
+ * Build a unique market ID string from an outcome.
+ * We use "hl-outcome-{outcomeId}" as the market ID.
+ */
+function toMarketId(outcomeId) {
+    return `hl-outcome-${outcomeId}`;
+}
+/**
+ * Extract the numeric outcome ID from our market ID format.
+ */
+function fromMarketId(marketId) {
+    const match = marketId.match(/^hl-outcome-(\d+)$/);
+    if (!match) {
+        throw new Error(`Invalid Hyperliquid market ID: ${marketId}`);
+    }
+    return parseInt(match[1], 10);
+}
+/**
+ * Build an outcome ID string for the unified type.
+ * Format: "{assetId}" which is the full numeric asset ID.
+ */
+function toOutcomeId(outcomeId, side) {
+    return String(encodeAssetId(outcomeId, side));
+}