ccxt 4.3.40 → 4.3.41

package/dist/cjs/src/pro/phemex.js

@@ -706,11 +706,11 @@ class phemex extends phemex$1 {
             client.resolve(orderbook, messageHash);
         }
         else {
-            const orderbook = this.safeValue(this.orderbooks, symbol);
-            if (orderbook !== undefined) {
-                const changes = this.safeValue2(message, 'book', 'orderbook_p', {});
-                const asks = this.safeValue(changes, 'asks', []);
-                const bids = this.safeValue(changes, 'bids', []);
+            if (symbol in this.orderbooks) {
+                const orderbook = this.orderbooks[symbol];
+                const changes = this.safeDict2(message, 'book', 'orderbook_p', {});
+                const asks = this.safeList(changes, 'asks', []);
+                const bids = this.safeList(changes, 'bids', []);
                 this.customHandleDeltas(orderbook['asks'], asks, market);
                 this.customHandleDeltas(orderbook['bids'], bids, market);
                 orderbook['nonce'] = nonce;

package/dist/cjs/src/pro/probit.js

@@ -450,11 +450,11 @@ class probit extends probit$1 {
         const symbol = this.safeSymbol(marketId);
         const dataBySide = this.groupBy(orderBook, 'side');
         const messageHash = 'orderbook:' + symbol;
-        let orderbook = this.safeValue(this.orderbooks, symbol);
-        if (orderbook === undefined) {
-            orderbook = this.orderBook({});
-            this.orderbooks[symbol] = orderbook;
+        // let orderbook = this.safeValue (this.orderbooks, symbol);
+        if (!(symbol in this.orderbooks)) {
+            this.orderbooks[symbol] = this.orderBook({});
         }
+        const orderbook = this.orderbooks[symbol];
         const reset = this.safeBool(message, 'reset', false);
         if (reset) {
             const snapshot = this.parseOrderBook(dataBySide, symbol, undefined, 'buy', 'sell', 'price', 'quantity');

package/dist/cjs/src/pro/upbit.js

@@ -2,6 +2,8 @@
 
 var upbit$1 = require('../upbit.js');
 var Cache = require('../base/ws/Cache.js');
+var sha256 = require('../static_dependencies/noble-hashes/sha256.js');
+var rsa = require('../base/functions/rsa.js');
 
 //  ---------------------------------------------------------------------------
 //  ---------------------------------------------------------------------------
@@ -13,10 +15,13 @@ class upbit extends upbit$1 {
                 'watchOrderBook': true,
                 'watchTicker': true,
                 'watchTrades': true,
+                'watchOrders': true,
+                'watchMyTrades': true,
+                'watchBalance': true,
             },
             'urls': {
                 'api': {
-                    'ws': 'wss://api.upbit.com/websocket/v1',
+                    'ws': 'wss://{hostname}/websocket/v1',
                 },
             },
             'options': {
@@ -29,7 +34,9 @@ class upbit extends upbit$1 {
         const market = this.market(symbol);
         symbol = market['symbol'];
         const marketId = market['id'];
-        const url = this.urls['api']['ws'];
+        const url = this.implodeParams(this.urls['api']['ws'], {
+            'hostname': this.hostname,
+        });
         this.options[channel] = this.safeValue(this.options, channel, {});
         this.options[channel][symbol] = true;
         const symbols = Object.keys(this.options[channel]);
@@ -53,6 +60,7 @@ class upbit extends upbit$1 {
          * @method
          * @name upbit#watchTicker
          * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+         * @see https://global-docs.upbit.com/reference/websocket-ticker
          * @param {string} symbol unified symbol of the market to fetch the ticker for
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
@@ -64,6 +72,7 @@ class upbit extends upbit$1 {
          * @method
          * @name upbit#watchTrades
          * @description get the list of most recent trades for a particular symbol
+         * @see https://global-docs.upbit.com/reference/websocket-trade
          * @param {string} symbol unified symbol of the market to fetch trades for
          * @param {int} [since] timestamp in ms of the earliest trade to fetch
          * @param {int} [limit] the maximum amount of trades to fetch
@@ -83,6 +92,7 @@ class upbit extends upbit$1 {
          * @method
          * @name upbit#watchOrderBook
          * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+         * @see https://global-docs.upbit.com/reference/websocket-orderbook
          * @param {string} symbol unified symbol of the market to fetch the order book for
          * @param {int} [limit] the maximum amount of order book entries to return
          * @param {object} [params] extra parameters specific to the exchange API endpoint
@@ -217,11 +227,317 @@ class upbit extends upbit$1 {
         const messageHash = 'trade:' + marketId;
         client.resolve(stored, messageHash);
     }
+    async authenticate(params = {}) {
+        this.checkRequiredCredentials();
+        const authenticated = this.options['ws']['token'];
+        if (authenticated === undefined) {
+            const auth = {
+                'access_key': this.apiKey,
+                'nonce': this.uuid(),
+            };
+            const token = rsa.jwt(auth, this.encode(this.secret), sha256.sha256, false);
+            this.options['ws']['token'] = token;
+            this.options['ws']['options']['headers'] = {
+                'authorization': 'Bearer ' + token,
+            };
+        }
+        const url = this.urls['api']['ws'] + '/private';
+        const client = this.client(url);
+        return client;
+    }
+    async watchPrivate(symbol, channel, messageHash, params = {}) {
+        await this.authenticate();
+        const request = {
+            'type': channel,
+        };
+        if (symbol !== undefined) {
+            await this.loadMarkets();
+            const market = this.market(symbol);
+            symbol = market['symbol'];
+            const symbols = [symbol];
+            const marketIds = this.marketIds(symbols);
+            request['codes'] = marketIds;
+            messageHash = messageHash + ':' + symbol;
+        }
+        let url = this.implodeParams(this.urls['api']['ws'], {
+            'hostname': this.hostname,
+        });
+        url += '/private';
+        const message = [
+            {
+                'ticket': this.uuid(),
+            },
+            request,
+        ];
+        return await this.watch(url, messageHash, message, messageHash);
+    }
+    async watchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name upbit#watchOrders
+         * @description watches information on multiple orders made by the user
+         * @see https://global-docs.upbit.com/reference/websocket-myorder
+         * @param {string} symbol unified market symbol of the market orders were made in
+         * @param {int} [since] the earliest time in ms to fetch orders for
+         * @param {int} [limit] the maximum number of order structures to retrieve
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        const channel = 'myOrder';
+        const messageHash = 'myOrder';
+        const orders = await this.watchPrivate(symbol, channel, messageHash);
+        if (this.newUpdates) {
+            limit = orders.getLimit(symbol, limit);
+        }
+        return this.filterBySymbolSinceLimit(orders, symbol, since, limit, true);
+    }
+    async watchMyTrades(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name upbit#watchMyTrades
+         * @description watches information on multiple trades made by the user
+         * @see https://global-docs.upbit.com/reference/websocket-myorder
+         * @param {string} symbol unified market symbol of the market orders were made in
+         * @param {int} [since] the earliest time in ms to fetch orders for
+         * @param {int} [limit] the maximum number of order structures to retrieve
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure
+         */
+        await this.loadMarkets();
+        const channel = 'myOrder';
+        const messageHash = 'myTrades';
+        const trades = await this.watchPrivate(symbol, channel, messageHash);
+        if (this.newUpdates) {
+            limit = trades.getLimit(symbol, limit);
+        }
+        return this.filterBySymbolSinceLimit(trades, symbol, since, limit, true);
+    }
+    parseWsOrderStatus(status) {
+        const statuses = {
+            'wait': 'open',
+            'done': 'closed',
+            'cancel': 'canceled',
+            'watch': 'open',
+            'trade': 'open',
+        };
+        return this.safeString(statuses, status, status);
+    }
+    parseWsOrder(order, market = undefined) {
+        //
+        // {
+        //     "type": "myOrder",
+        //     "code": "SGD-XRP",
+        //     "uuid": "ac2dc2a3-fce9-40a2-a4f6-5987c25c438f",
+        //     "ask_bid": "BID",
+        //     "order_type": "limit",
+        //     "state": "trade",
+        //     "price": 0.001453,
+        //     "avg_price": 0.00145372,
+        //     "volume": 30925891.29839369,
+        //     "remaining_volume": 29968038.09235948,
+        //     "executed_volume": 30925891.29839369,
+        //     "trades_count": 1,
+        //     "reserved_fee": 44.23943970238218,
+        //     "remaining_fee": 21.77177967409916,
+        //     "paid_fee": 22.467660028283017,
+        //     "locked": 43565.33112787242,
+        //     "executed_funds": 44935.32005656603,
+        //     "order_timestamp": 1710751590000,
+        //     "timestamp": 1710751597500,
+        //     "stream_type": "REALTIME"
+        // }
+        //
+        const id = this.safeString(order, 'uuid');
+        let side = this.safeStringLower(order, 'ask_bid');
+        if (side === 'bid') {
+            side = 'buy';
+        }
+        else {
+            side = 'sell';
+        }
+        const timestamp = this.parse8601(this.safeString(order, 'order_timestamp'));
+        const status = this.parseWsOrderStatus(this.safeString(order, 'state'));
+        const marketId = this.safeString(order, 'code');
+        market = this.safeMarket(marketId, market);
+        let fee = undefined;
+        const feeCost = this.safeString(order, 'paid_fee');
+        if (feeCost !== undefined) {
+            fee = {
+                'currency': market['quote'],
+                'cost': feeCost,
+            };
+        }
+        return this.safeOrder({
+            'info': order,
+            'id': id,
+            'clientOrderId': undefined,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'lastTradeTimestamp': this.safeString(order, 'trade_timestamp'),
+            'symbol': market['symbol'],
+            'type': this.safeString(order, 'order_type'),
+            'timeInForce': this.safeString(order, 'time_in_force'),
+            'postOnly': undefined,
+            'side': side,
+            'price': this.safeString(order, 'price'),
+            'stopPrice': undefined,
+            'triggerPrice': undefined,
+            'cost': this.safeString(order, 'executed_funds'),
+            'average': this.safeString(order, 'avg_price'),
+            'amount': this.safeString(order, 'volume'),
+            'filled': this.safeString(order, 'executed_volume'),
+            'remaining': this.safeString(order, 'remaining_volume'),
+            'status': status,
+            'fee': fee,
+            'trades': undefined,
+        });
+    }
+    parseWsTrade(trade, market = undefined) {
+        // see: parseWsOrder
+        let side = this.safeStringLower(trade, 'ask_bid');
+        if (side === 'bid') {
+            side = 'buy';
+        }
+        else {
+            side = 'sell';
+        }
+        const timestamp = this.parse8601(this.safeString(trade, 'trade_timestamp'));
+        const marketId = this.safeString(trade, 'code');
+        market = this.safeMarket(marketId, market);
+        let fee = undefined;
+        const feeCost = this.safeString(trade, 'paid_fee');
+        if (feeCost !== undefined) {
+            fee = {
+                'currency': market['quote'],
+                'cost': feeCost,
+            };
+        }
+        return this.safeTrade({
+            'id': this.safeString(trade, 'trade_uuid'),
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'symbol': market['symbol'],
+            'side': side,
+            'price': this.safeString(trade, 'price'),
+            'amount': this.safeString(trade, 'volume'),
+            'cost': this.safeString(trade, 'executed_funds'),
+            'order': this.safeString(trade, 'uuid'),
+            'takerOrMaker': undefined,
+            'type': this.safeString(trade, 'order_type'),
+            'fee': fee,
+            'info': trade,
+        }, market);
+    }
+    handleMyOrder(client, message) {
+        // see: parseWsOrder
+        const tradeId = this.safeString(message, 'trade_uuid');
+        if (tradeId !== undefined) {
+            this.handleMyTrade(client, message);
+        }
+        this.handleOrder(client, message);
+    }
+    handleMyTrade(client, message) {
+        // see: parseWsOrder
+        let myTrades = this.myTrades;
+        if (myTrades === undefined) {
+            const limit = this.safeInteger(this.options, 'tradesLimit', 1000);
+            myTrades = new Cache.ArrayCacheBySymbolById(limit);
+        }
+        const trade = this.parseWsTrade(message);
+        myTrades.append(trade);
+        let messageHash = 'myTrades';
+        client.resolve(myTrades, messageHash);
+        messageHash = 'myTrades:' + trade['symbol'];
+        client.resolve(myTrades, messageHash);
+    }
+    handleOrder(client, message) {
+        const parsed = this.parseWsOrder(message);
+        const symbol = this.safeString(parsed, 'symbol');
+        const orderId = this.safeString(parsed, 'id');
+        if (this.orders === undefined) {
+            const limit = this.safeInteger(this.options, 'ordersLimit', 1000);
+            this.orders = new Cache.ArrayCacheBySymbolById(limit);
+        }
+        const cachedOrders = this.orders;
+        const orders = this.safeValue(cachedOrders.hashmap, symbol, {});
+        const order = this.safeValue(orders, orderId);
+        if (order !== undefined) {
+            const fee = this.safeValue(order, 'fee');
+            if (fee !== undefined) {
+                parsed['fee'] = fee;
+            }
+            const fees = this.safeValue(order, 'fees');
+            if (fees !== undefined) {
+                parsed['fees'] = fees;
+            }
+            parsed['trades'] = this.safeValue(order, 'trades');
+            parsed['timestamp'] = this.safeInteger(order, 'timestamp');
+            parsed['datetime'] = this.safeString(order, 'datetime');
+        }
+        cachedOrders.append(parsed);
+        let messageHash = 'myOrder';
+        client.resolve(this.orders, messageHash);
+        messageHash = messageHash + ':' + symbol;
+        client.resolve(this.orders, messageHash);
+    }
+    async watchBalance(params = {}) {
+        /**
+         * @method
+         * @name upbit#watchBalance
+         * @see https://global-docs.upbit.com/reference/websocket-myasset
+         * @description query for balance and get the amount of funds available for trading or funds locked in orders
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
+         */
+        await this.loadMarkets();
+        const channel = 'myAsset';
+        const messageHash = 'myAsset';
+        return await this.watchPrivate(undefined, channel, messageHash);
+    }
+    handleBalance(client, message) {
+        //
+        // {
+        //     "type": "myAsset",
+        //     "asset_uuid": "e635f223-1609-4969-8fb6-4376937baad6",
+        //     "assets": [
+        //       {
+        //         "currency": "SGD",
+        //         "balance": 1386929.37231066771348207123,
+        //         "locked": 10329.670127489597585685
+        //       }
+        //     ],
+        //     "asset_timestamp": 1710146517259,
+        //     "timestamp": 1710146517267,
+        //     "stream_type": "REALTIME"
+        // }
+        //
+        const data = this.safeList(message, 'assets', []);
+        const timestamp = this.safeInteger(message, 'timestamp');
+        this.balance['timestamp'] = timestamp;
+        this.balance['datetime'] = this.iso8601(timestamp);
+        for (let i = 0; i < data.length; i++) {
+            const balance = data[i];
+            const currencyId = this.safeString(balance, 'currency');
+            const code = this.safeCurrencyCode(currencyId);
+            const available = this.safeString(balance, 'balance');
+            const frozen = this.safeString(balance, 'locked');
+            const account = this.account();
+            account['free'] = available;
+            account['used'] = frozen;
+            this.balance[code] = account;
+            this.balance = this.safeBalance(this.balance);
+        }
+        const messageHash = this.safeString(message, 'type');
+        client.resolve(this.balance, messageHash);
+    }
     handleMessage(client, message) {
         const methods = {
             'ticker': this.handleTicker,
             'orderbook': this.handleOrderBook,
             'trade': this.handleTrades,
+            'myOrder': this.handleMyOrder,
+            'myAsset': this.handleBalance,
         };
         const methodName = this.safeString(message, 'type');
         const method = this.safeValue(methods, methodName);

package/dist/cjs/src/pro/wazirx.js

@@ -520,21 +520,21 @@ class wazirx extends wazirx$1 {
         const market = this.safeMarket(marketId);
         const symbol = market['symbol'];
         const messageHash = 'orderbook:' + symbol;
-        const currentOrderBook = this.safeValue(this.orderbooks, symbol);
-        if (currentOrderBook === undefined) {
+        // const currentOrderBook = this.safeValue (this.orderbooks, symbol);
+        if (!(symbol in this.orderbooks)) {
             const snapshot = this.parseOrderBook(data, symbol, timestamp, 'b', 'a');
-            const orderBook = this.orderBook(snapshot);
-            this.orderbooks[symbol] = orderBook;
+            this.orderbooks[symbol] = this.orderBook(snapshot);
         }
         else {
-            const asks = this.safeValue(data, 'a', []);
-            const bids = this.safeValue(data, 'b', []);
-            this.handleDeltas(currentOrderBook['asks'], asks);
-            this.handleDeltas(currentOrderBook['bids'], bids);
-            currentOrderBook['nonce'] = timestamp;
-            currentOrderBook['timestamp'] = timestamp;
-            currentOrderBook['datetime'] = this.iso8601(timestamp);
-            this.orderbooks[symbol] = currentOrderBook;
+            const orderbook = this.orderbooks[symbol];
+            const asks = this.safeList(data, 'a', []);
+            const bids = this.safeList(data, 'b', []);
+            this.handleDeltas(orderbook['asks'], asks);
+            this.handleDeltas(orderbook['bids'], bids);
+            orderbook['nonce'] = timestamp;
+            orderbook['timestamp'] = timestamp;
+            orderbook['datetime'] = this.iso8601(timestamp);
+            this.orderbooks[symbol] = orderbook;
         }
         client.resolve(this.orderbooks[symbol], messageHash);
     }

package/dist/cjs/src/upbit.js

@@ -1884,25 +1884,33 @@ class upbit extends upbit$1 {
         }
         if (api === 'private') {
             this.checkRequiredCredentials();
+            headers = {};
             const nonce = this.uuid();
             const request = {
                 'access_key': this.apiKey,
                 'nonce': nonce,
             };
-            if (Object.keys(query).length) {
-                const auth = this.urlencode(query);
+            const hasQuery = Object.keys(query).length;
+            let auth = undefined;
+            if ((method !== 'GET') && (method !== 'DELETE')) {
+                body = this.json(params);
+                headers['Content-Type'] = 'application/json';
+                if (hasQuery) {
+                    auth = this.urlencode(query);
+                }
+            }
+            else {
+                if (hasQuery) {
+                    auth = this.urlencode(this.keysort(query));
+                }
+            }
+            if (auth !== undefined) {
                 const hash = this.hash(this.encode(auth), sha512.sha512);
                 request['query_hash'] = hash;
                 request['query_hash_alg'] = 'SHA512';
             }
             const token = rsa.jwt(request, this.encode(this.secret), sha256.sha256);
-            headers = {
-                'Authorization': 'Bearer ' + token,
-            };
-            if ((method !== 'GET') && (method !== 'DELETE')) {
-                body = this.json(params);
-                headers['Content-Type'] = 'application/json';
-            }
+            headers['Authorization'] = 'Bearer ' + token;
         }
         return { 'url': url, 'method': method, 'body': body, 'headers': headers };
     }

package/dist/cjs/src/woo.js

@@ -1297,7 +1297,9 @@ class woo extends woo$1 {
         //         "status":"CANCEL_ALL_SENT"
         //     }
         //
-        return response;
+        return [
+            this.safeOrder(response),
+        ];
     }
     async cancelAllOrdersAfter(timeout, params = {}) {
         /**
@@ -1324,7 +1326,9 @@ class woo extends woo$1 {
         //         "timestamp": 1711534302943
         //     }
         //
-        return response;
+        return [
+            this.safeOrder(response),
+        ];
     }
     async fetchOrder(id, symbol = undefined, params = {}) {
         /**

package/js/ccxt.d.ts

@@ -4,7 +4,7 @@ import * as functions from './src/base/functions.js';
 import * as errors from './src/base/errors.js';
 import type { Market, Trade, Fee, Ticker, OrderBook, Order, Transaction, Tickers, Currency, Balance, DepositAddress, WithdrawalResponse, DepositAddressResponse, OHLCV, Balances, PartialBalances, Dictionary, MinMax, Position, FundingRateHistory, Liquidation, FundingHistory, MarginMode, Greeks, Leverage, Leverages, Option, OptionChain, Conversion } from './src/base/types.js';
 import { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, ProxyError, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout } from './src/base/errors.js';
-declare const version = "4.3.39";
+declare const version = "4.3.40";
 import ace from './src/ace.js';
 import alpaca from './src/alpaca.js';
 import ascendex from './src/ascendex.js';

package/js/ccxt.js

@@ -38,7 +38,7 @@ import * as errors from './src/base/errors.js';
 import { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, ProxyError, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout } from './src/base/errors.js';
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.3.40';
+const version = '4.3.41';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';

package/js/src/abstract/binance.d.ts

@@ -1,6 +1,8 @@
 import { implicitReturnType } from '../base/types.js';
 import { Exchange as _Exchange } from '../base/Exchange.js';
 interface Exchange {
+    sapiGetCopyTradingFuturesUserStatus(params?: {}): Promise<implicitReturnType>;
+    sapiGetCopyTradingFuturesLeadSymbol(params?: {}): Promise<implicitReturnType>;
     sapiGetSystemStatus(params?: {}): Promise<implicitReturnType>;
     sapiGetAccountSnapshot(params?: {}): Promise<implicitReturnType>;
     sapiGetAccountInfo(params?: {}): Promise<implicitReturnType>;

package/js/src/abstract/binancecoinm.d.ts

@@ -1,6 +1,8 @@
 import { implicitReturnType } from '../base/types.js';
 import _binance from '../binance.js';
 interface binance {
+    sapiGetCopyTradingFuturesUserStatus(params?: {}): Promise<implicitReturnType>;
+    sapiGetCopyTradingFuturesLeadSymbol(params?: {}): Promise<implicitReturnType>;
     sapiGetSystemStatus(params?: {}): Promise<implicitReturnType>;
     sapiGetAccountSnapshot(params?: {}): Promise<implicitReturnType>;
     sapiGetAccountInfo(params?: {}): Promise<implicitReturnType>;

package/js/src/abstract/binanceus.d.ts

@@ -1,6 +1,8 @@
 import { implicitReturnType } from '../base/types.js';
 import _binance from '../binance.js';
 interface binance {
+    sapiGetCopyTradingFuturesUserStatus(params?: {}): Promise<implicitReturnType>;
+    sapiGetCopyTradingFuturesLeadSymbol(params?: {}): Promise<implicitReturnType>;
     sapiGetSystemStatus(params?: {}): Promise<implicitReturnType>;
     sapiGetAccountSnapshot(params?: {}): Promise<implicitReturnType>;
     sapiGetAccountInfo(params?: {}): Promise<implicitReturnType>;

package/js/src/abstract/binanceusdm.d.ts

@@ -1,6 +1,8 @@
 import { implicitReturnType } from '../base/types.js';
 import _binance from '../binance.js';
 interface binance {
+    sapiGetCopyTradingFuturesUserStatus(params?: {}): Promise<implicitReturnType>;
+    sapiGetCopyTradingFuturesLeadSymbol(params?: {}): Promise<implicitReturnType>;
     sapiGetSystemStatus(params?: {}): Promise<implicitReturnType>;
     sapiGetAccountSnapshot(params?: {}): Promise<implicitReturnType>;
     sapiGetAccountInfo(params?: {}): Promise<implicitReturnType>;

package/js/src/abstract/okx.d.ts

@@ -147,6 +147,9 @@ interface Exchange {
     privateGetAccountGreeks(params?: {}): Promise<implicitReturnType>;
     privateGetAccountPositionTiers(params?: {}): Promise<implicitReturnType>;
     privateGetAccountMmpConfig(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountFixedLoanBorrowingLimit(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountFixedLoanBorrowingQuote(params?: {}): Promise<implicitReturnType>;
+    privateGetAccountFixedLoanBorrowingOrdersList(params?: {}): Promise<implicitReturnType>;
     privateGetUsersSubaccountList(params?: {}): Promise<implicitReturnType>;
     privateGetAccountSubaccountBalances(params?: {}): Promise<implicitReturnType>;
     privateGetAssetSubaccountBalances(params?: {}): Promise<implicitReturnType>;
@@ -258,6 +261,10 @@ interface Exchange {
     privatePostAccountSetAccountLevel(params?: {}): Promise<implicitReturnType>;
     privatePostAccountMmpReset(params?: {}): Promise<implicitReturnType>;
     privatePostAccountMmpConfig(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountFixedLoanBorrowingOrder(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountFixedLoanAmendBorrowingOrder(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountFixedLoanManualReborrow(params?: {}): Promise<implicitReturnType>;
+    privatePostAccountFixedLoanRepayBorrowingOrder(params?: {}): Promise<implicitReturnType>;
     privatePostUsersSubaccountModifyApikey(params?: {}): Promise<implicitReturnType>;
     privatePostAssetSubaccountTransfer(params?: {}): Promise<implicitReturnType>;
     privatePostUsersSubaccountSetTransferOut(params?: {}): Promise<implicitReturnType>;

package/js/src/binance.js

@@ -239,6 +239,9 @@ export default class binance extends Exchange {
                     // UID (sapi) request rate limit of 180 000 per minute
                     // 1 UID (sapi) => cost = 0.006667 => (1000 / (50 * 0.006667)) * 60 = 180000
                     'get': {
+                        // copy trading
+                        'copyTrading/futures/userStatus': 2,
+                        'copyTrading/futures/leadSymbol': 2,
                         'system/status': 0.1,
                         // these endpoints require this.apiKey
                         'accountSnapshot': 240,

package/js/src/bitfinex2.js

@@ -1724,7 +1724,7 @@ export default class bitfinex2 extends Exchange {
         }
         const orders = this.safeList(response, 4, []);
         const order = this.safeList(orders, 0);
-        return this.parseOrder(order, market);
+        return this.parseOrder(this.extend({ 'result': order }), market);
     }
     async createOrders(orders, params = {}) {
         /**

package/js/src/bithumb.d.ts

@@ -24,8 +24,8 @@ export default class bithumb extends Exchange {
     parseOrderStatus(status: Str): string;
     parseOrder(order: Dict, market?: Market): Order;
     fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    cancelOrder(id: string, symbol?: Str, params?: {}): Promise<any>;
-    cancelUnifiedOrder(order: any, params?: {}): Promise<any>;
+    cancelOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
+    cancelUnifiedOrder(order: any, params?: {}): Promise<Order>;
     withdraw(code: string, amount: number, address: string, tag?: any, params?: {}): Promise<Transaction>;
     parseTransaction(transaction: Dict, currency?: Currency): Transaction;
     fixCommaNumber(numberStr: any): any;

package/js/src/bithumb.js

@@ -969,7 +969,15 @@ export default class bithumb extends Exchange {
             'order_currency': market['base'],
             'payment_currency': market['quote'],
         };
-        return await this.privatePostTradeCancel(this.extend(request, params));
+        const response = await this.privatePostTradeCancel(this.extend(request, params));
+        //
+        //    {
+        //       'status': 'string',
+        //    }
+        //
+        return this.safeOrder({
+            'info': response,
+        });
     }
     async cancelUnifiedOrder(order, params = {}) {
         const request = {