ccxt 4.1.65 → 4.1.67

package/README.md

@@ -211,13 +211,13 @@ console.log(version, Object.keys(exchanges));
 
 All-in-one browser bundle (dependencies included), served from a CDN of your choice:
 
-* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.1.65/dist/ccxt.browser.js
-* unpkg: https://unpkg.com/ccxt@4.1.65/dist/ccxt.browser.js
+* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.1.67/dist/ccxt.browser.js
+* unpkg: https://unpkg.com/ccxt@4.1.67/dist/ccxt.browser.js
 
 CDNs are not updated in real-time and may have delays. Defaulting to the most recent version without specifying the version number is not recommended. Please, keep in mind that we are not responsible for the correct operation of those CDN servers.
 
 ```HTML
-<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.1.65/dist/ccxt.browser.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.1.67/dist/ccxt.browser.js"></script>
 ```
 
 Creates a global `ccxt` object:

package/dist/ccxt.browser.js

@@ -7032,6 +7032,9 @@ class Exchange {
         this.origin = '*'; // CORS origin
         //
         this.agent = undefined; // maintained for backwards compatibility
+        this.nodeHttpModuleLoaded = false;
+        this.httpAgent = undefined;
+        this.httpsAgent = undefined;
         this.minFundingAddressLength = 1; // used in checkAddress
         this.substituteCommonCurrencyCodes = true; // reserved
         this.quoteJsonNumbers = true; // treat numbers in json as quoted precise strings
@@ -7193,6 +7196,12 @@ class Exchange {
         this.ymd = ymd;
         this.base64ToString = base64ToString;
         this.crc32 = crc32;
+        this.httpProxyAgentModule = undefined;
+        this.httpsProxyAgentModule = undefined;
+        this.socksProxyAgentModule = undefined;
+        this.socksProxyAgentModuleChecked = false;
+        this.proxyDictionaries = {};
+        this.proxyModulesLoaded = false;
         Object.assign(this, _functions_js__WEBPACK_IMPORTED_MODULE_0__);
         //
         //     if (isNode) {
@@ -7631,39 +7640,89 @@ class Exchange {
     log(...args) {
         console.log(...args);
     }
+    async loadProxyModules() {
+        this.proxyModulesLoaded = true;
+        // todo: possible sync alternatives: https://stackoverflow.com/questions/51069002/convert-import-to-synchronous
+        this.httpProxyAgentModule = await import(/* webpackIgnore: true */ '../static_dependencies/proxies/http-proxy-agent/index.js');
+        this.httpsProxyAgentModule = await import(/* webpackIgnore: true */ '../static_dependencies/proxies/https-proxy-agent/index.js');
+        if (this.socksProxyAgentModuleChecked === false) {
+            this.socksProxyAgentModuleChecked = true;
+            try {
+                // @ts-ignore
+                this.socksProxyAgentModule = await import(/* webpackIgnore: true */ 'socks-proxy-agent');
+            }
+            catch (e) { }
+        }
+    }
+    setProxyAgents(httpProxy, httpsProxy, socksProxy) {
+        let chosenAgent = undefined;
+        if (httpProxy) {
+            if (this.httpProxyAgentModule === undefined) {
+                throw new _errors_js__WEBPACK_IMPORTED_MODULE_3__.NotSupported(this.id + ' you need to load JS proxy modules with `.loadProxyModules()` method at first to use proxies');
+            }
+            if (!(httpProxy in this.proxyDictionaries)) {
+                this.proxyDictionaries[httpProxy] = new this.httpProxyAgentModule.HttpProxyAgent(httpProxy);
+            }
+            chosenAgent = this.proxyDictionaries[httpProxy];
+        }
+        else if (httpsProxy) {
+            if (this.httpsProxyAgentModule === undefined) {
+                throw new _errors_js__WEBPACK_IMPORTED_MODULE_3__.NotSupported(this.id + ' you need to load JS proxy modules with `.loadProxyModules()` method at first to use proxies');
+            }
+            if (!(httpsProxy in this.proxyDictionaries)) {
+                this.proxyDictionaries[httpsProxy] = new this.httpsProxyAgentModule.HttpsProxyAgent(httpsProxy);
+            }
+            chosenAgent = this.proxyDictionaries[httpsProxy];
+            chosenAgent.keepAlive = true;
+        }
+        else if (socksProxy) {
+            if (this.socksProxyAgentModule === undefined) {
+                throw new _errors_js__WEBPACK_IMPORTED_MODULE_3__.NotSupported(this.id + ' - to use SOCKS proxy with ccxt, at first you need install module "npm i socks-proxy-agent" and then initialize proxies with `.loadProxyModules()` method');
+            }
+            if (!(socksProxy in this.proxyDictionaries)) {
+                this.proxyDictionaries[socksProxy] = new this.socksProxyAgentModule.SocksProxyAgent(socksProxy);
+            }
+            chosenAgent = this.proxyDictionaries[socksProxy];
+        }
+        return chosenAgent;
+    }
     async fetch(url, method = 'GET', headers = undefined, body = undefined) {
+        // load node-http(s) modules only on first call
+        if (isNode) {
+            if (!this.nodeHttpModuleLoaded) {
+                this.nodeHttpModuleLoaded = true;
+                const httpsModule = await import(/* webpackIgnore: true */ 'node:https');
+                this.httpsAgent = new httpsModule.Agent({ keepAlive: true });
+            }
+        }
         // ##### PROXY & HEADERS #####
         headers = this.extend(this.headers, headers);
-        const [proxyUrl, httpProxy, httpsProxy, socksProxy] = this.checkProxySettings(url, method, headers, body);
+        // proxy-url
+        const proxyUrl = this.checkProxyUrlSettings(url, method, headers, body);
+        let isHttpAgentNeeded = false;
         if (proxyUrl !== undefined) {
             // in node we need to set header to *
             if (isNode) {
                 headers = this.extend({ 'Origin': this.origin }, headers);
+                if (proxyUrl.substring(0, 5) !== 'https') {
+                    // for `http://` protocol proxy-urls, we need to load `http` module only on first call
+                    if (!this.httpAgent) {
+                        const httpModule = await import(/* webpackIgnore: true */ 'node:http');
+                        this.httpAgent = new httpModule.Agent();
+                    }
+                    isHttpAgentNeeded = true;
+                }
             }
             url = proxyUrl + url;
         }
-        else if (httpProxy !== undefined) {
-            const module = await import(/* webpackIgnore: true */ '../static_dependencies/proxies/http-proxy-agent/index.js');
-            const proxyAgent = new module.HttpProxyAgent(httpProxy);
-            this.agent = proxyAgent;
-        }
-        else if (httpsProxy !== undefined) {
-            const module = await import(/* webpackIgnore: true */ '../static_dependencies/proxies/https-proxy-agent/index.js');
-            const proxyAgent = new module.HttpsProxyAgent(httpsProxy);
-            proxyAgent.keepAlive = true;
-            this.agent = proxyAgent;
-        }
-        else if (socksProxy !== undefined) {
-            let module = undefined;
-            try {
-                // @ts-ignore
-                module = await import(/* webpackIgnore: true */ 'socks-proxy-agent');
-            }
-            catch (e) {
-                throw new _errors_js__WEBPACK_IMPORTED_MODULE_3__.NotSupported(this.id + ' - to use SOCKS proxy with ccxt, at first you need install module "npm i socks-proxy-agent" ');
-            }
-            this.agent = new module.SocksProxyAgent(socksProxy);
+        // proxy agents
+        const [httpProxy, httpsProxy, socksProxy] = this.checkProxySettings(url, method, headers, body);
+        this.checkConflictingProxies(httpProxy || httpsProxy || socksProxy, proxyUrl);
+        if (!this.proxyModulesLoaded) {
+            await this.loadProxyModules(); // this is needed in JS, independently whether proxy properties were set or not, we have to load them because of necessity in WS, which would happen beyond 'fetch' method (WS/etc)
         }
+        const chosenAgent = this.setProxyAgents(httpProxy, httpsProxy, socksProxy);
+        // user-agent
         const userAgent = (this.userAgent !== undefined) ? this.userAgent : this.user_agent;
         if (userAgent && isNode) {
             if (typeof userAgent === 'string') {
@@ -7673,17 +7732,18 @@ class Exchange {
                 headers = this.extend(userAgent, headers);
             }
         }
+        // set final headers
         headers = this.setHeaders(headers);
-        // ######## end of proxies ########
+        // log
         if (this.verbose) {
             this.log("fetch Request:\n", this.id, method, url, "\nRequestHeaders:\n", headers, "\nRequestBody:\n", body, "\n");
         }
+        // end of proxies & headers
         if (this.fetchImplementation === undefined) {
             if (isNode) {
                 const module = await import(/* webpackIgnore: true */ '../static_dependencies/node-fetch/index.js');
                 if (this.agent === undefined) {
-                    const { Agent } = await import(/* webpackIgnore: true */ 'node:https');
-                    this.agent = new Agent({ keepAlive: true });
+                    this.agent = this.httpsAgent;
                 }
                 this.AbortError = module.AbortError;
                 this.fetchImplementation = module.default;
@@ -7702,6 +7762,15 @@ class Exchange {
         if (this.agent) {
             params['agent'] = this.agent;
         }
+        // override agent, if needed
+        if (isHttpAgentNeeded) {
+            // if proxyUrl is being used, so we don't overwrite `this.agent` itself
+            params['agent'] = this.httpAgent;
+        }
+        else if (chosenAgent) {
+            // if http(s)Proxy is being used
+            params['agent'] = chosenAgent;
+        }
         const controller = new AbortController();
         params['signal'] = controller.signal;
         const timeout = setTimeout(() => {
@@ -7902,6 +7971,11 @@ class Exchange {
             const onConnected = this.onConnected.bind(this);
             // decide client type here: ws / signalr / socketio
             const wsOptions = this.safeValue(this.options, 'ws', {});
+            // proxy agents
+            const [httpProxy, httpsProxy, socksProxy] = this.checkWsProxySettings();
+            const chosenAgent = this.setProxyAgents(httpProxy, httpsProxy, socksProxy);
+            const finalAgent = chosenAgent ? chosenAgent : this.agent;
+            //
             const options = this.deepExtend(this.streaming, {
                 'log': this.log ? this.log.bind(this) : this.log,
                 'ping': this.ping ? this.ping.bind(this) : this.ping,
@@ -7909,7 +7983,7 @@ class Exchange {
                 'throttler': new Throttler(this.tokenBucket),
                 // add support for proxies
                 'options': {
-                    'agent': this.agent,
+                    'agent': finalAgent,
                 }
             }, wsOptions);
             this.clients[url] = new _ws_WsClient_js__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .Z(url, onMessage, onError, onClose, onConnected, options);
@@ -8075,6 +8149,9 @@ class Exchange {
     getProperty(obj, property, defaultValue = undefined) {
         return (property in obj ? obj[property] : defaultValue);
     }
+    setProperty(obj, property, defaultValue = undefined) {
+        obj[property] = defaultValue;
+    }
     axolotl(payload, hexKey, ed25519) {
         return (0,_functions_crypto_js__WEBPACK_IMPORTED_MODULE_7__/* .axolotl */ .gC)(payload, hexKey, ed25519);
     }
@@ -8143,14 +8220,28 @@ class Exchange {
         }
         return undefined;
     }
-    checkProxySettings(url, method, headers, body) {
-        let proxyUrl = (this.proxyUrl !== undefined) ? this.proxyUrl : this.proxy_url;
-        const proxyUrlCallback = (this.proxyUrlCallback !== undefined) ? this.proxyUrlCallback : this.proxy_url_callback;
-        if (proxyUrlCallback !== undefined) {
-            proxyUrl = proxyUrlCallback(url, method, headers, body);
+    checkProxyUrlSettings(url = undefined, method = undefined, headers = undefined, body = undefined) {
+        const usedProxies = [];
+        let proxyUrl = undefined;
+        if (this.proxyUrl !== undefined) {
+            usedProxies.push('proxyUrl');
+            proxyUrl = this.proxyUrl;
+        }
+        if (this.proxy_url !== undefined) {
+            usedProxies.push('proxy_url');
+            proxyUrl = this.proxy_url;
+        }
+        if (this.proxyUrlCallback !== undefined) {
+            usedProxies.push('proxyUrlCallback');
+            proxyUrl = this.proxyUrlCallback(url, method, headers, body);
+        }
+        if (this.proxy_url_callback !== undefined) {
+            usedProxies.push('proxy_url_callback');
+            proxyUrl = this.proxy_url_callback(url, method, headers, body);
         }
         // backwards-compatibility
         if (this.proxy !== undefined) {
+            usedProxies.push('proxy');
             if (typeof this.proxy === 'function') {
                 proxyUrl = this.proxy(url, method, headers, body);
             }
@@ -8158,50 +8249,111 @@ class Exchange {
                 proxyUrl = this.proxy;
             }
         }
-        let httpProxy = (this.httpProxy !== undefined) ? this.httpProxy : this.http_proxy;
-        const httpProxyCallback = (this.httpProxyCallback !== undefined) ? this.httpProxyCallback : this.http_proxy_callback;
-        if (httpProxyCallback !== undefined) {
-            httpProxy = httpProxyCallback(url, method, headers, body);
-        }
-        let httpsProxy = (this.httpsProxy !== undefined) ? this.httpsProxy : this.https_proxy;
-        const httpsProxyCallback = (this.httpsProxyCallback !== undefined) ? this.httpsProxyCallback : this.https_proxy_callback;
-        if (httpsProxyCallback !== undefined) {
-            httpsProxy = httpsProxyCallback(url, method, headers, body);
-        }
-        let socksProxy = (this.socksProxy !== undefined) ? this.socksProxy : this.socks_proxy;
-        const socksProxyCallback = (this.socksProxyCallback !== undefined) ? this.socksProxyCallback : this.socks_proxy_callback;
-        if (socksProxyCallback !== undefined) {
-            socksProxy = socksProxyCallback(url, method, headers, body);
-        }
-        let val = 0;
-        if (proxyUrl !== undefined) {
-            val = val + 1;
-        }
-        if (proxyUrlCallback !== undefined) {
-            val = val + 1;
-        }
-        if (httpProxy !== undefined) {
-            val = val + 1;
-        }
-        if (httpProxyCallback !== undefined) {
-            val = val + 1;
-        }
-        if (httpsProxy !== undefined) {
-            val = val + 1;
-        }
-        if (httpsProxyCallback !== undefined) {
-            val = val + 1;
-        }
-        if (socksProxy !== undefined) {
-            val = val + 1;
-        }
-        if (socksProxyCallback !== undefined) {
-            val = val + 1;
+        const length = usedProxies.length;
+        if (length > 1) {
+            const joinedProxyNames = usedProxies.join(',');
+            throw new _errors_js__WEBPACK_IMPORTED_MODULE_3__.ExchangeError(this.id + ' you have multiple conflicting proxy_url settings (' + joinedProxyNames + '), please use only one from : proxyUrl, proxy_url, proxyUrlCallback, proxy_url_callback');
+        }
+        return proxyUrl;
+    }
+    checkProxySettings(url = undefined, method = undefined, headers = undefined, body = undefined) {
+        const usedProxies = [];
+        let httpProxy = undefined;
+        let httpsProxy = undefined;
+        let socksProxy = undefined;
+        // httpProxy
+        if (this.httpProxy !== undefined) {
+            usedProxies.push('httpProxy');
+            httpProxy = this.httpProxy;
+        }
+        if (this.http_proxy !== undefined) {
+            usedProxies.push('http_proxy');
+            httpProxy = this.http_proxy;
+        }
+        if (this.httpProxyCallback !== undefined) {
+            usedProxies.push('httpProxyCallback');
+            httpProxy = this.httpProxyCallback(url, method, headers, body);
+        }
+        if (this.http_proxy_callback !== undefined) {
+            usedProxies.push('http_proxy_callback');
+            httpProxy = this.http_proxy_callback(url, method, headers, body);
+        }
+        // httpsProxy
+        if (this.httpsProxy !== undefined) {
+            usedProxies.push('httpsProxy');
+            httpsProxy = this.httpsProxy;
+        }
+        if (this.https_proxy !== undefined) {
+            usedProxies.push('https_proxy');
+            httpsProxy = this.https_proxy;
+        }
+        if (this.httpsProxyCallback !== undefined) {
+            usedProxies.push('httpsProxyCallback');
+            httpsProxy = this.httpsProxyCallback(url, method, headers, body);
+        }
+        if (this.https_proxy_callback !== undefined) {
+            usedProxies.push('https_proxy_callback');
+            httpsProxy = this.https_proxy_callback(url, method, headers, body);
+        }
+        // socksProxy
+        if (this.socksProxy !== undefined) {
+            usedProxies.push('socksProxy');
+            socksProxy = this.socksProxy;
+        }
+        if (this.socks_proxy !== undefined) {
+            usedProxies.push('socks_proxy');
+            socksProxy = this.socks_proxy;
+        }
+        if (this.socksProxyCallback !== undefined) {
+            usedProxies.push('socksProxyCallback');
+            socksProxy = this.socksProxyCallback(url, method, headers, body);
+        }
+        if (this.socks_proxy_callback !== undefined) {
+            usedProxies.push('socks_proxy_callback');
+            socksProxy = this.socks_proxy_callback(url, method, headers, body);
+        }
+        // check
+        const length = usedProxies.length;
+        if (length > 1) {
+            const joinedProxyNames = usedProxies.join(',');
+            throw new _errors_js__WEBPACK_IMPORTED_MODULE_3__.ExchangeError(this.id + ' you have multiple conflicting settings (' + joinedProxyNames + '), please use only one from: httpProxy, httpsProxy, httpProxyCallback, httpsProxyCallback, socksProxy, socksProxyCallback');
+        }
+        return [httpProxy, httpsProxy, socksProxy];
+    }
+    checkWsProxySettings() {
+        const usedProxies = [];
+        let wsProxy = undefined;
+        let wssProxy = undefined;
+        // wsProxy
+        if (this.wsProxy !== undefined) {
+            usedProxies.push('wsProxy');
+            wsProxy = this.wsProxy;
+        }
+        if (this.ws_proxy !== undefined) {
+            usedProxies.push('ws_proxy');
+            wsProxy = this.ws_proxy;
+        }
+        // wsProxy
+        if (this.wssProxy !== undefined) {
+            usedProxies.push('wssProxy');
+            wssProxy = this.wssProxy;
+        }
+        if (this.wss_proxy !== undefined) {
+            usedProxies.push('wss_proxy');
+            wssProxy = this.wss_proxy;
+        }
+        // check
+        const length = usedProxies.length;
+        if (length > 1) {
+            const joinedProxyNames = usedProxies.join(',');
+            throw new _errors_js__WEBPACK_IMPORTED_MODULE_3__.ExchangeError(this.id + ' you have multiple conflicting settings (' + joinedProxyNames + '), please use only one from: wsProxy, wssProxy');
         }
-        if (val > 1) {
-            throw new _errors_js__WEBPACK_IMPORTED_MODULE_3__.ExchangeError(this.id + ' you have multiple conflicting proxy settings, please use only one from : proxyUrl, httpProxy, httpsProxy, socksProxy, userAgent');
+        return [wsProxy, wssProxy];
+    }
+    checkConflictingProxies(proxyAgentSet, proxyUrlSet) {
+        if (proxyAgentSet && proxyUrlSet) {
+            throw new _errors_js__WEBPACK_IMPORTED_MODULE_3__.ExchangeError(this.id + ' you have multiple conflicting proxy settings, please use only one from : proxyUrl, httpProxy, httpsProxy, socksProxy');
         }
-        return [proxyUrl, httpProxy, httpsProxy, socksProxy];
     }
     findMessageHashes(client, element) {
         const result = [];
@@ -8584,6 +8736,7 @@ class Exchange {
             'contract': undefined,
             'linear': undefined,
             'inverse': undefined,
+            'subType': undefined,
             'taker': undefined,
             'maker': undefined,
             'contractSize': undefined,
@@ -8661,6 +8814,15 @@ class Exchange {
                 'precision': this.precision,
                 'limits': this.limits,
             }, this.fees['trading'], value);
+            if (market['linear']) {
+                market['subType'] = 'linear';
+            }
+            else if (market['inverse']) {
+                market['subType'] = 'inverse';
+            }
+            else {
+                market['subType'] = undefined;
+            }
             values.push(market);
         }
         this.markets = this.indexBy(values, 'symbol');
@@ -26729,6 +26891,7 @@ class bingx extends _abstract_bingx_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"
                     'user': 'https://open-api.{hostname}/openApi',
                     'subAccount': 'https://open-api.{hostname}/openApi',
                     'account': 'https://open-api.{hostname}/openApi',
+                    'copyTrading': 'https://open-api.{hostname}/openApi',
                 },
                 'www': 'https://bingx.com/',
                 'doc': 'https://bingx-api.github.io/docs/',
@@ -86516,7 +86679,7 @@ class coinbase extends _abstract_coinbase_js__WEBPACK_IMPORTED_MODULE_0__/* ["de
          */
         await this.loadMarkets();
         const request = {
-            'limit': 100,
+            'limit': 250,
         };
         let response = undefined;
         const isV3 = this.safeValue(params, 'v3', false);
@@ -122181,6 +122344,13 @@ class gate extends _abstract_gate_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"]
             }
             else if (symbol in this.markets_by_id) {
                 const markets = this.markets_by_id[symbol];
+                const defaultType = this.safeString2(this.options, 'defaultType', 'defaultSubType', 'spot');
+                for (let i = 0; i < markets.length; i++) {
+                    const market = markets[i];
+                    if (market[defaultType]) {
+                        return market;
+                    }
+                }
                 return markets[0];
             }
             else if ((symbol.indexOf('-C') > -1) || (symbol.indexOf('-P') > -1)) {
@@ -287583,7 +287753,7 @@ SOFTWARE.
 
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.1.65';
+const version = '4.1.67';
 _src_base_Exchange_js__WEBPACK_IMPORTED_MODULE_0__/* .Exchange */ .e.ccxtVersion = version;
 //-----------------------------------------------------------------------------