tardis-dev/dist/mappers/cryptocom.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.CryptoComDerivativeTickerMapper = exports.CryptoComBookTickerMapper = exports.CryptoComBookChangeMapper = exports.CryptoComTradesMapper = void 0;
const handy_1 = require("../handy");
const mapper_1 = require("./mapper");
class CryptoComTradesMapper {
    constructor(_exchange) {
        this._exchange = _exchange;
    }
    canHandle(message) {
        return message.result !== undefined && message.result.channel === 'trade';
    }
    getFilters(symbols) {
        symbols = (0, handy_1.upperCaseSymbols)(symbols);
        return [
            {
                channel: 'trade',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        message.result.data.reverse();
        for (const item of message.result.data) {
            const trade = {
                type: 'trade',
                symbol: message.result.instrument_name,
                exchange: this._exchange,
                id: item.d.toString(),
                price: Number(item.p),
                amount: Number(item.q),
                side: item.s === 'BUY' ? 'buy' : 'sell',
                timestamp: new Date(item.t),
                localTimestamp
            };
            yield trade;
        }
    }
}
exports.CryptoComTradesMapper = CryptoComTradesMapper;
class CryptoComBookChangeMapper {
    constructor(_exchange) {
        this._exchange = _exchange;
    }
    canHandle(message) {
        return message.result !== undefined && message.result.channel.startsWith('book');
    }
    getFilters(symbols) {
        symbols = (0, handy_1.upperCaseSymbols)(symbols);
        return [
            {
                channel: 'book',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        if (message.result.data === undefined || message.result.data[0] === undefined) {
            return;
        }
        const bids = (message.result.channel === 'book' ? message.result.data[0].bids : message.result.data[0].update.bids) || [];
        const asks = (message.result.channel === 'book' ? message.result.data[0].asks : message.result.data[0].update.asks) || [];
        yield {
            type: 'book_change',
            symbol: message.result.instrument_name,
            exchange: this._exchange,
            isSnapshot: message.result.channel === 'book',
            bids: bids.map(this._mapBookLevel),
            asks: asks.map(this._mapBookLevel),
            timestamp: new Date(message.result.data[0].t),
            localTimestamp
        };
    }
    _mapBookLevel(level) {
        return { price: Number(level[0]), amount: Number(level[1]) };
    }
}
exports.CryptoComBookChangeMapper = CryptoComBookChangeMapper;
class CryptoComBookTickerMapper {
    constructor(_exchange) {
        this._exchange = _exchange;
    }
    canHandle(message) {
        return message.result !== undefined && message.result.channel === 'ticker';
    }
    getFilters(symbols) {
        symbols = (0, handy_1.upperCaseSymbols)(symbols);
        return [
            {
                channel: 'ticker',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        for (const item of message.result.data) {
            const bookTicker = {
                type: 'book_ticker',
                symbol: message.result.instrument_name,
                exchange: this._exchange,
                askAmount: undefined,
                askPrice: item.k !== undefined && item.k !== null ? Number(item.k) : undefined,
                bidPrice: item.b !== undefined && item.b !== null ? Number(item.b) : undefined,
                bidAmount: undefined,
                timestamp: new Date(item.t),
                localTimestamp: localTimestamp
            };
            yield bookTicker;
        }
    }
}
exports.CryptoComBookTickerMapper = CryptoComBookTickerMapper;
class CryptoComDerivativeTickerMapper {
    constructor(exchange) {
        this.exchange = exchange;
        this.pendingTickerInfoHelper = new mapper_1.PendingTickerInfoHelper();
        this._indexPrices = new Map();
    }
    canHandle(message) {
        if (message.result === undefined) {
            return false;
        }
        if (message.result.instrument_name === undefined) {
            return false;
        }
        // spot symbols
        if (message.result.instrument_name.includes('_')) {
            return false;
        }
        // options
        if (message.result.instrument_name.split('-').length === 3) {
            return false;
        }
        return (message.result.channel === 'ticker' ||
            message.result.channel === 'index' ||
            message.result.channel === 'mark' ||
            message.result.channel === 'funding');
    }
    getFilters(symbols) {
        symbols = (0, handy_1.upperCaseSymbols)(symbols);
        let indexes = [];
        if (symbols !== undefined) {
            indexes = [...new Set(symbols.map((s) => `${s.split('-')[0]}-INDEX`))];
        }
        const filters = [
            {
                channel: 'ticker',
                symbols
            },
            {
                channel: 'index',
                symbols: indexes
            },
            {
                channel: 'mark',
                symbols
            },
            {
                channel: 'funding',
                symbols
            },
            {
                channel: 'estimatedfunding',
                symbols
            }
        ];
        return filters;
    }
    *map(message, localTimestamp) {
        if (message.result.channel === 'index') {
            this._indexPrices.set(message.result.instrument_name.split('-')[0], Number(message.result.data[0].v));
            return;
        }
        const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(message.result.instrument_name, this.exchange);
        const lastIndexPrice = this._indexPrices.get(message.result.instrument_name.split('-')[0]);
        if (lastIndexPrice !== undefined) {
            pendingTickerInfo.updateIndexPrice(lastIndexPrice);
        }
        if (message.result.channel === 'ticker') {
            if (message.result.data[0].a !== null && message.result.data[0].a !== undefined) {
                pendingTickerInfo.updateLastPrice(Number(message.result.data[0].a));
            }
            if (message.result.data[0].oi !== null && message.result.data[0].oi !== undefined) {
                pendingTickerInfo.updateOpenInterest(Number(message.result.data[0].oi));
            }
        }
        if (message.result.channel === 'mark') {
            if (message.result.data[0].v !== null && message.result.data[0].v !== undefined) {
                pendingTickerInfo.updateMarkPrice(Number(message.result.data[0].v));
            }
        }
        if (message.result.channel === 'funding') {
            if (message.result.data[0].v !== null && message.result.data[0].v !== undefined) {
                pendingTickerInfo.updateFundingRate(Number(message.result.data[0].v));
                const nextFundingTimestamp = new Date(message.result.data[0].t);
                nextFundingTimestamp.setUTCHours(nextFundingTimestamp.getUTCHours() + 1);
                nextFundingTimestamp.setUTCMinutes(0, 0, 0);
                pendingTickerInfo.updateFundingTimestamp(nextFundingTimestamp);
            }
        }
        if (message.result.channel === 'estimatedfunding') {
            if (message.result.data[0] && message.result.data[0].v !== null && message.result.data[0].v !== undefined) {
                pendingTickerInfo.updatePredictedFundingRate(Number(message.result.data[0].v));
            }
        }
        pendingTickerInfo.updateTimestamp(new Date(message.result.data[0].t));
        if (pendingTickerInfo.hasChanged()) {
            yield pendingTickerInfo.getSnapshot(localTimestamp);
        }
    }
}
exports.CryptoComDerivativeTickerMapper = CryptoComDerivativeTickerMapper;
//# sourceMappingURL=cryptocom.js.map