cryptocurrency.api/dist/binance.js

Cryptocurrency API

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.types = exports.Binance = void 0;
const node_binance_api_1 = require("node-binance-api");
const I = require("./binance.types");
exports.types = I;
const lodash_1 = require("lodash");
const fourdollar_1 = require("fourdollar");
class Binance {
    constructor(options) {
        this._b = null;
        this._b = new node_binance_api_1.default().options(options);
        this.websockets = new BinanceWebsocket(this._b.websockets);
    }
    prices(symbol) {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((resolve, reject) => {
                this._b.prices(symbol, (err, res) => {
                    if (err) {
                        reject(err);
                        return;
                    }
                    const rs = [];
                    for (let r in res) {
                        rs.push({
                            symbol: r,
                            price: res[r],
                        });
                    }
                    if (rs.length == 1) {
                        resolve(this._bindTransType({
                            data: rs[0],
                        }));
                    }
                    else {
                        resolve(this._bindTransType({
                            data: rs,
                        }));
                    }
                });
            });
        });
    }
    candlesticks(symbol, interval, options) {
        return new Promise((resolve, reject) => {
            this._b.candlesticks(symbol, interval, (err, ticks, symbol) => {
                if (err) {
                    reject(err);
                    return;
                }
                const data = ticks.map(t => {
                    const [time, open, high, low, close, volume, closeTime, assetVolume, trades, buyBaseVolume, buyAssetVolume, ignored] = t;
                    return {
                        time,
                        open,
                        high,
                        low,
                        close,
                        volume,
                        closeTime,
                        assetVolume,
                        trades,
                        buyBaseVolume,
                        buyAssetVolume,
                        ignored,
                    };
                });
                resolve(this._bindTransType({
                    data,
                }));
            }, options);
        });
    }
    _bindTransType(res) {
        res.transType = transType.bind(res);
        return res;
    }
}
exports.Binance = Binance;
class BinanceWebsocket {
    constructor(_ws) {
        this._ws = _ws;
    }
    candlesticks(symbol, interval, callback) {
        return this._ws.candlesticks(symbol, interval, (candlesticks) => {
            const { e: eventType, E: eventTime, s: symbol, k: data, } = candlesticks;
            const { t: startTime, T: endTime, i: interval, f: firstTradeID, L: lastTradeID, o: open, h: high, l: low, c: close, v: volume, n: trades, x: isFinal, q: quoteVolume, V: buyVolume, Q: quoteBuyVolume, B: ignore, } = data;
            return callback(this._bindTransType({
                eventType,
                eventTime,
                symbol,
                data: {
                    startTime,
                    endTime,
                    symbol,
                    interval,
                    firstTradeID,
                    lastTradeID,
                    open,
                    close,
                    high,
                    low,
                    volume,
                    trades,
                    isFinal,
                    quoteVolume,
                    buyVolume,
                    quoteBuyVolume,
                    ignore,
                }
            }));
        });
    }
    terminate(id) {
        return this._ws.terminate(id);
    }
    _bindTransType(res) {
        res.transType = transType.bind(res);
        return res;
    }
}
function transType(data) {
    if (!data) {
        data = this;
    }
    let cpData = (0, lodash_1.clone)(data);
    cpData && cpData.transType && delete cpData.transType;
    if (cpData) {
        for (let key in cpData) {
            if (cpData[key] !== null && cpData[key] !== undefined) {
                if (typeof cpData[key] === 'object') {
                    cpData[key] = transType(cpData[key]);
                }
                else {
                    if ((0, fourdollar_1.isInteger)(cpData[key])) {
                        cpData[key] = parseInt(cpData[key]);
                    }
                    else if ((0, fourdollar_1.isFloat)(cpData[key])) {
                        cpData[key] = parseFloat(cpData[key]);
                    }
                }
            }
        }
    }
    return cpData;
}