ccxt 4.1.52 → 4.1.54

package/js/src/lbank.js

@@ -6,15 +6,15 @@
 
 //  ---------------------------------------------------------------------------
 import Exchange from './abstract/lbank.js';
-import { ExchangeError, DDoSProtection, AuthenticationError, InvalidOrder, BadRequest } from './base/errors.js';
-import { Precise } from './base/Precise.js';
+import { ExchangeError, InvalidAddress, DuplicateOrderId, InsufficientFunds, InvalidOrder, InvalidNonce, AuthenticationError, RateLimitExceeded, PermissionDenied, BadRequest, BadSymbol } from './base/errors.js';
 import { TICK_SIZE } from './base/functions/number.js';
+import { Precise } from './base/Precise.js';
 import { md5 } from './static_dependencies/noble-hashes/md5.js';
-import { rsa } from './base/functions/rsa.js';
 import { sha256 } from './static_dependencies/noble-hashes/sha256.js';
+import { rsa } from './base/functions/rsa.js';
 //  ---------------------------------------------------------------------------
 /**
- * @class lbank
+ * @class lbank2
  * @extends Exchange
  */
 export default class lbank extends Exchange {
@@ -23,15 +23,19 @@ export default class lbank extends Exchange {
             'id': 'lbank',
             'name': 'LBank',
             'countries': ['CN'],
-            'version': 'v1',
+            'version': 'v2',
+            // 50 per second for making and cancelling orders 1000ms / 50 = 20
+            // 20 per second for all other requests, cost = 50 / 20 = 2.5
+            'rateLimit': 20,
             'has': {
-                'CORS': undefined,
+                'CORS': false,
                 'spot': true,
                 'margin': false,
-                'swap': false,
+                'swap': undefined,
                 'future': false,
                 'option': false,
                 'addMargin': false,
+                'cancelAllOrders': true,
                 'cancelOrder': true,
                 'createOrder': true,
                 'createReduceOnlyOrder': false,
@@ -44,20 +48,23 @@ export default class lbank extends Exchange {
                 'fetchBorrowRateHistory': false,
                 'fetchBorrowRates': false,
                 'fetchBorrowRatesPerSymbol': false,
-                'fetchClosedOrders': true,
+                'fetchClosedOrders': false,
+                'fetchDepositWithdrawFee': 'emulated',
+                'fetchDepositWithdrawFees': true,
                 'fetchFundingHistory': false,
                 'fetchFundingRate': false,
                 'fetchFundingRateHistory': false,
                 'fetchFundingRates': false,
                 'fetchIndexOHLCV': false,
+                'fetchIsolatedPositions': false,
                 'fetchLeverage': false,
                 'fetchLeverageTiers': false,
                 'fetchMarginMode': false,
                 'fetchMarkets': true,
                 'fetchMarkOHLCV': false,
+                'fetchMyTrades': true,
                 'fetchOHLCV': true,
-                'fetchOpenInterestHistory': false,
-                'fetchOpenOrders': false,
+                'fetchOpenOrders': true,
                 'fetchOrder': true,
                 'fetchOrderBook': true,
                 'fetchOrders': true,
@@ -68,9 +75,10 @@ export default class lbank extends Exchange {
                 'fetchPremiumIndexOHLCV': false,
                 'fetchTicker': true,
                 'fetchTickers': true,
+                'fetchTime': true,
                 'fetchTrades': true,
-                'fetchTradingFee': false,
-                'fetchTradingFees': false,
+                'fetchTradingFees': true,
+                'fetchTransactionFees': true,
                 'reduceMargin': false,
                 'setLeverage': false,
                 'setMarginMode': false,
@@ -95,35 +103,95 @@ export default class lbank extends Exchange {
                 'logo': 'https://user-images.githubusercontent.com/1294454/38063602-9605e28a-3302-11e8-81be-64b1e53c4cfb.jpg',
                 'api': {
                     'rest': 'https://api.lbank.info',
+                    'contract': 'https://lbkperp.lbank.com',
                 },
+                'api2': 'https://api.lbkex.com',
                 'www': 'https://www.lbank.info',
-                'doc': 'https://github.com/LBank-exchange/lbank-official-api-docs',
-                'fees': 'https://www.lbank.info/fees.html',
+                'doc': 'https://www.lbank.info/en-US/docs/index.html',
+                'fees': 'https://lbankinfo.zendesk.com/hc/en-gb/articles/360012072873-Trading-Fees',
                 'referral': 'https://www.lbank.info/invitevip?icode=7QCY',
             },
             'api': {
-                'public': {
-                    'get': [
-                        'currencyPairs',
-                        'ticker',
-                        'depth',
-                        'trades',
-                        'kline',
-                        'accuracy',
-                    ],
+                'spot': {
+                    'public': {
+                        'get': {
+                            'currencyPairs': 2.5,
+                            'accuracy': 2.5,
+                            'usdToCny': 2.5,
+                            'withdrawConfigs': 2.5,
+                            'timestamp': 2.5,
+                            'ticker/24hr': 2.5,
+                            'ticker': 2.5,
+                            'depth': 2.5,
+                            'incrDepth': 2.5,
+                            'trades': 2.5,
+                            'kline': 2.5,
+                            // new quote endpoints
+                            'supplement/system_ping': 2.5,
+                            'supplement/incrDepth': 2.5,
+                            'supplement/trades': 2.5,
+                            'supplement/ticker/price': 2.5,
+                            'supplement/ticker/bookTicker': 2.5,
+                        },
+                        'post': {
+                            'supplement/system_status': 2.5,
+                        },
+                    },
+                    'private': {
+                        'post': {
+                            // account
+                            'user_info': 2.5,
+                            'subscribe/get_key': 2.5,
+                            'subscribe/refresh_key': 2.5,
+                            'subscribe/destroy_key': 2.5,
+                            'get_deposit_address': 2.5,
+                            'deposit_history': 2.5,
+                            // order
+                            'create_order': 1,
+                            'batch_create_order': 1,
+                            'cancel_order': 1,
+                            'cancel_clientOrders': 1,
+                            'orders_info': 2.5,
+                            'orders_info_history': 2.5,
+                            'order_transaction_detail': 2.5,
+                            'transaction_history': 2.5,
+                            'orders_info_no_deal': 2.5,
+                            // withdraw
+                            'withdraw': 2.5,
+                            'withdrawCancel': 2.5,
+                            'withdraws': 2.5,
+                            'supplement/user_info': 2.5,
+                            'supplement/withdraw': 2.5,
+                            'supplement/deposit_history': 2.5,
+                            'supplement/withdraws': 2.5,
+                            'supplement/get_deposit_address': 2.5,
+                            'supplement/asset_detail': 2.5,
+                            'supplement/customer_trade_fee': 2.5,
+                            'supplement/api_Restrictions': 2.5,
+                            // new quote endpoints
+                            'supplement/system_ping': 2.5,
+                            // new order endpoints
+                            'supplement/create_order_test': 1,
+                            'supplement/create_order': 1,
+                            'supplement/cancel_order': 1,
+                            'supplement/cancel_order_by_symbol': 1,
+                            'supplement/orders_info': 2.5,
+                            'supplement/orders_info_no_deal': 2.5,
+                            'supplement/orders_info_history': 2.5,
+                            'supplement/user_info_account': 2.5,
+                            'supplement/transaction_history': 2.5,
+                        },
+                    },
                 },
-                'private': {
-                    'post': [
-                        'user_info',
-                        'create_order',
-                        'cancel_order',
-                        'orders_info',
-                        'orders_info_history',
-                        'withdraw',
-                        'withdrawCancel',
-                        'withdraws',
-                        'withdrawConfigs',
-                    ],
+                'contract': {
+                    'public': {
+                        'get': {
+                            'cfd/openApi/v1/pub/getTime': 2.5,
+                            'cfd/openApi/v1/pub/instrument': 2.5,
+                            'cfd/openApi/v1/pub/marketData': 2.5,
+                            'cfd/openApi/v1/pub/marketOrder': 2.5,
+                        },
+                    },
                 },
             },
             'fees': {
@@ -136,64 +204,188 @@ export default class lbank extends Exchange {
                 },
             },
             'commonCurrencies': {
-                'GMT': 'GMT Token',
-                'PNT': 'Penta',
-                'SHINJA': 'SHINJA(1M)',
                 'VET_ERC20': 'VEN',
+                'PNT': 'Penta',
             },
+            'precisionMode': TICK_SIZE,
             'options': {
                 'cacheSecretAsPem': true,
+                'createMarketBuyOrderRequiresPrice': true,
+                'fetchTrades': {
+                    'method': 'spotPublicGetTrades', // or 'spotPublicGetTradesSupplement'
+                },
+                'fetchTransactionFees': {
+                    'method': 'fetchPrivateTransactionFees', // or 'fetchPublicTransactionFees'
+                },
+                'fetchDepositWithdrawFees': {
+                    'method': 'fetchPrivateDepositWithdrawFees', // or 'fetchPublicDepositWithdrawFees'
+                },
+                'fetchDepositAddress': {
+                    'method': 'fetchDepositAddressDefault', // or fetchDepositAddressSupplement
+                },
+                'createOrder': {
+                    'method': 'spotPrivatePostSupplementCreateOrder', // or spotPrivatePostCreateOrder
+                },
+                'fetchOrder': {
+                    'method': 'fetchOrderSupplement', // or fetchOrderDefault
+                },
+                'fetchBalance': {
+                    'method': 'spotPrivatePostSupplementUserInfo', // or spotPrivatePostSupplementUserInfoAccount or spotPrivatePostUserInfo
+                },
+                'networks': {
+                    'ERC20': 'erc20',
+                    'ETH': 'erc20',
+                    'TRC20': 'trc20',
+                    'TRX': 'trc20',
+                    'OMNI': 'omni',
+                    'ASA': 'asa',
+                    'BEP20': 'bep20(bsc)',
+                    'BSC': 'bep20(bsc)',
+                    'HT': 'heco',
+                    'BNB': 'bep2',
+                    'BTC': 'btc',
+                    'DOGE': 'dogecoin',
+                    'MATIC': 'matic',
+                    'POLYGON': 'matic',
+                    'OEC': 'oec',
+                    'BTCTRON': 'btctron',
+                    'XRP': 'xrp',
+                    // other unusual chains with number of listed currencies supported
+                    //     'avax c-chain': 1,
+                    //     klay: 12,
+                    //     bta: 1,
+                    //     fantom: 1,
+                    //     celo: 1,
+                    //     sol: 2,
+                    //     zenith: 1,
+                    //     ftm: 5,
+                    //     bep20: 1, (single token with mis-named chain) SSS
+                    //     bitci: 1,
+                    //     sgb: 1,
+                    //     moonbeam: 1,
+                    //     ekta: 1,
+                    //     etl: 1,
+                    //     arbitrum: 1,
+                    //     tpc: 1,
+                    //     ptx: 1
+                    // }
+                },
+                'inverse-networks': {
+                    'erc20': 'ERC20',
+                    'trc20': 'TRC20',
+                    'omni': 'OMNI',
+                    'asa': 'ASA',
+                    'bep20(bsc)': 'BSC',
+                    'bep20': 'BSC',
+                    'heco': 'HT',
+                    'bep2': 'BNB',
+                    'btc': 'BTC',
+                    'dogecoin': 'DOGE',
+                    'matic': 'MATIC',
+                    'oec': 'OEC',
+                    'btctron': 'BTCTRON',
+                    'xrp': 'XRP',
+                },
+                'defaultNetworks': {
+                    'USDT': 'TRC20',
+                },
             },
-            'precisionMode': TICK_SIZE,
         });
     }
+    async fetchTime(params = {}) {
+        /**
+         * @method
+         * @name lbank2#fetchTime
+         * @description fetches the current integer timestamp in milliseconds from the exchange server
+         * @see https://www.lbank.info/en-US/docs/index.html#get-timestamp
+         * @see https://www.lbank.com/en-US/docs/contract.html#get-the-current-time
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
+         * @returns {int} the current integer timestamp in milliseconds from the exchange server
+         */
+        let type = undefined;
+        [type, params] = this.handleMarketTypeAndParams('fetchTime', undefined, params);
+        let response = undefined;
+        if (type === 'swap') {
+            response = await this.contractPublicGetCfdOpenApiV1PubGetTime(params);
+        }
+        else {
+            response = await this.spotPublicGetTimestamp(params);
+        }
+        //
+        // spot
+        //
+        //     {
+        //         "result": "true",
+        //         "data": 1691789627950,
+        //         "error_code": 0,
+        //         "ts": 1691789627950
+        //     }
+        //
+        // swap
+        //
+        //     {
+        //         "data": 1691789627950,
+        //         "error_code": 0,
+        //         "msg": "Success",
+        //         "result": "true",
+        //         "success": true
+        //     }
+        //
+        return this.safeInteger(response, 'data');
+    }
     async fetchMarkets(params = {}) {
         /**
          * @method
-         * @name lbank#fetchMarkets
-         * @description retrieves data on all markets for lbank
+         * @name lbank2#fetchMarkets
+         * @description retrieves data on all markets for lbank2
+         * @see https://www.lbank.com/en-US/docs/index.html#trading-pairs
+         * @see https://www.lbank.com/en-US/docs/contract.html#query-contract-information-list
          * @param {object} [params] extra parameters specific to the exchange api endpoint
          * @returns {object[]} an array of objects representing market data
          */
-        const response = await this.publicGetAccuracy(params);
+        const marketsPromises = [
+            this.fetchSpotMarkets(params),
+            this.fetchSwapMarkets(params),
+        ];
+        const resolvedMarkets = await Promise.all(marketsPromises);
+        return this.arrayConcat(resolvedMarkets[0], resolvedMarkets[1]);
+    }
+    async fetchSpotMarkets(params = {}) {
+        const response = await this.spotPublicGetAccuracy(params);
         //
-        //    [
-        //        {
-        //            "symbol": "btc_usdt",
-        //            "quantityAccuracy": "4",
-        //            "minTranQua": "0.0001",
-        //            "priceAccuracy": "2"
-        //        },
-        //        ...
-        //    ]
+        //     {
+        //         "result": "true",
+        //         "data": [
+        //             {
+        //                 "symbol": "btc_usdt",
+        //                 "quantityAccuracy": "4",
+        //                 "minTranQua": "0.0001",
+        //                 "priceAccuracy": "2"
+        //             },
+        //         ],
+        //         "error_code": 0,
+        //         "ts": 1691560288484
+        //     }
         //
+        const data = this.safeValue(response, 'data', []);
         const result = [];
-        for (let i = 0; i < response.length; i++) {
-            const market = response[i];
-            const id = market['symbol'];
-            const parts = id.split('_');
-            let baseId = undefined;
-            let quoteId = undefined;
-            const numParts = parts.length;
-            // lbank will return symbols like "vet_erc20_usdt"
-            if (numParts > 2) {
-                baseId = parts[0] + '_' + parts[1];
-                quoteId = parts[2];
-            }
-            else {
-                baseId = parts[0];
-                quoteId = parts[1];
-            }
+        for (let i = 0; i < data.length; i++) {
+            const market = data[i];
+            const marketId = this.safeString(market, 'symbol');
+            const parts = marketId.split('_');
+            const baseId = parts[0];
+            const quoteId = parts[1];
             const base = this.safeCurrencyCode(baseId);
             const quote = this.safeCurrencyCode(quoteId);
+            const symbol = base + '/' + quote;
             result.push({
-                'id': id,
-                'symbol': base + '/' + quote,
+                'id': marketId,
+                'symbol': symbol,
                 'base': base,
                 'quote': quote,
-                'settle': undefined,
                 'baseId': baseId,
                 'quoteId': quoteId,
+                'settle': undefined,
                 'settleId': undefined,
                 'type': 'spot',
                 'spot': true,
@@ -220,7 +412,7 @@ export default class lbank extends Exchange {
                         'max': undefined,
                     },
                     'amount': {
-                        'min': this.safeFloat(market, 'minTranQua'),
+                        'min': this.safeNumber(market, 'minTranQua'),
                         'max': undefined,
                     },
                     'price': {
@@ -233,178 +425,499 @@ export default class lbank extends Exchange {
                     },
                 },
                 'created': undefined,
-                'info': id,
+                'info': market,
+            });
+        }
+        return result;
+    }
+    async fetchSwapMarkets(params = {}) {
+        const request = {
+            'productGroup': 'SwapU',
+        };
+        const response = await this.contractPublicGetCfdOpenApiV1PubInstrument(this.extend(request, params));
+        //
+        //     {
+        //         "data": [
+        //             {
+        //                 "priceLimitUpperValue": 0.2,
+        //                 "symbol": "BTCUSDT",
+        //                 "volumeTick": 0.0001,
+        //                 "indexPrice": "29707.70200000",
+        //                 "minOrderVolume": "0.0001",
+        //                 "priceTick": 0.1,
+        //                 "maxOrderVolume": "30.0",
+        //                 "baseCurrency": "BTC",
+        //                 "volumeMultiple": 1.0,
+        //                 "exchangeID": "Exchange",
+        //                 "priceCurrency": "USDT",
+        //                 "priceLimitLowerValue": 0.2,
+        //                 "clearCurrency": "USDT",
+        //                 "symbolName": "BTCUSDT",
+        //                 "defaultLeverage": 20.0,
+        //                 "minOrderCost": "5.0"
+        //             },
+        //         ],
+        //         "error_code": 0,
+        //         "msg": "Success",
+        //         "result": "true",
+        //         "success": true
+        //     }
+        //
+        const data = this.safeValue(response, 'data', []);
+        const result = [];
+        for (let i = 0; i < data.length; i++) {
+            const market = data[i];
+            const marketId = this.safeString(market, 'symbol');
+            const baseId = this.safeString(market, 'baseCurrency');
+            const settleId = this.safeString(market, 'clearCurrency');
+            const quoteId = settleId;
+            const base = this.safeCurrencyCode(baseId);
+            const quote = this.safeCurrencyCode(quoteId);
+            const settle = this.safeCurrencyCode(settleId);
+            const symbol = base + '/' + quote + ':' + settle;
+            result.push({
+                'id': marketId,
+                'symbol': symbol,
+                'base': base,
+                'quote': quote,
+                'settle': settle,
+                'baseId': baseId,
+                'quoteId': quoteId,
+                'settleId': settleId,
+                'type': 'swap',
+                'spot': false,
+                'margin': false,
+                'swap': true,
+                'future': false,
+                'option': false,
+                'active': true,
+                'contract': true,
+                'linear': true,
+                'inverse': undefined,
+                'contractSize': this.safeNumber(market, 'volumeMultiple'),
+                'expiry': undefined,
+                'expiryDatetime': undefined,
+                'strike': undefined,
+                'optionType': undefined,
+                'precision': {
+                    'amount': this.safeNumber(market, 'volumeTick'),
+                    'price': this.safeNumber(market, 'priceTick'),
+                },
+                'limits': {
+                    'leverage': {
+                        'min': undefined,
+                        'max': undefined,
+                    },
+                    'amount': {
+                        'min': this.safeNumber(market, 'minOrderVolume'),
+                        'max': this.safeNumber(market, 'maxOrderVolume'),
+                    },
+                    'price': {
+                        'min': this.safeNumber(market, 'priceLimitLowerValue'),
+                        'max': this.safeNumber(market, 'priceLimitUpperValue'),
+                    },
+                    'cost': {
+                        'min': this.safeNumber(market, 'minOrderCost'),
+                        'max': undefined,
+                    },
+                },
+                'created': undefined,
+                'info': market,
             });
         }
         return result;
     }
     parseTicker(ticker, market = undefined) {
+        //
+        // spot: fetchTicker, fetchTickers
         //
         //     {
-        //         "symbol":"btc_usdt",
-        //         "ticker":{
-        //             "high":43416.06,
-        //             "vol":7031.7427,
-        //             "low":41804.26,
-        //             "change":1.33,
-        //             "turnover":300302447.81,
-        //             "latest":43220.4
+        //         "symbol": "btc_usdt",
+        //         "ticker": {
+        //             "high": "29695.57",
+        //             "vol": "6890.2789",
+        //             "low": "29110",
+        //             "change": "0.58",
+        //             "turnover": "202769821.06",
+        //             "latest": "29405.98"
         //         },
-        //         "timestamp":1642201617747
+        //         "timestamp": :1692064274908
+        //     }
+        //
+        // swap: fetchTickers
+        //
+        //     {
+        //         "prePositionFeeRate": "0.000053",
+        //         "volume": "2435.459",
+        //         "symbol": "BTCUSDT",
+        //         "highestPrice": "29446.5",
+        //         "lowestPrice": "29362.9",
+        //         "openPrice": "29419.5",
+        //         "markedPrice": "29385.1",
+        //         "turnover": "36345526.2438402",
+        //         "lastPrice": "29387.0"
         //     }
         //
-        const marketId = this.safeString(ticker, 'symbol');
-        market = this.safeMarket(marketId, market, '_');
-        const symbol = market['symbol'];
         const timestamp = this.safeInteger(ticker, 'timestamp');
-        const info = ticker;
-        ticker = info['ticker'];
-        const last = this.safeString(ticker, 'latest');
-        const percentage = this.safeString(ticker, 'change');
+        const marketId = this.safeString(ticker, 'symbol');
+        const symbol = this.safeSymbol(marketId, market);
+        const tickerData = this.safeValue(ticker, 'ticker', {});
+        market = this.safeMarket(marketId, market);
+        const data = (market['contract']) ? ticker : tickerData;
         return this.safeTicker({
             'symbol': symbol,
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
-            'high': this.safeString(ticker, 'high'),
-            'low': this.safeString(ticker, 'low'),
+            'high': this.safeString2(data, 'high', 'highestPrice'),
+            'low': this.safeString2(data, 'low', 'lowestPrice'),
             'bid': undefined,
             'bidVolume': undefined,
             'ask': undefined,
             'askVolume': undefined,
             'vwap': undefined,
-            'open': undefined,
-            'close': last,
-            'last': last,
+            'open': this.safeString(data, 'openPrice'),
+            'close': undefined,
+            'last': this.safeString2(data, 'latest', 'lastPrice'),
             'previousClose': undefined,
             'change': undefined,
-            'percentage': percentage,
+            'percentage': this.safeString(data, 'change'),
             'average': undefined,
-            'baseVolume': this.safeString(ticker, 'vol'),
-            'quoteVolume': this.safeString(ticker, 'turnover'),
-            'info': info,
+            'baseVolume': this.safeString2(data, 'vol', 'volume'),
+            'quoteVolume': this.safeString(data, 'turnover'),
+            'info': ticker,
         }, market);
     }
     async fetchTicker(symbol, params = {}) {
         /**
          * @method
-         * @name lbank#fetchTicker
+         * @name lbank2#fetchTicker
          * @description fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+         * @see https://www.lbank.info/en-US/docs/index.html#query-current-market-data-new
          * @param {string} symbol unified symbol of the market to fetch the ticker for
-         * @param {object} [params] extra parameters specific to the lbank api endpoint
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
          * @returns {object} a [ticker structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#ticker-structure}
          */
         await this.loadMarkets();
         const market = this.market(symbol);
+        if (market['swap']) {
+            const responseForSwap = await this.fetchTickers([market['symbol']], params);
+            return this.safeValue(responseForSwap, market['symbol']);
+        }
         const request = {
             'symbol': market['id'],
         };
-        const response = await this.publicGetTicker(this.extend(request, params));
-        // {
-        //     "symbol":"btc_usdt",
-        //     "ticker":{
-        //         "high":43416.06,
-        //         "vol":7031.7427,
-        //         "low":41804.26,
-        //         "change":1.33,
-        //         "turnover":300302447.81,
-        //         "latest":43220.4
-        //         },
-        //     "timestamp":1642201617747
-        // }
-        return this.parseTicker(response, market);
+        const response = await this.spotPublicGetTicker24hr(this.extend(request, params));
+        //
+        //     {
+        //         "result": "true",
+        //         "data": [
+        //             {
+        //                 "symbol": "btc_usdt",
+        //                 "ticker": {
+        //                     "high": "29695.57",
+        //                     "vol": "6890.2789",
+        //                     "low": "29110",
+        //                     "change": "0.58",
+        //                     "turnover": "202769821.06",
+        //                     "latest": "29405.98"
+        //                 },
+        //                 "timestamp": :1692064274908
+        //             }
+        //         ],
+        //         "error_code": 0,
+        //         "ts": :1692064276872
+        //     }
+        //
+        const data = this.safeValue(response, 'data', []);
+        const first = this.safeValue(data, 0, {});
+        return this.parseTicker(first, market);
     }
     async fetchTickers(symbols = undefined, params = {}) {
         /**
          * @method
-         * @name lbank#fetchTickers
+         * @name lbank2#fetchTickers
          * @description fetches price tickers for multiple markets, statistical calculations with the information calculated over the past 24 hours each market
+         * @see https://www.lbank.info/en-US/docs/index.html#query-current-market-data-new
+         * @see https://www.lbank.com/en-US/docs/contract.html#query-contract-market-list
          * @param {string[]|undefined} symbols unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
          * @param {object} [params] extra parameters specific to the lbank api endpoint
          * @returns {object} a dictionary of [ticker structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#ticker-structure}
          */
         await this.loadMarkets();
-        symbols = this.marketSymbols(symbols);
-        const request = {
-            'symbol': 'all',
-        };
-        const response = await this.publicGetTicker(this.extend(request, params));
-        const result = {};
-        for (let i = 0; i < response.length; i++) {
-            const ticker = this.parseTicker(response[i]);
-            const symbol = ticker['symbol'];
-            result[symbol] = ticker;
+        let market = undefined;
+        if (symbols !== undefined) {
+            symbols = this.marketSymbols(symbols);
+            const symbolsLength = symbols.length;
+            if (symbolsLength > 0) {
+                market = this.market(symbols[0]);
+            }
+        }
+        const request = {};
+        let type = undefined;
+        [type, params] = this.handleMarketTypeAndParams('fetchTickers', market, params);
+        let response = undefined;
+        if (type === 'swap') {
+            request['productGroup'] = 'SwapU';
+            response = await this.contractPublicGetCfdOpenApiV1PubMarketData(this.extend(request, params));
+        }
+        else {
+            request['symbol'] = 'all';
+            response = await this.spotPublicGetTicker24hr(this.extend(request, params));
         }
-        return this.filterByArrayTickers(result, 'symbol', symbols);
+        //
+        // spot
+        //
+        //     {
+        //         "result": "true",
+        //         "data": [
+        //             {
+        //                 "symbol": "btc_usdt",
+        //                 "ticker": {
+        //                     "high": "29695.57",
+        //                     "vol": "6890.2789",
+        //                     "low": "29110",
+        //                     "change": "0.58",
+        //                     "turnover": "202769821.06",
+        //                     "latest": "29405.98"
+        //                 },
+        //                 "timestamp": :1692064274908
+        //             }
+        //         ],
+        //         "error_code": 0,
+        //         "ts": :1692064276872
+        //     }
+        //
+        // swap
+        //
+        //     {
+        //         "data": [
+        //             {
+        //                 "prePositionFeeRate": "0.000053",
+        //                 "volume": "2435.459",
+        //                 "symbol": "BTCUSDT",
+        //                 "highestPrice": "29446.5",
+        //                 "lowestPrice": "29362.9",
+        //                 "openPrice": "29419.5",
+        //                 "markedPrice": "29385.1",
+        //                 "turnover": "36345526.2438402",
+        //                 "lastPrice": "29387.0"
+        //             },
+        //         ],
+        //         "error_code": 0,
+        //         "msg": "Success",
+        //         "result": "true",
+        //         "success": true
+        //     }
+        //
+        const data = this.safeValue(response, 'data', []);
+        return this.parseTickers(data, symbols);
     }
-    async fetchOrderBook(symbol, limit = 60, params = {}) {
+    async fetchOrderBook(symbol, limit = undefined, params = {}) {
         /**
          * @method
-         * @name lbank#fetchOrderBook
+         * @name lbank2#fetchOrderBook
          * @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+         * @see https://www.lbank.info/en-US/docs/index.html#query-market-depth
+         * @see https://www.lbank.com/en-US/docs/contract.html#get-handicap
          * @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 lbank api endpoint
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
          * @returns {object} A dictionary of [order book structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-book-structure} indexed by market symbols
          */
         await this.loadMarkets();
-        let size = 60;
-        if (limit !== undefined) {
-            size = Math.min(limit, size);
-        }
         const market = this.market(symbol);
+        if (limit === undefined) {
+            limit = 60;
+        }
         const request = {
             'symbol': market['id'],
-            'size': size,
         };
-        const response = await this.publicGetDepth(this.extend(request, params));
-        return this.parseOrderBook(response, market['symbol']);
+        let type = undefined;
+        [type, params] = this.handleMarketTypeAndParams('fetchOrderBook', market, params);
+        let response = undefined;
+        if (type === 'swap') {
+            request['depth'] = limit;
+            response = await this.contractPublicGetCfdOpenApiV1PubMarketOrder(this.extend(request, params));
+        }
+        else {
+            request['size'] = limit;
+            response = await this.spotPublicGetDepth(this.extend(request, params));
+        }
+        //
+        // spot
+        //
+        //     {
+        //         "result": "true",
+        //         "data": {
+        //             "asks": [
+        //                 ["29243.37", "2.8783"],
+        //                 ["29243.39", "2.2842"],
+        //                 ["29243.4", "0.0337"]
+        //             ],
+        //             "bids": [
+        //                 ["29243.36", "1.5258"],
+        //                 ["29243.34", "0.8218"],
+        //                 ["29243.28", "1.285"]
+        //             ],
+        //             "timestamp": :1692157328820
+        //         },
+        //         "error_code": 0,
+        //         "ts": :1692157328820
+        //     }
+        //
+        // swap
+        //
+        //     {
+        //         "data": {
+        //             "symbol": "BTCUSDT",
+        //             "asks": [
+        //                 {
+        //                     "volume": "14.6535",
+        //                     "price": "29234.2",
+        //                     "orders": "1"
+        //                 },
+        //             ],
+        //             "bids": [
+        //                 {
+        //                     "volume": "13.4899",
+        //                     "price": "29234.1",
+        //                     "orders": "4"
+        //                 },
+        //             ]
+        //         },
+        //         "error_code": 0,
+        //         "msg": "Success",
+        //         "result": "true",
+        //         "success": true
+        //     }
+        //
+        const orderbook = this.safeValue(response, 'data', {});
+        const timestamp = this.milliseconds();
+        if (market['swap']) {
+            return this.parseOrderBook(orderbook, market['symbol'], timestamp, 'bids', 'asks', 'price', 'volume');
+        }
+        return this.parseOrderBook(orderbook, market['symbol'], timestamp);
     }
     parseTrade(trade, market = undefined) {
-        market = this.safeMarket(undefined, market);
-        const timestamp = this.safeInteger(trade, 'date_ms');
-        const priceString = this.safeString(trade, 'price');
-        const amountString = this.safeString(trade, 'amount');
-        const price = this.parseNumber(priceString);
-        const amount = this.parseNumber(amountString);
-        const cost = this.parseNumber(Precise.stringMul(priceString, amountString));
-        const id = this.safeString(trade, 'tid');
-        const type = undefined;
-        let side = this.safeString(trade, 'type');
-        // remove type additions from i.e. buy_maker, sell_maker, buy_ioc, sell_ioc, buy_fok, sell_fok
-        const splited = side.split('_');
-        side = splited[0];
-        return {
-            'id': id,
-            'info': this.safeValue(trade, 'info', trade),
+        //
+        // fetchTrades (old) spotPublicGetTrades
+        //
+        //      {
+        //          "date_ms":1647021989789,
+        //          "amount":0.0028,
+        //          "price":38804.2,
+        //          "type":"buy",
+        //          "tid":"52d5616ee35c43019edddebe59b3e094"
+        //      }
+        //
+        //
+        // fetchTrades (new) spotPublicGetTradesSupplement
+        //
+        //      {
+        //          "quoteQty":1675.048485,
+        //          "price":0.127545,
+        //          "qty":13133,
+        //          "id":"3589541dc22e4357b227283650f714e2",
+        //          "time":1648058297110,
+        //          "isBuyerMaker":false
+        //      }
+        //
+        // fetchMyTrades (private)
+        //
+        //      {
+        //          "orderUuid":"38b4e7a4-14f6-45fd-aba1-1a37024124a0",
+        //          "tradeFeeRate":0.0010000000,
+        //          "dealTime":1648500944496,
+        //          "dealQuantity":30.00000000000000000000,
+        //          "tradeFee":0.00453300000000000000,
+        //          "txUuid":"11f3850cc6214ea3b495adad3a032794",
+        //          "dealPrice":0.15111300000000000000,
+        //          "dealVolumePrice":4.53339000000000000000,
+        //          "tradeType":"sell_market"
+        //      }
+        //
+        let timestamp = this.safeInteger2(trade, 'date_ms', 'time');
+        if (timestamp === undefined) {
+            timestamp = this.safeInteger(trade, 'dealTime');
+        }
+        let amountString = this.safeString2(trade, 'amount', 'qty');
+        if (amountString === undefined) {
+            amountString = this.safeString(trade, 'dealQuantity');
+        }
+        let priceString = this.safeString(trade, 'price');
+        if (priceString === undefined) {
+            priceString = this.safeString(trade, 'dealPrice');
+        }
+        let costString = this.safeString(trade, 'quoteQty');
+        if (costString === undefined) {
+            costString = this.safeString(trade, 'dealVolumePrice');
+        }
+        let side = this.safeString2(trade, 'tradeType', 'type');
+        let type = undefined;
+        let takerOrMaker = undefined;
+        if (side !== undefined) {
+            const parts = side.split('_');
+            side = this.safeString(parts, 0);
+            const typePart = this.safeString(parts, 1);
+            type = 'limit';
+            takerOrMaker = 'taker';
+            if (typePart !== undefined) {
+                if (typePart === 'market') {
+                    type = 'market';
+                }
+                else if (typePart === 'maker') {
+                    takerOrMaker = 'maker';
+                }
+            }
+        }
+        let id = this.safeString2(trade, 'tid', 'id');
+        if (id === undefined) {
+            id = this.safeString(trade, 'txUuid');
+        }
+        const order = this.safeString(trade, 'orderUuid');
+        const symbol = this.safeSymbol(undefined, market);
+        let fee = undefined;
+        const feeCost = this.safeString(trade, 'tradeFee');
+        if (feeCost !== undefined) {
+            fee = {
+                'cost': feeCost,
+                'currency': (side === 'buy') ? market['base'] : market['quote'],
+                'rate': this.safeString(trade, 'tradeFeeRate'),
+            };
+        }
+        return this.safeTrade({
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
-            'symbol': market['symbol'],
-            'order': undefined,
+            'symbol': symbol,
+            'id': id,
+            'order': order,
             'type': type,
+            'takerOrMaker': takerOrMaker,
             'side': side,
-            'takerOrMaker': undefined,
-            'price': price,
-            'amount': amount,
-            'cost': cost,
-            'fee': undefined,
-        };
+            'price': priceString,
+            'amount': amountString,
+            'cost': costString,
+            'fee': fee,
+            'info': trade,
+        }, market);
     }
     async fetchTrades(symbol, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
-         * @name lbank#fetchTrades
+         * @name lbank2#fetchTrades
          * @description get the list of most recent trades for a particular symbol
+         * @see https://www.lbank.info/en-US/docs/index.html#query-historical-transactions
+         * @see https://www.lbank.info/en-US/docs/index.html#recent-transactions-list
          * @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
-         * @param {object} [params] extra parameters specific to the lbank api endpoint
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
          * @returns {Trade[]} a list of [trade structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#public-trades}
          */
         await this.loadMarkets();
         const market = this.market(symbol);
         const request = {
             'symbol': market['id'],
-            'size': 100,
         };
         if (since !== undefined) {
             request['time'] = since;
@@ -412,19 +925,45 @@ export default class lbank extends Exchange {
         if (limit !== undefined) {
             request['size'] = Math.min(limit, 600);
         }
-        const response = await this.publicGetTrades(this.extend(request, params));
-        return this.parseTrades(response, market, since, limit);
+        else {
+            request['size'] = 600; // max
+        }
+        let method = this.safeString(params, 'method');
+        params = this.omit(params, 'method');
+        if (method === undefined) {
+            const options = this.safeValue(this.options, 'fetchTrades', {});
+            method = this.safeString(options, 'method', 'spotPublicGetTrades');
+        }
+        const response = await this[method](this.extend(request, params));
+        //
+        //      {
+        //          "result":"true",
+        //          "data": [
+        //              {
+        //                  "date_ms":1647021989789,
+        //                  "amount":0.0028,
+        //                  "price":38804.2,
+        //                  "type":"buy",
+        //                  "tid":"52d5616ee35c43019edddebe59b3e094"
+        //               }
+        //           ],
+        //           "error_code":0,
+        //           "ts":1647021999308
+        //      }
+        //
+        const trades = this.safeValue(response, 'data', []);
+        return this.parseTrades(trades, market, since, limit);
     }
     parseOHLCV(ohlcv, market = undefined) {
         //
-        //     [
-        //         1590969600,
-        //         0.02451657,
-        //         0.02452675,
-        //         0.02443701,
-        //         0.02447814,
-        //         238.38210000
-        //     ]
+        //   [
+        //     1482311500, // timestamp
+        //     5423.23,    // open
+        //     5472.80,    // high
+        //     5516.09,    // low
+        //     5462,       // close
+        //     234.3250    // volume
+        //   ],
         //
         return [
             this.safeTimestamp(ohlcv, 0),
@@ -432,25 +971,27 @@ export default class lbank extends Exchange {
             this.safeNumber(ohlcv, 2),
             this.safeNumber(ohlcv, 3),
             this.safeNumber(ohlcv, 4),
-            this.safeNumber(ohlcv, 5),
+            this.safeNumber(ohlcv, 5), // volume
         ];
     }
-    async fetchOHLCV(symbol, timeframe = '1m', since = undefined, limit = 1000, params = {}) {
+    async fetchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
         /**
          * @method
-         * @name lbank#fetchOHLCV
+         * @name lbank2#fetchOHLCV
          * @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+         * @see https://www.lbank.info/en-US/docs/index.html#query-k-bar-data
          * @param {string} symbol unified symbol of the market to fetch OHLCV data for
          * @param {string} timeframe the length of time each candle represents
          * @param {int} [since] timestamp in ms of the earliest candle to fetch
          * @param {int} [limit] the maximum amount of candles to fetch
-         * @param {object} [params] extra parameters specific to the lbank api endpoint
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
          * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
          */
+        // endpoint doesnt work
         await this.loadMarkets();
         const market = this.market(symbol);
         if (limit === undefined) {
-            limit = 100; // it's defined in lbank2
+            limit = 100;
         }
         if (since === undefined) {
             const duration = this.parseTimeframe(timeframe);
@@ -459,428 +1000,1777 @@ export default class lbank extends Exchange {
         const request = {
             'symbol': market['id'],
             'type': this.safeString(this.timeframes, timeframe, timeframe),
-            'size': limit,
             'time': this.parseToInt(since / 1000),
+            'size': limit, // max 2000
         };
-        const response = await this.publicGetKline(this.extend(request, params));
+        const response = await this.spotPublicGetKline(this.extend(request, params));
+        const ohlcvs = this.safeValue(response, 'data', []);
+        //
         //
-        //     [
-        //         [1590969600,0.02451657,0.02452675,0.02443701,0.02447814,238.38210000],
-        //         [1590969660,0.02447814,0.02449883,0.02443209,0.02445973,212.40270000],
-        //         [1590969720,0.02445973,0.02452067,0.02445909,0.02446151,266.16920000],
-        //     ]
+        // [
+        //   [
+        //     1482311500,
+        //     5423.23,
+        //     5472.80,
+        //     5516.09,
+        //     5462,
+        //     234.3250
+        //   ],
+        //   [
+        //     1482311400,
+        //     5432.52,
+        //     5459.87,
+        //     5414.30,
+        //     5428.23,
+        //     213.7329
+        //   ]
+        // ]
         //
-        return this.parseOHLCVs(response, market, timeframe, since, limit);
+        return this.parseOHLCVs(ohlcvs, market, timeframe, since, limit);
     }
     parseBalance(response) {
+        //
+        // spotPrivatePostUserInfo
+        //
+        //      {
+        //          "toBtc": {
+        //              "egc:": "0",
+        //              "iog": "0",
+        //              "ksm": "0",
+        //              },
+        //          "freeze": {
+        //              "egc": "0",
+        //              "iog": "0",
+        //              "ksm": "0" ,
+        //              },
+        //          "asset": {
+        //              "egc": "0",
+        //              "iog": "0",
+        //              "ksm": "0",
+        //              },
+        //          "free": {
+        //              "egc": "0",
+        //              "iog": "0",
+        //              "ksm": "0",
+        //              }
+        //      }
+        //
+        // spotPrivatePostSupplementUserInfoAccount
+        //
+        //      {
+        //          "balances":[
+        //              {
+        //                  "asset":"lbk",
+        //                  "free":"0",
+        //                  "locked":"0"
+        //              }, ...
+        //          ]
+        //      }
+        //
+        // spotPrivatePostSupplementUserInfo
+        //
+        //      [
+        //          {
+        //              "usableAmt":"31.45130723",
+        //              "assetAmt":"31.45130723",
+        //              "networkList":[
+        //                  {
+        //                      "isDefault":true,
+        //                      "withdrawFeeRate":"",
+        //                      "name":"bep20(bsc)",
+        //                      "withdrawMin":30,
+        //                      "minLimit":0.0001,
+        //                      "minDeposit":0.0001,
+        //                      "feeAssetCode":"doge",
+        //                      "withdrawFee":"30",
+        //                      "type":1,
+        //                      "coin":"doge",
+        //                      "network":"bsc"
+        //                  },
+        //                  {
+        //                      "isDefault":false,
+        //                      "withdrawFeeRate":"",
+        //                      "name":"dogecoin",
+        //                      "withdrawMin":10,
+        //                      "minLimit":0.0001,
+        //                      "minDeposit":10,
+        //                      "feeAssetCode":"doge",
+        //                      "withdrawFee":"10",
+        //                      "type":1,
+        //                      "coin":"doge",
+        //                      "network":"dogecoin"
+        //                  }
+        //              ],
+        //              "freezeAmt":"0",
+        //              "coin":"doge"
+        //          }, ...
+        //      ]
+        //
+        const timestamp = this.safeInteger(response, 'ts');
         const result = {
             'info': response,
-            'timestamp': undefined,
-            'datetime': undefined,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
         };
-        const info = this.safeValue(response, 'info', {});
-        const free = this.safeValue(info, 'free', {});
-        const freeze = this.safeValue(info, 'freeze', {});
-        const asset = this.safeValue(info, 'asset', {});
-        const currencyIds = Object.keys(free);
-        for (let i = 0; i < currencyIds.length; i++) {
-            const currencyId = currencyIds[i];
-            const code = this.safeCurrencyCode(currencyId);
-            const account = this.account();
-            account['free'] = this.safeString(free, currencyId);
-            account['used'] = this.safeString(freeze, currencyId);
-            account['total'] = this.safeString(asset, currencyId);
-            result[code] = account;
+        const data = this.safeValue(response, 'data');
+        // from spotPrivatePostUserInfo
+        const toBtc = this.safeValue(data, 'toBtc');
+        if (toBtc !== undefined) {
+            const used = this.safeValue(data, 'freeze', {});
+            const free = this.safeValue(data, 'free', {});
+            const currencies = Object.keys(free);
+            for (let i = 0; i < currencies.length; i++) {
+                const currencyId = currencies[i];
+                const code = this.safeCurrencyCode(currencyId);
+                const account = this.account();
+                account['used'] = this.safeString(used, currencyId);
+                account['free'] = this.safeString(free, currencyId);
+                result[code] = account;
+            }
+            return this.safeBalance(result);
+        }
+        // from spotPrivatePostSupplementUserInfoAccount
+        const balances = this.safeValue(data, 'balances');
+        if (balances !== undefined) {
+            for (let i = 0; i < balances.length; i++) {
+                const item = balances[i];
+                const currencyId = this.safeString(item, 'asset');
+                const codeInner = this.safeCurrencyCode(currencyId);
+                const account = this.account();
+                account['free'] = this.safeString(item, 'free');
+                account['used'] = this.safeString(item, 'locked');
+                result[codeInner] = account;
+            }
+            return this.safeBalance(result);
+        }
+        // from spotPrivatePostSupplementUserInfo
+        const isArray = Array.isArray(data);
+        if (isArray === true) {
+            for (let i = 0; i < data.length; i++) {
+                const item = data[i];
+                const currencyId = this.safeString(item, 'coin');
+                const codeInner = this.safeCurrencyCode(currencyId);
+                const account = this.account();
+                account['free'] = this.safeString(item, 'usableAmt');
+                account['used'] = this.safeString(item, 'freezeAmt');
+                result[codeInner] = account;
+            }
+            return this.safeBalance(result);
         }
-        return this.safeBalance(result);
+        return undefined;
     }
     async fetchBalance(params = {}) {
         /**
          * @method
-         * @name lbank#fetchBalance
+         * @name lbank2#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 lbank api endpoint
+         * @see https://www.lbank.info/en-US/docs/index.html#asset-information
+         * @see https://www.lbank.info/en-US/docs/index.html#account-information
+         * @see https://www.lbank.info/en-US/docs/index.html#get-all-coins-information
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
          * @returns {object} a [balance structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#balance-structure}
          */
         await this.loadMarkets();
-        const response = await this.privatePostUserInfo(params);
+        let method = this.safeString(params, 'method');
+        if (method === undefined) {
+            const options = this.safeValue(this.options, 'fetchBalance', {});
+            method = this.safeString(options, 'method', 'spotPrivatePostSupplementUserInfo');
+        }
+        const response = await this[method]();
         //
-        //     {
-        //         "result":"true",
-        //         "info":{
-        //             "freeze":{
-        //                 "iog":"0.00000000",
-        //                 "ssc":"0.00000000",
-        //                 "eon":"0.00000000",
-        //             },
-        //             "asset":{
-        //                 "iog":"0.00000000",
-        //                 "ssc":"0.00000000",
-        //                 "eon":"0.00000000",
-        //             },
-        //             "free":{
-        //                 "iog":"0.00000000",
-        //                 "ssc":"0.00000000",
-        //                 "eon":"0.00000000",
-        //             },
-        //         }
-        //     }
+        //    {
+        //        "result": "true",
+        //        "data": [
+        //            {
+        //                "usableAmt": "14.36",
+        //                "assetAmt": "14.36",
+        //                "networkList": [
+        //                    {
+        //                        "isDefault": false,
+        //                        "withdrawFeeRate": "",
+        //                        "name": "erc20",
+        //                        "withdrawMin": 30,
+        //                        "minLimit": 0.0001,
+        //                        "minDeposit": 20,
+        //                        "feeAssetCode": "usdt",
+        //                        "withdrawFee": "30",
+        //                        "type": 1,
+        //                        "coin": "usdt",
+        //                        "network": "eth"
+        //                    },
+        //                    ...
+        //                ],
+        //                "freezeAmt": "0",
+        //                "coin": "ada"
+        //            }
+        //        ],
+        //        "code": 0
+        //    }
         //
         return this.parseBalance(response);
     }
-    parseOrderStatus(status) {
-        const statuses = {
-            '-1': 'cancelled',
-            '0': 'open',
-            '1': 'open',
-            '2': 'closed',
-            '4': 'closed', // disposal processing
-        };
-        return this.safeString(statuses, status);
-    }
-    parseOrder(order, market = undefined) {
+    parseTradingFee(fee, market = undefined) {
         //
-        //     {
-        //         "symbol"："eth_btc",
-        //         "amount"：10.000000,
-        //         "create_time"：1484289832081,
-        //         "price"：5000.000000,
-        //         "avg_price"：5277.301200,
-        //         "type"："sell",
-        //         "order_id"："ab704110-af0d-48fd-a083-c218f19a4a55",
-        //         "deal_amount"：10.000000,
-        //         "status"：2
-        //     }
+        //      {
+        //          "symbol":"skt_usdt",
+        //          "makerCommission":"0.10",
+        //          "takerCommission":"0.10"
+        //      }
         //
-        const marketId = this.safeString(order, 'symbol');
-        const symbol = this.safeSymbol(marketId, market, '_');
-        const timestamp = this.safeInteger(order, 'create_time');
-        // Limit Order Request Returns: Order Price
-        // Market Order Returns: cny amount of market order
-        const price = this.safeString(order, 'price');
-        const amount = this.safeString(order, 'amount');
-        const filled = this.safeString(order, 'deal_amount');
-        const average = this.safeString(order, 'avg_price');
-        const status = this.parseOrderStatus(this.safeString(order, 'status'));
-        const id = this.safeString(order, 'order_id');
-        const type = this.safeString(order, 'order_type');
-        const side = this.safeString(order, 'type');
-        return this.safeOrder({
-            'id': id,
-            'clientOrderId': undefined,
-            'datetime': this.iso8601(timestamp),
-            'timestamp': timestamp,
-            'lastTradeTimestamp': undefined,
-            'status': status,
+        const marketId = this.safeString(fee, 'symbol');
+        const symbol = this.safeSymbol(marketId);
+        return {
+            'info': fee,
             'symbol': symbol,
-            'type': type,
-            'timeInForce': undefined,
-            'postOnly': undefined,
-            'side': side,
-            'price': price,
-            'stopPrice': undefined,
-            'triggerPrice': undefined,
-            'cost': undefined,
-            'amount': amount,
-            'filled': filled,
-            'remaining': undefined,
-            'trades': undefined,
-            'fee': undefined,
-            'info': this.safeValue(order, 'info', order),
-            'average': average,
-        }, market);
+            'maker': this.safeNumber(fee, 'makerCommission'),
+            'taker': this.safeNumber(fee, 'takerCommission'),
+        };
     }
-    async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
+    async fetchTradingFee(symbol, params = {}) {
         /**
          * @method
-         * @name lbank#createOrder
-         * @description create a trade order
-         * @param {string} symbol unified symbol of the market to create an order in
-         * @param {string} type 'market' or 'limit'
-         * @param {string} side 'buy' or 'sell'
-         * @param {float} amount how much of currency you want to trade in units of base currency
+         * @name lbank2#fetchTradingFee
+         * @description fetch the trading fees for a market
+         * @see https://www.lbank.info/en-US/docs/index.html#transaction-fee-rate-query
+         * @param {string} symbol unified market symbol
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
+         * @returns {object} a [fee structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#fee-structure}
+         */
+        const market = this.market(symbol);
+        const result = await this.fetchTradingFees(this.extend(params, { 'category': market['id'] }));
+        return result;
+    }
+    async fetchTradingFees(params = {}) {
+        /**
+         * @method
+         * @name lbank2#fetchTradingFees
+         * @description fetch the trading fees for multiple markets
+         * @see https://www.lbank.info/en-US/docs/index.html#transaction-fee-rate-query
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
+         * @returns {object} a dictionary of [fee structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#fee-structure} indexed by market symbols
+         */
+        await this.loadMarkets();
+        const request = {};
+        const response = await this.spotPrivatePostSupplementCustomerTradeFee(this.extend(request, params));
+        const fees = this.safeValue(response, 'data', []);
+        const result = {};
+        for (let i = 0; i < fees.length; i++) {
+            const fee = this.parseTradingFee(fees[i]);
+            const symbol = fee['symbol'];
+            result[symbol] = fee;
+        }
+        return result;
+    }
+    async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
+        /**
+         * @method
+         * @name lbank2#createOrder
+         * @description create a trade order
+         * @see https://www.lbank.info/en-US/docs/index.html#place-order
+         * @see https://www.lbank.info/en-US/docs/index.html#place-an-order
+         * @param {string} symbol unified symbol of the market to create an order in
+         * @param {string} type 'market' or 'limit'
+         * @param {string} side 'buy' or 'sell'
+         * @param {float} amount how much of currency you want to trade in units of base currency
          * @param {float} [price] the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
-         * @param {object} [params] extra parameters specific to the lbank api endpoint
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
          * @returns {object} an [order structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
          */
         await this.loadMarkets();
         const market = this.market(symbol);
-        let order = {
+        const clientOrderId = this.safeString2(params, 'custom_id', 'clientOrderId');
+        const postOnly = this.safeValue(params, 'postOnly', false);
+        const timeInForce = this.safeStringUpper(params, 'timeInForce');
+        params = this.omit(params, ['custom_id', 'clientOrderId', 'timeInForce', 'postOnly']);
+        const request = {
             'symbol': market['id'],
-            'type': side,
-            'amount': amount,
         };
-        if (type === 'market') {
-            order['type'] += '_market';
+        const ioc = (timeInForce === 'IOC');
+        const fok = (timeInForce === 'FOK');
+        const maker = (postOnly || (timeInForce === 'PO'));
+        if ((type === 'market') && (ioc || fok || maker)) {
+            throw new InvalidOrder(this.id + ' createOrder () does not allow market FOK, IOC, or postOnly orders. Only limit IOC, FOK, and postOnly orders are allowed');
         }
-        else {
-            order['price'] = price;
+        if (type === 'limit') {
+            request['type'] = side;
+            request['price'] = this.priceToPrecision(symbol, price);
+            request['amount'] = this.amountToPrecision(symbol, amount);
+            if (ioc) {
+                request['type'] = side + '_' + 'ioc';
+            }
+            else if (fok) {
+                request['type'] = side + '_' + 'fok';
+            }
+            else if (maker) {
+                request['type'] = side + '_' + 'maker';
+            }
+        }
+        else if (type === 'market') {
+            if (side === 'sell') {
+                request['type'] = side + '_' + 'market';
+                request['amount'] = this.amountToPrecision(symbol, amount);
+            }
+            else if (side === 'buy') {
+                request['type'] = side + '_' + 'market';
+                if (this.options['createMarketBuyOrderRequiresPrice']) {
+                    if (price === undefined) {
+                        throw new InvalidOrder(this.id + " createOrder () requires the price argument with market buy orders to calculate total order cost (amount to spend), where cost = amount * price. Supply the price argument to createOrder() call if you want the cost to be calculated for you from price and amount, or, alternatively, add .options['createMarketBuyOrderRequiresPrice'] = false to supply the cost in the amount argument (the exchange-specific behaviour)");
+                    }
+                    else {
+                        const amountString = this.numberToString(amount);
+                        const priceString = this.numberToString(price);
+                        const quoteAmount = Precise.stringMul(amountString, priceString);
+                        const cost = this.parseNumber(quoteAmount);
+                        request['price'] = this.priceToPrecision(symbol, cost);
+                    }
+                }
+                else {
+                    request['price'] = amount;
+                }
+            }
+        }
+        if (clientOrderId !== undefined) {
+            request['custom_id'] = clientOrderId;
         }
-        const response = await this.privatePostCreateOrder(this.extend(order, params));
-        order = this.omit(order, 'type');
-        order['order_id'] = response['order_id'];
-        order['type'] = side;
-        order['order_type'] = type;
-        order['create_time'] = this.milliseconds();
-        order['info'] = response;
-        return this.parseOrder(order, market);
+        let method = undefined;
+        method = this.safeString(params, 'method');
+        params = this.omit(params, 'method');
+        if (method === undefined) {
+            const options = this.safeValue(this.options, 'createOrder', {});
+            method = this.safeString(options, 'method', 'spotPrivatePostSupplementCreateOrder');
+        }
+        const response = await this[method](this.extend(request, params));
+        //
+        //      {
+        //          "result":true,
+        //          "data":{
+        //              "symbol":"doge_usdt",
+        //              "order_id":"0cf8a3de-4597-4296-af45-be7abaa06b07"
+        //              },
+        //          "error_code":0,
+        //          "ts":1648162321043
+        //      }
+        //
+        const result = this.safeValue(response, 'data', {});
+        return this.safeOrder({
+            'id': this.safeString(result, 'order_id'),
+            'info': result,
+        }, market);
     }
-    async cancelOrder(id, symbol = undefined, params = {}) {
+    parseOrderStatus(status) {
+        const statuses = {
+            '-1': 'canceled',
+            '0': 'open',
+            '1': 'open',
+            '2': 'closed',
+            '3': 'canceled',
+            '4': 'closed', // disposal processing
+        };
+        return this.safeString(statuses, status, status);
+    }
+    parseOrder(order, market = undefined) {
+        //
+        // fetchOrderSupplement (private)
+        //
+        //      {
+        //          "cummulativeQuoteQty":0,
+        //          "symbol":"doge_usdt",
+        //          "executedQty":0,
+        //          "orderId":"53d2d53e-70fb-4398-b722-f48571a5f61e",
+        //          "origQty":1E+2,
+        //          "price":0.05,
+        //          "clientOrderId":null,
+        //          "origQuoteOrderQty":5,
+        //          "updateTime":1648163406000,
+        //          "time":1648163139387,
+        //          "type":"buy_maker",
+        //          "status":-1
+        //      }
+        //
+        //
+        // fetchOrderDefault (private)
+        //
+        //      {
+        //          "symbol":"shib_usdt",
+        //          "amount":1,
+        //          "create_time":1649367863356,
+        //          "price":0.0000246103,
+        //          "avg_price":0.00002466180000000104,
+        //          "type":"buy_market",
+        //          "order_id":"abe8b92d-86d9-4d6d-b71e-d14f5fb53ddf",
+        //          "custom_id": "007",                                 // field only present if user creates it at order time
+        //          "deal_amount":40548.54065802,
+        //          "status":2
+        //      }
+        //
+        // fetchOpenOrders (private)
+        //
+        //      {
+        //          "cummulativeQuoteQty":0,
+        //          "symbol":"doge_usdt",
+        //          "executedQty":0,
+        //          "orderId":"73878edf-008d-4e4c-8041-df1f1b2cd8bb",
+        //          "origQty":100,
+        //          "price":0.05,
+        //          "origQuoteOrderQty":5,
+        //          "updateTime":1648501762000,
+        //          "time":1648501762353,
+        //          "type":"buy",
+        //          "status":0
+        //      }
+        //
+        // fetchOrders (private)
+        //
+        //      {
+        //          "cummulativeQuoteQty":0,
+        //          "symbol":"doge_usdt",
+        //          "executedQty":0,
+        //          "orderId":"2cadc7cc-b5f6-486b-a5b4-d6ac49a9c186",
+        //          "origQty":100,
+        //          "price":0.05,
+        //          "origQuoteOrderQty":5,
+        //          "updateTime":1648501384000,
+        //          "time":1648501363889,
+        //          "type":"buy",
+        //          "status":-1
+        //      }
+        //
+        const id = this.safeString2(order, 'orderId', 'order_id');
+        const clientOrderId = this.safeString2(order, 'clientOrderId', 'custom_id');
+        const timestamp = this.safeInteger2(order, 'time', 'create_time');
+        const rawStatus = this.safeString(order, 'status');
+        const marketId = this.safeString(order, 'symbol');
+        market = this.safeMarket(marketId, market);
+        let timeInForce = undefined;
+        let postOnly = false;
+        let type = 'limit';
+        const rawType = this.safeString(order, 'type'); // buy, sell, buy_market, sell_market, buy_maker,sell_maker,buy_ioc,sell_ioc, buy_fok, sell_fok
+        const parts = rawType.split('_');
+        const side = this.safeString(parts, 0);
+        const typePart = this.safeString(parts, 1); // market, maker, ioc, fok or undefined (limit)
+        if (typePart === 'market') {
+            type = 'market';
+        }
+        if (typePart === 'maker') {
+            postOnly = true;
+            timeInForce = 'PO';
+        }
+        if (typePart === 'ioc') {
+            timeInForce = 'IOC';
+        }
+        if (typePart === 'fok') {
+            timeInForce = 'FOK';
+        }
+        const price = this.safeString(order, 'price');
+        const costString = this.safeString(order, 'cummulativeQuoteQty');
+        let amountString = undefined;
+        if (rawType !== 'buy_market') {
+            amountString = this.safeString2(order, 'origQty', 'amount');
+        }
+        const filledString = this.safeString2(order, 'executedQty', 'deal_amount');
+        return this.safeOrder({
+            'id': id,
+            'clientOrderId': clientOrderId,
+            'datetime': this.iso8601(timestamp),
+            'timestamp': timestamp,
+            'lastTradeTimestamp': undefined,
+            'status': this.parseOrderStatus(rawStatus),
+            'symbol': market['symbol'],
+            'type': type,
+            'timeInForce': timeInForce,
+            'postOnly': postOnly,
+            'side': side,
+            'price': price,
+            'stopPrice': undefined,
+            'triggerPrice': undefined,
+            'cost': costString,
+            'amount': amountString,
+            'filled': filledString,
+            'remaining': undefined,
+            'trades': undefined,
+            'fee': undefined,
+            'info': order,
+            'average': undefined,
+        }, market);
+    }
+    async fetchOrder(id, symbol = undefined, params = {}) {
         /**
          * @method
-         * @name lbank#cancelOrder
-         * @description cancels an open order
-         * @param {string} id order id
+         * @name lbank2#fetchOrder
+         * @description fetches information on an order made by the user
+         * @see https://www.lbank.info/en-US/docs/index.html#query-order
+         * @see https://www.lbank.info/en-US/docs/index.html#query-order-new
          * @param {string} symbol unified symbol of the market the order was made in
-         * @param {object} [params] extra parameters specific to the lbank api endpoint
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
          * @returns {object} An [order structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
          */
         await this.loadMarkets();
+        let method = this.safeString(params, 'method');
+        if (method === undefined) {
+            const options = this.safeValue(this.options, 'fetchOrder', {});
+            method = this.safeString(options, 'method', 'fetchOrderSupplement');
+        }
+        if (method === 'fetchOrderSupplement') {
+            return await this.fetchOrderSupplement(id, symbol, params);
+        }
+        return await this.fetchOrderDefault(id, symbol, params);
+    }
+    async fetchOrderSupplement(id, symbol = undefined, params = {}) {
+        this.checkRequiredSymbol('fetchOrder', symbol);
+        await this.loadMarkets();
         const market = this.market(symbol);
         const request = {
             'symbol': market['id'],
-            'order_id': id,
+            'orderId': id,
         };
-        const response = await this.privatePostCancelOrder(this.extend(request, params));
-        return response;
+        const response = await this.spotPrivatePostSupplementOrdersInfo(this.extend(request, params));
+        //
+        //      {
+        //          "result":true,
+        //          "data":{
+        //              "cummulativeQuoteQty":0,
+        //              "symbol":"doge_usdt",
+        //              "executedQty":0,
+        //              "orderId":"53d2d53e-70fb-4398-b722-f48571a5f61e",
+        //              "origQty":1E+2,
+        //              "price":0.05,
+        //              "clientOrderId":null,
+        //              "origQuoteOrderQty":5,
+        //              "updateTime":1648163406000,
+        //              "time":1648163139387,
+        //              "type":"buy_maker",
+        //              "status":-1
+        //              },
+        //          "error_code":0,
+        //          "ts":1648164471827
+        //      }
+        //
+        const result = this.safeValue(response, 'data', {});
+        return this.parseOrder(result);
     }
-    async fetchOrder(id, symbol = undefined, params = {}) {
-        /**
-         * @method
-         * @name lbank#fetchOrder
-         * @description fetches information on an order made by the user
-         * @param {string} symbol unified symbol of the market the order was made in
-         * @param {object} [params] extra parameters specific to the lbank api endpoint
-         * @returns {object} An [order structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
-         */
+    async fetchOrderDefault(id, symbol = undefined, params = {}) {
         // Id can be a list of ids delimited by a comma
+        this.checkRequiredSymbol('fetchOrder', symbol);
         await this.loadMarkets();
         const market = this.market(symbol);
         const request = {
             'symbol': market['id'],
             'order_id': id,
         };
-        const response = await this.privatePostOrdersInfo(this.extend(request, params));
-        const data = this.safeValue(response, 'orders', []);
-        const orders = this.parseOrders(data, market);
-        const numOrders = orders.length;
+        const response = await this.spotPrivatePostOrdersInfo(this.extend(request, params));
+        //
+        //      {
+        //          "result":true,
+        //          "data":[
+        //              {
+        //                  "symbol":"doge_usdt",
+        //                  "amount":18,
+        //                  "create_time":1647455223186,
+        //                  "price":0,
+        //                  "avg_price":0.113344,
+        //                  "type":"sell_market",
+        //                  "order_id":"d4ca1ddd-40d9-42c1-9717-5de435865bec",
+        //                  "deal_amount":18,
+        //                  "status":2
+        //                }
+        //            ],
+        //          "error_code":0,
+        //          "ts":1647455270776
+        //      }
+        //
+        const result = this.safeValue(response, 'data', []);
+        const numOrders = result.length;
         if (numOrders === 1) {
-            return orders[0];
+            return this.parseOrder(result[0]);
         }
         else {
-            throw new BadRequest(this.id + ' fetchOrder() can only return one order at a time. Found ' + numOrders + ' orders.');
+            // const parsedOrders = [];
+            // for (let i = 0; i < numOrders; i++) {
+            //     const parsedOrder = this.parseOrder (result[i]);
+            //     parsedOrders.push (parsedOrder);
+            // }
+            // return parsedOrders;
+            throw new BadRequest(this.id + ' fetchOrder() can only fetch one order at a time');
+        }
+    }
+    async fetchMyTrades(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name lbank2#fetchMyTrades
+         * @description fetch all trades made by the user
+         * @see https://www.lbank.info/en-US/docs/index.html#past-transaction-details
+         * @param {string} symbol unified market symbol
+         * @param {int} [since] the earliest time in ms to fetch trades for
+         * @param {int} [limit] the maximum number of trade structures to retrieve
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
+         * @returns {Trade[]} a list of [trade structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#trade-structure}
+         */
+        this.checkRequiredSymbol('fetchMyTrades', symbol);
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        since = this.safeValue(params, 'start_date', since);
+        params = this.omit(params, 'start_date');
+        const request = {
+            'symbol': market['id'],
+            // 'start_date' Start time yyyy-mm-dd, the maximum is today, the default is yesterday
+            // 'end_date' Finish time yyyy-mm-dd, the maximum is today, the default is today
+            // 'The start': and end date of the query window is up to 2 days
+            // 'from' Initial transaction number inquiring
+            // 'direct' inquire direction,The default is the 'next' which is the positive sequence of dealing time，the 'prev' is inverted order of dealing time
+            // 'size' Query the number of defaults to 100
+        };
+        if (limit !== undefined) {
+            request['size'] = limit;
+        }
+        if (since !== undefined) {
+            request['start_date'] = this.ymd(since, '-'); // max query 2 days ago
+            request['end_date'] = this.ymd(since + 86400000, '-'); // will cover 2 days
         }
+        const response = await this.spotPrivatePostTransactionHistory(this.extend(request, params));
+        //
+        //      {
+        //          "result":true,
+        //          "data":[
+        //              {
+        //                  "orderUuid":"38b4e7a4-14f6-45fd-aba1-1a37024124a0",
+        //                  "tradeFeeRate":0.0010000000,
+        //                  "dealTime":1648500944496,
+        //                  "dealQuantity":30.00000000000000000000,
+        //                  "tradeFee":0.00453300000000000000,
+        //                  "txUuid":"11f3850cc6214ea3b495adad3a032794",
+        //                  "dealPrice":0.15111300000000000000,
+        //                  "dealVolumePrice":4.53339000000000000000,
+        //                  "tradeType":"sell_market"
+        //              }
+        //          ],
+        //          "error_code":0,
+        //          "ts":1648509742164
+        //      }
+        //
+        const trades = this.safeValue(response, 'data', []);
+        return this.parseTrades(trades, market, since, limit);
     }
     async fetchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
-         * @name lbank#fetchOrders
+         * @name lbank2#fetchOrders
          * @description fetches information on multiple orders made by the user
+         * @see https://www.lbank.info/en-US/docs/index.html#query-all-orders
          * @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  orde structures to retrieve
-         * @param {object} [params] extra parameters specific to the lbank api endpoint
+         * @param {int} [limit] the maximum number of order structures to retrieve
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
          * @returns {Order[]} a list of [order structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
          */
+        // default query is for canceled and completely filled orders
+        // does not return open orders unless specified explicitly
+        this.checkRequiredSymbol('fetchOrders', symbol);
         await this.loadMarkets();
+        const market = this.market(symbol);
         if (limit === undefined) {
             limit = 100;
         }
-        const market = this.market(symbol);
         const request = {
             'symbol': market['id'],
             'current_page': 1,
             'page_length': limit,
+            // 'status'  -1: Cancelled, 0: Unfilled, 1: Partially filled, 2: Completely filled, 3: Partially filled and cancelled, 4: Cancellation is being processed
         };
-        const response = await this.privatePostOrdersInfoHistory(this.extend(request, params));
-        const data = this.safeValue(response, 'orders', []);
-        return this.parseOrders(data, undefined, since, limit);
+        const response = await this.spotPrivatePostSupplementOrdersInfoHistory(this.extend(request, params));
+        //
+        //      {
+        //          "result":true,
+        //          "data":{
+        //              "total":1,
+        //              "page_length":100,
+        //              "orders":[
+        //                  {
+        //                      "cummulativeQuoteQty":0,
+        //                      "symbol":"doge_usdt",
+        //                      "executedQty":0,
+        //                      "orderId":"2cadc7cc-b5f6-486b-a5b4-d6ac49a9c186",
+        //                      "origQty":100,
+        //                      "price":0.05,
+        //                      "origQuoteOrderQty":5,
+        //                      "updateTime":1648501384000,
+        //                      "time":1648501363889,
+        //                      "type":"buy",
+        //                      "status":-1
+        //                  }, ...
+        //              ],
+        //              "current_page":1
+        //          },
+        //          "error_code":0,
+        //          "ts":1648505706348
+        //      }
+        //
+        const result = this.safeValue(response, 'data', {});
+        const orders = this.safeValue(result, 'orders', []);
+        return this.parseOrders(orders, market, since, limit);
     }
-    async fetchClosedOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+    async fetchOpenOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
-         * @name lbank#fetchClosedOrders
-         * @description fetches information on multiple closed orders made by the user
-         * @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  orde structures to retrieve
-         * @param {object} [params] extra parameters specific to the lbank api endpoint
+         * @name lbank2#fetchOpenOrders
+         * @description fetch all unfilled currently open orders
+         * @see https://www.lbank.info/en-US/docs/index.html#current-pending-order
+         * @param {string} symbol unified market symbol
+         * @param {int} [since] the earliest time in ms to fetch open orders for
+         * @param {int} [limit] the maximum number of open order structures to retrieve
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
          * @returns {Order[]} a list of [order structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
          */
+        this.checkRequiredSymbol('fetchOpenOrders', symbol);
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        if (limit === undefined) {
+            limit = 100;
+        }
+        const request = {
+            'symbol': market['id'],
+            'current_page': 1,
+            'page_length': limit,
+        };
+        const response = await this.spotPrivatePostSupplementOrdersInfoNoDeal(this.extend(request, params));
+        //
+        //      {
+        //          "result":true,
+        //          "data":{
+        //              "total":1,
+        //              "page_length":100,
+        //              "orders":[
+        //                  {
+        //                      "cummulativeQuoteQty":0,
+        //                      "symbol":"doge_usdt",
+        //                      "executedQty":0,
+        //                      "orderId":"73878edf-008d-4e4c-8041-df1f1b2cd8bb",
+        //                      "origQty":100,
+        //                      "price":0.05,
+        //                      "origQuoteOrderQty":5,
+        //                      "updateTime":1648501762000,
+        //                      "time":1648501762353,
+        //                      "type":"buy",
+        //                      "status":0
+        //                  }, ...
+        //             ],
+        //             "current_page":1
+        //         },
+        //         "error_code":0,
+        //         "ts":1648506110196
+        //     }
+        //
+        const result = this.safeValue(response, 'data', {});
+        const orders = this.safeValue(result, 'orders', []);
+        return this.parseOrders(orders, market, since, limit);
+    }
+    async cancelOrder(id, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name lbank2#cancelOrder
+         * @description cancels an open order
+         * @see https://www.lbank.info/en-US/docs/index.html#cancel-order-new
+         * @param {string} id order id
+         * @param {string} symbol unified symbol of the market the order was made in
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
+         * @returns {object} An [order structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+         */
+        this.checkRequiredSymbol('cancelOrder', symbol);
+        await this.loadMarkets();
+        const clientOrderId = this.safeString2(params, 'origClientOrderId', 'clientOrderId');
+        params = this.omit(params, ['origClientOrderId', 'clientOrderId']);
+        const market = this.market(symbol);
+        const request = {
+            'symbol': market['id'],
+            'orderId': id,
+        };
+        if (clientOrderId !== undefined) {
+            request['origClientOrderId'] = clientOrderId;
+        }
+        const response = await this.spotPrivatePostSupplementCancelOrder(this.extend(request, params));
+        //
+        //   {
+        //      "result":true,
+        //      "data":{
+        //          "executedQty":0.0,
+        //          "price":0.05,
+        //          "origQty":100.0,
+        //          "tradeType":"buy",
+        //          "status":0
+        //          },
+        //      "error_code":0,
+        //      "ts":1648501286196
+        //  }
+        const result = this.safeValue(response, 'data', {});
+        return result;
+    }
+    async cancelAllOrders(symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name lbank2#cancelAllOrders
+         * @description cancel all open orders in a market
+         * @see https://www.lbank.info/en-US/docs/index.html#cancel-all-pending-orders-for-a-single-trading-pair
+         * @param {string} symbol unified market symbol of the market to cancel orders in
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
+         * @returns {object[]} a list of [order structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+         */
+        this.checkRequiredSymbol('cancelAllOrders', symbol);
         await this.loadMarkets();
-        if (symbol !== undefined) {
-            const market = this.market(symbol);
-            symbol = market['symbol'];
+        const market = this.market(symbol);
+        const request = {
+            'symbol': market['id'],
+        };
+        const response = await this.spotPrivatePostSupplementCancelOrderBySymbol(this.extend(request, params));
+        //
+        //      {
+        //          "result":"true",
+        //          "data":[
+        //              {
+        //                  "executedQty":0.00000000000000000000,
+        //                  "orderId":"293ef71b-3e67-4962-af93-aa06990a045f",
+        //                  "price":0.05000000000000000000,
+        //                  "origQty":100.00000000000000000000,
+        //                  "tradeType":"buy",
+        //                  "status":0
+        //              },
+        //          ],
+        //          "error_code":0,
+        //          "ts":1648506641469
+        //      }
+        //
+        const result = this.safeValue(response, 'data', []);
+        return result;
+    }
+    getNetworkCodeForCurrency(currencyCode, params) {
+        const defaultNetworks = this.safeValue(this.options, 'defaultNetworks');
+        const defaultNetwork = this.safeStringUpper(defaultNetworks, currencyCode);
+        const networks = this.safeValue(this.options, 'networks', {});
+        let network = this.safeStringUpper(params, 'network', defaultNetwork); // this line allows the user to specify either ERC20 or ETH
+        network = this.safeString(networks, network, network); // handle ERC20>ETH alias
+        return network;
+    }
+    async fetchDepositAddress(code, params = {}) {
+        /**
+         * @method
+         * @name lbank2#fetchDepositAddress
+         * @description fetch the deposit address for a currency associated with this account
+         * @see https://www.lbank.info/en-US/docs/index.html#get-deposit-address
+         * @see https://www.lbank.info/en-US/docs/index.html#the-user-obtains-the-deposit-address
+         * @param {string} code unified currency code
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
+         * @returns {object} an [address structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#address-structure}
+         */
+        await this.loadMarkets();
+        let method = this.safeString(params, 'method');
+        params = this.omit(params, 'method');
+        if (method === undefined) {
+            const options = this.safeValue(this.options, 'fetchDepositAddress', {});
+            method = this.safeString(options, 'method', 'fetchDepositAddressDefault');
         }
-        const orders = await this.fetchOrders(symbol, since, limit, params);
-        const closed = this.filterBy(orders, 'status', 'closed');
-        const canceled = this.filterBy(orders, 'status', 'cancelled'); // cancelled orders may be partially filled
-        const allOrders = this.arrayConcat(closed, canceled);
-        return this.filterBySymbolSinceLimit(allOrders, symbol, since, limit);
+        return await this[method](code, params);
+    }
+    async fetchDepositAddressDefault(code, params = {}) {
+        await this.loadMarkets();
+        const currency = this.currency(code);
+        const request = {
+            'assetCode': currency['id'],
+        };
+        const network = this.getNetworkCodeForCurrency(code, params);
+        if (network !== undefined) {
+            request['netWork'] = network; // ... yes, really lol
+            params = this.omit(params, 'network');
+        }
+        const response = await this.spotPrivatePostGetDepositAddress(this.extend(request, params));
+        //
+        //      {
+        //          "result":true,
+        //          "data":{
+        //              "assetCode":"usdt",
+        //              "address":"0xc85689d37ca650bf2f2161364cdedee21eb6ca53",
+        //              "memo":null,
+        //              "netWork":"bep20(bsc)"
+        //              },
+        //          "error_code":0,
+        //          "ts":1648075865103
+        //      }
+        //
+        const result = this.safeValue(response, 'data');
+        const address = this.safeString(result, 'address');
+        const tag = this.safeString(result, 'memo');
+        const networkId = this.safeString(result, 'netWork');
+        const inverseNetworks = this.safeValue(this.options, 'inverse-networks', {});
+        const networkCode = this.safeStringUpper(inverseNetworks, networkId, networkId);
+        return {
+            'currency': code,
+            'address': address,
+            'tag': tag,
+            'network': networkCode,
+            'info': response,
+        };
+    }
+    async fetchDepositAddressSupplement(code, params = {}) {
+        // returns the address for whatever the default network is...
+        await this.loadMarkets();
+        const currency = this.currency(code);
+        const request = {
+            'coin': currency['id'],
+        };
+        const networks = this.safeValue(this.options, 'networks');
+        let network = this.safeStringUpper(params, 'network');
+        network = this.safeString(networks, network, network);
+        if (network !== undefined) {
+            request['networkName'] = network;
+            params = this.omit(params, 'network');
+        }
+        const response = await this.spotPrivatePostSupplementGetDepositAddress(this.extend(request, params));
+        //
+        //      {
+        //          "result":true,
+        //          "data":{
+        //              "address":"TDxtabCC8iQwaxUUrPcE4WL2jArGAfvQ5A",
+        //              "memo":null,
+        //              "coin":"usdt"
+        //              },
+        //          "error_code":0,
+        //          "ts":1648073818880
+        //     }
+        //
+        const result = this.safeValue(response, 'data');
+        const address = this.safeString(result, 'address');
+        const tag = this.safeString(result, 'memo');
+        const inverseNetworks = this.safeValue(this.options, 'inverse-networks', {});
+        const networkCode = this.safeStringUpper(inverseNetworks, network, network);
+        return {
+            'currency': code,
+            'address': address,
+            'tag': tag,
+            'network': networkCode,
+            'info': response,
+        };
     }
     async withdraw(code, amount, address, tag = undefined, params = {}) {
         /**
          * @method
-         * @name lbank#withdraw
+         * @name lbank2#withdraw
          * @description make a withdrawal
+         * @see https://www.lbank.info/en-US/docs/index.html#withdrawal
          * @param {string} code unified currency code
          * @param {float} amount the amount to withdraw
          * @param {string} address the address to withdraw to
          * @param {string} tag
-         * @param {object} [params] extra parameters specific to the lbank api endpoint
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
          * @returns {object} a [transaction structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#transaction-structure}
          */
         [tag, params] = this.handleWithdrawTagAndParams(tag, params);
-        // mark and fee are optional params, mark is a note and must be less than 255 characters
         this.checkAddress(address);
         await this.loadMarkets();
+        const fee = this.safeString(params, 'fee');
+        params = this.omit(params, 'fee');
+        // The relevant coin network fee can be found by calling fetchDepositWithdrawFees (), note: if no network param is supplied then the default network will be used, this can also be found in fetchDepositWithdrawFees ().
+        this.checkRequiredArgument('withdraw', fee, 'fee');
         const currency = this.currency(code);
         const request = {
-            'assetCode': currency['id'],
+            'address': address,
+            'coin': currency['id'],
             'amount': amount,
-            'account': address,
+            'fee': fee, // the correct coin-network fee must be supplied, which can be found by calling fetchDepositWithdrawFees (private)
+            // 'networkName': defaults to the defaultNetwork of the coin which can be found in the /supplement/user_info endpoint
+            // 'memo': memo: memo word of bts and dct
+            // 'mark': Withdrawal Notes
+            // 'name': Remarks of the address. After filling in this parameter, it will be added to the withdrawal address book of the currency.
+            // 'withdrawOrderId': withdrawOrderId
+            // 'type': type=1 is for intra-site transfer
         };
         if (tag !== undefined) {
             request['memo'] = tag;
         }
-        const response = this.privatePostWithdraw(this.extend(request, params));
+        const network = this.safeStringUpper2(params, 'network', 'networkName');
+        params = this.omit(params, ['network', 'networkName']);
+        const networks = this.safeValue(this.options, 'networks');
+        const networkId = this.safeString(networks, network, network);
+        if (networkId !== undefined) {
+            request['networkName'] = networkId;
+        }
+        const response = await this.spotPrivatePostSupplementWithdraw(this.extend(request, params));
         //
-        //     {
-        //         "result": "true",
-        //         "withdrawId": 90082,
-        //         "fee":0.001
-        //     }
+        //      {
+        //          "result":true,
+        //          "data": {
+        //              "fee":10.00000000000000000000,
+        //              "withdrawId":1900376
+        //              },
+        //          "error_code":0,
+        //          "ts":1648992501414
+        //      }
         //
-        return this.parseTransaction(response, currency);
+        const result = this.safeValue(response, 'data', {});
+        return {
+            'info': result,
+            'id': this.safeString(result, 'withdrawId'),
+        };
+    }
+    parseTransactionStatus(status, type) {
+        const statuses = {
+            'deposit': {
+                '1': 'pending',
+                '2': 'ok',
+                '3': 'failed',
+                '4': 'canceled',
+                '5': 'transfer',
+            },
+            'withdrawal': {
+                '1': 'pending',
+                '2': 'canceled',
+                '3': 'failed',
+                '4': 'ok',
+            },
+        };
+        return this.safeString(this.safeValue(statuses, type, {}), status, status);
     }
     parseTransaction(transaction, currency = undefined) {
         //
-        // withdraw
+        // fetchDeposits (private)
+        //
+        //      {
+        //          "insertTime":1649012310000,
+        //          "amount":9.00000000000000000000,
+        //          "address":"TYASr5UV6HEcXatwdFQfmLVUqQQQMUxHLS",
+        //          "networkName":"trc20",
+        //          "txId":"081e4e9351dd0274922168da5f2d14ea6c495b1c3b440244f4a6dd9fe196bf2b",
+        //          "coin":"usdt",
+        //          "status":"2"
+        //      }
         //
-        //     {
-        //         "result": "true",
-        //         "withdrawId": 90082,
-        //         "fee":0.001
-        //     }
         //
-        currency = this.safeCurrency(undefined, currency);
+        // fetchWithdrawals (private)
+        //
+        //      {
+        //          "amount":2.00000000000000000000,
+        //          "address":"TBjrW5JHDyPZjFc5nrRMhRWUDaJmhGhmD6",
+        //          "fee":1.00000000000000000000,
+        //          "networkName":"trc20",
+        //          "coid":"usdt",
+        //          "transferType":"数字资产提现",
+        //          "txId":"47eeee2763ad49b8817524dacfa7d092fb58f8b0ab7e5d25473314df1a793c3d",
+        //          "id":1902194,
+        //          "applyTime":1649014002000,
+        //          "status":"4"
+        //      }
+        //
+        const id = this.safeString(transaction, 'id');
+        let type = undefined;
+        if (id === undefined) {
+            type = 'deposit';
+        }
+        else {
+            type = 'withdrawal';
+        }
+        const txid = this.safeString(transaction, 'txId');
+        const timestamp = this.safeInteger2(transaction, 'insertTime', 'applyTime');
+        const networks = this.safeValue(this.options, 'inverse-networks', {});
+        const networkId = this.safeString(transaction, 'networkName');
+        const network = this.safeString(networks, networkId, networkId);
+        const address = this.safeString(transaction, 'address');
+        let addressFrom = undefined;
+        let addressTo = undefined;
+        if (type === 'deposit') {
+            addressFrom = address;
+        }
+        else {
+            addressTo = address;
+        }
+        const amount = this.safeNumber(transaction, 'amount');
+        const currencyId = this.safeString2(transaction, 'coin', 'coid');
+        const code = this.safeCurrencyCode(currencyId, currency);
+        const status = this.parseTransactionStatus(this.safeString(transaction, 'status'), type);
+        let fee = undefined;
+        const feeCost = this.safeNumber(transaction, 'fee');
+        if (feeCost !== undefined) {
+            fee = {
+                'cost': feeCost,
+                'currency': code,
+            };
+        }
         return {
-            'id': this.safeString2(transaction, 'id', 'withdrawId'),
-            'txid': undefined,
-            'timestamp': undefined,
-            'datetime': undefined,
-            'network': undefined,
-            'addressFrom': undefined,
-            'address': undefined,
-            'addressTo': undefined,
-            'amount': undefined,
-            'type': undefined,
-            'currency': currency['code'],
-            'status': undefined,
-            'updated': undefined,
-            'tagFrom': undefined,
+            'info': transaction,
+            'id': id,
+            'txid': txid,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'network': network,
+            'address': address,
+            'addressTo': addressTo,
+            'addressFrom': addressFrom,
             'tag': undefined,
             'tagTo': undefined,
+            'tagFrom': undefined,
+            'type': type,
+            'amount': amount,
+            'currency': code,
+            'status': status,
+            'updated': undefined,
             'comment': undefined,
-            'internal': undefined,
-            'fee': undefined,
-            'info': transaction,
+            'internal': (status === 'transfer'),
+            'fee': fee,
         };
     }
-    convertSecretToPem(secret) {
-        const lineLength = 64;
-        const secretLength = secret.length - 0;
-        let numLines = this.parseToInt(secretLength / lineLength);
-        numLines = this.sum(numLines, 1);
-        let pem = "-----BEGIN PRIVATE KEY-----\n"; // eslint-disable-line
-        for (let i = 0; i < numLines; i++) {
-            const start = i * lineLength;
-            const end = this.sum(start, lineLength);
-            pem += this.secret.slice(start, end) + "\n"; // eslint-disable-line
+    async fetchDeposits(code = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name lbank2#fetchDeposits
+         * @description fetch all deposits made to an account
+         * @see https://www.lbank.info/en-US/docs/index.html#get-recharge-history
+         * @param {string} code unified currency code
+         * @param {int} [since] the earliest time in ms to fetch deposits for
+         * @param {int} [limit] the maximum number of deposits structures to retrieve
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
+         * @returns {object[]} a list of [transaction structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#transaction-structure}
+         */
+        await this.loadMarkets();
+        const request = {
+        // 'status': Recharge status: ("1","Applying"),("2","Recharge successful"),("3","Recharge failed"),("4","Already Cancel"), ("5", "Transfer")
+        // 'endTime': end time, timestamp in milliseconds, default now
+        };
+        let currency = undefined;
+        if (code !== undefined) {
+            currency = this.currency(code);
+            request['coin'] = currency['id'];
         }
-        return pem + '-----END PRIVATE KEY-----';
+        if (since !== undefined) {
+            request['startTime'] = since;
+        }
+        const response = await this.spotPrivatePostSupplementDepositHistory(this.extend(request, params));
+        //
+        //      {
+        //          "result":true,
+        //          "data": {
+        //              "total":1,
+        //              "depositOrders": [
+        //                  {
+        //                      "insertTime":1649012310000,
+        //                      "amount":9.00000000000000000000,
+        //                      "address":"TYASr5UV6HEcXatwdFQfmLVUqQQQMUxHLS",
+        //                      "networkName":"trc20",
+        //                      "txId":"081e4e9351dd0274922168da5f2d14ea6c495b1c3b440244f4a6dd9fe196bf2b",
+        //                      "coin":"usdt",
+        //                      "status":"2"
+        //                  },
+        //              ],
+        //              "page_length":20,
+        //              "current_page":1
+        //          },
+        //          "error_code":0,
+        //          "ts":1649719721758
+        //      }
+        //
+        const data = this.safeValue(response, 'data', {});
+        const deposits = this.safeValue(data, 'depositOrders', []);
+        return this.parseTransactions(deposits, currency, since, limit);
+    }
+    async fetchWithdrawals(code = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name lbank2#fetchWithdrawals
+         * @description fetch all withdrawals made from an account
+         * @see https://www.lbank.info/en-US/docs/index.html#get-withdrawal-history
+         * @param {string} code unified currency code
+         * @param {int} [since] the earliest time in ms to fetch withdrawals for
+         * @param {int} [limit] the maximum number of withdrawals structures to retrieve
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
+         * @returns {object[]} a list of [transaction structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#transaction-structure}
+         */
+        await this.loadMarkets();
+        const request = {
+        // 'status': Recharge status: ("1","Applying"),("2","Recharge successful"),("3","Recharge failed"),("4","Already Cancel"), ("5", "Transfer")
+        // 'endTime': end time, timestamp in milliseconds, default now
+        // 'withdrawOrderId': Custom withdrawal id
+        };
+        let currency = undefined;
+        if (code !== undefined) {
+            currency = this.currency(code);
+            request['coin'] = currency['id'];
+        }
+        if (since !== undefined) {
+            request['startTime'] = since;
+        }
+        const response = await this.spotPrivatePostSupplementWithdraws(this.extend(request, params));
+        //
+        //      {
+        //          "result":true,
+        //          "data": {
+        //              "total":1,
+        //              "withdraws": [
+        //                  {
+        //                      "amount":2.00000000000000000000,
+        //                      "address":"TBjrW5JHDyPZjFc5nrRMhRWUDaJmhGhmD6",
+        //                      "fee":1.00000000000000000000,
+        //                      "networkName":"trc20",
+        //                      "coid":"usdt",
+        //                      "transferType":"数字资产提现",
+        //                      "txId":"47eeee2763ad49b8817524dacfa7d092fb58f8b0ab7e5d25473314df1a793c3d",
+        //                      "id":1902194,
+        //                      "applyTime":1649014002000,
+        //                      "status":"4"
+        //                  },
+        //              ],
+        //              "page_length":20,
+        //              "current_page":1
+        //          },
+        //          "error_code":0,
+        //          "ts":1649720362362
+        //      }
+        //
+        const data = this.safeValue(response, 'data', {});
+        const withdraws = this.safeValue(data, 'withdraws', []);
+        return this.parseTransactions(withdraws, currency, since, limit);
+    }
+    async fetchTransactionFees(codes = undefined, params = {}) {
+        /**
+         * @method
+         * @name lbank2#fetchTransactionFees
+         * @deprecated
+         * @description please use fetchDepositWithdrawFees instead
+         * @param {string[]|undefined} codes not used by lbank2 fetchTransactionFees ()
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
+         * @returns {object} a list of [fee structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#fee-structure}
+         */
+        // private only returns information for currencies with non-zero balance
+        await this.loadMarkets();
+        const isAuthorized = this.checkRequiredCredentials(false);
+        let result = undefined;
+        if (isAuthorized === true) {
+            let method = this.safeString(params, 'method');
+            params = this.omit(params, 'method');
+            if (method === undefined) {
+                const options = this.safeValue(this.options, 'fetchTransactionFees', {});
+                method = this.safeString(options, 'method', 'fetchPrivateTransactionFees');
+            }
+            result = await this[method](params);
+        }
+        else {
+            result = await this.fetchPublicTransactionFees(params);
+        }
+        return result;
+    }
+    async fetchPrivateTransactionFees(params = {}) {
+        // complete response
+        // incl. for coins which undefined in public method
+        await this.loadMarkets();
+        const response = await this.spotPrivatePostSupplementUserInfo();
+        //
+        //    {
+        //        "result": "true",
+        //        "data": [
+        //            {
+        //                "usableAmt": "14.36",
+        //                "assetAmt": "14.36",
+        //                "networkList": [
+        //                    {
+        //                        "isDefault": false,
+        //                        "withdrawFeeRate": "",
+        //                        "name": "erc20",
+        //                        "withdrawMin": 30,
+        //                        "minLimit": 0.0001,
+        //                        "minDeposit": 20,
+        //                        "feeAssetCode": "usdt",
+        //                        "withdrawFee": "30",
+        //                        "type": 1,
+        //                        "coin": "usdt",
+        //                        "network": "eth"
+        //                    },
+        //                    ...
+        //                ],
+        //                "freezeAmt": "0",
+        //                "coin": "ada"
+        //            }
+        //        ],
+        //        "code": 0
+        //    }
+        //
+        const result = this.safeValue(response, 'data', []);
+        const withdrawFees = {};
+        for (let i = 0; i < result.length; i++) {
+            const entry = result[i];
+            const currencyId = this.safeString(entry, 'coin');
+            const code = this.safeCurrencyCode(currencyId);
+            const networkList = this.safeValue(entry, 'networkList', []);
+            withdrawFees[code] = {};
+            for (let j = 0; j < networkList.length; j++) {
+                const networkEntry = networkList[j];
+                const networkId = this.safeString(networkEntry, 'name');
+                const networkCode = this.safeString(this.options['inverse-networks'], networkId, networkId);
+                const fee = this.safeNumber(networkEntry, 'withdrawFee');
+                if (fee !== undefined) {
+                    withdrawFees[code][networkCode] = fee;
+                }
+            }
+        }
+        return {
+            'withdraw': withdrawFees,
+            'deposit': {},
+            'info': response,
+        };
+    }
+    async fetchPublicTransactionFees(params = {}) {
+        // extremely incomplete response
+        // vast majority fees undefined
+        await this.loadMarkets();
+        const code = this.safeString2(params, 'coin', 'assetCode');
+        params = this.omit(params, ['coin', 'assetCode']);
+        const request = {};
+        if (code !== undefined) {
+            const currency = this.currency(code);
+            request['assetCode'] = currency['id'];
+        }
+        const response = await this.spotPublicGetWithdrawConfigs(this.extend(request, params));
+        //
+        //    {
+        //        "result": "true",
+        //        "data": [
+        //          {
+        //            "amountScale": "4",
+        //            "chain": "heco",
+        //            "assetCode": "lbk",
+        //            "min": "200",
+        //            "transferAmtScale": "4",
+        //            "canWithDraw": true,
+        //            "fee": "100",
+        //            "minTransfer": "0.0001",
+        //            "type": "1"
+        //          },
+        //          ...
+        //        ],
+        //        "error_code": "0",
+        //        "ts": "1663364435973"
+        //    }
+        //
+        const result = this.safeValue(response, 'data', []);
+        const withdrawFees = {};
+        for (let i = 0; i < result.length; i++) {
+            const item = result[i];
+            const canWithdraw = this.safeValue(item, 'canWithDraw');
+            if (canWithdraw === 'true') {
+                const currencyId = this.safeString(item, 'assetCode');
+                const codeInner = this.safeCurrencyCode(currencyId);
+                const chain = this.safeString(item, 'chain');
+                let network = this.safeString(this.options['inverse-networks'], chain, chain);
+                if (network === undefined) {
+                    network = codeInner;
+                }
+                const fee = this.safeString(item, 'fee');
+                if (withdrawFees[codeInner] === undefined) {
+                    withdrawFees[codeInner] = {};
+                }
+                withdrawFees[codeInner][network] = this.parseNumber(fee);
+            }
+        }
+        return {
+            'withdraw': withdrawFees,
+            'deposit': {},
+            'info': response,
+        };
+    }
+    async fetchDepositWithdrawFees(codes = undefined, params = {}) {
+        /**
+         * @method
+         * @name lbank2#fetchDepositWithdrawFees
+         * @description when using private endpoint, only returns information for currencies with non-zero balance, use public method by specifying this.options['fetchDepositWithdrawFees']['method'] = 'fetchPublicDepositWithdrawFees'
+         * @see https://www.lbank.info/en-US/docs/index.html#get-all-coins-information
+         * @see https://www.lbank.info/en-US/docs/index.html#withdrawal-configurations
+         * @param {string[]|undefined} codes array of unified currency codes
+         * @param {object} [params] extra parameters specific to the lbank2 api endpoint
+         * @returns {object} a list of [fee structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#fee-structure}
+         */
+        await this.loadMarkets();
+        const isAuthorized = this.checkRequiredCredentials(false);
+        let method = undefined;
+        if (isAuthorized === true) {
+            method = this.safeString(params, 'method');
+            params = this.omit(params, 'method');
+            if (method === undefined) {
+                const options = this.safeValue(this.options, 'fetchDepositWithdrawFees', {});
+                method = this.safeString(options, 'method', 'fetchPrivateDepositWithdrawFees');
+            }
+        }
+        else {
+            method = 'fetchPublicDepositWithdrawFees';
+        }
+        return await this[method](codes, params);
+    }
+    async fetchPrivateDepositWithdrawFees(codes = undefined, params = {}) {
+        // complete response
+        // incl. for coins which undefined in public method
+        await this.loadMarkets();
+        const response = await this.spotPrivatePostSupplementUserInfo(params);
+        //
+        //    {
+        //        "result": "true",
+        //        "data": [
+        //            {
+        //                "usableAmt": "14.36",
+        //                "assetAmt": "14.36",
+        //                "networkList": [
+        //                    {
+        //                        "isDefault": false,
+        //                        "withdrawFeeRate": "",
+        //                        "name": "erc20",
+        //                        "withdrawMin": 30,
+        //                        "minLimit": 0.0001,
+        //                        "minDeposit": 20,
+        //                        "feeAssetCode": "usdt",
+        //                        "withdrawFee": "30",
+        //                        "type": 1,
+        //                        "coin": "usdt",
+        //                        "network": "eth"
+        //                    },
+        //                    ...
+        //                ],
+        //                "freezeAmt": "0",
+        //                "coin": "ada"
+        //            }
+        //        ],
+        //        "code": 0
+        //    }
+        //
+        const data = this.safeValue(response, 'data', []);
+        return this.parseDepositWithdrawFees(data, codes, 'coin');
+    }
+    async fetchPublicDepositWithdrawFees(codes = undefined, params = {}) {
+        // extremely incomplete response
+        // vast majority fees undefined
+        await this.loadMarkets();
+        const request = {};
+        const response = await this.spotPublicGetWithdrawConfigs(this.extend(request, params));
+        //
+        //    {
+        //        "result": "true",
+        //        "data": [
+        //            {
+        //                "amountScale": "4",
+        //                "chain": "heco",
+        //                "assetCode": "lbk",
+        //                "min": "200",
+        //                "transferAmtScale": "4",
+        //                "canWithDraw": true,
+        //                "fee": "100",
+        //                "minTransfer": "0.0001",
+        //                "type": "1"
+        //            },
+        //            ...
+        //        ],
+        //        "error_code": "0",
+        //        "ts": "1663364435973"
+        //    }
+        //
+        const data = this.safeValue(response, 'data', []);
+        return this.parsePublicDepositWithdrawFees(data, codes);
+    }
+    parsePublicDepositWithdrawFees(response, codes = undefined) {
+        //
+        //    [
+        //        {
+        //            "amountScale": "4",
+        //            "chain": "heco",
+        //            "assetCode": "lbk",
+        //            "min": "200",
+        //            "transferAmtScale": "4",
+        //            "canWithDraw": true,
+        //            "fee": "100",
+        //            "minTransfer": "0.0001",
+        //            "type": "1"
+        //        },
+        //        ...
+        //    ]
+        //
+        const result = {};
+        for (let i = 0; i < response.length; i++) {
+            const fee = response[i];
+            const canWithdraw = this.safeValue(fee, 'canWithDraw');
+            if (canWithdraw === true) {
+                const currencyId = this.safeString(fee, 'assetCode');
+                const code = this.safeCurrencyCode(currencyId);
+                if (codes === undefined || this.inArray(code, codes)) {
+                    const withdrawFee = this.safeNumber(fee, 'fee');
+                    if (withdrawFee !== undefined) {
+                        const resultValue = this.safeValue(result, code);
+                        if (resultValue === undefined) {
+                            result[code] = this.depositWithdrawFee([fee]);
+                        }
+                        else {
+                            result[code]['info'].push(fee);
+                        }
+                        const chain = this.safeString(fee, 'chain');
+                        const networkCode = this.safeString(this.options['inverse-networks'], chain, chain);
+                        if (networkCode !== undefined) {
+                            result[code]['networks'][networkCode] = {
+                                'withdraw': {
+                                    'fee': withdrawFee,
+                                    'percentage': undefined,
+                                },
+                                'deposit': {
+                                    'fee': undefined,
+                                    'percentage': undefined,
+                                },
+                            };
+                        }
+                        else {
+                            result[code]['withdraw'] = {
+                                'fee': withdrawFee,
+                                'percentage': undefined,
+                            };
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    parseDepositWithdrawFee(fee, currency = undefined) {
+        //
+        // * only used for fetchPrivateDepositWithdrawFees
+        //
+        //    {
+        //        "usableAmt": "14.36",
+        //        "assetAmt": "14.36",
+        //        "networkList": [
+        //            {
+        //                "isDefault": false,
+        //                "withdrawFeeRate": "",
+        //                "name": "erc20",
+        //                "withdrawMin": 30,
+        //                "minLimit": 0.0001,
+        //                "minDeposit": 20,
+        //                "feeAssetCode": "usdt",
+        //                "withdrawFee": "30",
+        //                "type": 1,
+        //                "coin": "usdt",
+        //                "network": "eth"
+        //            },
+        //            ...
+        //        ],
+        //        "freezeAmt": "0",
+        //        "coin": "ada"
+        //    }
+        //
+        const result = this.depositWithdrawFee(fee);
+        const networkList = this.safeValue(fee, 'networkList', []);
+        for (let j = 0; j < networkList.length; j++) {
+            const networkEntry = networkList[j];
+            const networkId = this.safeString(networkEntry, 'name');
+            const networkCode = this.safeStringUpper(this.options['inverse-networks'], networkId, networkId);
+            const withdrawFee = this.safeNumber(networkEntry, 'withdrawFee');
+            const isDefault = this.safeValue(networkEntry, 'isDefault');
+            if (withdrawFee !== undefined) {
+                if (isDefault) {
+                    result['withdraw'] = {
+                        'fee': withdrawFee,
+                        'percentage': undefined,
+                    };
+                }
+                result['networks'][networkCode] = {
+                    'withdraw': {
+                        'fee': withdrawFee,
+                        'percentage': undefined,
+                    },
+                    'deposit': {
+                        'fee': undefined,
+                        'percentage': undefined,
+                    },
+                };
+            }
+        }
+        return result;
     }
     sign(path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
         let query = this.omit(params, this.extractParams(path));
         let url = this.urls['api']['rest'] + '/' + this.version + '/' + this.implodeParams(path, params);
-        // Every endpoint ends with ".do"
-        url += '.do';
-        if (api === 'public') {
+        // Every spot endpoint ends with ".do"
+        if (api[0] === 'spot') {
+            url += '.do';
+        }
+        else {
+            url = this.urls['api']['contract'] + '/' + this.implodeParams(path, params);
+        }
+        if (api[1] === 'public') {
             if (Object.keys(query).length) {
-                url += '?' + this.urlencode(query);
+                url += '?' + this.urlencode(this.keysort(query));
             }
         }
         else {
             this.checkRequiredCredentials();
-            query = this.keysort(this.extend({
+            const timestamp = this.milliseconds().toString();
+            const echostr = this.uuid22() + this.uuid16();
+            query = this.extend({
                 'api_key': this.apiKey,
-            }, query));
-            const queryString = this.rawencode(query);
-            const message = this.hash(this.encode(queryString), md5).toUpperCase();
-            const cacheSecretAsPem = this.safeValue(this.options, 'cacheSecretAsPem', true);
-            let pem = undefined;
-            if (cacheSecretAsPem) {
-                pem = this.safeValue(this.options, 'pem');
-                if (pem === undefined) {
-                    pem = this.convertSecretToPem(this.secret);
-                    this.options['pem'] = pem;
-                }
+            }, query);
+            let signatureMethod = undefined;
+            if (this.secret.length > 32) {
+                signatureMethod = 'RSA';
             }
             else {
-                pem = this.convertSecretToPem(this.secret);
+                signatureMethod = 'HmacSHA256';
             }
-            query['sign'] = rsa(message, pem, sha256);
-            body = this.urlencode(query);
-            headers = { 'Content-Type': 'application/x-www-form-urlencoded' };
+            const auth = this.rawencode(this.keysort(this.extend({
+                'echostr': echostr,
+                'signature_method': signatureMethod,
+                'timestamp': timestamp,
+            }, query)));
+            const encoded = this.encode(auth);
+            const hash = this.hash(encoded, md5);
+            const uppercaseHash = hash.toUpperCase();
+            let sign = undefined;
+            if (signatureMethod === 'RSA') {
+                const cacheSecretAsPem = this.safeValue(this.options, 'cacheSecretAsPem', true);
+                let pem = undefined;
+                if (cacheSecretAsPem) {
+                    pem = this.safeValue(this.options, 'pem');
+                    if (pem === undefined) {
+                        pem = this.convertSecretToPem(this.encode(this.secret));
+                        this.options['pem'] = pem;
+                    }
+                }
+                else {
+                    pem = this.convertSecretToPem(this.encode(this.secret));
+                }
+                sign = rsa(uppercaseHash, pem, sha256);
+            }
+            else if (signatureMethod === 'HmacSHA256') {
+                sign = this.hmac(this.encode(uppercaseHash), this.encode(this.secret), sha256);
+            }
+            query['sign'] = sign;
+            body = this.urlencode(this.keysort(query));
+            headers = {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'timestamp': timestamp,
+                'signature_method': signatureMethod,
+                'echostr': echostr,
+            };
         }
         return { 'url': url, 'method': method, 'body': body, 'headers': headers };
     }
+    convertSecretToPem(secret) {
+        const lineLength = 64;
+        const secretLength = secret.length - 0;
+        let numLines = this.parseToInt(secretLength / lineLength);
+        numLines = this.sum(numLines, 1);
+        let pem = "-----BEGIN PRIVATE KEY-----\n"; // eslint-disable-line
+        for (let i = 0; i < numLines; i++) {
+            const start = i * lineLength;
+            const end = this.sum(start, lineLength);
+            pem += this.secret.slice(start, end) + "\n"; // eslint-disable-line
+        }
+        return pem + '-----END PRIVATE KEY-----';
+    }
     handleErrors(httpCode, reason, url, method, headers, body, response, requestHeaders, requestBody) {
         if (response === undefined) {
             return undefined;
         }
-        const success = this.safeString(response, 'result');
-        if (success === 'false') {
+        const success = this.safeValue(response, 'result');
+        if (success === 'false' || !success) {
             const errorCode = this.safeString(response, 'error_code');
             const message = this.safeString({
                 '10000': 'Internal error',
                 '10001': 'The required parameters can not be empty',
-                '10002': 'verification failed',
-                '10003': 'Illegal parameters',
-                '10004': 'User requests are too frequent',
-                '10005': 'Key does not exist',
-                '10006': 'user does not exist',
+                '10002': 'Validation failed',
+                '10003': 'Invalid parameter',
+                '10004': 'Request too frequent',
+                '10005': 'Secret key does not exist',
+                '10006': 'User does not exist',
                 '10007': 'Invalid signature',
-                '10008': 'This currency pair is not supported',
-                '10009': 'Limit orders can not be missing orders and the number of orders',
-                '10010': 'Order price or order quantity must be greater than 0',
-                '10011': 'Market orders can not be missing the amount of the order',
-                '10012': 'market sell orders can not be missing orders',
-                '10013': 'is less than the minimum trading position 0.001',
-                '10014': 'Account number is not enough',
-                '10015': 'The order type is wrong',
-                '10016': 'Account balance is not enough',
-                '10017': 'Abnormal server',
-                '10018': 'order inquiry can not be more than 50 less than one',
-                '10019': 'withdrawal orders can not be more than 3 less than one',
-                '10020': 'less than the minimum amount of the transaction limit of 0.001',
-                '10022': 'Insufficient key authority',
+                '10008': 'Invalid Trading Pair',
+                '10009': 'Price and/or Amount are required for limit order',
+                '10010': 'Price and/or Amount must be less than minimum requirement',
+                // '10011': 'Market orders can not be missing the amount of the order',
+                // '10012': 'market sell orders can not be missing orders',
+                '10013': 'The amount is too small',
+                '10014': 'Insufficient amount of money in the account',
+                '10015': 'Invalid order type',
+                '10016': 'Insufficient account balance',
+                '10017': 'Server Error',
+                '10018': 'Page size should be between 1 and 50',
+                '10019': 'Cancel NO more than 3 orders in one request',
+                '10020': 'Volume < 0.001',
+                '10021': 'Price < 0.01',
+                '10022': 'Invalid authorization',
+                '10023': 'Market Order is not supported yet',
+                '10024': 'User cannot trade on this pair',
+                '10025': 'Order has been filled',
+                '10026': 'Order has been cancelld',
+                '10027': 'Order is cancelling',
+                '10028': 'Wrong query time',
+                '10029': 'from is not in the query time',
+                '10030': 'from do not match the transaction type of inqury',
+                '10031': 'echostr length must be valid and length must be from 30 to 40',
+                '10033': 'Failed to create order',
+                '10036': 'customID duplicated',
+                '10100': 'Has no privilege to withdraw',
+                '10101': 'Invalid fee rate to withdraw',
+                '10102': 'Too little to withdraw',
+                '10103': 'Exceed daily limitation of withdraw',
+                '10104': 'Cancel was rejected',
+                '10105': 'Request has been cancelled',
+                '10106': 'None trade time',
+                '10107': 'Start price exception',
+                '10108': 'can not create order',
+                '10109': 'wallet address is not mapping',
+                '10110': 'transfer fee is not mapping',
+                '10111': 'mount > 0',
+                '10112': 'fee is too lower',
+                '10113': 'transfer fee is 0',
+                '10600': 'intercepted by replay attacks filter, check timestamp',
+                '10601': 'Interface closed unavailable',
+                '10701': 'invalid asset code',
+                '10702': 'not allowed deposit',
             }, errorCode, this.json(response));
             const ErrorClass = this.safeValue({
+                '10001': BadRequest,
                 '10002': AuthenticationError,
-                '10004': DDoSProtection,
+                '10003': BadRequest,
+                '10004': RateLimitExceeded,
                 '10005': AuthenticationError,
                 '10006': AuthenticationError,
                 '10007': AuthenticationError,
+                '10008': BadSymbol,
                 '10009': InvalidOrder,
                 '10010': InvalidOrder,
-                '10011': InvalidOrder,
-                '10012': InvalidOrder,
                 '10013': InvalidOrder,
-                '10014': InvalidOrder,
+                '10014': InsufficientFunds,
                 '10015': InvalidOrder,
-                '10016': InvalidOrder,
-                '10022': AuthenticationError,
+                '10016': InsufficientFunds,
+                '10017': ExchangeError,
+                '10018': BadRequest,
+                '10019': BadRequest,
+                '10020': BadRequest,
+                '10021': InvalidOrder,
+                '10022': PermissionDenied,
+                '10023': InvalidOrder,
+                '10024': PermissionDenied,
+                '10025': InvalidOrder,
+                '10026': InvalidOrder,
+                '10027': InvalidOrder,
+                '10028': BadRequest,
+                '10029': BadRequest,
+                '10030': BadRequest,
+                '10031': InvalidNonce,
+                '10033': ExchangeError,
+                '10036': DuplicateOrderId,
+                '10100': PermissionDenied,
+                '10101': BadRequest,
+                '10102': InsufficientFunds,
+                '10103': ExchangeError,
+                '10104': ExchangeError,
+                '10105': ExchangeError,
+                '10106': BadRequest,
+                '10107': BadRequest,
+                '10108': ExchangeError,
+                '10109': InvalidAddress,
+                '10110': ExchangeError,
+                '10111': BadRequest,
+                '10112': BadRequest,
+                '10113': BadRequest,
+                '10600': BadRequest,
+                '10601': ExchangeError,
+                '10701': BadSymbol,
+                '10702': PermissionDenied, // 'not allowed deposit',
             }, errorCode, ExchangeError);
             throw new ErrorClass(message);
         }