tardis-dev/dist/mappers/delta.js

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

import { fromMicroSecondsToDate, upperCaseSymbols } from "../handy.js";
import { PendingTickerInfoHelper } from "./mapper.js";
export class DeltaTradesMapper {
    _useV2Channels;
    constructor(_useV2Channels) {
        this._useV2Channels = _useV2Channels;
    }
    canHandle(message) {
        return message.type === (this._useV2Channels ? 'all_trades' : 'recent_trade');
    }
    getFilters(symbols) {
        symbols = upperCaseSymbols(symbols);
        return [
            {
                channel: this._useV2Channels ? 'all_trades' : 'recent_trade',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        yield {
            type: 'trade',
            symbol: message.symbol,
            exchange: 'delta',
            id: undefined,
            price: Number(message.price),
            amount: Number(message.size),
            side: message.buyer_role === 'taker' ? 'buy' : 'sell',
            timestamp: fromMicroSecondsToDate(message.timestamp),
            localTimestamp: localTimestamp
        };
    }
}
const mapBookLevel = (level) => {
    return {
        price: Number(level.limit_price),
        amount: Number(level.size)
    };
};
const mapL2Level = (level) => {
    return {
        price: Number(level[0]),
        amount: Number(level[1])
    };
};
export class DeltaBookChangeMapper {
    _useL2UpdatesChannel;
    constructor(_useL2UpdatesChannel) {
        this._useL2UpdatesChannel = _useL2UpdatesChannel;
    }
    canHandle(message) {
        if (this._useL2UpdatesChannel) {
            return message.type === 'l2_updates';
        }
        return message.type === 'l2_orderbook';
    }
    getFilters(symbols) {
        symbols = upperCaseSymbols(symbols);
        if (this._useL2UpdatesChannel) {
            return [
                {
                    channel: 'l2_updates',
                    symbols
                }
            ];
        }
        return [
            {
                channel: 'l2_orderbook',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        if (message.type === 'l2_updates') {
            yield {
                type: 'book_change',
                symbol: message.symbol,
                exchange: 'delta',
                isSnapshot: message.action === 'snapshot',
                bids: message.bids !== undefined ? message.bids.map(mapL2Level) : [],
                asks: message.asks !== undefined ? message.asks.map(mapL2Level) : [],
                timestamp: message.timestamp !== undefined ? fromMicroSecondsToDate(message.timestamp) : localTimestamp,
                localTimestamp
            };
        }
        else {
            if (message.buy === undefined && message.sell === undefined) {
                return;
            }
            yield {
                type: 'book_change',
                symbol: message.symbol,
                exchange: 'delta',
                isSnapshot: true,
                bids: message.buy !== undefined ? message.buy.map(mapBookLevel) : [],
                asks: message.sell !== undefined ? message.sell.map(mapBookLevel) : [],
                timestamp: message.timestamp !== undefined ? fromMicroSecondsToDate(message.timestamp) : localTimestamp,
                localTimestamp
            };
        }
    }
}
export class DeltaDerivativeTickerMapper {
    _useV2Channels;
    constructor(_useV2Channels) {
        this._useV2Channels = _useV2Channels;
    }
    pendingTickerInfoHelper = new PendingTickerInfoHelper();
    canHandle(message) {
        return (message.type === (this._useV2Channels ? 'all_trades' : 'recent_trade') ||
            message.type === 'funding_rate' ||
            message.type === 'mark_price');
    }
    getFilters(symbols) {
        symbols = upperCaseSymbols(symbols);
        return [
            {
                channel: this._useV2Channels ? 'all_trades' : 'recent_trade',
                symbols
            },
            {
                channel: 'funding_rate',
                symbols
            },
            {
                channel: 'mark_price',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(message.symbol.replace('MARK:', ''), 'delta');
        if (message.type === 'recent_trade' || message.type === 'all_trades') {
            pendingTickerInfo.updateLastPrice(Number(message.price));
        }
        if (message.type === 'mark_price') {
            pendingTickerInfo.updateMarkPrice(Number(message.price));
        }
        if (message.type === 'funding_rate') {
            if (message.funding_rate !== undefined) {
                pendingTickerInfo.updateFundingRate(Number(message.funding_rate));
            }
            if (message.predicted_funding_rate !== undefined) {
                pendingTickerInfo.updatePredictedFundingRate(Number(message.predicted_funding_rate));
            }
            if (message.next_funding_realization !== undefined) {
                pendingTickerInfo.updateFundingTimestamp(fromMicroSecondsToDate(message.next_funding_realization));
            }
        }
        pendingTickerInfo.updateTimestamp(fromMicroSecondsToDate(message.timestamp));
        if (pendingTickerInfo.hasChanged()) {
            yield pendingTickerInfo.getSnapshot(localTimestamp);
        }
    }
}
export class DeltaBookTickerMapper {
    canHandle(message) {
        return message.type === 'l1_orderbook';
    }
    getFilters(symbols) {
        symbols = upperCaseSymbols(symbols);
        return [
            {
                channel: 'l1_orderbook',
                symbols
            }
        ];
    }
    *map(message, localTimestamp) {
        const ticker = {
            type: 'book_ticker',
            symbol: message.symbol,
            exchange: 'delta',
            askAmount: message.ask_qty !== undefined ? Number(message.ask_qty) : undefined,
            askPrice: message.best_ask !== undefined ? Number(message.best_ask) : undefined,
            bidPrice: message.best_bid !== undefined ? Number(message.best_bid) : undefined,
            bidAmount: message.bid_qty !== undefined ? Number(message.bid_qty) : undefined,
            timestamp: message.timestamp !== undefined ? fromMicroSecondsToDate(message.timestamp) : localTimestamp,
            localTimestamp: localTimestamp
        };
        yield ticker;
    }
}
//# sourceMappingURL=delta.js.map