ccxt 4.2.11 → 4.2.13

package/dist/cjs/js/src/base/ws/Cache.js

@@ -0,0 +1,254 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/* eslint-disable max-classes-per-file */
+// @ts-nocheck
+class BaseCache extends Array {
+    constructor(maxSize = undefined) {
+        super();
+        Object.defineProperty(this, 'maxSize', {
+            __proto__: null,
+            value: maxSize,
+            writable: true,
+        });
+    }
+    clear() {
+        this.length = 0;
+    }
+}
+class ArrayCache extends BaseCache {
+    constructor(maxSize = undefined) {
+        super(maxSize);
+        Object.defineProperty(this, 'nestedNewUpdatesBySymbol', {
+            __proto__: null,
+            value: false,
+            writable: true,
+        });
+        Object.defineProperty(this, 'newUpdatesBySymbol', {
+            __proto__: null,
+            value: {},
+            writable: true,
+        });
+        Object.defineProperty(this, 'clearUpdatesBySymbol', {
+            __proto__: null,
+            value: {},
+            writable: true,
+        });
+        Object.defineProperty(this, 'allNewUpdates', {
+            __proto__: null,
+            value: 0,
+            writable: true,
+        });
+        Object.defineProperty(this, 'clearAllUpdates', {
+            __proto__: null,
+            value: false,
+            writable: true,
+        });
+    }
+    getLimit(symbol, limit) {
+        let newUpdatesValue = undefined;
+        if (symbol === undefined) {
+            newUpdatesValue = this.allNewUpdates;
+            this.clearAllUpdates = true;
+        }
+        else {
+            newUpdatesValue = this.newUpdatesBySymbol[symbol];
+            if ((newUpdatesValue !== undefined) && this.nestedNewUpdatesBySymbol) {
+                newUpdatesValue = newUpdatesValue.size;
+            }
+            this.clearUpdatesBySymbol[symbol] = true;
+        }
+        if (newUpdatesValue === undefined) {
+            return limit;
+        }
+        else if (limit !== undefined) {
+            return Math.min(newUpdatesValue, limit);
+        }
+        else {
+            return newUpdatesValue;
+        }
+    }
+    append(item) {
+        // maxSize may be 0 when initialized by a .filter() copy-construction
+        if (this.maxSize && (this.length === this.maxSize)) {
+            this.shift();
+        }
+        this.push(item);
+        if (this.clearAllUpdates) {
+            this.clearAllUpdates = false;
+            this.clearUpdatesBySymbol = {};
+            this.allNewUpdates = 0;
+            this.newUpdatesBySymbol = {};
+        }
+        if (this.clearUpdatesBySymbol[item.symbol]) {
+            this.clearUpdatesBySymbol[item.symbol] = false;
+            this.newUpdatesBySymbol[item.symbol] = 0;
+        }
+        this.newUpdatesBySymbol[item.symbol] = (this.newUpdatesBySymbol[item.symbol] || 0) + 1;
+        this.allNewUpdates = (this.allNewUpdates || 0) + 1;
+    }
+}
+class ArrayCacheByTimestamp extends BaseCache {
+    constructor(maxSize = undefined) {
+        super(maxSize);
+        Object.defineProperty(this, 'hashmap', {
+            __proto__: null,
+            value: {},
+            writable: true,
+        });
+        Object.defineProperty(this, 'sizeTracker', {
+            __proto__: null,
+            value: new Set(),
+            writable: true,
+        });
+        Object.defineProperty(this, 'newUpdates', {
+            __proto__: null,
+            value: 0,
+            writable: true,
+        });
+        Object.defineProperty(this, 'clearUpdates', {
+            __proto__: null,
+            value: false,
+            writable: true,
+        });
+    }
+    getLimit(symbol, limit) {
+        this.clearUpdates = true;
+        if (limit === undefined) {
+            return this.newUpdates;
+        }
+        return Math.min(this.newUpdates, limit);
+    }
+    append(item) {
+        if (item[0] in this.hashmap) {
+            const reference = this.hashmap[item[0]];
+            if (reference !== item) {
+                for (const prop in item) {
+                    reference[prop] = item[prop];
+                }
+            }
+        }
+        else {
+            this.hashmap[item[0]] = item;
+            if (this.maxSize && (this.length === this.maxSize)) {
+                const deleteReference = this.shift();
+                delete this.hashmap[deleteReference[0]];
+            }
+            this.push(item);
+        }
+        if (this.clearUpdates) {
+            this.clearUpdates = false;
+            this.sizeTracker.clear();
+        }
+        this.sizeTracker.add(item[0]);
+        this.newUpdates = this.sizeTracker.size;
+    }
+}
+class ArrayCacheBySymbolById extends ArrayCache {
+    constructor(maxSize = undefined) {
+        super(maxSize);
+        this.nestedNewUpdatesBySymbol = true;
+        Object.defineProperty(this, 'hashmap', {
+            __proto__: null,
+            value: {},
+            writable: true,
+        });
+    }
+    append(item) {
+        const byId = this.hashmap[item.symbol] = this.hashmap[item.symbol] || {};
+        if (item.id in byId) {
+            const reference = byId[item.id];
+            if (reference !== item) {
+                for (const prop in item) {
+                    reference[prop] = item[prop];
+                }
+            }
+            item = reference;
+            const index = this.findIndex((x) => x.id === item.id);
+            // move the order to the end of the array
+            this.splice(index, 1);
+        }
+        else {
+            byId[item.id] = item;
+        }
+        if (this.maxSize && (this.length === this.maxSize)) {
+            const deleteReference = this.shift();
+            delete this.hashmap[deleteReference.symbol][deleteReference.id];
+        }
+        this.push(item);
+        if (this.clearAllUpdates) {
+            this.clearAllUpdates = false;
+            this.clearUpdatesBySymbol = {};
+            this.allNewUpdates = 0;
+            this.newUpdatesBySymbol = {};
+        }
+        if (this.newUpdatesBySymbol[item.symbol] === undefined) {
+            this.newUpdatesBySymbol[item.symbol] = new Set();
+        }
+        if (this.clearUpdatesBySymbol[item.symbol]) {
+            this.clearUpdatesBySymbol[item.symbol] = false;
+            this.newUpdatesBySymbol[item.symbol].clear();
+        }
+        // in case an exchange updates the same order id twice
+        const idSet = this.newUpdatesBySymbol[item.symbol];
+        const beforeLength = idSet.size;
+        idSet.add(item.id);
+        const afterLength = idSet.size;
+        this.allNewUpdates = (this.allNewUpdates || 0) + (afterLength - beforeLength);
+    }
+}
+class ArrayCacheBySymbolBySide extends ArrayCache {
+    constructor() {
+        super();
+        this.nestedNewUpdatesBySymbol = true;
+        Object.defineProperty(this, 'hashmap', {
+            __proto__: null,
+            value: {},
+            writable: true,
+        });
+    }
+    append(item) {
+        const bySide = this.hashmap[item.symbol] = this.hashmap[item.symbol] || {};
+        if (item.side in bySide) {
+            const reference = bySide[item.side];
+            if (reference !== item) {
+                for (const prop in item) {
+                    reference[prop] = item[prop];
+                }
+            }
+            item = reference;
+            const index = this.findIndex((x) => x.symbol === item.symbol && x.side === item.side);
+            // move the order to the end of the array
+            this.splice(index, 1);
+        }
+        else {
+            bySide[item.side] = item;
+        }
+        this.push(item);
+        if (this.clearAllUpdates) {
+            this.clearAllUpdates = false;
+            this.clearUpdatesBySymbol = {};
+            this.allNewUpdates = 0;
+            this.newUpdatesBySymbol = {};
+        }
+        if (this.newUpdatesBySymbol[item.symbol] === undefined) {
+            this.newUpdatesBySymbol[item.symbol] = new Set();
+        }
+        if (this.clearUpdatesBySymbol[item.symbol]) {
+            this.clearUpdatesBySymbol[item.symbol] = false;
+            this.newUpdatesBySymbol[item.symbol].clear();
+        }
+        // in case an exchange updates the same order id twice
+        const sideSet = this.newUpdatesBySymbol[item.symbol];
+        const beforeLength = sideSet.size;
+        sideSet.add(item.side);
+        const afterLength = sideSet.size;
+        this.allNewUpdates = (this.allNewUpdates || 0) + (afterLength - beforeLength);
+    }
+}
+
+exports.ArrayCache = ArrayCache;
+exports.ArrayCacheBySymbolById = ArrayCacheBySymbolById;
+exports.ArrayCacheBySymbolBySide = ArrayCacheBySymbolBySide;
+exports.ArrayCacheByTimestamp = ArrayCacheByTimestamp;

