ccxt 4.4.68 → 4.4.70

package/js/src/paradex.js

@@ -73,10 +73,10 @@ export default class paradex extends Exchange {
                 'fetchIsolatedBorrowRate': false,
                 'fetchIsolatedBorrowRates': false,
                 'fetchLedger': false,
-                'fetchLeverage': false,
+                'fetchLeverage': true,
                 'fetchLeverageTiers': false,
                 'fetchLiquidations': true,
-                'fetchMarginMode': undefined,
+                'fetchMarginMode': true,
                 'fetchMarketLeverageTiers': false,
                 'fetchMarkets': true,
                 'fetchMarkOHLCV': false,
@@ -110,8 +110,8 @@ export default class paradex extends Exchange {
                 'repayCrossMargin': false,
                 'repayIsolatedMargin': false,
                 'sandbox': true,
-                'setLeverage': false,
-                'setMarginMode': false,
+                'setLeverage': true,
+                'setMarginMode': true,
                 'setPositionMode': false,
                 'transfer': false,
                 'withdraw': false,
@@ -153,12 +153,23 @@ export default class paradex extends Exchange {
                         'system/state': 1,
                         'system/time': 1,
                         'trades': 1,
+                        'vaults': 1,
+                        'vaults/balance': 1,
+                        'vaults/config': 1,
+                        'vaults/history': 1,
+                        'vaults/positions': 1,
+                        'vaults/summary': 1,
+                        'vaults/transfers': 1,
                     },
                 },
                 'private': {
                     'get': {
                         'account': 1,
+                        'account/info': 1,
+                        'account/history': 1,
+                        'account/margin': 1,
                         'account/profile': 1,
+                        'account/subaccounts': 1,
                         'balance': 1,
                         'fills': 1,
                         'funding/payments': 1,
@@ -171,20 +182,34 @@ export default class paradex extends Exchange {
                         'orders/by_client_id/{client_id}': 1,
                         'orders/{order_id}': 1,
                         'points_data/{market}/{program}': 1,
+                        'referrals/qr-code': 1,
                         'referrals/summary': 1,
                         'transfers': 1,
+                        'algo/orders': 1,
+                        'algo/orders-history': 1,
+                        'algo/orders/{algo_id}': 1,
+                        'vaults/account-summary': 1,
                     },
                     'post': {
+                        'account/margin/{market}': 1,
+                        'account/profile/max_slippage': 1,
                         'account/profile/referral_code': 1,
                         'account/profile/username': 1,
                         'auth': 1,
                         'onboarding': 1,
                         'orders': 1,
+                        'orders/batch': 1,
+                        'algo/orders': 1,
+                        'vaults': 1,
+                    },
+                    'put': {
+                        'orders/{order_id}': 1,
                     },
                     'delete': {
                         'orders': 1,
                         'orders/by_client_id/{client_id}': 1,
                         'orders/{order_id}': 1,
+                        'algo/orders/{algo_id}': 1,
                     },
                 },
             },
@@ -2123,6 +2148,149 @@ export default class paradex extends Exchange {
         };
         return this.safeString(statuses, status, status);
     }
