tardis-dev/dist/mappers/poloniex.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.PoloniexBookChangeMapper = exports.PoloniexTradesMapper = exports.PoloniexV2BookChangeMapper = exports.PoloniexV2TradesMapper = void 0;
const handy_1 = require("../handy");
class PoloniexV2TradesMapper {
    canHandle(message) {
        return message.channel === 'trades' && message.data !== undefined && message.data.length > 0;
    }
    getFilters(symbols) {
        symbols = (0, handy_1.upperCaseSymbols)(symbols);
        return [
            {
                channel: 'trades',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        for (const item of message.data) {
            yield {
                type: 'trade',
                symbol: item.symbol,
                exchange: 'poloniex',
                id: item.id,
                price: Number(item.price),
                amount: Number(item.quantity),
                side: item.takerSide === 'sell' ? 'sell' : 'buy',
                timestamp: new Date(item.createTime),
                localTimestamp: localTimestamp
            };
        }
    }
}
exports.PoloniexV2TradesMapper = PoloniexV2TradesMapper;
const mapBookLevelV2 = (level) => {
    return {
        price: Number(level[0]),
        amount: Number(level[1])
    };
};
class PoloniexV2BookChangeMapper {
    canHandle(message) {
        return message.channel === 'book_lv2' && message.data !== undefined && message.data.length > 0;
    }
    getFilters(symbols) {
        symbols = (0, handy_1.upperCaseSymbols)(symbols);
        return [
            {
                channel: 'book_lv2',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        for (const item of message.data) {
            const bookSnapshot = {
                type: 'book_change',
                symbol: item.symbol,
                exchange: 'poloniex',
                isSnapshot: message.action === 'snapshot',
                bids: item.bids.map(mapBookLevelV2),
                asks: item.asks.map(mapBookLevelV2),
                timestamp: new Date(item.ts),
                localTimestamp: localTimestamp
            };
            yield bookSnapshot;
        }
    }
}
exports.PoloniexV2BookChangeMapper = PoloniexV2BookChangeMapper;
class PoloniexTradesMapper {
    constructor() {
        this._channelIdToSymbolMap = new Map();
    }
    canHandle(message) {
        if (Array.isArray(message) === false) {
            return false;
        }
        if (message.length < 3) {
            return false;
        }
        // store mapping between channel id and symbols
        if (message[2][0][0] === 'i') {
            this._channelIdToSymbolMap.set(message[0], message[2][0][1].currencyPair);
        }
        return message[2].some((m) => m[0] === 't');
    }
    getFilters(symbols) {
        symbols = (0, handy_1.upperCaseSymbols)(symbols);
        return [
            {
                channel: 'price_aggregated_book',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        const lastItem = message[message.length - 1];
        const symbol = typeof lastItem === 'string' ? lastItem : this._channelIdToSymbolMap.get(message[0]);
        if (symbol === undefined) {
            return;
        }
        for (const item of message[2]) {
            if (item[0] !== 't') {
                continue;
            }
            const [_, id, side, price, size, timestamp] = item;
            yield {
                type: 'trade',
                symbol,
                exchange: 'poloniex',
                id: String(id),
                price: Number(price),
                amount: Number(size),
                side: side === 1 ? 'buy' : 'sell',
                timestamp: new Date(timestamp * 1000),
                localTimestamp: localTimestamp
            };
        }
    }
}
exports.PoloniexTradesMapper = PoloniexTradesMapper;
const mapSnapshotLevels = (levels) => {
    return Object.keys(levels).map((key) => {
        return {
            price: Number(key),
            amount: Number(levels[key])
        };
    });
};
const mapBookLevel = (level) => {
    return {
        price: Number(level[2]),
        amount: Number(level[3])
    };
};
class PoloniexBookChangeMapper {
    constructor() {
        this._channelIdToSymbolMap = new Map();
    }
    canHandle(message) {
        if (Array.isArray(message) === false) {
            return false;
        }
        if (message.length < 3) {
            return false;
        }
        // store mapping between channel id and symbols
        if (message[2][0][0] === 'i') {
            this._channelIdToSymbolMap.set(message[0], message[2][0][1].currencyPair);
        }
        return message[2].some((m) => m[0] === 'i' || m[0] === 'o');
    }
    getFilters(symbols) {
        symbols = (0, handy_1.upperCaseSymbols)(symbols);
        return [
            {
                channel: 'price_aggregated_book',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        const lastItem = message[message.length - 1];
        const symbol = typeof lastItem === 'string' ? lastItem : this._channelIdToSymbolMap.get(message[0]);
        if (symbol === undefined) {
            return;
        }
        let updates = [];
        for (const item of message[2]) {
            if (item[0] === 'i') {
                const bookSnapshot = {
                    type: 'book_change',
                    symbol,
                    exchange: 'poloniex',
                    isSnapshot: true,
                    bids: mapSnapshotLevels(item[1].orderBook[1]),
                    asks: mapSnapshotLevels(item[1].orderBook[0]),
                    timestamp: localTimestamp,
                    localTimestamp: localTimestamp
                };
                yield bookSnapshot;
            }
            else if (item[0] === 'o') {
                updates.push(item);
            }
        }
        if (updates.length > 0) {
            const bookUpdate = {
                type: 'book_change',
                symbol,
                exchange: 'poloniex',
                isSnapshot: false,
                bids: updates.filter((u) => u[1] == 1).map(mapBookLevel),
                asks: updates.filter((u) => u[1] == 0).map(mapBookLevel),
                timestamp: localTimestamp,
                localTimestamp: localTimestamp
            };
            yield bookUpdate;
        }
    }
}
exports.PoloniexBookChangeMapper = PoloniexBookChangeMapper;
//# sourceMappingURL=poloniex.js.map