ccxt 4.2.18 → 4.2.20

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

@@ -1,254 +0,0 @@
-'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

@@ -1,299 +0,0 @@
-'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

@@ -1,34 +0,0 @@
-'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

@@ -1,107 +0,0 @@
-'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;