tardis-dev/dist/mappers/lighter.js

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

import { asNonZeroNumberOrUndefined } from "../handy.js";
import { PendingTickerInfoHelper } from "./mapper.js";
function parseChannelMarketId(channel) {
    const colonIndex = channel.indexOf(':');
    if (colonIndex < 0) {
        return undefined;
    }
    const suffix = channel.slice(colonIndex + 1);
    if (suffix === 'all') {
        return undefined;
    }
    return suffix;
}
export class LighterTradesMapper {
    canHandle(message) {
        return message.type === 'update/trade';
    }
    getFilters(symbols) {
        return [
            {
                channel: 'trade',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        for (const trade of message.trades) {
            yield {
                type: 'trade',
                symbol: trade.market_id.toString(),
                exchange: 'lighter',
                id: trade.trade_id_str,
                price: Number(trade.price),
                amount: Number(trade.size),
                side: trade.is_maker_ask ? 'buy' : 'sell',
                timestamp: new Date(trade.timestamp),
                localTimestamp
            };
        }
    }
}
export class LighterLiquidationMapper {
    canHandle(message) {
        return message.type === 'update/trade';
    }
    getFilters(symbols) {
        return [
            {
                channel: 'trade',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        if (!Array.isArray(message.liquidation_trades)) {
            return;
        }
        for (const trade of message.liquidation_trades) {
            if (trade.type !== 'liquidation') {
                continue;
            }
            yield {
                type: 'liquidation',
                symbol: trade.market_id.toString(),
                exchange: 'lighter',
                id: trade.trade_id_str,
                price: Number(trade.price),
                amount: Number(trade.size),
                side: trade.is_maker_ask ? 'buy' : 'sell',
                timestamp: new Date(trade.timestamp),
                localTimestamp
            };
        }
    }
}
export class LighterBookChangeMapper {
    canHandle(message) {
        return message.type === 'subscribed/order_book' || message.type === 'update/order_book';
    }
    getFilters(symbols) {
        return [
            {
                channel: 'order_book',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        const symbol = parseChannelMarketId(message.channel);
        if (symbol === undefined)
            return;
        yield {
            type: 'book_change',
            symbol,
            exchange: 'lighter',
            isSnapshot: message.type === 'subscribed/order_book',
            bids: message.order_book.bids.map(this.mapLevel),
            asks: message.order_book.asks.map(this.mapLevel),
            timestamp: new Date(message.timestamp),
            localTimestamp
        };
    }
    mapLevel(level) {
        return {
            price: Number(level.price),
            amount: Number(level.size)
        };
    }
}
export class LighterBookTickerMapper {
    canHandle(message) {
        return message.type === 'update/ticker';
    }
    getFilters(symbols) {
        return [
            {
                channel: 'ticker',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        const symbol = parseChannelMarketId(message.channel);
        if (symbol === undefined)
            return;
        yield {
            type: 'book_ticker',
            symbol,
            exchange: 'lighter',
            askAmount: asNonZeroNumberOrUndefined(message.ticker?.a?.size),
            askPrice: asNonZeroNumberOrUndefined(message.ticker?.a?.price),
            bidPrice: asNonZeroNumberOrUndefined(message.ticker?.b?.price),
            bidAmount: asNonZeroNumberOrUndefined(message.ticker?.b?.size),
            timestamp: new Date(message.timestamp),
            localTimestamp
        };
    }
}
export class LighterDerivativeTickerMapper {
    pendingTickerInfoHelper = new PendingTickerInfoHelper();
    canHandle(message) {
        return message.type === 'update/market_stats';
    }
    getFilters(_symbols) {
        return [
            {
                channel: 'market_stats',
                symbols: []
            }
        ];
    }
    *map(message, localTimestamp) {
        for (const entry of this.iterateMarketStats(message)) {
            const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(entry.market_id.toString(), 'lighter');
            pendingTickerInfo.updateMarkPrice(Number(entry.mark_price));
            pendingTickerInfo.updateIndexPrice(Number(entry.index_price));
            pendingTickerInfo.updateFundingRate(Number(entry.current_funding_rate));
            pendingTickerInfo.updateLastPrice(Number(entry.last_trade_price));
            pendingTickerInfo.updateOpenInterest(Number(entry.open_interest));
            if (pendingTickerInfo.hasChanged()) {
                pendingTickerInfo.updateTimestamp(new Date(message.timestamp));
                yield pendingTickerInfo.getSnapshot(localTimestamp);
            }
        }
    }
    *iterateMarketStats(message) {
        if (message.channel === 'market_stats:all') {
            for (const key of Object.keys(message.market_stats)) {
                yield message.market_stats[key];
            }
            return;
        }
        yield message.market_stats;
    }
}
//# sourceMappingURL=lighter.js.map