ccxt-ir 4.10.0 → 4.11.0

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

@@ -0,0 +1,260 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+/* 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);
+        this.hashmap = {};
+        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,
+        });
+        Object.defineProperty(this, 'hashmap', {
+            __proto__: null,
+            value: {},
+            writable: true,
+            enumerable: false,
+        });
+    }
+    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) {
+                // eslint-disable-next-line
+                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, // make it invisible
+        //     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);
+    }
+}
+export { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide, };

package/js/src/src/base/ws/Client.d.ts

@@ -0,0 +1,53 @@
+import { Future } from './Future.js';
+import { Dictionary, Str } from '../types.js';
+export default class Client {
+    connected: Promise<any>;
+    disconnected: ReturnType<typeof Future>;
+    futures: Dictionary<any>;
+    rejections: Dictionary<any>;
+    keepAlive: number;
+    connection: any;
+    connectionTimeout: any;
+    verbose: boolean;
+    connectionTimer: any;
+    lastPong: any;
+    maxPingPongMisses: any;
+    pingInterval: any;
+    connectionEstablished: any;
+    gunzip: any;
+    error: any;
+    inflate: any;
+    url: string;
+    isConnected: any;
+    onConnectedCallback: any;
+    onMessageCallback: any;
+    onErrorCallback: any;
+    onCloseCallback: any;
+    ping: any;
+    subscriptions: Dictionary<any>;
+    throttle: any;
+    decompressBinary: boolean;
+    constructor(url: string, onMessageCallback: Function | undefined, onErrorCallback: Function | undefined, onCloseCallback: Function | undefined, onConnectedCallback: Function | undefined, config?: {});
+    future(messageHash: string): any;
+    resolve(result: any, messageHash: Str): any;
+    reject(result: any, messageHash?: Str): any;
+    log(...args: any[]): void;
+    connect(backoffDelay?: number): void;
+    isOpen(): boolean;
+    reset(error: any): void;
+    onConnectionTimeout(): void;
+    setConnectionTimeout(): void;
+    clearConnectionTimeout(): void;
+    setPingInterval(): void;
+    clearPingInterval(): void;
+    onPingInterval(): void;
+    onOpen(): void;
+    onPing(): void;
+    onPong(): void;
+    onError(error: any): void;
+    onClose(event: any): void;
+    onUpgrade(message: any): void;
+    send(message: any): Promise<any>;
+    close(): void;
+    onMessage(messageEvent: any): void;
+}

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

@@ -0,0 +1,307 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+import { RequestTimeout, NetworkError, NotSupported, BaseError, ExchangeClosedByUser } from '../../base/errors.js';
+import { inflateSync, gunzipSync } from '../../static_dependencies/fflake/browser.js';
+import { Future } from './Future.js';
+import { isNode, isJsonEncodedObject, deepExtend, milliseconds, } from '../../base/functions.js';
+import { utf8 } from '../../static_dependencies/scure-base/index.js';
+export default class Client {
+    constructor(url, onMessageCallback, onErrorCallback, onCloseCallback, onConnectedCallback, config = {}) {
+        this.verbose = false;
+        this.decompressBinary = true;
+        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, deepExtend(defaults, config));
+        // connection-related Future
+        this.connected = Future();
+    }
+    future(messageHash) {
+        if (!(messageHash in this.futures)) {
+            this.futures[messageHash] = 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 !== undefined) && (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 NotSupported('connect() not implemented yet');
+    }
+    isOpen() {
+        throw new NotSupported('isOpen() not implemented yet');
+    }
+    reset(error) {
+        this.clearConnectionTimeout();
+        this.clearPingInterval();
+        this.reject(error);
+    }
+    onConnectionTimeout() {
+        if (!this.isOpen()) {
+            const error = new 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 = milliseconds();
+            this.lastPong = this.lastPong || now;
+            if ((this.lastPong + this.keepAlive * this.maxPingPongMisses) < now) {
+                this.onError(new RequestTimeout('Connection to ' + this.url + ' timed out due to a ping-pong keepalive missing on time'));
+            }
+            else {
+                let message;
+                if (this.ping) {
+                    message = this.ping(this);
+                }
+                if (message) {
+                    this.send(message).catch((error) => {
+                        this.onError(error);
+                    });
+                }
+                else if (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 = 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 = milliseconds();
+        if (this.verbose) {
+            this.log(new Date(), 'onPong');
+        }
+    }
+    onError(error) {
+        if (this.verbose) {
+            this.log(new Date(), 'onError', error.message);
+        }
+        if (!(error instanceof BaseError)) {
+            // in case of ErrorEvent from node_modules/ws/lib/event-target.js
+            error = new 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 NetworkError('connection closed by remote server, closing code ' + String(event.code)));
+        }
+        if (this.error instanceof 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();
+        if (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 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 = gunzipSync(arrayBuffer);
+                }
+                else if (this.inflate) {
+                    arrayBuffer = inflateSync(arrayBuffer);
+                }
+                message = utf8.encode(arrayBuffer);
+            }
+            else {
+                if (this.decompressBinary) {
+                    message = message.toString();
+                }
+            }
+        }
+        try {
+            if (isJsonEncodedObject(message)) {
+                message = message.toString();
+                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);
+        }
+    }
+}

package/js/src/src/base/ws/Future.d.ts

@@ -0,0 +1,8 @@
+export interface FutureInterface extends Promise<any> {
+    resolve(value: unknown): void;
+    reject(reason?: any): void;
+}
+export declare function Future(): FutureInterface;
+export declare namespace Future {
+    var race: (futures: any) => FutureInterface;
+}

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

@@ -0,0 +1,35 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+// @ts-nocheck
+import { Unpromise } from "../../static_dependencies/watchable/src/unpromise.js";
+export 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
+        queueMicrotask(() => {
+            resolve.apply(this, arguments);
+        });
+    };
+    p.reject = function _reject() {
+        // eslint-disable-next-line prefer-rest-params
+        queueMicrotask(() => {
+            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(Unpromise.race(futures));

package/js/src/src/base/ws/OrderBook.d.ts

@@ -0,0 +1,25 @@
+import { IOrderBookSide } from './OrderBookSide.js';
+import { Int, Str } from '../types.js';
+interface CustomOrderBookProp {
+    cache: any[];
+}
+declare class OrderBook implements CustomOrderBookProp {
+    cache: any[];
+    asks: IOrderBookSide<any>;
+    bids: IOrderBookSide<any>;
+    timestamp: Int;
+    datetime: Str;
+    nonce: Int;
+    symbol: Str;
+    constructor(snapshot?: {}, depth?: any);
+    limit(): this;
+    update(snapshot: any): this;
+    reset(snapshot?: {}): this;
+}
+declare class CountedOrderBook extends OrderBook {
+    constructor(snapshot?: {}, depth?: any);
+}
+declare class IndexedOrderBook extends OrderBook {
+    constructor(snapshot?: {}, depth?: any);
+}
+export { OrderBook, CountedOrderBook, IndexedOrderBook, };