+    /**
+     * @method
+     * @name paradex#fetchMarginMode
+     * @description fetches the margin mode of a specific symbol
+     * @see https://docs.api.testnet.paradex.trade/#get-account-margin-configuration
+     * @param {string} symbol unified symbol of the market the order was made in
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {object} a [margin mode structure]{@link https://docs.ccxt.com/#/?id=margin-mode-structure}
+     */
+    async fetchMarginMode(symbol, params = {}) {
+        await this.authenticateRest();
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'market': market['id'],
+        };
+        const response = await this.privateGetAccountMargin(this.extend(request, params));
+        //
+        // {
+        //     "account": "0x6343248026a845b39a8a73fbe9c7ef0a841db31ed5c61ec1446aa9d25e54dbc",
+        //     "configs": [
+        //         {
+        //             "market": "SOL-USD-PERP",
+        //             "leverage": 50,
+        //             "margin_type": "CROSS"
+        //         }
+        //     ]
+        // }
+        //
+        const configs = this.safeList(response, 'configs');
+        return this.parseMarginMode(this.safeDict(configs, 0), market);
+    }
+    parseMarginMode(rawMarginMode, market = undefined) {
+        const marketId = this.safeString(rawMarginMode, 'market');
+        market = this.safeMarket(marketId, market);
+        const marginMode = this.safeStringLower(rawMarginMode, 'margin_type');
+        return {
+            'info': rawMarginMode,
+            'symbol': market['symbol'],
+            'marginMode': marginMode,
+        };
+    }
+    /**
+     * @method
+     * @name paradex#setMarginMode
+     * @description set margin mode to 'cross' or 'isolated'
+     * @see https://docs.api.testnet.paradex.trade/#set-margin-configuration
+     * @param {string} marginMode 'cross' or 'isolated'
+     * @param {string} symbol unified market symbol
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {float} [params.leverage] the rate of leverage
+     * @returns {object} response from the exchange
+     */
+    async setMarginMode(marginMode, symbol = undefined, params = {}) {
+        this.checkRequiredArgument('setMarginMode', symbol, 'symbol');
+        await this.authenticateRest();
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        let leverage = undefined;
+        [leverage, params] = this.handleOptionAndParams(params, 'setMarginMode', 'leverage', 1);
+        const request = {
+            'market': market['id'],
+            'leverage': leverage,
+            'margin_type': this.encodeMarginMode(marginMode),
+        };
+        return await this.privatePostAccountMarginMarket(this.extend(request, params));
+    }
+    /**
+     * @method
+     * @name paradex#fetchLeverage
+     * @description fetch the set leverage for a market
+     * @see https://docs.api.testnet.paradex.trade/#get-account-margin-configuration
+     * @param {string} symbol unified market symbol
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {object} a [leverage structure]{@link https://docs.ccxt.com/#/?id=leverage-structure}
+     */
+    async fetchLeverage(symbol, params = {}) {
+        await this.authenticateRest();
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'market': market['id'],
+        };
+        const response = await this.privateGetAccountMargin(this.extend(request, params));
+        //
+        // {
+        //     "account": "0x6343248026a845b39a8a73fbe9c7ef0a841db31ed5c61ec1446aa9d25e54dbc",
+        //     "configs": [
+        //         {
+        //             "market": "SOL-USD-PERP",
+        //             "leverage": 50,
+        //             "margin_type": "CROSS"
+        //         }
+        //     ]
+        // }
+        //
+        const configs = this.safeList(response, 'configs');
+        return this.parseLeverage(this.safeDict(configs, 0), market);
+    }
+    parseLeverage(leverage, market = undefined) {
+        const marketId = this.safeString(leverage, 'market');
+        market = this.safeMarket(marketId, market);
+        const marginMode = this.safeStringLower(leverage, 'margin_type');
+        return {
+            'info': leverage,
+            'symbol': this.safeSymbol(marketId, market),
+            'marginMode': marginMode,
+            'longLeverage': this.safeInteger(leverage, 'leverage'),
+            'shortLeverage': this.safeInteger(leverage, 'leverage'),
+        };
+    }
+    encodeMarginMode(mode) {
+        const modes = {
+            'cross': 'CROSS',
+            'isolated': 'ISOLATED',
+        };
+        return this.safeString(modes, mode, mode);
+    }
+    /**
+     * @method
+     * @name paradex#setLeverage
+     * @description set the level of leverage for a market
+     * @see https://docs.api.testnet.paradex.trade/#set-margin-configuration
+     * @param {float} leverage the rate of leverage
+     * @param {string} [symbol] unified market symbol (is mandatory for swap markets)
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {string} [params.marginMode] 'cross' or 'isolated'
+     * @returns {object} response from the exchange
+     */
+    async setLeverage(leverage, symbol = undefined, params = {}) {
+        this.checkRequiredArgument('setLeverage', symbol, 'symbol');
+        await this.authenticateRest();
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        let marginMode = undefined;
+        [marginMode, params] = this.handleMarginModeAndParams('setLeverage', params, 'cross');
+        const request = {
+            'market': market['id'],
+            'leverage': leverage,
+            'margin_type': this.encodeMarginMode(marginMode),
+        };
+        return await this.privatePostAccountMarginMarket(this.extend(request, params));
+    }
     sign(path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
         let url = this.implodeHostname(this.urls['api'][this.version]) + '/' + this.implodeParams(path, params);
         const query = this.omit(params, this.extractParams(path));

package/js/src/phemex.d.ts

@@ -289,7 +289,7 @@ export default class phemex extends Exchange {
      * @see https://phemex-docs.github.io/#query-account-positions-with-unrealized-pnl
      * @param {string[]} [symbols] list of unified market symbols
      * @param {object} [params] extra parameters specific to the exchange API endpoint
-     * @param {string} [params.code] the currency code to fetch positions for, USD, BTC or USDT, USD is the default
+     * @param {string} [params.code] the currency code to fetch positions for, USD, BTC or USDT, USDT is the default
      * @param {string} [params.method] *USDT contracts only* 'privateGetGAccountsAccountPositions' or 'privateGetAccountsPositions' default is 'privateGetGAccountsAccountPositions'
      * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/#/?id=position-structure}
      */

package/js/src/phemex.js

@@ -3798,7 +3798,7 @@ export default class phemex extends Exchange {
      * @see https://phemex-docs.github.io/#query-account-positions-with-unrealized-pnl
      * @param {string[]} [symbols] list of unified market symbols
      * @param {object} [params] extra parameters specific to the exchange API endpoint
-     * @param {string} [params.code] the currency code to fetch positions for, USD, BTC or USDT, USD is the default
+     * @param {string} [params.code] the currency code to fetch positions for, USD, BTC or USDT, USDT is the default
      * @param {string} [params.method] *USDT contracts only* 'privateGetGAccountsAccountPositions' or 'privateGetAccountsPositions' default is 'privateGetGAccountsAccountPositions'
      * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/#/?id=position-structure}
      */
@@ -3806,7 +3806,7 @@ export default class phemex extends Exchange {
         await this.loadMarkets();
         symbols = this.marketSymbols(symbols);
         let subType = undefined;
-        let code = this.safeString2(params, 'currency', 'code', 'USD');
+        let code = this.safeString2(params, 'currency', 'code', 'USDT');
         params = this.omit(params, ['currency', 'code']);
         let settle = undefined;
         let market = undefined;

package/js/src/pro/bitget.js

@@ -42,6 +42,10 @@ export default class bitget extends bitgetRest {
                         'public': 'wss://ws.bitget.com/v2/ws/public',
                         'private': 'wss://ws.bitget.com/v2/ws/private',
                     },
+                    'demo': {
+                        'public': 'wss://wspap.bitget.com/v2/ws/public',
+                        'private': 'wss://wspap.bitget.com/v2/ws/private',
+                    },
                 },
             },
             'options': {
@@ -1162,7 +1166,7 @@ export default class bitget extends bitgetRest {
         else {
             [instType, params] = this.getInstType(market, params);
         }
-        if (type === 'spot') {
+        if (type === 'spot' && (symbol !== undefined)) {
             subscriptionHash = subscriptionHash + ':' + symbol;
         }
         if (isTrigger) {
@@ -1776,7 +1780,14 @@ export default class bitget extends bitgetRest {
         client.resolve(this.balance, messageHash);
     }
     async watchPublic(messageHash, args, params = {}) {
-        const url = this.urls['api']['ws']['public'];
+        let url = this.urls['api']['ws']['public'];
+        const sandboxMode = this.safeBool2(this.options, 'sandboxMode', 'sandbox', false);
+        if (sandboxMode) {
+            const instType = this.safeString(args, 'instType');
+            if ((instType !== 'SCOIN-FUTURES') && (instType !== 'SUSDT-FUTURES') && (instType !== 'SUSDC-FUTURES')) {
+                url = this.urls['api']['demo']['public'];
+            }
+        }
         const request = {
             'op': 'subscribe',
             'args': [args],
@@ -1785,7 +1796,14 @@ export default class bitget extends bitgetRest {
         return await this.watch(url, messageHash, message, messageHash);
     }
     async unWatchPublic(messageHash, args, params = {}) {
-        const url = this.urls['api']['ws']['public'];
+        let url = this.urls['api']['ws']['public'];
+        const sandboxMode = this.safeBool2(this.options, 'sandboxMode', 'sandbox', false);
+        if (sandboxMode) {
+            const instType = this.safeString(args, 'instType');
+            if ((instType !== 'SCOIN-FUTURES') && (instType !== 'SUSDT-FUTURES') && (instType !== 'SUSDC-FUTURES')) {
+                url = this.urls['api']['demo']['public'];
+            }
+        }
         const request = {
             'op': 'unsubscribe',
             'args': [args],
@@ -1794,7 +1812,15 @@ export default class bitget extends bitgetRest {
         return await this.watch(url, messageHash, message, messageHash);
     }
     async watchPublicMultiple(messageHashes, argsArray, params = {}) {
-        const url = this.urls['api']['ws']['public'];
+        let url = this.urls['api']['ws']['public'];
+        const sandboxMode = this.safeBool2(this.options, 'sandboxMode', 'sandbox', false);
+        if (sandboxMode) {
+            const argsArrayFirst = this.safeDict(argsArray, 0, {});
+            const instType = this.safeString(argsArrayFirst, 'instType');
+            if ((instType !== 'SCOIN-FUTURES') && (instType !== 'SUSDT-FUTURES') && (instType !== 'SUSDC-FUTURES')) {
+                url = this.urls['api']['demo']['public'];
+            }
+        }
         const request = {
             'op': 'subscribe',
             'args': argsArray,
@@ -1804,7 +1830,7 @@ export default class bitget extends bitgetRest {
     }
     async authenticate(params = {}) {
         this.checkRequiredCredentials();
-        const url = this.urls['api']['ws']['private'];
+        const url = this.safeString(params, 'url');
         const client = this.client(url);
         const messageHash = 'authenticated';
         const future = client.future(messageHash);
@@ -1831,8 +1857,15 @@ export default class bitget extends bitgetRest {
         return await future;
     }
     async watchPrivate(messageHash, subscriptionHash, args, params = {}) {
-        await this.authenticate();
-        const url = this.urls['api']['ws']['private'];
+        let url = this.urls['api']['ws']['private'];
+        const sandboxMode = this.safeBool2(this.options, 'sandboxMode', 'sandbox', false);
+        if (sandboxMode) {
+            const instType = this.safeString(args, 'instType');
+            if ((instType !== 'SCOIN-FUTURES') && (instType !== 'SUSDT-FUTURES') && (instType !== 'SUSDC-FUTURES')) {
+                url = this.urls['api']['demo']['private'];
+            }
+        }
+        await this.authenticate({ 'url': url });
         const request = {
             'op': 'subscribe',
             'args': [args],

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

@@ -329,6 +329,7 @@ export default class bybit extends bybitRest {
      * @param {int} [since] the earliest time in ms to fetch liquidations for
      * @param {int} [limit] the maximum number of liquidation structures to retrieve
      * @param {object} [params] exchange specific parameters for the bitmex api endpoint
+     * @param {string} [params.method] exchange specific method, supported: liquidation, allLiquidation
      * @returns {object} an array of [liquidation structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#liquidation-structure}
      */
     watchLiquidations(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Liquidation[]>;

package/js/src/pro/bybit.js

@@ -1560,6 +1560,7 @@ export default class bybit extends bybitRest {
      * @param {int} [since] the earliest time in ms to fetch liquidations for
      * @param {int} [limit] the maximum number of liquidation structures to retrieve
      * @param {object} [params] exchange specific parameters for the bitmex api endpoint
+     * @param {string} [params.method] exchange specific method, supported: liquidation, allLiquidation
      * @returns {object} an array of [liquidation structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#liquidation-structure}
      */
     async watchLiquidations(symbol, since = undefined, limit = undefined, params = {}) {
@@ -1568,8 +1569,10 @@ export default class bybit extends bybitRest {
         symbol = market['symbol'];
         const url = await this.getUrlByMarketType(symbol, false, 'watchLiquidations', params);
         params = this.cleanParams(params);
+        let method = undefined;
+        [method, params] = this.handleOptionAndParams(params, 'watchLiquidations', 'method', 'liquidation');
         const messageHash = 'liquidations::' + symbol;
-        const topic = 'liquidation.' + market['id'];
+        const topic = method + '.' + market['id'];
         const newLiquidation = await this.watchTopics(url, [messageHash], [topic], params);
         if (this.newUpdates) {
             return newLiquidation;
@@ -1578,53 +1581,97 @@ export default class bybit extends bybitRest {
     }
     handleLiquidation(client, message) {
         //
-        //   {
-        //       "data": {
-        //           "price": "0.03803",
-        //           "side": "Buy",
-        //           "size": "1637",
-        //           "symbol": "GALAUSDT",
-        //           "updatedTime": 1673251091822
-        //       },
-        //       "topic": "liquidation.GALAUSDT",
-        //       "ts": 1673251091822,
-        //       "type": "snapshot"
-        //   }
+        //     {
+        //         "data": {
+        //             "price": "0.03803",
+        //             "side": "Buy",
+        //             "size": "1637",
+        //             "symbol": "GALAUSDT",
+        //             "updatedTime": 1673251091822
+        //         },
+        //         "topic": "liquidation.GALAUSDT",
+        //         "ts": 1673251091822,
+        //         "type": "snapshot"
+        //     }
         //
-        const rawLiquidation = this.safeDict(message, 'data', {});
-        const marketId = this.safeString(rawLiquidation, 'symbol');
-        const market = this.safeMarket(marketId, undefined, '', 'contract');
-        const symbol = market['symbol'];
-        const liquidation = this.parseWsLiquidation(rawLiquidation, market);
-        let liquidations = this.safeValue(this.liquidations, symbol);
-        if (liquidations === undefined) {
-            const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
-            liquidations = new ArrayCache(limit);
-        }
-        liquidations.append(liquidation);
-        this.liquidations[symbol] = liquidations;
-        client.resolve([liquidation], 'liquidations');
-        client.resolve([liquidation], 'liquidations::' + symbol);
+        //     {
+        //         "topic": "allLiquidation.ROSEUSDT",
+        //         "type": "snapshot",
+        //         "ts": 1739502303204,
+        //         "data": [
+        //             {
+        //                 "T": 1739502302929,
+        //                 "s": "ROSEUSDT",
+        //                 "S": "Sell",
+        //                 "v": "20000",
+        //                 "p": "0.04499"
+        //             }
+        //         ]
+        //     }
+        //
+        if (Array.isArray(message['data'])) {
+            const rawLiquidations = this.safeList(message, 'data', []);
+            for (let i = 0; i < rawLiquidations.length; i++) {
+                const rawLiquidation = rawLiquidations[i];
+                const marketId = this.safeString(rawLiquidation, 's');
+                const market = this.safeMarket(marketId, undefined, '', 'contract');
+                const symbol = market['symbol'];
+                const liquidation = this.parseWsLiquidation(rawLiquidation, market);
+                let liquidations = this.safeValue(this.liquidations, symbol);
+                if (liquidations === undefined) {
+                    const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
+                    liquidations = new ArrayCache(limit);
+                }
+                liquidations.append(liquidation);
+                this.liquidations[symbol] = liquidations;
+                client.resolve([liquidation], 'liquidations');
+                client.resolve([liquidation], 'liquidations::' + symbol);
+            }
+        }
+        else {
+            const rawLiquidation = this.safeDict(message, 'data', {});
+            const marketId = this.safeString(rawLiquidation, 'symbol');
+            const market = this.safeMarket(marketId, undefined, '', 'contract');
+            const symbol = market['symbol'];
+            const liquidation = this.parseWsLiquidation(rawLiquidation, market);
+            let liquidations = this.safeValue(this.liquidations, symbol);
+            if (liquidations === undefined) {
+                const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
+                liquidations = new ArrayCache(limit);
+            }
+            liquidations.append(liquidation);
+            this.liquidations[symbol] = liquidations;
+            client.resolve([liquidation], 'liquidations');
+            client.resolve([liquidation], 'liquidations::' + symbol);
+        }
     }
     parseWsLiquidation(liquidation, market = undefined) {
         //
-        //    {
-        //        "price": "0.03803",
-        //        "side": "Buy",
-        //        "size": "1637",
-        //        "symbol": "GALAUSDT",
-        //        "updatedTime": 1673251091822
-        //    }
+        //     {
+        //         "price": "0.03803",
+        //         "side": "Buy",
+        //         "size": "1637",
+        //         "symbol": "GALAUSDT",
+        //         "updatedTime": 1673251091822
+        //     }
+        //
+        //     {
+        //         "T": 1739502302929,
+        //         "s": "ROSEUSDT",
+        //         "S": "Sell",
+        //         "v": "20000",
+        //         "p": "0.04499"
+        //     }
         //
-        const marketId = this.safeString(liquidation, 'symbol');
+        const marketId = this.safeString2(liquidation, 'symbol', 's');
         market = this.safeMarket(marketId, market, '', 'contract');
-        const timestamp = this.safeInteger(liquidation, 'updatedTime');
+        const timestamp = this.safeInteger2(liquidation, 'updatedTime', 'T');
         return this.safeLiquidation({
             'info': liquidation,
             'symbol': market['symbol'],
-            'contracts': this.safeNumber(liquidation, 'size'),
+            'contracts': this.safeNumber2(liquidation, 'size', 'v'),
             'contractSize': this.safeNumber(market, 'contractSize'),
-            'price': this.safeNumber(liquidation, 'price'),
+            'price': this.safeNumber2(liquidation, 'price', 'p'),
             'baseValue': undefined,
             'quoteValue': undefined,
             'timestamp': timestamp,
@@ -2438,6 +2485,7 @@ export default class bybit extends bybitRest {
             'user.openapi.perp.trade': this.handleMyTrades,
             'position': this.handlePositions,
             'liquidation': this.handleLiquidation,
+            'allLiquidation': this.handleLiquidation,
             'pong': this.handlePong,
             'order.create': this.handleOrderWs,
             'order.amend': this.handleOrderWs,

package/js/src/tradeogre.d.ts

@@ -78,6 +78,7 @@ export default class tradeogre extends Exchange {
      * @name tradeogre#fetchBalance
      * @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
+     * @param {string} [params.currency] currency to fetch the balance for
      * @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
      */
     fetchBalance(params?: {}): Promise<import("./base/types.js").Balances>;

package/js/src/tradeogre.js

@@ -125,12 +125,12 @@ export default class tradeogre extends Exchange {
                         'orders/{market}': 1,
                         'ticker/{market}': 1,
                         'history/{market}': 1,
+                        'chart/{interval}/{market}/{timestamp}': 1,
                         'chart/{interval}/{market}': 1,
                     },
                 },
                 'private': {
                     'get': {
-                        'account/balance': 1,
                         'account/balances': 1,
                         'account/order/{uuid}': 1,
                     },
@@ -140,6 +140,7 @@ export default class tradeogre extends Exchange {
                         'order/cancel': 1,
                         'orders': 1,
                         'account/orders': 1,
+                        'account/balance': 1,
                     },
                 },
             },
@@ -417,15 +418,15 @@ export default class tradeogre extends Exchange {
             'ask': this.safeString(ticker, 'ask'),
             'askVolume': undefined,
             'vwap': undefined,
-            'open': this.safeString(ticker, 'open'),
-            'close': undefined,
+            'open': this.safeString(ticker, 'initialprice'),
+            'close': this.safeString(ticker, 'price'),
             'last': undefined,
             'previousClose': undefined,
             'change': undefined,
             'percentage': undefined,
             'average': undefined,
-            'baseVolume': this.safeString(ticker, 'volume'),
-            'quoteVolume': undefined,
+            'baseVolume': undefined,
+            'quoteVolume': this.safeString(ticker, 'volume'),
             'info': ticker,
         }, market);
     }
@@ -448,12 +449,16 @@ export default class tradeogre extends Exchange {
             'market': market['id'],
             'interval': this.safeString(this.timeframes, timeframe, timeframe),
         };
+        let response = undefined;
         const until = this.safeInteger(params, 'until');
         if (until !== undefined) {
             params = this.omit(params, 'until');
-            request['timestamp'] = until;
+            request['timestamp'] = this.parseToInt(until / 1000);
+            response = await this.publicGetChartIntervalMarketTimestamp(this.extend(request, params));
+        }
+        else {
+            response = await this.publicGetChartIntervalMarket(this.extend(request, params));
         }
-        const response = await this.publicGetChartIntervalMarket(this.extend(request, params));
         //
         //     [
         //         [
@@ -482,9 +487,9 @@ export default class tradeogre extends Exchange {
         return [
             this.safeTimestamp(ohlcv, 0),
             this.safeNumber(ohlcv, 1),
+            this.safeNumber(ohlcv, 2),
             this.safeNumber(ohlcv, 3),
             this.safeNumber(ohlcv, 4),
-            this.safeNumber(ohlcv, 2),
             this.safeNumber(ohlcv, 5),
         ];
     }
@@ -588,11 +593,29 @@ export default class tradeogre extends Exchange {
      * @name tradeogre#fetchBalance
      * @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
+     * @param {string} [params.currency] currency to fetch the balance for
      * @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
      */
     async fetchBalance(params = {}) {
         await this.loadMarkets();
-        const response = await this.privateGetAccountBalances(params);
+        let response = undefined;
+        const currency = this.safeString(params, 'currency');
+        if (currency !== undefined) {
+            response = await this.privatePostAccountBalance(params);
+            const singleCurrencyresult = {
+                'info': response,
+            };
+            const code = this.safeCurrencyCode(currency);
+            const account = {
+                'total': this.safeNumber(response, 'balance'),
+                'free': this.safeNumber(response, 'available'),
+            };
+            singleCurrencyresult[code] = account;
+            return this.safeBalance(singleCurrencyresult);
+        }
+        else {
+            response = await this.privateGetAccountBalances(params);
+        }
         const result = this.safeDict(response, 'balances', {});
         return this.parseBalance(result);
     }
@@ -756,11 +779,11 @@ export default class tradeogre extends Exchange {
             'side': this.safeString(order, 'type'),
             'price': this.safeString(order, 'price'),
             'triggerPrice': undefined,
-            'amount': this.safeString(order, 'quantity'),
+            'amount': undefined,
             'cost': undefined,
             'average': undefined,
             'filled': this.safeString(order, 'fulfilled'),
-            'remaining': undefined,
+            'remaining': this.safeString(order, 'quantity'),
             'status': undefined,
             'fee': {
                 'currency': undefined,