ccxt 4.2.59 → 4.2.61

package/js/src/kraken.js

@@ -24,7 +24,10 @@ export default class kraken extends Exchange {
             'name': 'Kraken',
             'countries': ['US'],
             'version': '0',
-            'rateLimit': 3000,
+            // rate-limits: https://support.kraken.com/hc/en-us/articles/206548367-What-are-the-API-rate-limits-#1
+            // for public: 1 req/s
+            // for private: every second 0.33 weight added to your allowed capacity (some private endpoints need 1 weight, some need 2)
+            'rateLimit': 1000,
             'certified': false,
             'pro': true,
             'has': {
@@ -154,7 +157,7 @@ export default class kraken extends Exchange {
                 },
                 'public': {
                     'get': {
-                        // public endpoint rate-limits are described in article: https://support.kraken.com/hc/en-us/articles/206548367-What-are-the-API-rate-limits-#1
+                        // rate-limits explained in comment in the top of this file
                         'Assets': 1,
                         'AssetPairs': 1,
                         'Depth': 1,
@@ -170,48 +173,48 @@ export default class kraken extends Exchange {
                     'post': {
                         'AddOrder': 0,
                         'AddOrderBatch': 0,
-                        'AddExport': 1,
-                        'Balance': 1,
-                        'CancelAll': 1,
-                        'CancelAllOrdersAfter': 1,
+                        'AddExport': 3,
+                        'Balance': 3,
+                        'CancelAll': 3,
+                        'CancelAllOrdersAfter': 3,
                         'CancelOrder': 0,
                         'CancelOrderBatch': 0,
-                        'ClosedOrders': 1,
-                        'DepositAddresses': 1,
-                        'DepositMethods': 1,
-                        'DepositStatus': 1,
+                        'ClosedOrders': 3,
+                        'DepositAddresses': 3,
+                        'DepositMethods': 3,
+                        'DepositStatus': 3,
                         'EditOrder': 0,
-                        'ExportStatus': 1,
-                        'GetWebSocketsToken': 1,
-                        'Ledgers': 2,
-                        'OpenOrders': 1,
-                        'OpenPositions': 1,
-                        'QueryLedgers': 1,
-                        'QueryOrders': 1,
-                        'QueryTrades': 1,
-                        'RetrieveExport': 1,
-                        'RemoveExport': 1,
-                        'BalanceEx': 1,
-                        'TradeBalance': 1,
-                        'TradesHistory': 2,
-                        'TradeVolume': 1,
-                        'Withdraw': 1,
-                        'WithdrawCancel': 1,
-                        'WithdrawInfo': 1,
-                        'WithdrawMethods': 1,
-                        'WithdrawAddresses': 1,
-                        'WithdrawStatus': 1,
-                        'WalletTransfer': 1,
+                        'ExportStatus': 3,
+                        'GetWebSocketsToken': 3,
+                        'Ledgers': 6,
+                        'OpenOrders': 3,
+                        'OpenPositions': 3,
+                        'QueryLedgers': 3,
+                        'QueryOrders': 3,
+                        'QueryTrades': 3,
+                        'RetrieveExport': 3,
+                        'RemoveExport': 3,
+                        'BalanceEx': 3,
+                        'TradeBalance': 3,
+                        'TradesHistory': 6,
+                        'TradeVolume': 3,
+                        'Withdraw': 3,
+                        'WithdrawCancel': 3,
+                        'WithdrawInfo': 3,
+                        'WithdrawMethods': 3,
+                        'WithdrawAddresses': 3,
+                        'WithdrawStatus': 3,
+                        'WalletTransfer': 3,
                         // sub accounts
-                        'CreateSubaccount': 1,
-                        'AccountTransfer': 1,
+                        'CreateSubaccount': 3,
+                        'AccountTransfer': 3,
                         // earn
-                        'Earn/Allocate': 1,
-                        'Earn/Deallocate': 1,
-                        'Earn/AllocateStatus': 1,
-                        'Earn/DeallocateStatus': 1,
-                        'Earn/Strategies': 1,
-                        'Earn/Allocations': 1,
+                        'Earn/Allocate': 3,
+                        'Earn/Deallocate': 3,
+                        'Earn/AllocateStatus': 3,
+                        'Earn/DeallocateStatus': 3,
+                        'Earn/Strategies': 3,
+                        'Earn/Allocations': 3,
                     },
                 },
             },
@@ -1547,8 +1550,14 @@ export default class kraken extends Exchange {
         //      }
         //  }
         //
-        const description = this.safeValue(order, 'descr', {});
-        const orderDescription = this.safeString(description, 'order', description);
+        const description = this.safeDict(order, 'descr', {});
+        let orderDescription = undefined;
+        if (description !== undefined) {
+            orderDescription = this.safeString(description, 'order');
+        }
+        else {
+            orderDescription = this.safeString(order, 'descr');
+        }
         let side = undefined;
         let type = undefined;
         let marketId = undefined;

package/js/src/krakenfutures.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/krakenfutures.js';
-import type { TransferEntry, Int, OrderSide, OrderType, OHLCV, Trade, FundingRateHistory, OrderRequest, Order, Balances, Str, Ticker, OrderBook, Tickers, Strings, Market, Currency, Leverage } from './base/types.js';
+import type { TransferEntry, Int, OrderSide, OrderType, OHLCV, Trade, FundingRateHistory, OrderRequest, Order, Balances, Str, Ticker, OrderBook, Tickers, Strings, Market, Currency, Leverage, Leverages } from './base/types.js';
 /**
  * @class krakenfutures
  * @augments Exchange
@@ -94,6 +94,7 @@ export default class krakenfutures extends Exchange {
     transferOut(code: string, amount: any, params?: {}): Promise<TransferEntry>;
     transfer(code: string, amount: number, fromAccount: string, toAccount: string, params?: {}): Promise<TransferEntry>;
     setLeverage(leverage: Int, symbol?: Str, params?: {}): Promise<any>;
+    fetchLeverages(symbols?: string[], params?: {}): Promise<Leverages>;
     fetchLeverage(symbol: string, params?: {}): Promise<Leverage>;
     parseLeverage(leverage: any, market?: any): Leverage;
     handleErrors(code: any, reason: any, url: any, method: any, headers: any, body: any, response: any, requestHeaders: any, requestBody: any): any;

package/js/src/krakenfutures.js

@@ -58,6 +58,7 @@ export default class krakenfutures extends Exchange {
                 'fetchIsolatedBorrowRates': false,
                 'fetchIsolatedPositions': false,
                 'fetchLeverage': true,
+                'fetchLeverages': true,
                 'fetchLeverageTiers': true,
                 'fetchMarketLeverageTiers': 'emulated',
                 'fetchMarkets': true,
@@ -2459,6 +2460,33 @@ export default class krakenfutures extends Exchange {
         //
         return await this.privatePutLeveragepreferences(this.extend(request, params));
     }
+    async fetchLeverages(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name krakenfutures#fetchLeverages
+         * @description fetch the set leverage for all contract and margin markets
+         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-multi-collateral-get-the-leverage-setting-for-a-market
+         * @param {string[]} [symbols] a list of unified market symbols
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a list of [leverage structures]{@link https://docs.ccxt.com/#/?id=leverage-structure}
+         */
+        await this.loadMarkets();
+        const response = await this.privateGetLeveragepreferences(params);
+        //
+        //     {
+        //         "result": "success",
+        //         "serverTime": "2024-03-06T02:35:46.336Z",
+        //         "leveragePreferences": [
+        //             {
+        //                 "symbol": "PF_ETHUSD",
+        //                 "maxLeverage": 30.00
+        //             },
+        //         ]
+        //     }
+        //
+        const leveragePreferences = this.safeList(response, 'leveragePreferences', []);
+        return this.parseLeverages(leveragePreferences, symbols, 'symbol');
+    }
     async fetchLeverage(symbol, params = {}) {
         /**
          * @method

package/js/src/kucoinfutures.js

@@ -36,6 +36,7 @@ export default class kucoinfutures extends kucoin {
                 'addMargin': true,
                 'cancelAllOrders': true,
                 'cancelOrder': true,
+                'closeAllPositions': false,
                 'closePosition': true,
                 'closePositions': false,
                 'createDepositAddress': true,
@@ -2073,8 +2074,8 @@ export default class kucoinfutures extends kucoin {
         //        }
         //    }
         //
-        const data = this.safeValue(response, 'data', {});
-        const trades = this.safeValue(data, 'items', {});
+        const data = this.safeDict(response, 'data', {});
+        const trades = this.safeList(data, 'items', []);
         return this.parseTrades(trades, market, since, limit);
     }
     async fetchTrades(symbol, since = undefined, limit = undefined, params = {}) {

package/js/src/okx.js

@@ -5671,7 +5671,7 @@ export default class okx extends Exchange {
         const fromAccountId = this.safeString(transfer, 'from');
         const toAccountId = this.safeString(transfer, 'to');
         const accountsById = this.safeValue(this.options, 'accountsById', {});
-        const timestamp = this.safeInteger(transfer, 'ts', this.milliseconds());
+        const timestamp = this.safeInteger(transfer, 'ts');
         const balanceChange = this.safeString(transfer, 'sz');
         if (balanceChange !== undefined) {
             amount = this.parseNumber(Precise.stringAbs(balanceChange));

package/js/src/phemex.js

@@ -3361,7 +3361,7 @@ export default class phemex extends Exchange {
         //         ]
         //     }
         //
-        const data = this.safeValue(response, 'data', {});
+        const data = this.safeList(response, 'data', []);
         return this.parseTransactions(data, currency, since, limit);
     }
     async fetchWithdrawals(code = undefined, since = undefined, limit = undefined, params = {}) {
@@ -3401,7 +3401,7 @@ export default class phemex extends Exchange {
         //         ]
         //     }
         //
-        const data = this.safeValue(response, 'data', {});
+        const data = this.safeList(response, 'data', []);
         return this.parseTransactions(data, currency, since, limit);
     }
     parseTransactionStatus(status) {

package/js/src/pro/binance.js

@@ -2602,8 +2602,21 @@ export default class binance extends binanceRest {
         //     }
         //
         const marketId = this.safeString(position, 's');
-        const positionSide = this.safeStringLower(position, 'ps');
-        const hedged = positionSide !== 'both';
+        const contracts = this.safeString(position, 'pa');
+        const contractsAbs = Precise.stringAbs(this.safeString(position, 'pa'));
+        let positionSide = this.safeStringLower(position, 'ps');
+        let hedged = true;
+        if (positionSide === 'both') {
+            hedged = false;
+            if (!Precise.stringEq(contracts, '0')) {
+                if (Precise.stringLt(contracts, '0')) {
+                    positionSide = 'short';
+                }
+                else {
+                    positionSide = 'long';
+                }
+            }
+        }
         return this.safePosition({
             'info': position,
             'id': undefined,
@@ -2614,7 +2627,7 @@ export default class binance extends binanceRest {
             'entryPrice': this.safeNumber(position, 'ep'),
             'unrealizedPnl': this.safeNumber(position, 'up'),
             'percentage': undefined,
-            'contracts': this.safeNumber(position, 'pa'),
+            'contracts': this.parseNumber(contractsAbs),
             'contractSize': undefined,
             'markPrice': undefined,
             'side': positionSide,

package/js/src/pro/bingx.js

@@ -559,6 +559,7 @@ export default class bingx extends bingxRest {
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
          */
+        await this.loadMarkets();
         const market = this.market(symbol);
         const [marketType, query] = this.handleMarketTypeAndParams('watchOHLCV', market, params);
         const url = this.safeValue(this.urls['api']['ws'], marketType);

package/js/src/pro/deribit.d.ts

@@ -25,7 +25,7 @@ export default class deribit extends deribitRest {
     watchOHLCVForSymbols(symbolsAndTimeframes: string[][], since?: Int, limit?: Int, params?: {}): Promise<import("../base/types.js").Dictionary<import("../base/types.js").Dictionary<OHLCV[]>>>;
     handleOHLCV(client: Client, message: any): void;
     parseWsOHLCV(ohlcv: any, market?: any): OHLCV;
-    watchMultipleWrapper(channelName: string, channelDescriptor: string, symbolsArray?: any, params?: {}): Promise<any>;
+    watchMultipleWrapper(channelName: string, channelDescriptor: Str, symbolsArray?: any, params?: {}): Promise<any>;
     handleMessage(client: Client, message: any): void;
     handleAuthenticationMessage(client: Client, message: any): any;
     authenticate(params?: {}): Promise<any>;

package/js/src/static_dependencies/ethers/abi-coder.d.ts

@@ -0,0 +1,50 @@
+/**
+ *  When sending values to or receiving values from a [[Contract]], the
+ *  data is generally encoded using the [ABI standard](link-solc-abi).
+ *
+ *  The AbiCoder provides a utility to encode values to ABI data and
+ *  decode values from ABI data.
+ *
+ *  Most of the time, developers should favour the [[Contract]] class,
+ *  which further abstracts a lot of the finer details of ABI data.
+ *
+ *  @_section api/abi/abi-coder:ABI Encoding
+ */
+import { Result } from "./coders/abstract-coder.js";
+import { ParamType } from "./fragments.js";
+import type { BytesLike } from "./utils/index.js";
+/**
+ *  The **AbiCoder** is a low-level class responsible for encoding JavaScript
+ *  values into binary data and decoding binary data into JavaScript values.
+ */
+export declare class AbiCoder {
+    #private;
+    /**
+     *  Get the default values for the given %%types%%.
+     *
+     *  For example, a ``uint`` is by default ``0`` and ``bool``
+     *  is by default ``false``.
+     */
+    getDefaultValue(types: ReadonlyArray<string | ParamType>): Result;
+    /**
+     *  Encode the %%values%% as the %%types%% into ABI data.
+     *
+     *  @returns DataHexstring
+     */
+    encode(types: ReadonlyArray<string | ParamType>, values: ReadonlyArray<any>): string;
+    /**
+     *  Decode the ABI %%data%% as the %%types%% into values.
+     *
+     *  If %%loose%% decoding is enabled, then strict padding is
+     *  not enforced. Some older versions of Solidity incorrectly
+     *  padded event data emitted from ``external`` functions.
+     */
+    decode(types: ReadonlyArray<string | ParamType>, data: BytesLike, loose?: boolean): Result;
+    static _setDefaultMaxInflation(value: number): void;
+    /**
+     *  Returns the shared singleton instance of a default [[AbiCoder]].
+     *
+     *  On the first call, the instance is created internally.
+     */
+    static defaultAbiCoder(): AbiCoder;
+}

package/js/src/static_dependencies/ethers/abi-coder.js

@@ -0,0 +1,148 @@
+// ----------------------------------------------------------------------------
+
+// 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
+
+/**
+ *  When sending values to or receiving values from a [[Contract]], the
+ *  data is generally encoded using the [ABI standard](link-solc-abi).
+ *
+ *  The AbiCoder provides a utility to encode values to ABI data and
+ *  decode values from ABI data.
+ *
+ *  Most of the time, developers should favour the [[Contract]] class,
+ *  which further abstracts a lot of the finer details of ABI data.
+ *
+ *  @_section api/abi/abi-coder:ABI Encoding
+ */
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AbiCoder_instances, _AbiCoder_getCoder;
+// See: https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI
+import { assertArgumentCount, assertArgument } from "./utils/index.js";
+import { Reader, Writer } from "./coders/abstract-coder.js";
+import { AddressCoder } from "./coders/address.js";
+import { ArrayCoder } from "./coders/array.js";
+import { BooleanCoder } from "./coders/boolean.js";
+import { BytesCoder } from "./coders/bytes.js";
+import { FixedBytesCoder } from "./coders/fixed-bytes.js";
+import { NullCoder } from "./coders/null.js";
+import { NumberCoder } from "./coders/number.js";
+import { StringCoder } from "./coders/string.js";
+import { TupleCoder } from "./coders/tuple.js";
+import { ParamType } from "./fragments.js";
+// https://docs.soliditylang.org/en/v0.8.17/control-structures.html
+const PanicReasons = new Map();
+PanicReasons.set(0x00, "GENERIC_PANIC");
+PanicReasons.set(0x01, "ASSERT_FALSE");
+PanicReasons.set(0x11, "OVERFLOW");
+PanicReasons.set(0x12, "DIVIDE_BY_ZERO");
+PanicReasons.set(0x21, "ENUM_RANGE_ERROR");
+PanicReasons.set(0x22, "BAD_STORAGE_DATA");
+PanicReasons.set(0x31, "STACK_UNDERFLOW");
+PanicReasons.set(0x32, "ARRAY_RANGE_ERROR");
+PanicReasons.set(0x41, "OUT_OF_MEMORY");
+PanicReasons.set(0x51, "UNINITIALIZED_FUNCTION_CALL");
+const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);
+const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
+let defaultCoder = null;
+let defaultMaxInflation = 1024;
+/**
+ *  The **AbiCoder** is a low-level class responsible for encoding JavaScript
+ *  values into binary data and decoding binary data into JavaScript values.
+ */
+export class AbiCoder {
+    constructor() {
+        _AbiCoder_instances.add(this);
+    }
+    /**
+     *  Get the default values for the given %%types%%.
+     *
+     *  For example, a ``uint`` is by default ``0`` and ``bool``
+     *  is by default ``false``.
+     */
+    getDefaultValue(types) {
+        const coders = types.map((type) => __classPrivateFieldGet(this, _AbiCoder_instances, "m", _AbiCoder_getCoder).call(this, ParamType.from(type)));
+        const coder = new TupleCoder(coders, "_");
+        return coder.defaultValue();
+    }
+    /**
+     *  Encode the %%values%% as the %%types%% into ABI data.
+     *
+     *  @returns DataHexstring
+     */
+    encode(types, values) {
+        assertArgumentCount(values.length, types.length, "types/values length mismatch");
+        const coders = types.map((type) => __classPrivateFieldGet(this, _AbiCoder_instances, "m", _AbiCoder_getCoder).call(this, ParamType.from(type)));
+        const coder = (new TupleCoder(coders, "_"));
+        const writer = new Writer();
+        coder.encode(writer, values);
+        return writer.data;
+    }
+    /**
+     *  Decode the ABI %%data%% as the %%types%% into values.
+     *
+     *  If %%loose%% decoding is enabled, then strict padding is
+     *  not enforced. Some older versions of Solidity incorrectly
+     *  padded event data emitted from ``external`` functions.
+     */
+    decode(types, data, loose) {
+        const coders = types.map((type) => __classPrivateFieldGet(this, _AbiCoder_instances, "m", _AbiCoder_getCoder).call(this, ParamType.from(type)));
+        const coder = new TupleCoder(coders, "_");
+        return coder.decode(new Reader(data, loose, defaultMaxInflation));
+    }
+    static _setDefaultMaxInflation(value) {
+        assertArgument(typeof (value) === "number" && Number.isInteger(value), "invalid defaultMaxInflation factor", "value", value);
+        defaultMaxInflation = value;
+    }
+    /**
+     *  Returns the shared singleton instance of a default [[AbiCoder]].
+     *
+     *  On the first call, the instance is created internally.
+     */
+    static defaultAbiCoder() {
+        if (defaultCoder == null) {
+            defaultCoder = new AbiCoder();
+        }
+        return defaultCoder;
+    }
+}
+_AbiCoder_instances = new WeakSet(), _AbiCoder_getCoder = function _AbiCoder_getCoder(param) {
+    if (param.isArray()) {
+        return new ArrayCoder(__classPrivateFieldGet(this, _AbiCoder_instances, "m", _AbiCoder_getCoder).call(this, param.arrayChildren), param.arrayLength, param.name);
+    }
+    if (param.isTuple()) {
+        return new TupleCoder(param.components.map((c) => __classPrivateFieldGet(this, _AbiCoder_instances, "m", _AbiCoder_getCoder).call(this, c)), param.name);
+    }
+    switch (param.baseType) {
+        case "address":
+            return new AddressCoder(param.name);
+        case "bool":
+            return new BooleanCoder(param.name);
+        case "string":
+            return new StringCoder(param.name);
+        case "bytes":
+            return new BytesCoder(param.name);
+        case "":
+            return new NullCoder(param.name);
+    }
+    // u?int[0-9]*
+    let match = param.type.match(paramTypeNumber);
+    if (match) {
+        let size = parseInt(match[2] || "256");
+        assertArgument(size !== 0 && size <= 256 && (size % 8) === 0, "invalid " + match[1] + " bit length", "param", param);
+        return new NumberCoder(size / 8, (match[1] === "int"), param.name);
+    }
+    // bytes[0-9]+
+    match = param.type.match(paramTypeBytes);
+    if (match) {
+        let size = parseInt(match[1]);
+        assertArgument(size !== 0 && size <= 32, "invalid bytes length", "param", param);
+        return new FixedBytesCoder(size, param.name);
+    }
+    assertArgument(false, "invalid type", "type", param.type);
+};

package/js/src/static_dependencies/ethers/address/address.d.ts

@@ -0,0 +1,55 @@
+/**
+ *  Returns a normalized and checksumed address for %%address%%.
+ *  This accepts non-checksum addresses, checksum addresses and
+ *  [[getIcapAddress]] formats.
+ *
+ *  The checksum in Ethereum uses the capitalization (upper-case
+ *  vs lower-case) of the characters within an address to encode
+ *  its checksum, which offers, on average, a checksum of 15-bits.
+ *
+ *  If %%address%% contains both upper-case and lower-case, it is
+ *  assumed to already be a checksum address and its checksum is
+ *  validated, and if the address fails its expected checksum an
+ *  error is thrown.
+ *
+ *  If you wish the checksum of %%address%% to be ignore, it should
+ *  be converted to lower-case (i.e. ``.toLowercase()``) before
+ *  being passed in. This should be a very rare situation though,
+ *  that you wish to bypass the safegaurds in place to protect
+ *  against an address that has been incorrectly copied from another
+ *  source.
+ *
+ *  @example:
+ *    // Adds the checksum (via upper-casing specific letters)
+ *    getAddress("0x8ba1f109551bd432803012645ac136ddd64dba72")
+ *    //_result:
+ *
+ *    // Converts ICAP address and adds checksum
+ *    getAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36");
+ *    //_result:
+ *
+ *    // Throws an error if an address contains mixed case,
+ *    // but the checksum fails
+ *    getAddress("0x8Ba1f109551bD432803012645Ac136ddd64DBA72")
+ *    //_error:
+ */
+export declare function getAddress(address: string): string;
+/**
+ *  The [ICAP Address format](link-icap) format is an early checksum
+ *  format which attempts to be compatible with the banking
+ *  industry [IBAN format](link-wiki-iban) for bank accounts.
+ *
+ *  It is no longer common or a recommended format.
+ *
+ *  @example:
+ *    getIcapAddress("0x8ba1f109551bd432803012645ac136ddd64dba72");
+ *    //_result:
+ *
+ *    getIcapAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36");
+ *    //_result:
+ *
+ *    // Throws an error if the ICAP checksum is wrong
+ *    getIcapAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK37");
+ *    //_error:
+ */
+export declare function getIcapAddress(address: string): string;