coinrayjs 1.4.34

package/dist/coinray.js

@@ -0,0 +1,957 @@
+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());
+    });
+};
+import axios from "axios";
+import { Socket } from "phoenix";
+import { camelize, createJWT, encryptPayload, jwkToPublicKey, jwtExpired, parseJWT, safeBigNumber, safeTime, signHMAC } from "./util";
+import Market from "./market";
+import Exchange from "./exchange";
+import BigNumber from "bignumber.js";
+import _ from "lodash";
+import I18n from "./i18n";
+const VERSION = require('../package.json').version;
+export class CoinrayError extends Error {
+    constructor({ code, message, exchange }) {
+        super("Request failed");
+        this.name = "CoinrayError";
+        this.errorCode = code;
+        this.errorMessage = message;
+        this.exchange = exchange;
+    }
+}
+export default class Coinray {
+    constructor(token, { apiEndpoint, orderEndpoint, websocketEndpoint } = {
+        apiEndpoint: "https://api.coinray.eu",
+        orderEndpoint: "https://api.coinray.eu",
+        websocketEndpoint: "wss://ws.coinray.eu/v1",
+    }) {
+        this._tickerListeners = {};
+        this._tradeListeners = {};
+        this._tradeSnapshots = {};
+        this._orderbookListeners = {};
+        this._orderbookSnapshots = {};
+        this._candleTradeListeners = {};
+        this._candleListeners = {};
+        this._candles = {};
+        this._channels = {};
+        this.tickersSubscribed = false;
+        this.tradesSubscribed = false;
+        this.orderBookSubscribed = false;
+        this.authenticateDevice = (credential, sessionKey) => {
+            this._credential = credential;
+            this._sessionKey = sessionKey;
+        };
+        this.destroy = () => {
+            this._tradeListeners = {};
+            this._orderbookListeners = {};
+            this._tickerListeners = {};
+            this._channels = {};
+            if (this._timeOffsetInterval) {
+                clearInterval(this._timeOffsetInterval);
+            }
+            if (this._tokenCheckInterval) {
+                clearInterval(this._tokenCheckInterval);
+            }
+            this.disconnect();
+        };
+        this.checkToken = () => __awaiter(this, void 0, void 0, function* () {
+            if (jwtExpired(this._token)) {
+                console.log("Coinray token expired. Can refresh:", !!this._onTokenExpired);
+                if (!this._onTokenExpired) {
+                    return false;
+                }
+                if (!this._refreshingToken) {
+                    this._refreshingToken = this._onTokenExpired();
+                }
+                try {
+                    this._token = yield this._refreshingToken;
+                }
+                catch (error) {
+                    console.log("Coinray token could not be refreshed", error);
+                    this._refreshingToken = undefined;
+                    return false;
+                }
+                this._refreshingToken = undefined;
+                if (!jwtExpired(this._token)) {
+                    this.reconnect();
+                }
+                else {
+                    return false;
+                }
+            }
+            return true;
+        });
+        this.setTransport = (transport) => {
+            this._transport = transport;
+        };
+        this.onTokenExpired = (callback) => {
+            this._onTokenExpired = callback;
+            this._tokenCheckInterval = setInterval(this.checkToken, 5000);
+        };
+        this.refreshToken = (token) => {
+            this._token = token;
+        };
+        this.getNonce = () => {
+            if (this._nonceOffset > 900) {
+                this._nonceOffset = 0;
+            }
+            this._nonceOffset += 1;
+            return this.getTime() + this._nonceOffset;
+        };
+        this.getTime = () => {
+            return Math.floor(new Date().getTime() / 1000) * 1000 + this._timeOffset;
+        };
+        this.loadTimeOffset = () => __awaiter(this, void 0, void 0, function* () {
+            const { result } = yield this.get("/coinray/time");
+            this._timeOffset = result.time - new Date().getTime();
+        });
+        this.getToken = () => __awaiter(this, void 0, void 0, function* () {
+            const tokenValid = yield this.checkToken();
+            if (tokenValid) {
+                return this._token;
+            }
+            else {
+                throw new Error("Token is expired. call refreshToken in the onTokenExpired callback");
+            }
+        });
+        this.reconnect = () => {
+            if (this._connected) {
+                // @ts-ignore
+                this.socket.conn.close();
+            }
+        };
+        this.disconnect = () => {
+            if (this._socket) {
+                this._socket.disconnect();
+                this._socket = undefined;
+            }
+            this._connected = undefined;
+        };
+        this.connect = () => __awaiter(this, void 0, void 0, function* () {
+            if (this._connected) {
+                yield this._connected;
+                return;
+            }
+            else {
+                this._connected = new Promise((resolve) => {
+                    this.markConnected = resolve;
+                });
+            }
+            // @ts-ignore
+            this.socket.onOpen((event) => {
+                if (this._onOpen) {
+                    this._onOpen(event);
+                }
+            });
+            // @ts-ignore
+            this.socket.onError((event) => {
+                if (this._onError) {
+                    this._onError(event);
+                }
+            });
+            this.socket.connect();
+            this.markConnected();
+        });
+        this.onOpen = (callback) => {
+            this._onOpen = callback;
+        };
+        this.onError = (callback) => {
+            this._onError = callback;
+        };
+        this.resubscribe = () => {
+            if (this._firstOpen) {
+                this._firstOpen = false;
+                return;
+            }
+            Object.keys(this._tickerListeners).forEach((exchangeCode) => {
+                if (this._tickerListeners[exchangeCode].length > 0) {
+                    const channel = this.getChannel("tickers");
+                    channel.push("subscribe", { exchangeCodes: [exchangeCode] }, 5000);
+                }
+            });
+            Object.keys(this._tradeListeners).forEach((coinraySymbol) => {
+                if (this._tradeListeners[coinraySymbol].length > 0) {
+                    const channel = this.getChannel("trades");
+                    channel.push("subscribe", { symbols: coinraySymbol, snapshots: true }, 5000);
+                }
+            });
+            Object.keys(this._orderbookListeners).forEach((coinraySymbol) => {
+                if (this._orderbookListeners[coinraySymbol].length > 0) {
+                    const channel = this.getChannel("orderbooks");
+                    channel.push("subscribe", { symbols: coinraySymbol, snapshots: true }, 5000);
+                }
+            });
+        };
+        this.subscribeTickers = (exchangeCode, callback) => __awaiter(this, void 0, void 0, function* () {
+            if (this._tickerListeners[exchangeCode] && this._tickerListeners[exchangeCode].length > 0) {
+                this._tickerListeners[exchangeCode].push(callback);
+                return callback;
+            }
+            // Run only once per coinraySymbol
+            this._tickerListeners[exchangeCode] = [callback];
+            yield this.connect();
+            const channel = this.getChannel("tickers");
+            channel.push("subscribe", { exchangeCodes: [exchangeCode] }, 5000);
+            if (this.tickersSubscribed) {
+                return callback;
+            }
+            this.tickersSubscribed = true;
+            channel.on("update", (payload) => {
+                let { exchange_code: exchangeCode, tickers } = payload;
+                const callbacks = Object.values(this._tickerListeners[exchangeCode]);
+                const parsedTickers = tickers.map(Coinray._parseTicker);
+                callbacks.map((callback) => callback({
+                    type: "tickers:update",
+                    exchangeCode,
+                    tickers: parsedTickers
+                }));
+            });
+            channel.on("error", (payload) => console.error(payload));
+            return callback;
+        });
+        this.unsubscribeTickers = (exchangeCode, callback) => {
+            if (callback && this._tickerListeners[exchangeCode]) {
+                this._tickerListeners[exchangeCode] = this._tickerListeners[exchangeCode].filter((c) => c !== callback);
+                if (this._tickerListeners[exchangeCode].length === 0) {
+                    this.getChannel("tickers")
+                        .push("unsubscribe", { exchangeCodes: [exchangeCode] }, 5000);
+                }
+            }
+            else {
+                this._tickerListeners[exchangeCode] = [];
+            }
+        };
+        this.subscribeTrades = ({ coinraySymbol }, callback) => __awaiter(this, void 0, void 0, function* () {
+            if (this._tradeListeners[coinraySymbol] && this._tradeListeners[coinraySymbol].length > 0) {
+                this._tradeListeners[coinraySymbol].push(callback);
+                callback({
+                    type: "trades:snapshot",
+                    coinraySymbol: coinraySymbol,
+                    trades: this._tradeSnapshots[coinraySymbol]
+                });
+                return callback;
+            }
+            // Run only once per coinraySymbol
+            this._tradeSnapshots[coinraySymbol] = [];
+            this._tradeListeners[coinraySymbol] = [callback];
+            yield this.connect();
+            const channel = this.getChannel("trades");
+            channel.push("subscribe", { symbols: coinraySymbol, snapshots: true }, 5000);
+            if (this.tradesSubscribed) {
+                return callback;
+            }
+            this.tradesSubscribed = true;
+            channel.on("snapshot", ({ symbol, trades }) => {
+                const callbacks = Object.values(this._tradeListeners[symbol]);
+                const parsedTrades = trades.map(Coinray._parseTrade);
+                this._tradeSnapshots[symbol] = parsedTrades;
+                callbacks.map((callback) => callback({
+                    type: "trades:snapshot",
+                    coinraySymbol: symbol,
+                    trades: parsedTrades
+                }));
+            });
+            channel.on("update", ({ symbol, trades }) => {
+                const callbacks = Object.values(this._tradeListeners[symbol]);
+                const parsedTrades = trades.map(Coinray._parseTrade);
+                const snapshot = [...parsedTrades, ...this._tradeSnapshots[symbol]];
+                const minTime = new Date(new Date().getTime() - 120000);
+                const relevantSnapshot = snapshot.filter(({ time }) => time > minTime);
+                if (relevantSnapshot.length > 100) {
+                    this._tradeSnapshots[symbol] = relevantSnapshot;
+                }
+                else {
+                    this._tradeSnapshots[symbol] = snapshot.slice(0, 100);
+                }
+                callbacks.map((callback) => callback({
+                    type: "trades:update",
+                    coinraySymbol: symbol,
+                    trades: parsedTrades
+                }));
+            });
+            channel.on("error", (payload) => console.error(payload));
+            return callback;
+        });
+        this.unsubscribeTrades = ({ coinraySymbol }, callback) => {
+            if (callback && this._tradeListeners[coinraySymbol]) {
+                this._tradeListeners[coinraySymbol] = this._tradeListeners[coinraySymbol].filter((c) => c !== callback);
+                if (this._tradeListeners[coinraySymbol].length === 0) {
+                    this.getChannel("trades")
+                        .push("unsubscribe", { symbols: coinraySymbol }, 5000);
+                }
+            }
+            else {
+                this._tradeSnapshots[coinraySymbol] = [];
+                this._tradeListeners[coinraySymbol] = [];
+            }
+        };
+        this.subscribeOrderBook = ({ coinraySymbol }, callback) => __awaiter(this, void 0, void 0, function* () {
+            if (this._orderbookListeners[coinraySymbol] && this._orderbookListeners[coinraySymbol].length > 0) {
+                this._orderbookListeners[coinraySymbol].push(callback);
+                callback({
+                    type: "orderBook:snapshot",
+                    coinraySymbol: coinraySymbol,
+                    orderBook: this._orderbookSnapshots[coinraySymbol]
+                });
+                return callback;
+            }
+            this._orderbookSnapshots[coinraySymbol] = { minSeq: 0, maxSeq: 0, bids: {}, asks: {} };
+            this._orderbookListeners[coinraySymbol] = [callback];
+            yield this.connect();
+            const channel = this.getChannel("orderbooks");
+            channel.push("subscribe", { symbols: coinraySymbol }, 10000);
+            if (this.orderBookSubscribed) {
+                return callback;
+            }
+            this.orderBookSubscribed = true;
+            channel.on("snapshot", ({ orderbooks }) => {
+                const incoming_symbols = Object.keys(orderbooks);
+                incoming_symbols.forEach(symbol => {
+                    const callbacks = Object.values(this._orderbookListeners[symbol]);
+                    const parsedOrderBook = Coinray._parseOrderBookSnapshot(orderbooks[symbol]);
+                    this._orderbookSnapshots[symbol] = parsedOrderBook;
+                    callbacks.map((callback) => callback({
+                        type: "orderBook:snapshot",
+                        coinraySymbol: symbol,
+                        orderBook: parsedOrderBook
+                    }));
+                });
+            });
+            channel.on("update", ({ orderbooks }) => {
+                const incoming_symbols = Object.keys(orderbooks);
+                if (incoming_symbols.length === 0) {
+                    return;
+                }
+                incoming_symbols.forEach(symbol => {
+                    const callbacks = Object.values(this._orderbookListeners[symbol]);
+                    const parsedOrderBook = Coinray._parseOrderBookUpdate(orderbooks[symbol]);
+                    this._orderbookSnapshots[symbol] = Coinray._updateOrderBook(this._orderbookSnapshots[symbol], parsedOrderBook);
+                    callbacks.map((callback) => callback({
+                        type: "orderBook:update",
+                        coinraySymbol: symbol,
+                        orderBook: parsedOrderBook
+                    }));
+                });
+            });
+            channel.on("error", (payload) => console.error(payload));
+            return callback;
+        });
+        this.unsubscribeOrderBook = ({ coinraySymbol }, callback) => {
+            if (callback && this._orderbookListeners[coinraySymbol]) {
+                this._orderbookListeners[coinraySymbol] = this._orderbookListeners[coinraySymbol].filter((c) => c !== callback);
+                if (this._orderbookListeners[coinraySymbol].length === 0) {
+                    this.getChannel("orderbooks")
+                        .push("unsubscribe", { symbols: coinraySymbol }, 5000);
+                }
+            }
+            else {
+                this._orderbookSnapshots[coinraySymbol] = { minSeq: 0, maxSeq: 0, bids: {}, asks: {} };
+                this._orderbookListeners[coinraySymbol] = [];
+            }
+        };
+        this.subscribeCandles = ({ coinraySymbol, resolution, lastCandle }, callback) => __awaiter(this, void 0, void 0, function* () {
+            const candleId = `${coinraySymbol}-${resolution}`;
+            if (this._candleListeners[candleId] && this._candleListeners[candleId].length > 0) {
+                this._candleListeners[candleId].push(callback);
+                return callback;
+            }
+            this._candleListeners[candleId] = [callback];
+            const candleCallback = ({ type, coinraySymbol, trades }) => {
+                const callbacks = Object.values(this._candleListeners[candleId]);
+                const lastCandles = Coinray._tradesToLastCandle(resolution, trades);
+                const lastCandle = lastCandles[lastCandles.length - 1];
+                if (lastCandle) {
+                    if (this._candles[candleId] && type === "trades:snapshot") {
+                        this._candles[candleId].skipVolume = true;
+                    }
+                    this._candles[candleId] = Coinray._mergeCandle(this._candles[candleId], lastCandle);
+                    callbacks.map((callback) => callback({
+                        coinraySymbol,
+                        resolution,
+                        candle: this._candles[candleId],
+                        previousCandles: lastCandles
+                    }));
+                }
+            };
+            if (this._candleTradeListeners[coinraySymbol]) {
+                this._candleTradeListeners[coinraySymbol][candleId] = candleCallback;
+            }
+            else {
+                this._candleTradeListeners[coinraySymbol] = { [candleId]: candleCallback };
+            }
+            this._candles[candleId] = lastCandle || { time: 0 };
+            yield this.subscribeTrades({ coinraySymbol }, candleCallback);
+            return callback;
+        });
+        this.unsubscribeCandles = ({ coinraySymbol, resolution }, callback) => {
+            const candleId = `${coinraySymbol}-${resolution}`;
+            if (callback && this._candleListeners[candleId]) {
+                this._candleListeners[candleId] = this._candleListeners[candleId].filter((c) => c !== callback);
+            }
+            else {
+                this._candleListeners[candleId] = [];
+            }
+            if (this._candleListeners[candleId].length === 0) {
+                this.unsubscribeTrades({ coinraySymbol }, this._candleTradeListeners[coinraySymbol][candleId]);
+                delete this._candles[candleId];
+                delete this._candleTradeListeners[coinraySymbol][candleId];
+            }
+        };
+        this.fetchCandles = ({ coinraySymbol, resolution, start, end, useWebSocket }) => __awaiter(this, void 0, void 0, function* () {
+            const minDate = new Date();
+            minDate.setMinutes(minDate.getMinutes() - 5);
+            let indexedSnapshot = {};
+            const candlePromise = this.get("candles", {
+                version: "v1",
+                params: {
+                    symbol: coinraySymbol,
+                    resolution: resolution,
+                    start_time: start,
+                    end_time: end
+                }
+            });
+            // Fetch data from the websocket snapshot to merge the highs and lows
+            if (useWebSocket && end > minDate.getTime() / 1000) {
+                const subscribe = new Promise(resolve => {
+                    let timeout = setTimeout(() => resolve([]), 1000);
+                    const onSnapshot = ({ previousCandles }) => {
+                        clearTimeout(timeout);
+                        this.unsubscribeCandles({ coinraySymbol, resolution }, onSnapshot);
+                        resolve(previousCandles);
+                    };
+                    this.subscribeCandles({ coinraySymbol, resolution }, onSnapshot);
+                });
+                const snapshot = yield subscribe;
+                indexedSnapshot = _.keyBy(snapshot, ({ time }) => time.getTime());
+            }
+            const { result } = yield candlePromise;
+            return result.map(Coinray._parseCandle).map((candle) => {
+                const snapshotCandle = indexedSnapshot[candle.time.getTime()];
+                if (snapshotCandle) {
+                    return Coinray._mergeCandle(candle, snapshotCandle);
+                }
+                else {
+                    return candle;
+                }
+            });
+        });
+        this.fetchExchanges = () => __awaiter(this, void 0, void 0, function* () {
+            const { result: { exchanges } } = yield this.get("exchanges", {
+                version: "v1",
+            });
+            return exchanges.map((exhange) => Exchange.Create(exhange, this));
+        });
+        this.fetchMarkets = (exchange) => __awaiter(this, void 0, void 0, function* () {
+            const { result: { markets } } = yield this.get("markets", {
+                version: "v1",
+                params: {
+                    exchange
+                }
+            });
+            return markets.map((market) => {
+                try {
+                    return Market.Create(market, this);
+                }
+                catch (error) {
+                    return new Market(market, this);
+                }
+            });
+        });
+        this.fetchTrades = (coinraySymbol) => __awaiter(this, void 0, void 0, function* () {
+            const { result: trades } = yield this.get("trades", {
+                version: "v1",
+                params: {
+                    symbol: coinraySymbol
+                }
+            });
+            return trades.map(Coinray._parseTrade);
+        });
+        this.fetchOrderBook = (coinraySymbol) => __awaiter(this, void 0, void 0, function* () {
+            const { result: { seq, asks, bids } } = yield this.get("order_book", {
+                version: "v1",
+                params: {
+                    symbol: coinraySymbol
+                }
+            });
+            return Coinray._parseOrderBookSnapshot({ seq, asks, bids });
+        });
+        this.createCredential = (deviceId, password) => __awaiter(this, void 0, void 0, function* () {
+            const publicKey = yield this.publicKey();
+            try {
+                const encryptedPassword = yield encryptPayload(yield createJWT({ password }), publicKey);
+                const { result } = yield this.post("credentials", {
+                    secret: password,
+                    body: {
+                        deviceId, encryptedPassword
+                    }
+                });
+                return result;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+        this.wrapApiKey = (apiKeySettings) => __awaiter(this, void 0, void 0, function* () {
+            const publicKey = yield this.publicKey();
+            try {
+                const apiKey = JSON.stringify(apiKeySettings);
+                const encryptedApiKey = yield encryptPayload(yield createJWT({ apiKey }), publicKey);
+                const { result } = yield this.post("credentials/wrap_api_key", {
+                    secret: this._sessionKey,
+                    body: {
+                        encryptedApiKey, credential: this._credential
+                    }
+                });
+                return result;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+        this.testAccount = (accountTest) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { result } = yield this.post("account/test", {
+                    secret: this._sessionKey,
+                    apiEndpoint: this.config.orderEndpoint,
+                    body: Object.assign(Object.assign({}, accountTest), { credential: this._credential })
+                });
+                return result;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+        this.createSmartOrderSignature = (smartOrder) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { result } = yield this.post("order/smart_order_signature", {
+                    secret: this._sessionKey,
+                    apiEndpoint: this.config.orderEndpoint,
+                    body: { smartOrder, credential: this._credential }
+                });
+                return result;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+        this.createOrder = (order) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { result } = yield this.post("order", {
+                    secret: this._sessionKey,
+                    apiEndpoint: this.config.orderEndpoint,
+                    body: Object.assign(Object.assign({}, order), { credential: this._credential })
+                });
+                return result;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+        this.updateOrder = (order) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { result } = yield this.patch("order", {
+                    secret: this._sessionKey,
+                    apiEndpoint: this.config.orderEndpoint,
+                    body: Object.assign(Object.assign({}, order), { credential: this._credential })
+                });
+                return result;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+        this.cancelOrder = (order) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { result } = yield this.delete("order", {
+                    secret: this._sessionKey,
+                    apiEndpoint: this.config.orderEndpoint,
+                    body: Object.assign(Object.assign({}, order), { credential: this._credential })
+                });
+                return result;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+        this.createWebSocketToken = ({ exchangeCode, encryptedApiKey }) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { result } = yield this.post("exchanges/ws_token", {
+                    secret: this._sessionKey,
+                    apiEndpoint: this.config.orderEndpoint,
+                    body: { encryptedApiKey, exchangeCode, credential: this._credential }
+                });
+                return result;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+        this.fetchPositions = ({ exchangeCode, encryptedApiKey }) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { result } = yield this.get("futures/positions", {
+                    secret: this._sessionKey,
+                    apiEndpoint: this.config.orderEndpoint,
+                    params: {
+                        credential: this._credential,
+                        exchangeCode,
+                        encryptedApiKey
+                    }
+                });
+                return result;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+        this.getBalances = ({ exchangeCode, encryptedApiKey }) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { result: { balances, positions } } = yield this.get("account/balances", {
+                    secret: this._sessionKey,
+                    apiEndpoint: this.config.orderEndpoint,
+                    params: {
+                        credential: this._credential,
+                        exchangeCode,
+                        encryptedApiKey
+                    }
+                });
+                return { balances: balances.map(Coinray._parseBalance), positions };
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+        this.setLeverage = ({ coinraySymbol, leverage, encryptedApiKey }) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { result } = yield this.post("futures/leverage", {
+                    secret: this._sessionKey,
+                    apiEndpoint: this.config.orderEndpoint,
+                    body: {
+                        credential: this._credential,
+                        coinraySymbol,
+                        leverage,
+                        encryptedApiKey
+                    }
+                });
+                return result;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+        this.setMarginType = ({ coinraySymbol, marginType, encryptedApiKey }) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { result } = yield this.post("futures/margin_type", {
+                    secret: this._sessionKey,
+                    apiEndpoint: this.config.orderEndpoint,
+                    body: {
+                        credential: this._credential,
+                        coinraySymbol,
+                        marginType,
+                        encryptedApiKey
+                    }
+                });
+                return result;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+        this.get = (endpoint, { apiEndpoint = undefined, version = "v2", headers = {}, params = {}, secret = "" } = {}) => __awaiter(this, void 0, void 0, function* () {
+            return yield this._request(endpoint, "GET", {
+                version,
+                apiEndpoint,
+                headers,
+                secret,
+                params
+            });
+        });
+        this.post = (endpoint, attributes) => __awaiter(this, void 0, void 0, function* () { return yield this._request(endpoint, "POST", attributes); });
+        this.patch = (endpoint, attributes) => __awaiter(this, void 0, void 0, function* () { return yield this._request(endpoint, "PATCH", attributes); });
+        this.delete = (endpoint, attributes) => __awaiter(this, void 0, void 0, function* () { return yield this._request(endpoint, "delete", attributes); });
+        this._token = token;
+        this._nonceOffset = 0;
+        this._timeOffset = 0;
+        this._firstOpen = true;
+        this.config = {
+            apiEndpoint: apiEndpoint || "https://coinray.io",
+            orderEndpoint: orderEndpoint || apiEndpoint || "https://coinray.io",
+            websocketEndpoint: websocketEndpoint || "wss://ws.coinray.io/v1"
+        };
+        this.loadTimeOffset().then();
+        this._timeOffsetInterval = setInterval(this.loadTimeOffset, 60 * 1000);
+    }
+    publicKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._publicKey) {
+                const { result: { jwk } } = yield this.get("credentials/certificate");
+                this._publicKey = yield jwkToPublicKey(jwk);
+            }
+            return this._publicKey;
+        });
+    }
+    get clientId() {
+        return parseJWT(this._token).header.kid;
+    }
+    get socket() {
+        if (!this._token) {
+            throw new Error("Token not present");
+        }
+        if (!this._socket) {
+            this._socket = new Socket(this.config.websocketEndpoint, {
+                heartbeatIntervalMs: 5000,
+                transport: this._transport,
+                reconnectAfterMs: (tries) => {
+                    if (jwtExpired(this._token)) {
+                        return 30000;
+                    }
+                    else {
+                        return 1000;
+                    }
+                }
+            });
+            this.onOpen(this.resubscribe);
+        }
+        // @ts-ignore
+        this._socket.params = () => ({ reconnect: true, token: this._token, client: "coinrayjs", version: VERSION });
+        return this._socket;
+    }
+    getChannel(name) {
+        this.connect();
+        if (this._channels[name]) {
+            return this._channels[name];
+        }
+        const channel = this.socket.channel(name, {});
+        this._channels[name] = channel;
+        channel.join();
+        return channel;
+    }
+    _request(endpoint, method, { apiEndpoint, version = "v2", headers = {}, params = {}, body = {}, secret = "" }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = yield this.getToken();
+            const paramString = Object.entries(params).length > 0 ? '?' + Object.entries(params).map(([key, val]) => val ? `${key}=${val}` : undefined).filter(Boolean).join('&') : "";
+            const nonce = this.getNonce();
+            const requestUri = `/api/${version}/${endpoint}${paramString}`;
+            if (version === "v2") {
+                const dataToSign = [nonce, method.toUpperCase(), requestUri, method === "GET" ? "" : JSON.stringify(body)].join("");
+                const signature = signHMAC(dataToSign, secret);
+                headers = Object.assign(Object.assign({}, headers), { "Cr-Access-Token": `${token}`, "Cr-Nonce": nonce, "Cr-Signature": signature });
+            }
+            const options = {
+                method,
+                url: (apiEndpoint || this.config.apiEndpoint) + requestUri,
+                timeout: 20000,
+                headers: Object.assign({ "Accept": "application/json", "Content-Type": "application/json", "Authorization": `Bearer ${token}`, "Cr-Client-version": VERSION }, headers),
+                data: method === "GET" ? undefined : JSON.stringify(body)
+            };
+            try {
+                const response = yield axios(options);
+                let result;
+                if (response.status === 200) {
+                    result = response.data;
+                }
+                else if (response.status === 204) {
+                    result = {};
+                }
+                else {
+                    result = response.data;
+                }
+                return { result: camelize(result), _headers: response.headers };
+            }
+            catch (error) {
+                const { response, request } = error;
+                if (response) {
+                    const { error } = response.data;
+                    throw new CoinrayError(error);
+                }
+                else {
+                    throw error;
+                }
+            }
+        });
+    }
+    static _parseOrderBookSnapshot({ asks, bids, min_seq, max_seq }) {
+        return {
+            minSeq: min_seq,
+            maxSeq: max_seq,
+            asks: Coinray._parseBidAsk(asks),
+            bids: Coinray._parseBidAsk(bids),
+        };
+    }
+    static _parseOrderBookUpdate({ asks_diff, bids_diff, min_seq, max_seq }) {
+        return {
+            minSeq: min_seq,
+            maxSeq: max_seq,
+            asks: Coinray._parseBidAsk(asks_diff),
+            bids: Coinray._parseBidAsk(bids_diff),
+        };
+    }
+    static _updateOrderBook(orderBook, { asks, bids, min_seq, max_seq }) {
+        const update = (side, updates) => {
+            _.forEach(updates, (quantity, price) => {
+                if (quantity.gt(0)) {
+                    side[price] = quantity;
+                }
+                else {
+                    delete side[price];
+                }
+            });
+        };
+        orderBook.minSeq = min_seq;
+        orderBook.maxSeq = max_seq;
+        update(orderBook.bids, bids);
+        update(orderBook.asks, asks);
+        return orderBook;
+    }
+    static _parseBidAsk(bidAsk) {
+        if (Array.isArray(bidAsk)) {
+            return bidAsk.reduce((acc, [price, quantity]) => {
+                acc[price] = new BigNumber(quantity);
+                return acc;
+            }, {});
+        }
+        else {
+            return Object.keys(bidAsk).reduce((acc, price) => {
+                acc[price] = new BigNumber(bidAsk[price]);
+                return acc;
+            }, {});
+        }
+    }
+    static _parseCandle(result) {
+        if (result) {
+            const [time, open, high, low, close, baseVolume, quoteVolume] = result;
+            return {
+                time: safeTime(time),
+                open: safeBigNumber(open),
+                high: safeBigNumber(high),
+                low: safeBigNumber(low),
+                close: safeBigNumber(close),
+                baseVolume: safeBigNumber(baseVolume),
+                quoteVolume: safeBigNumber(quoteVolume),
+            };
+        }
+        else {
+            throw new Error("Candle");
+        }
+    }
+    static _parseTrade([id, time, price, quantity, isBuy]) {
+        return {
+            id,
+            time: safeTime(time),
+            price: safeBigNumber(price),
+            quantity: safeBigNumber(quantity),
+            type: ['1', 'buy'].includes(isBuy.toString()) ? "buy" : "sell"
+        };
+    }
+    static _parseTicker(ticker) {
+        return {
+            askPrice: safeBigNumber(ticker.a),
+            baseVolume: safeBigNumber(ticker.bv),
+            bidPrice: safeBigNumber(ticker.b),
+            btcVolume: safeBigNumber(ticker.B),
+            coinraySymbol: ticker.s,
+            highPrice1s: safeBigNumber(ticker.h),
+            highPrice24h: safeBigNumber(ticker.H),
+            lastPrice: safeBigNumber(ticker.c),
+            lowPrice1s: safeBigNumber(ticker.l),
+            lowPrice24h: safeBigNumber(ticker.L),
+            openPrice1s: safeBigNumber(ticker.o),
+            openPrice24h: safeBigNumber(ticker.O),
+            quoteVolume: safeBigNumber(ticker.qv),
+            usdVolume: safeBigNumber(ticker.U)
+        };
+    }
+    static _parseBalance(balance) {
+        let newBalance = {
+            currency: balance.currency,
+            available: safeBigNumber(balance.available),
+            inOrders: safeBigNumber(balance.inOrders),
+            total: safeBigNumber(balance.inOrders),
+        };
+        if (balance.initialMargin) {
+            newBalance = Object.assign(Object.assign({}, newBalance), {
+                initialMargin: safeBigNumber(balance.initialMargin),
+                openOrderInitialMargin: safeBigNumber(balance.openOrderInitialMargin),
+                positionInitialMargin: safeBigNumber(balance.positionInitialMargin),
+                unrealizedProfit: safeBigNumber(balance.unrealizedProfit),
+                crossWalletBalance: safeBigNumber(balance.crossWalletBalance),
+                crossUnrealizedProfit: safeBigNumber(balance.crossUnrealizedProfit),
+            });
+        }
+        return newBalance;
+    }
+    static _tradesToLastCandle(resolution, trades) {
+        if (trades.length > 0 && trades[0].time > trades[trades.length - 1].time) {
+            trades = trades.reverse();
+        }
+        const seconds = Coinray._resolutionToSeconds(resolution);
+        const groupedTrades = _.groupBy(trades.reverse(), ({ time }) => Math.floor(time.getTime() / seconds) * seconds);
+        return _.sortBy(Object.keys(groupedTrades), (date) => parseInt(date)).map((date) => {
+            const currentCandleTrades = groupedTrades[date];
+            const currentTime = currentCandleTrades[0].time.getTime();
+            const startDate = new Date(currentTime - (currentTime % seconds));
+            if (currentCandleTrades.length === 0) {
+                return undefined;
+            }
+            let first = currentCandleTrades[0];
+            let open, low, high, close;
+            let baseVolume = new BigNumber(0);
+            let quoteVolume = new BigNumber(0);
+            open = low = high = close = first.price;
+            currentCandleTrades.reverse().map(({ price, quantity }) => {
+                low = BigNumber.min(low, price);
+                high = BigNumber.max(high, price);
+                close = price;
+                baseVolume = baseVolume.plus(quantity);
+                quoteVolume = quoteVolume.plus(quantity.multipliedBy(price));
+            });
+            return {
+                time: new Date(startDate),
+                open,
+                high,
+                low,
+                close,
+                baseVolume,
+                quoteVolume,
+            };
+        });
+    }
+    ;
+    static _mergeCandle(currentCandle, candle) {
+        if (!currentCandle || currentCandle.time < candle.time) {
+            return candle;
+        }
+        currentCandle.high = BigNumber.max(currentCandle.high, candle.high);
+        currentCandle.low = BigNumber.min(currentCandle.low, candle.low);
+        currentCandle.close = candle.close;
+        if (currentCandle.skipVolume) {
+            currentCandle.skipVolume = false;
+        }
+        else {
+            currentCandle.baseVolume = currentCandle.baseVolume.plus(candle.baseVolume);
+            currentCandle.quoteVolume = currentCandle.quoteVolume.plus(candle.quoteVolume);
+        }
+        return currentCandle;
+    }
+    static _resolutionToSeconds(resolution) {
+        if (resolution.indexOf("W") > 0) {
+            return parseInt(resolution) * 24 * 60 * 60 * 1000;
+        }
+        else if (resolution.indexOf("D") > 0) {
+            return parseInt(resolution) * 24 * 60 * 60 * 1000;
+        }
+        else if (resolution === "D") {
+            return 24 * 60 * 60 * 1000;
+        }
+        else {
+            return parseInt(resolution) * 60 * 1000;
+        }
+    }
+}
+Coinray.I18n = I18n;
+//# sourceMappingURL=coinray.js.map