tardis-dev/dist/mappers/bitget.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.BitgetDerivativeTickerMapper = exports.BitgetBookTickerMapper = exports.BitgetBookChangeMapper = exports.BitgetTradesMapper = void 0;
const handy_1 = require("../handy");
const mapper_1 = require("./mapper");
class BitgetTradesMapper {
    _exchange;
    constructor(_exchange) {
        this._exchange = _exchange;
    }
    canHandle(message) {
        return message.arg.channel === 'trade' && message.action === 'update';
    }
    getFilters(symbols) {
        symbols = (0, handy_1.upperCaseSymbols)(symbols);
        return [
            {
                channel: 'trade',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        for (let trade of message.data) {
            yield {
                type: 'trade',
                symbol: message.arg.instId,
                exchange: this._exchange,
                id: trade.tradeId,
                price: Number(trade.price),
                amount: Number(trade.size),
                side: trade.side === 'buy' ? 'buy' : 'sell',
                timestamp: new Date(Number(trade.ts)),
                localTimestamp: localTimestamp
            };
        }
    }
}
exports.BitgetTradesMapper = BitgetTradesMapper;
function mapPriceLevel(level) {
    return {
        price: Number(level[0]),
        amount: Number(level[1])
    };
}
class BitgetBookChangeMapper {
    _exchange;
    constructor(_exchange) {
        this._exchange = _exchange;
    }
    canHandle(message) {
        return message.arg.channel === 'books15' && message.action === 'snapshot';
    }
    getFilters(symbols) {
        symbols = (0, handy_1.upperCaseSymbols)(symbols);
        return [
            {
                channel: 'books15',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        for (let orderbookData of message.data) {
            yield {
                type: 'book_change',
                symbol: message.arg.instId,
                exchange: this._exchange,
                isSnapshot: message.action === 'snapshot',
                bids: orderbookData.bids.map(mapPriceLevel),
                asks: orderbookData.asks.map(mapPriceLevel),
                timestamp: new Date(Number(orderbookData.ts)),
                localTimestamp
            };
        }
    }
}
exports.BitgetBookChangeMapper = BitgetBookChangeMapper;
class BitgetBookTickerMapper {
    _exchange;
    constructor(_exchange) {
        this._exchange = _exchange;
    }
    canHandle(message) {
        return message.arg.channel === 'books1' && message.action === 'snapshot';
    }
    getFilters(symbols) {
        symbols = (0, handy_1.upperCaseSymbols)(symbols);
        return [
            {
                channel: `books1`,
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        for (const bboMessage of message.data) {
            const ticker = {
                type: 'book_ticker',
                symbol: message.arg.instId,
                exchange: this._exchange,
                askAmount: bboMessage.asks[0] ? Number(bboMessage.asks[0][1]) : undefined,
                askPrice: bboMessage.asks[0] ? Number(bboMessage.asks[0][0]) : undefined,
                bidPrice: bboMessage.bids[0] ? Number(bboMessage.bids[0][0]) : undefined,
                bidAmount: bboMessage.bids[0] ? Number(bboMessage.bids[0][1]) : undefined,
                timestamp: new Date(Number(bboMessage.ts)),
                localTimestamp: localTimestamp
            };
            yield ticker;
        }
    }
}
exports.BitgetBookTickerMapper = BitgetBookTickerMapper;
class BitgetDerivativeTickerMapper {
    pendingTickerInfoHelper = new mapper_1.PendingTickerInfoHelper();
    canHandle(message) {
        return message.arg.channel === 'ticker' && message.action === 'snapshot';
    }
    getFilters(symbols) {
        return [
            {
                channel: 'ticker',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        for (const tickerMessage of message.data) {
            const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(tickerMessage.symbol, 'bitget-futures');
            pendingTickerInfo.updateIndexPrice(Number(tickerMessage.indexPrice));
            pendingTickerInfo.updateMarkPrice(Number(tickerMessage.markPrice));
            pendingTickerInfo.updateOpenInterest(Number(tickerMessage.holdingAmount));
            pendingTickerInfo.updateLastPrice(Number(tickerMessage.lastPr));
            pendingTickerInfo.updateTimestamp(new Date(Number(tickerMessage.ts)));
            if (tickerMessage.nextFundingTime !== '0') {
                pendingTickerInfo.updateFundingTimestamp(new Date(Number(tickerMessage.nextFundingTime)));
                pendingTickerInfo.updateFundingRate(Number(tickerMessage.fundingRate));
            }
            if (pendingTickerInfo.hasChanged()) {
                yield pendingTickerInfo.getSnapshot(localTimestamp);
            }
        }
    }
}
exports.BitgetDerivativeTickerMapper = BitgetDerivativeTickerMapper;
//# sourceMappingURL=bitget.js.map