package/dist/cjs/js/src/base/ws/Client.js

@@ -0,0 +1,299 @@
+'use strict';
+
+var errors = require('../errors.js');
+var browser = require('../../static_dependencies/fflake/browser.js');
+var Future = require('./Future.js');
+var platform = require('../functions/platform.js');
+var generic = require('../functions/generic.js');
+var encode = require('../functions/encode.js');
+require('../functions/crypto.js');
+var time = require('../functions/time.js');
+var index = require('../../static_dependencies/scure-base/index.js');
+
+class Client {
+    constructor(url, onMessageCallback, onErrorCallback, onCloseCallback, onConnectedCallback, config = {}) {
+        const defaults = {
+            url,
+            onMessageCallback,
+            onErrorCallback,
+            onCloseCallback,
+            onConnectedCallback,
+            verbose: false,
+            protocols: undefined,
+            options: undefined,
+            futures: {},
+            subscriptions: {},
+            rejections: {},
+            connected: undefined,
+            error: undefined,
+            connectionStarted: undefined,
+            connectionEstablished: undefined,
+            isConnected: false,
+            connectionTimer: undefined,
+            connectionTimeout: 10000,
+            pingInterval: undefined,
+            ping: undefined,
+            keepAlive: 30000,
+            maxPingPongMisses: 2.0,
+            // timeout is not used atm
+            // timeout: 30000, // throw if a request is not satisfied in 30 seconds, false to disable
+            connection: undefined,
+            startedConnecting: false,
+            gunzip: false,
+            inflate: false,
+        };
+        Object.assign(this, generic.deepExtend(defaults, config));
+        // connection-related Future
+        this.connected = Future.Future();
+    }
+    future(messageHash) {
+        if (!(messageHash in this.futures)) {
+            this.futures[messageHash] = Future.Future();
+        }
+        const future = this.futures[messageHash];
+        if (messageHash in this.rejections) {
+            future.reject(this.rejections[messageHash]);
+            delete this.rejections[messageHash];
+        }
+        return future;
+    }
+    resolve(result, messageHash) {
+        if (this.verbose && (messageHash === undefined)) {
+            this.log(new Date(), 'resolve received undefined messageHash');
+        }
+        if (messageHash in this.futures) {
+            const promise = this.futures[messageHash];
+            promise.resolve(result);
+            delete this.futures[messageHash];
+        }
+        return result;
+    }
+    reject(result, messageHash = undefined) {
+        if (messageHash) {
+            if (messageHash in this.futures) {
+                const promise = this.futures[messageHash];
+                promise.reject(result);
+                delete this.futures[messageHash];
+            }
+            else {
+                // in the case that a promise was already fulfilled
+                // and the client has not yet called watchMethod to create a new future
+                // calling client.reject will do nothing
+                // this means the rejection will be ignored and the code will continue executing
+                // instead we store the rejection for later
+                this.rejections[messageHash] = result;
+            }
+        }
+        else {
+            const messageHashes = Object.keys(this.futures);
+            for (let i = 0; i < messageHashes.length; i++) {
+                this.reject(result, messageHashes[i]);
+            }
+        }
+        return result;
+    }
+    log(...args) {
+        console.log(...args);
+        // console.dir (args, { depth: null })
+    }
+    connect(backoffDelay = 0) {
+        throw new errors.NotSupported('connect() not implemented yet');
+    }
+    isOpen() {
+        throw new errors.NotSupported('isOpen() not implemented yet');
+    }
+    reset(error) {
+        this.clearConnectionTimeout();
+        this.clearPingInterval();
+        this.reject(error);
+    }
+    onConnectionTimeout() {
+        if (!this.isOpen()) {
+            const error = new errors.RequestTimeout('Connection to ' + this.url + ' failed due to a connection timeout');
+            this.onError(error);
+            this.connection.close(1006);
+        }
+    }
+    setConnectionTimeout() {
+        if (this.connectionTimeout) {
+            const onConnectionTimeout = this.onConnectionTimeout.bind(this);
+            this.connectionTimer = setTimeout(onConnectionTimeout, this.connectionTimeout);
+        }
+    }
+    clearConnectionTimeout() {
+        if (this.connectionTimer) {
+            this.connectionTimer = clearTimeout(this.connectionTimer);
+        }
+    }
+    setPingInterval() {
+        if (this.keepAlive) {
+            const onPingInterval = this.onPingInterval.bind(this);
+            this.pingInterval = setInterval(onPingInterval, this.keepAlive);
+        }
+    }
+    clearPingInterval() {
+        if (this.pingInterval) {
+            this.pingInterval = clearInterval(this.pingInterval);
+        }
+    }
+    onPingInterval() {
+        if (this.keepAlive && this.isOpen()) {
+            const now = time.milliseconds();
+            this.lastPong = this.lastPong || now;
+            if ((this.lastPong + this.keepAlive * this.maxPingPongMisses) < now) {
+                this.onError(new errors.RequestTimeout('Connection to ' + this.url + ' timed out due to a ping-pong keepalive missing on time'));
+            }
+            else {
+                if (this.ping) {
+                    this.send(this.ping(this));
+                }
+                else if (platform.isNode) {
+                    // can't do this inside browser
+                    // https://stackoverflow.com/questions/10585355/sending-websocket-ping-pong-frame-from-browser
+                    this.connection.ping();
+                }
+                else {
+                    // browsers handle ping-pong automatically therefore
+                    // in a browser we update lastPong on every call to
+                    // this function as if pong just came in to prevent the
+                    // client from thinking it's a stalled connection
+                    this.lastPong = now;
+                }
+            }
+        }
+    }
+    onOpen() {
+        if (this.verbose) {
+            this.log(new Date(), 'onOpen');
+        }
+        this.connectionEstablished = time.milliseconds();
+        this.isConnected = true;
+        this.connected.resolve(this.url);
+        // this.connection.terminate () // debugging
+        this.clearConnectionTimeout();
+        this.setPingInterval();
+        this.onConnectedCallback(this);
+    }
+    // this method is not used at this time, because in JS the ws client will
+    // respond to pings coming from the server with pongs automatically
+    // however, some devs may want to track connection states in their app
+    onPing() {
+        if (this.verbose) {
+            this.log(new Date(), 'onPing');
+        }
+    }
+    onPong() {
+        this.lastPong = time.milliseconds();
+        if (this.verbose) {
+            this.log(new Date(), 'onPong');
+        }
+    }
+    onError(error) {
+        if (this.verbose) {
+            this.log(new Date(), 'onError', error.message);
+        }
+        if (!(error instanceof errors.BaseError)) {
+            // in case of ErrorEvent from node_modules/ws/lib/event-target.js
+            error = new errors.NetworkError(error.message);
+        }
+        this.error = error;
+        this.reset(this.error);
+        this.onErrorCallback(this, this.error);
+    }
+    /* eslint-disable no-shadow */
+    onClose(event) {
+        if (this.verbose) {
+            this.log(new Date(), 'onClose', event);
+        }
+        if (!this.error) {
+            // todo: exception types for server-side disconnects
+            this.reset(new errors.NetworkError('connection closed by remote server, closing code ' + String(event.code)));
+        }
+        if (this.error instanceof errors.ExchangeClosedByUser) {
+            this.reset(this.error);
+        }
+        if (this.disconnected !== undefined) {
+            this.disconnected.resolve(true);
+        }
+        this.onCloseCallback(this, event);
+    }
+    // this method is not used at this time
+    // but may be used to read protocol-level data like cookies, headers, etc
+    onUpgrade(message) {
+        if (this.verbose) {
+            this.log(new Date(), 'onUpgrade');
+        }
+    }
+    async send(message) {
+        if (this.verbose) {
+            this.log(new Date(), 'sending', message);
+        }
+        message = (typeof message === 'string') ? message : JSON.stringify(message);
+        const future = Future.Future();
+        if (platform.isNode) {
+            /* eslint-disable no-inner-declarations */
+            /* eslint-disable jsdoc/require-jsdoc */
+            function onSendComplete(error) {
+                if (error) {
+                    future.reject(error);
+                }
+                else {
+                    future.resolve(null);
+                }
+            }
+            this.connection.send(message, {}, onSendComplete);
+        }
+        else {
+            this.connection.send(message);
+            future.resolve(null);
+        }
+        return future;
+    }
+    close() {
+        throw new errors.NotSupported('close() not implemented yet');
+    }
+    onMessage(messageEvent) {
+        // if we use onmessage we get MessageEvent objects
+        // MessageEvent {isTrusted: true, data: "{"e":"depthUpdate","E":1581358737706,"s":"ETHBTC",…"0.06200000"]],"a":[["0.02261300","0.00000000"]]}", origin: "wss://stream.binance.com:9443", lastEventId: "", source: null, …}
+        let message = messageEvent.data;
+        let arrayBuffer;
+        if (typeof message !== 'string') {
+            if (this.gunzip || this.inflate) {
+                arrayBuffer = new Uint8Array(message.buffer.slice(message.byteOffset, message.byteOffset + message.byteLength));
+                if (this.gunzip) {
+                    arrayBuffer = browser.gunzipSync(arrayBuffer);
+                }
+                else if (this.inflate) {
+                    arrayBuffer = browser.inflateSync(arrayBuffer);
+                }
+                message = index.utf8.encode(arrayBuffer);
+            }
+            else {
+                message = message.toString();
+            }
+        }
+        try {
+            if (encode.isJsonEncodedObject(message)) {
+                message = JSON.parse(message.replace(/:(\d{15,}),/g, ':"$1",'));
+            }
+            if (this.verbose) {
+                this.log(new Date(), 'onMessage', message);
+                // unlimited depth
+                // this.log (new Date (), 'onMessage', util.inspect (message, false, null, true))
+                // this.log (new Date (), 'onMessage', JSON.stringify (message, null, 4))
+            }
+        }
+        catch (e) {
+            this.log(new Date(), 'onMessage JSON.parse', e);
+            // reset with a json encoding error ?
+        }
+        try {
+            this.onMessageCallback(this, message);
+        }
+        catch (error) {
+            this.reject(error);
+        }
+    }
+}
+
+module.exports = Client;

