tardis-dev/dist/mappers/hyperliquid.js

Convenient access to tick-level historical and real-time cryptocurrency market data via Node.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.HyperliquidDerivativeTickerMapper = exports.HyperliquidBookTickerMapper = exports.HyperliquidBookChangeMapper = exports.HyperliquidTradesMapper = void 0;
const mapper_1 = require("./mapper");
const KILO_SYMBOLS = ['kPEPE', 'kSHIB', 'kBONK', 'kFLOKI', 'kLUNC', 'kDOGS', 'kNEIRO'];
function getApiSymbolId(symbol) {
    const potentialKSymbol = symbol.charAt(0).toLowerCase() + symbol.slice(1);
    if (KILO_SYMBOLS.includes(potentialKSymbol)) {
        return potentialKSymbol;
    }
    if (symbol.includes(':')) {
        const [prefix, suffix] = symbol.split(':');
        return prefix.toLowerCase() + ':' + suffix;
    }
    return symbol;
}
function getSymbols(symbols) {
    if (symbols !== undefined) {
        return symbols.map(getApiSymbolId);
    }
    return;
}
class HyperliquidTradesMapper {
    _seenSymbols = new Set();
    canHandle(message) {
        return message.channel === 'trades';
    }
    getFilters(symbols) {
        symbols = getSymbols(symbols);
        return [
            {
                channel: 'trades',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        for (const hyperliquidTrade of message.data) {
            if (this._seenSymbols.has(hyperliquidTrade.coin) === false) {
                this._seenSymbols.add(hyperliquidTrade.coin);
                break;
            }
            yield {
                type: 'trade',
                symbol: hyperliquidTrade.coin.toUpperCase(),
                exchange: 'hyperliquid',
                id: hyperliquidTrade.tid.toString(),
                price: Number(hyperliquidTrade.px),
                amount: Number(hyperliquidTrade.sz),
                side: hyperliquidTrade.side === 'B' ? 'buy' : 'sell',
                timestamp: new Date(hyperliquidTrade.time),
                localTimestamp: localTimestamp
            };
        }
    }
}
exports.HyperliquidTradesMapper = HyperliquidTradesMapper;
function mapHyperliquidLevel(level) {
    return {
        price: Number(level.px),
        amount: Number(level.sz)
    };
}
class HyperliquidBookChangeMapper {
    canHandle(message) {
        return message.channel === 'l2Book';
    }
    getFilters(symbols) {
        symbols = getSymbols(symbols);
        return [
            {
                channel: 'l2Book',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        yield {
            type: 'book_change',
            symbol: message.data.coin.toUpperCase(),
            exchange: 'hyperliquid',
            isSnapshot: true,
            bids: (message.data.levels[0] ? message.data.levels[0] : []).map(mapHyperliquidLevel),
            asks: (message.data.levels[1] ? message.data.levels[1] : []).map(mapHyperliquidLevel),
            timestamp: new Date(message.data.time),
            localTimestamp
        };
    }
}
exports.HyperliquidBookChangeMapper = HyperliquidBookChangeMapper;
class HyperliquidBookTickerMapper {
    canHandle(message) {
        return message.channel === 'bbo';
    }
    getFilters(symbols) {
        symbols = getSymbols(symbols);
        return [
            {
                channel: 'bbo',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        const bbo = message.data.bbo;
        const bestBid = bbo[0];
        const bestAsk = bbo[1];
        const ticker = {
            type: 'book_ticker',
            symbol: message.data.coin.toUpperCase(),
            exchange: 'hyperliquid',
            bidPrice: bestBid ? Number(bestBid.px) : undefined,
            bidAmount: bestBid ? Number(bestBid.sz) : undefined,
            askPrice: bestAsk ? Number(bestAsk.px) : undefined,
            askAmount: bestAsk ? Number(bestAsk.sz) : undefined,
            timestamp: new Date(message.data.time),
            localTimestamp: localTimestamp
        };
        yield ticker;
    }
}
exports.HyperliquidBookTickerMapper = HyperliquidBookTickerMapper;
class HyperliquidDerivativeTickerMapper {
    pendingTickerInfoHelper = new mapper_1.PendingTickerInfoHelper();
    canHandle(message) {
        return message.channel === 'activeAssetCtx';
    }
    getFilters(symbols) {
        symbols = getSymbols(symbols);
        return [
            {
                channel: 'activeAssetCtx',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        const symbol = message.data.coin.toUpperCase();
        const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(symbol, 'hyperliquid');
        if (message.data.ctx.funding !== undefined) {
            pendingTickerInfo.updateFundingRate(Number(message.data.ctx.funding));
        }
        if (message.data.ctx.markPx !== undefined) {
            pendingTickerInfo.updateMarkPrice(Number(message.data.ctx.markPx));
        }
        if (message.data.ctx.openInterest !== undefined) {
            pendingTickerInfo.updateOpenInterest(Number(message.data.ctx.openInterest));
        }
        if (message.data.ctx.oraclePx !== undefined) {
            pendingTickerInfo.updateIndexPrice(Number(message.data.ctx.oraclePx));
        }
        if (pendingTickerInfo.hasChanged()) {
            pendingTickerInfo.updateTimestamp(localTimestamp);
            yield pendingTickerInfo.getSnapshot(localTimestamp);
        }
    }
}
exports.HyperliquidDerivativeTickerMapper = HyperliquidDerivativeTickerMapper;
//# sourceMappingURL=hyperliquid.js.map