ccxt 4.5.39 → 4.5.41

package/dist/cjs/src/base/functions/io.js

@@ -0,0 +1,160 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var platform = require('./platform.js');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+/*  ------------------------------------------------------------------------ */
+/*  ------------------------------------------------------------------------ */
+let fsSyncModule = null;
+let osSyncModule = null;
+let pathSyncModule = null;
+/*  ------------------------------------------------------------------------ */
+/**
+ * Initialize synchronous file system module (Node.js only)
+ * Uses dynamic import to prevent bundling in browser builds
+ */
+async function initFileSystem() {
+    if (platform.isNode) {
+        if (fsSyncModule === null) {
+            try {
+                // Dynamic import with webpackIgnore to prevent bundling
+                fsSyncModule = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(/* webpackIgnore: true */ 'node:fs')); });
+            }
+            catch (e) { } // Silent fail in browser or if fs is unavailable
+        }
+        if (osSyncModule === null) {
+            try {
+                osSyncModule = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(/* webpackIgnore: true */ 'node:os')); });
+            }
+            catch (e) { } // Silent fail in browser or if os is unavailable
+        }
+        if (pathSyncModule === null) {
+            try {
+                pathSyncModule = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(/* webpackIgnore: true */ 'node:path')); });
+            }
+            catch (e) { } // Silent fail in browser or if path is unavailable
+        }
+    }
+}
+if (platform.isNode) {
+    // Pre-initialize synchronous fs module for sync methods
+    initFileSystem();
+}
+/*  ------------------------------------------------------------------------ */
+/**
+ * Get system temporary directory (Node.js only)
+ * @returns Temporary directory path with trailing slash, or undefined
+ */
+function getTempDir() {
+    if (!platform.isNode || osSyncModule === null) {
+        return undefined;
+    }
+    try {
+        const tmpDir = pathSyncModule.resolve(osSyncModule.tmpdir());
+        const sep = pathSyncModule ? pathSyncModule.sep : '/';
+        return tmpDir.endsWith(sep) ? tmpDir : tmpDir + sep;
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+/**
+ * Check if file path is ccxt-cache file, so users are ensured there is no access possible to other files
+ * @param path File path to check
+ */
+function ensureWhitelistedFile(filePath) {
+    if (pathSyncModule === null) {
+        throw new Error('path module is not available');
+    }
+    const sanitizedFilePath = pathSyncModule.resolve(filePath);
+    if ((sanitizedFilePath.startsWith(filePath) && sanitizedFilePath.endsWith('.ccxtfile')) || sanitizedFilePath.endsWith('.wasm')) {
+        return;
+    }
+    throw new Error('invalid file path: ' + filePath);
+}
+/*  ------------------------------------------------------------------------ */
+/**
+ * Read file contents synchronously (Node.js only)
+ * @param path File path to read
+ * @param encoding File encoding (default: 'utf8')
+ * @returns File contents as string, or undefined in browser
+ */
+function readFile(path, encoding = 'utf8') {
+    if (!platform.isNode || fsSyncModule === null) {
+        // Sync module not initialized yet
+        return undefined;
+    }
+    ensureWhitelistedFile(path);
+    try {
+        return fsSyncModule.readFileSync(path, encoding);
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+/*  ------------------------------------------------------------------------ */
+/**
+ * Write file contents synchronously (Node.js only)
+ * @param path File path to write
+ * @param data Data to write
+ * @param encoding File encoding (default: 'utf8')
+ */
+function writeFile(path, data, encoding = 'utf8') {
+    if (!platform.isNode || fsSyncModule === null) {
+        return false;
+    }
+    ensureWhitelistedFile(path);
+    try {
+        fsSyncModule.writeFileSync(path, data, encoding);
+        return true;
+    }
+    catch (e) {
+        // Silent fail
+        return false;
+    }
+}
+/*  ------------------------------------------------------------------------ */
+/**
+ * Check if file exists synchronously (Node.js only)
+ * @param path File path to check
+ * @returns true if file exists, false otherwise
+ */
+function existsFile(path) {
+    if (!platform.isNode || fsSyncModule === null) {
+        // Sync module not initialized yet
+        return false;
+    }
+    ensureWhitelistedFile(path);
+    try {
+        fsSyncModule.accessSync(path);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+
+exports.existsFile = existsFile;
+exports.getTempDir = getTempDir;
+exports.initFileSystem = initFileSystem;
+exports.readFile = readFile;
+exports.writeFile = writeFile;

package/dist/cjs/src/base/functions.js

@@ -12,6 +12,7 @@ var crypto = require('./functions/crypto.js');
 var time = require('./functions/time.js');
 var throttle = require('./functions/throttle.js');
 var misc = require('./functions/misc.js');
+var io = require('./functions/io.js');
 
 /*  ------------------------------------------------------------------------ */
 /*  ------------------------------------------------------------------------ */
@@ -159,3 +160,8 @@ exports.parseTimeframe = misc.parseTimeframe;
 exports.roundTimeframe = misc.roundTimeframe;
 exports.selfIsDefined = misc.selfIsDefined;
 exports.vwap = misc.vwap;
+exports.existsFile = io.existsFile;
+exports.getTempDir = io.getTempDir;
+exports.initFileSystem = io.initFileSystem;
+exports.readFile = io.readFile;
+exports.writeFile = io.writeFile;

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

@@ -10,6 +10,7 @@ var generic = require('../functions/generic.js');
 var encode = require('../functions/encode.js');
 require('../functions/crypto.js');
 var time = require('../functions/time.js');
+require('../functions/io.js');
 var index = require('../../static_dependencies/scure-base/index.js');
 
 class Client {

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

@@ -9,6 +9,7 @@ require('../functions/encode.js');
 require('../functions/crypto.js');
 var time = require('../functions/time.js');
 var misc = require('../functions/misc.js');
+require('../functions/io.js');
 var Future = require('./Future.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

package/dist/cjs/src/binance.js

@@ -66,6 +66,7 @@ class binance extends binance$1["default"] {
                 'editOrder': true,
                 'editOrders': true,
                 'fetchAccounts': undefined,
+                'fetchADLRank': true,
                 'fetchAllGreeks': true,
                 'fetchBalance': true,
                 'fetchBidsAsks': true,
@@ -135,9 +136,11 @@ class binance extends binance$1["default"] {
                 'fetchOrders': true,
                 'fetchOrderTrades': true,
                 'fetchPosition': true,
+                'fetchPositionADLRank': true,
                 'fetchPositionHistory': false,
                 'fetchPositionMode': true,
                 'fetchPositions': true,
+                'fetchPositionsADLRank': true,
                 'fetchPositionsHistory': false,
                 'fetchPositionsRisk': true,
                 'fetchPremiumIndexOHLCV': true,
@@ -6413,6 +6416,7 @@ class binance extends binance$1["default"] {
      * @param {string} [params.stopLossOrTakeProfit] 'stopLoss' or 'takeProfit', required for spot trailing orders
      * @param {string} [params.positionSide] *swap and portfolio margin only* "BOTH" for one-way mode, "LONG" for buy side of hedged mode, "SHORT" for sell side of hedged mode
      * @param {bool} [params.hedged] *swap and portfolio margin only* true for hedged mode, false for one way mode, default is false
+     * @param {string} [params.clientOrderId] the clientOrderId of the order
      * @returns {object} an [order structure]{@link https://docs.ccxt.com/?id=order-structure}
      */
     async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
@@ -14625,6 +14629,145 @@ class binance extends binance$1["default"] {
             'longShortRatio': this.safeNumber(info, 'longShortRatio'),
         };
     }
+    /**
+     * @method
+     * @name binance#fetchADLRank
+     * @description fetches the auto deleveraging rank and risk percentage for a symbol
+     * @see https://developers.binance.com/docs/derivatives/usds-margined-futures/market-data/rest-api/ADL-Risk
+     * @param {string} symbol unified symbol of the market to fetch the auto deleveraging rank for
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {object} an [auto de leverage structure]{@link https://docs.ccxt.com/?id=auto-de-leverage-structure}
+     */
+    async fetchADLRank(symbol, params = {}) {
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'symbol': market['id'],
+        };
+        let subType = undefined;
+        [subType, params] = this.handleSubTypeAndParams('fetchADLRank', market, params);
+        let response = undefined;
+        if (subType === 'linear') {
+            response = await this.fapiPublicGetSymbolAdlRisk(this.extend(request, params));
+            //
+            //     {
+            //         "symbol": "BTCUSDT",
+            //         "adlRisk": "LOW",
+            //         "updateTime": 1766827800453
+            //     }
+            //
+        }
+        else {
+            throw new errors.BadRequest(this.id + ' fetchADLRank() supports linear subTypes only');
+        }
+        return this.parseADLRank(response, market);
+    }
+    /**
+     * @method
+     * @name binance#fetchPositionsADLRank
+     * @description fetches the auto deleveraging rank and risk percentage for a list of symbols that have open positions
+     * @see https://developers.binance.com/docs/derivatives/usds-margined-futures/trade/rest-api/Position-ADL-Quantile-Estimation
+     * @see https://developers.binance.com/docs/derivatives/coin-margined-futures/trade/rest-api/Position-ADL-Quantile-Estimation
+     * @see https://developers.binance.com/docs/derivatives/portfolio-margin/trade/UM-Position-ADL-Quantile-Estimation
+     * @see https://developers.binance.com/docs/derivatives/portfolio-margin/trade/CM-Position-ADL-Quantile-Estimation
+     * @param {string[]} [symbols] list of unified market symbols
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {boolean} [params.portfolioMargin] set to true for the portfolio margin account
+     * @returns {object[]} an array of [auto de leverage structure]{@link https://docs.ccxt.com/?id=auto-de-leverage-structure}
+     */
+    async fetchPositionsADLRank(symbols = undefined, params = {}) {
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, true, true, true);
+        const market = this.getMarketFromSymbols(symbols);
+        let subType = undefined;
+        [subType, params] = this.handleSubTypeAndParams('fetchPositionsADLRank', market, params);
+        let isPortfolioMargin = undefined;
+        [isPortfolioMargin, params] = this.handleOptionAndParams2(params, 'fetchPositionsADLRank', 'papi', 'portfolioMargin', false);
+        let response = undefined;
+        if (subType === 'linear') {
+            if (isPortfolioMargin) {
+                response = await this.papiGetUmAdlQuantile(params);
+            }
+            else {
+                response = await this.fapiPrivateGetAdlQuantile(params);
+            }
+        }
+        else if (subType === 'inverse') {
+            if (isPortfolioMargin) {
+                response = await this.papiGetCmAdlQuantile(params);
+            }
+            else {
+                response = await this.dapiPrivateGetAdlQuantile(params);
+            }
+        }
+        else {
+            throw new errors.BadRequest(this.id + ' fetchPositionsADLRank() supports linear and inverse subTypes only');
+        }
+        //
+        //     [
+        //         {
+        //             "symbol": "BTCUSDT",
+        //             "adlQuantile": {
+        //                 "LONG": 0,
+        //                 "SHORT": 0,
+        //                 "BOTH": 1
+        //             }
+        //         }
+        //     ]
+        //
+        return this.parseADLRanks(response, symbols);
+    }
+    parseADLRank(info, market = undefined) {
+        //
+        // fetchADLRank
+        //
+        //     {
+        //         "symbol": "BTCUSDT",
+        //         "adlRisk": "LOW",
+        //         "updateTime": 1766827800453
+        //     }
+        //
+        // fetchPositionADLRank
+        //
+        //     {
+        //         "symbol": "BTCUSDT",
+        //         "adlQuantile": {
+        //             "LONG": 0,
+        //             "SHORT": 0,
+        //             "BOTH": 1
+        //         }
+        //     }
+        //
+        const adlQuantile = this.safeDict(info, 'adlQuantile', {});
+        const longNum = this.safeNumber(adlQuantile, 'LONG');
+        const shortNum = this.safeNumber(adlQuantile, 'SHORT');
+        const both = this.safeNumber(adlQuantile, 'BOTH');
+        let rank = undefined;
+        if (both !== undefined) {
+            rank = both;
+        }
+        else {
+            if (longNum !== undefined && shortNum !== undefined) {
+                if (longNum > shortNum) {
+                    rank = longNum;
+                }
+                else {
+                    rank = shortNum;
+                }
+            }
+        }
+        const marketId = this.safeString(info, 'symbol');
+        const timestamp = this.safeInteger2(info, 'timestamp', 'updateTime');
+        return {
+            'info': info,
+            'symbol': this.safeSymbol(marketId, market, undefined, 'contract'),
+            'rank': rank,
+            'rating': this.safeStringLower(info, 'adlRisk'),
+            'percentage': undefined,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+        };
+    }
 }
 
 exports["default"] = binance;