package/dist/cjs/js/src/base/ws/Future.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// @ts-nocheck
+function Future() {
+    let resolve = undefined, reject = undefined;
+    const p = new Promise((resolve_, reject_) => {
+        resolve = resolve_;
+        reject = reject_;
+    });
+    p.resolve = function _resolve() {
+        // eslint-disable-next-line prefer-rest-params
+        setTimeout(() => {
+            resolve.apply(this, arguments);
+        });
+    };
+    p.reject = function _reject() {
+        // eslint-disable-next-line prefer-rest-params
+        setTimeout(() => {
+            reject.apply(this, arguments);
+        });
+    };
+    return p;
+}
+function wrapFuture(aggregatePromise) {
+    const p = Future();
+    // wrap the promises as a future
+    aggregatePromise.then(p.resolve, p.reject);
+    return p;
+}
+Future.race = (futures) => wrapFuture(Promise.race(futures));
+
+exports.Future = Future;

package/dist/cjs/js/src/base/ws/OrderBook.js

@@ -0,0 +1,107 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var time = require('../functions/time.js');
+var generic = require('../functions/generic.js');
+var OrderBookSide = require('./OrderBookSide.js');
+
+/* eslint-disable max-classes-per-file */
+// ----------------------------------------------------------------------------
+// overwrites absolute volumes at price levels
+class OrderBook {
+    constructor(snapshot = {}, depth = undefined) {
+        Object.defineProperty(this, 'cache', {
+            __proto__: null,
+            value: [],
+            writable: true,
+        });
+        depth = depth || Number.MAX_SAFE_INTEGER;
+        const defaults = {
+            'bids': [],
+            'asks': [],
+            'timestamp': undefined,
+            'datetime': undefined,
+            'nonce': undefined,
+            'symbol': undefined,
+        };
+        // merge to this
+        const entries = Object.entries(generic.extend(defaults, snapshot));
+        for (let i = 0; i < entries.length; i++) {
+            const [property, value] = entries[i];
+            this[property] = value;
+        }
+        // wrap plain arrays with Bids/Asks classes if necessary
+        if (this.asks.constructor.name === 'Array') {
+            this.asks = new OrderBookSide.Asks(this.asks, depth);
+        }
+        if (this.bids.constructor.name === 'Array') {
+            this.bids = new OrderBookSide.Bids(this.bids, depth);
+        }
+        if (this.timestamp) {
+            this.datetime = time.iso8601(this.timestamp);
+        }
+    }
+    limit() {
+        this.asks.limit();
+        this.bids.limit();
+        return this;
+    }
+    update(snapshot) {
+        if ((snapshot.nonce !== undefined) &&
+            (this.nonce !== undefined) &&
+            (snapshot.nonce <= this.nonce)) {
+            return this;
+        }
+        this.nonce = snapshot.nonce;
+        this.timestamp = snapshot.timestamp;
+        this.datetime = time.iso8601(this.timestamp);
+        return this.reset(snapshot);
+    }
+    reset(snapshot = {}) {
+        this.asks.index.fill(Number.MAX_VALUE);
+        this.asks.length = 0;
+        if (snapshot.asks) {
+            for (let i = 0; i < snapshot.asks.length; i++) {
+                this.asks.storeArray(snapshot.asks[i]);
+            }
+        }
+        this.bids.index.fill(Number.MAX_VALUE);
+        this.bids.length = 0;
+        if (snapshot.bids) {
+            for (let i = 0; i < snapshot.bids.length; i++) {
+                this.bids.storeArray(snapshot.bids[i]);
+            }
+        }
+        this.nonce = snapshot.nonce;
+        this.timestamp = snapshot.timestamp;
+        this.datetime = time.iso8601(this.timestamp);
+        this.symbol = snapshot.symbol;
+        return this;
+    }
+}
+// ----------------------------------------------------------------------------
+// overwrites absolute volumes at price levels
+// or deletes price levels based on order counts (3rd value in a bidask delta)
+class CountedOrderBook extends OrderBook {
+    constructor(snapshot = {}, depth = undefined) {
+        super(generic.extend(snapshot, {
+            'asks': new OrderBookSide.CountedAsks(snapshot.asks || [], depth),
+            'bids': new OrderBookSide.CountedBids(snapshot.bids || [], depth),
+        }));
+    }
+}
+// ----------------------------------------------------------------------------
+// indexed by order ids (3rd value in a bidask delta)
+class IndexedOrderBook extends OrderBook {
+    constructor(snapshot = {}, depth = undefined) {
+        super(generic.extend(snapshot, {
+            'asks': new OrderBookSide.IndexedAsks(snapshot.asks || [], depth),
+            'bids': new OrderBookSide.IndexedBids(snapshot.bids || [], depth),
+        }));
+    }
+}
+
+exports.CountedOrderBook = CountedOrderBook;
+exports.IndexedOrderBook = IndexedOrderBook;
+exports.OrderBook = OrderBook;