ccxt 4.2.68__py2.py3-none-any.whl → 4.2.70__py2.py3-none-any.whl

ccxt/async_support/htx.py

@@ -486,6 +486,7 @@ class htx(Exchange, ImplicitAPI):
                             'v2/sub-user/api-key-modification': 1,
                             'v2/sub-user/api-key-deletion': 1,
                             'v1/subuser/transfer': 10,
+                            'v1/trust/user/active/credit': 10,
                             # Trading
                             'v1/order/orders/place': 0.2,
                             'v1/order/batch-orders': 0.4,

ccxt/async_support/kucoin.py

@@ -429,6 +429,7 @@ class kucoin(Exchange, ImplicitAPI):
                 '12h': '12hour',
                 '1d': '1day',
                 '1w': '1week',
+                '1M': '1month',
             },
             'precisionMode': TICK_SIZE,
             'exceptions': {
@@ -4183,7 +4184,7 @@ class kucoin(Exchange, ImplicitAPI):
         url = url + endpoint
         isFuturePrivate = (api == 'futuresPrivate')
         isPrivate = (api == 'private')
-        isBroker = (api == 'private')
+        isBroker = (api == 'broker')
         if isPrivate or isFuturePrivate or isBroker:
             self.check_required_credentials()
             timestamp = str(self.nonce())
@@ -4212,7 +4213,8 @@ class kucoin(Exchange, ImplicitAPI):
                 headers['KC-API-PARTNER'] = partnerId
             if isBroker:
                 brokerName = self.safe_string(partner, 'name')
-                headers['KC-BROKER-NAME'] = brokerName
+                if brokerName is not None:
+                    headers['KC-BROKER-NAME'] = brokerName
         return {'url': url, 'method': method, 'body': body, 'headers': headers}
 
     def handle_errors(self, code, reason, url, method, headers, body, response, requestHeaders, requestBody):

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.2.68'
+__version__ = '4.2.70'
 
 # -----------------------------------------------------------------------------
 

ccxt/bitstamp.py

@@ -6,7 +6,7 @@
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.bitstamp import ImplicitAPI
 import hashlib
-from ccxt.base.types import Balances, Currency, Int, Market, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Balances, Currency, Int, Market, Order, TransferEntry, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied
@@ -98,6 +98,7 @@ class bitstamp(Exchange, ImplicitAPI):
                 'setLeverage': False,
                 'setMarginMode': False,
                 'setPositionMode': False,
+                'transfer': True,
                 'withdraw': True,
             },
             'urls': {
@@ -1983,6 +1984,68 @@ class bitstamp(Exchange, ImplicitAPI):
         response = getattr(self, method)(self.extend(request, params))
         return self.parse_transaction(response, currency)
 
+    def transfer(self, code: str, amount: float, fromAccount: str, toAccount: str, params={}) -> TransferEntry:
+        """
+        transfer currency internally between wallets on the same account
+        :see: https://www.bitstamp.net/api/#tag/Sub-account/operation/TransferFromMainToSub
+        :see: https://www.bitstamp.net/api/#tag/Sub-account/operation/TransferFromSubToMain
+        :param str code: unified currency code
+        :param float amount: amount to transfer
+        :param str fromAccount: account to transfer from
+        :param str toAccount: account to transfer to
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `transfer structure <https://docs.ccxt.com/#/?id=transfer-structure>`
+        """
+        self.load_markets()
+        currency = self.currency(code)
+        amount = self.currency_to_precision(code, amount)
+        amount = self.parse_to_numeric(amount)
+        request = {
+            'amount': amount,
+            'currency': currency['id'].upper(),
+        }
+        response = None
+        if fromAccount == 'main':
+            request['subAccount'] = toAccount
+            response = self.privatePostTransferFromMain(self.extend(request, params))
+        elif toAccount == 'main':
+            request['subAccount'] = fromAccount
+            response = self.privatePostTransferToMain(self.extend(request, params))
+        else:
+            raise BadRequest(self.id + ' transfer() only supports from or to main')
+        #
+        #    {status: 'ok'}
+        #
+        transfer = self.parse_transfer(response, currency)
+        transfer['amount'] = amount
+        transfer['fromAccount'] = fromAccount
+        transfer['toAccount'] = toAccount
+        return transfer
+
+    def parse_transfer(self, transfer, currency=None):
+        #
+        #    {status: 'ok'}
+        #
+        status = self.safe_string(transfer, 'status')
+        return {
+            'info': transfer,
+            'id': None,
+            'timestamp': None,
+            'datetime': None,
+            'currency': currency['code'],
+            'amount': None,
+            'fromAccount': None,
+            'toAccount': None,
+            'status': self.parse_transfer_status(status),
+        }
+
+    def parse_transfer_status(self, status):
+        statuses = {
+            'ok': 'ok',
+            'error': 'failed',
+        }
+        return self.safe_string(statuses, status, status)
+
     def nonce(self):
         return self.milliseconds()
 

ccxt/gate.py

@@ -6,7 +6,7 @@
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.gate import ImplicitAPI
 import hashlib
-from ccxt.base.types import Balances, Currency, Greeks, Int, Market, Order, TransferEntry, OrderBook, OrderRequest, OrderSide, OrderType, FundingHistory, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Balances, Currency, Greeks, Int, Leverage, Leverages, Market, Order, TransferEntry, OrderBook, OrderRequest, OrderSide, OrderType, FundingHistory, Str, Strings, Ticker, Tickers, Trade, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied
@@ -133,7 +133,8 @@ class gate(Exchange, ImplicitAPI):
                 'fetchIsolatedBorrowRate': False,
                 'fetchIsolatedBorrowRates': False,
                 'fetchLedger': True,
-                'fetchLeverage': False,
+                'fetchLeverage': True,
+                'fetchLeverages': True,
                 'fetchLeverageTiers': True,
                 'fetchLiquidations': True,
                 'fetchMarginMode': False,
@@ -4198,7 +4199,9 @@ class gate(Exchange, ImplicitAPI):
         lastTradeTimestamp = self.safe_integer(order, 'update_time_ms')
         if lastTradeTimestamp is None:
             lastTradeTimestamp = self.safe_timestamp_2(order, 'update_time', 'finish_time')
-        marketType = 'spot' if ('currency_pair' in order) else 'contract'
+        marketType = 'contract'
+        if ('currency_pair' in order) or ('market' in order):
+            marketType = 'spot'
         exchangeSymbol = self.safe_string_2(order, 'currency_pair', 'market', contract)
         symbol = self.safe_symbol(exchangeSymbol, market, '_', marketType)
         # Everything below self(above return) is related to fees
@@ -6514,6 +6517,166 @@ class gate(Exchange, ImplicitAPI):
             side = ''  # side is not used but needs to be present, otherwise crashes in php
         return self.create_order(symbol, 'market', side, 0, None, params)
 
+    def fetch_leverage(self, symbol: str, params={}) -> Leverage:
+        """
+        fetch the set leverage for a market
+        :see: https://www.gate.io/docs/developers/apiv4/en/#get-unified-account-information
+        :see: https://www.gate.io/docs/developers/apiv4/en/#get-detail-of-lending-market
+        :see: https://www.gate.io/docs/developers/apiv4/en/#query-one-single-margin-currency-pair-deprecated
+        :param str symbol: unified market symbol
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param boolean [params.unified]: default False, set to True for fetching the unified accounts leverage
+        :returns dict: a `leverage structure <https://docs.ccxt.com/#/?id=leverage-structure>`
+        """
+        self.load_markets()
+        market = None
+        if symbol is not None:
+            # unified account does not require a symbol
+            market = self.market(symbol)
+        request = {}
+        response = None
+        isUnified = self.safe_bool(params, 'unified')
+        params = self.omit(params, 'unified')
+        if market['spot']:
+            request['currency_pair'] = market['id']
+            if isUnified:
+                response = self.publicMarginGetUniCurrencyPairsCurrencyPair(self.extend(request, params))
+                #
+                #     {
+                #         "currency_pair": "BTC_USDT",
+                #         "base_min_borrow_amount": "0.0001",
+                #         "quote_min_borrow_amount": "1",
+                #         "leverage": "10"
+                #     }
+                #
+            else:
+                response = self.publicMarginGetCurrencyPairsCurrencyPair(self.extend(request, params))
+                #
+                #     {
+                #         "id": "BTC_USDT",
+                #         "base": "BTC",
+                #         "quote": "USDT",
+                #         "leverage": 10,
+                #         "min_base_amount": "0.0001",
+                #         "min_quote_amount": "1",
+                #         "max_quote_amount": "40000000",
+                #         "status": 1
+                #     }
+                #
+        elif isUnified:
+            response = self.privateUnifiedGetAccounts(self.extend(request, params))
+            #
+            #     {
+            #         "user_id": 10001,
+            #         "locked": False,
+            #         "balances": {
+            #             "ETH": {
+            #                 "available": "0",
+            #                 "freeze": "0",
+            #                 "borrowed": "0.075393666654",
+            #                 "negative_liab": "0",
+            #                 "futures_pos_liab": "0",
+            #                 "equity": "1016.1",
+            #                 "total_freeze": "0",
+            #                 "total_liab": "0"
+            #             },
+            #             "POINT": {
+            #                 "available": "9999999999.017023138734",
+            #                 "freeze": "0",
+            #                 "borrowed": "0",
+            #                 "negative_liab": "0",
+            #                 "futures_pos_liab": "0",
+            #                 "equity": "12016.1",
+            #                 "total_freeze": "0",
+            #                 "total_liab": "0"
+            #             },
+            #             "USDT": {
+            #                 "available": "0.00000062023",
+            #                 "freeze": "0",
+            #                 "borrowed": "0",
+            #                 "negative_liab": "0",
+            #                 "futures_pos_liab": "0",
+            #                 "equity": "16.1",
+            #                 "total_freeze": "0",
+            #                 "total_liab": "0"
+            #             }
+            #         },
+            #         "total": "230.94621713",
+            #         "borrowed": "161.66395521",
+            #         "total_initial_margin": "1025.0524665088",
+            #         "total_margin_balance": "3382495.944473949183",
+            #         "total_maintenance_margin": "205.01049330176",
+            #         "total_initial_margin_rate": "3299.827135672679",
+            #         "total_maintenance_margin_rate": "16499.135678363399",
+            #         "total_available_margin": "3381470.892007440383",
+            #         "unified_account_total": "3381470.892007440383",
+            #         "unified_account_total_liab": "0",
+            #         "unified_account_total_equity": "100016.1",
+            #         "leverage": "2"
+            #     }
+            #
+        else:
+            raise NotSupported(self.id + ' fetchLeverage() does not support ' + market['type'] + ' markets')
+        return self.parse_leverage(response, market)
+
+    def fetch_leverages(self, symbols: List[str] = None, params={}) -> Leverages:
+        """
+        fetch the set leverage for all leverage markets, only spot margin is supported on gate
+        :see: https://www.gate.io/docs/developers/apiv4/en/#list-lending-markets
+        :see: https://www.gate.io/docs/developers/apiv4/en/#list-all-supported-currency-pairs-supported-in-margin-trading-deprecated
+        :param str[] symbols: a list of unified market symbols
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param boolean [params.unified]: default False, set to True for fetching unified account leverages
+        :returns dict: a list of `leverage structures <https://docs.ccxt.com/#/?id=leverage-structure>`
+        """
+        self.load_markets()
+        symbols = self.market_symbols(symbols)
+        response = None
+        isUnified = self.safe_bool(params, 'unified')
+        params = self.omit(params, 'unified')
+        marketIdRequest = 'id'
+        if isUnified:
+            marketIdRequest = 'currency_pair'
+            response = self.publicMarginGetUniCurrencyPairs(params)
+            #
+            #     [
+            #         {
+            #             "currency_pair": "1INCH_USDT",
+            #             "base_min_borrow_amount": "8",
+            #             "quote_min_borrow_amount": "1",
+            #             "leverage": "3"
+            #         },
+            #     ]
+            #
+        else:
+            response = self.publicMarginGetCurrencyPairs(params)
+            #
+            #     [
+            #         {
+            #             "id": "1CAT_USDT",
+            #             "base": "1CAT",
+            #             "quote": "USDT",
+            #             "leverage": 3,
+            #             "min_base_amount": "71",
+            #             "min_quote_amount": "1",
+            #             "max_quote_amount": "10000",
+            #             "status": 1
+            #         },
+            #     ]
+            #
+        return self.parse_leverages(response, symbols, marketIdRequest, 'spot')
+
+    def parse_leverage(self, leverage, market=None) -> Leverage:
+        marketId = self.safe_string_2(leverage, 'currency_pair', 'id')
+        leverageValue = self.safe_integer(leverage, 'leverage')
+        return {
+            'info': leverage,
+            'symbol': self.safe_symbol(marketId, market, '_', 'spot'),
+            'marginMode': None,
+            'longLeverage': leverageValue,
+            'shortLeverage': leverageValue,
+        }
+
     def handle_errors(self, code, reason, url, method, headers, body, response, requestHeaders, requestBody):
         if response is None:
             return None

ccxt/gemini.py

@@ -41,7 +41,7 @@ class gemini(Exchange, ImplicitAPI):
                 'CORS': None,
                 'spot': True,
                 'margin': False,
-                'swap': False,
+                'swap': True,
                 'future': False,
                 'option': False,
                 'addMargin': False,
@@ -266,11 +266,11 @@ class gemini(Exchange, ImplicitAPI):
                 },
             },
             'options': {
-                'fetchMarketsMethod': 'fetch_markets_from_web',  # fetch_markets_from_api, fetch_markets_from_web
+                'fetchMarketsMethod': 'fetch_markets_from_api',  # fetch_markets_from_api, fetch_markets_from_web
                 'fetchMarketFromWebRetries': 10,
                 'fetchMarketsFromAPI': {
                     'fetchDetailsForAllSymbols': False,
-                    'fetchDetailsForMarketIds': [],
+                    'quoteCurrencies': ['USDT', 'GUSD', 'USD', 'DAI', 'EUR', 'GBP', 'SGD', 'BTC', 'ETH', 'LTC', 'BCH'],
                 },
                 'fetchMarkets': {
                     'webApiEnable': True,  # fetches from WEB
@@ -321,10 +321,7 @@ class gemini(Exchange, ImplicitAPI):
             return None
         #
         #    {
-        #        "tradingPairs": [
-        #            ["BTCAUD", 2, 8, "0.00001", 10, True],
-        #            ...
-        #        ],
+        #        "tradingPairs": [['BTCUSD', 2, 8, '0.00001', 10, True],  ...],
         #        "currencies": [
         #            ["ORCA", "Orca", 204, 6, 0, 6, 8, False, null, "solana"],  #, precisions seem to be the 5th index
         #            ["ATOM", "Cosmos", 44, 6, 0, 6, 8, False, null, "cosmos"],
@@ -343,6 +340,7 @@ class gemini(Exchange, ImplicitAPI):
         #    }
         #
         result = {}
+        self.options['tradingPairs'] = self.safe_list(data, 'tradingPairs')
         currenciesArray = self.safe_value(data, 'currencies', [])
         for i in range(0, len(currenciesArray)):
             currency = currenciesArray[i]
@@ -539,7 +537,7 @@ class gemini(Exchange, ImplicitAPI):
         return result
 
     def fetch_markets_from_api(self, params={}):
-        response = self.publicGetV1Symbols(params)
+        marketIdsRaw = self.publicGetV1Symbols(params)
         #
         #     [
         #         "btcusd",
@@ -547,87 +545,166 @@ class gemini(Exchange, ImplicitAPI):
         #         ...
         #     ]
         #
-        result = {}
-        for i in range(0, len(response)):
-            marketId = response[i]
-            market = {
-                'symbol': marketId,
-            }
-            result[marketId] = self.parse_market(market)
-        options = self.safe_value(self.options, 'fetchMarketsFromAPI', {})
-        fetchDetailsForAllSymbols = self.safe_bool(options, 'fetchDetailsForAllSymbols', False)
-        fetchDetailsForMarketIds = self.safe_value(options, 'fetchDetailsForMarketIds', [])
-        promises = []
+        result = []
+        options = self.safe_dict(self.options, 'fetchMarketsFromAPI', {})
+        bugSymbol = 'efilfil'  # we skip self inexistent test symbol, which bugs other functions
         marketIds = []
-        if fetchDetailsForAllSymbols:
-            marketIds = response
+        for i in range(0, len(marketIdsRaw)):
+            if marketIdsRaw[i] != bugSymbol:
+                marketIds.append(marketIdsRaw[i])
+        if self.safe_bool(options, 'fetchDetailsForAllSymbols', False):
+            promises = []
+            for i in range(0, len(marketIds)):
+                marketId = marketIds[i]
+                request = {
+                    'symbol': marketId,
+                }
+                promises.append(self.publicGetV1SymbolsDetailsSymbol(self.extend(request, params)))
+                #
+                #     {
+                #         "symbol": "BTCUSD",
+                #         "base_currency": "BTC",
+                #         "quote_currency": "USD",
+                #         "tick_size": 1E-8,
+                #         "quote_increment": 0.01,
+                #         "min_order_size": "0.00001",
+                #         "status": "open",
+                #         "wrap_enabled": False
+                #     }
+                #
+            responses = promises
+            for i in range(0, len(responses)):
+                result.append(self.parse_market(responses[i]))
         else:
-            marketIds = fetchDetailsForMarketIds
-        for i in range(0, len(marketIds)):
-            marketId = marketIds[i]
-            request = {
-                'symbol': marketId,
-            }
-            promises.append(self.publicGetV1SymbolsDetailsSymbol(self.extend(request, params)))
-            #
-            #     {
-            #         "symbol": "BTCUSD",
-            #         "base_currency": "BTC",
-            #         "quote_currency": "USD",
-            #         "tick_size": 1E-8,
-            #         "quote_increment": 0.01,
-            #         "min_order_size": "0.00001",
-            #         "status": "open",
-            #         "wrap_enabled": False
-            #     }
-            #
-        promises = promises
-        for i in range(0, len(promises)):
-            responseInner = promises[i]
-            marketId = self.safe_string_lower(responseInner, 'symbol')
-            result[marketId] = self.parse_market(responseInner)
-        return self.to_array(result)
+            # use trading-pairs info, if it was fetched
+            tradingPairs = self.safe_list(self.options, 'tradingPairs')
+            if tradingPairs is not None:
+                indexedTradingPairs = self.index_by(tradingPairs, 0)
+                for i in range(0, len(marketIds)):
+                    marketId = marketIds[i]
+                    tradingPair = self.safe_list(indexedTradingPairs, marketId.upper())
+                    if tradingPair is not None:
+                        result.append(self.parse_market(tradingPair))
+            else:
+                for i in range(0, len(marketIds)):
+                    result.append(self.parse_market(marketIds[i]))
+        return result
 
     def parse_market(self, response) -> Market:
-        marketId = self.safe_string_lower(response, 'symbol')
-        baseId = self.safe_string(response, 'base_currency')
-        quoteId = self.safe_string(response, 'quote_currency')
-        if baseId is None:
-            idLength = len(marketId) - 0
-            isUSDT = marketId.find('usdt') >= 0
-            quoteSize = 4 if isUSDT else 3
-            baseId = marketId[0:idLength - quoteSize]  # Not True for all markets
-            quoteId = marketId[idLength - quoteSize:idLength]
+        #
+        # response might be:
+        #
+        #     btcusd
+        #
+        # or
+        #
+        #     [
+        #         'BTCUSD',   # symbol
+        #         2,          # priceTickDecimalPlaces
+        #         8,          # quantityTickDecimalPlaces
+        #         '0.00001',  # quantityMinimum
+        #         10,         # quantityRoundDecimalPlaces
+        #         True        # minimumsAreInclusive
+        #     ],
+        #
+        # or
+        #
+        #     {
+        #         "symbol": "BTCUSD",  # perpetuals have 'PERP' suffix, i.e. DOGEUSDPERP
+        #         "base_currency": "BTC",
+        #         "quote_currency": "USD",
+        #         "tick_size": 1E-8,
+        #         "quote_increment": 0.01,
+        #         "min_order_size": "0.00001",
+        #         "status": "open",
+        #         "wrap_enabled": False
+        #         "product_type": "swap",  # only in perps
+        #         "contract_type": "linear",  # only in perps
+        #         "contract_price_currency": "GUSD"  # only in perps
+        #     }
+        #
+        marketId = None
+        baseId = None
+        quoteId = None
+        settleId = None
+        tickSize = None
+        increment = None
+        minSize = None
+        status = None
+        swap = False
+        contractSize = None
+        linear = None
+        inverse = None
+        isString = (isinstance(response, str))
+        isArray = (isinstance(response, list))
+        if not isString and not isArray:
+            marketId = self.safe_string_lower(response, 'symbol')
+            minSize = self.safe_number(response, 'min_order_size')
+            tickSize = self.safe_number(response, 'tick_size')
+            increment = self.safe_number(response, 'quote_increment')
+            status = self.parse_market_active(self.safe_string(response, 'status'))
+            baseId = self.safe_string(response, 'base_currency')
+            quoteId = self.safe_string(response, 'quote_currency')
+            settleId = self.safe_string(response, 'contract_price_currency')
+        else:
+            # if no detailed API was called, then parse either string or array
+            if isString:
+                marketId = response
+            else:
+                marketId = self.safe_string_lower(response, 0)
+                minSize = self.safe_number(response, 3)
+                tickSize = self.parse_number(self.parse_precision(self.safe_string(response, 1)))
+                increment = self.parse_number(self.parse_precision(self.safe_string(response, 2)))
+            marketIdUpper = marketId.upper()
+            isPerp = (marketIdUpper.find('PERP') >= 0)
+            marketIdWithoutPerp = marketIdUpper.replace('PERP', '')
+            quoteQurrencies = self.handle_option('fetchMarketsFromAPI', 'quoteCurrencies', [])
+            for i in range(0, len(quoteQurrencies)):
+                quoteCurrency = quoteQurrencies[i]
+                if marketIdWithoutPerp.endswith(quoteCurrency):
+                    baseId = marketIdWithoutPerp.replace(quoteCurrency, '')
+                    quoteId = quoteCurrency
+                    if isPerp:
+                        settleId = quoteCurrency  # always same
+                    break
         base = self.safe_currency_code(baseId)
         quote = self.safe_currency_code(quoteId)
-        status = self.safe_string(response, 'status')
+        settle = self.safe_currency_code(settleId)
+        symbol = base + '/' + quote
+        if settleId is not None:
+            symbol = symbol + ':' + settle
+            swap = True
+            contractSize = tickSize  # always same
+            linear = True  # always linear
+            inverse = False
+        type = 'swap' if swap else 'spot'
         return {
             'id': marketId,
-            'symbol': base + '/' + quote,
+            'symbol': symbol,
             'base': base,
             'quote': quote,
-            'settle': None,
+            'settle': settle,
             'baseId': baseId,
             'quoteId': quoteId,
-            'settleId': None,
-            'type': 'spot',
-            'spot': True,
+            'settleId': settleId,
+            'type': type,
+            'spot': not swap,
             'margin': False,
-            'swap': False,
+            'swap': swap,
             'future': False,
             'option': False,
-            'active': self.parse_market_active(status),
-            'contract': False,
-            'linear': None,
-            'inverse': None,
-            'contractSize': None,
+            'active': status,
+            'contract': swap,
+            'linear': linear,
+            'inverse': inverse,
+            'contractSize': contractSize,
             'expiry': None,
             'expiryDatetime': None,
             'strike': None,
             'optionType': None,
             'precision': {
-                'price': self.safe_number(response, 'quote_increment'),
-                'amount': self.safe_number(response, 'tick_size'),
+                'price': increment,
+                'amount': tickSize,
             },
             'limits': {
                 'leverage': {
@@ -635,7 +712,7 @@ class gemini(Exchange, ImplicitAPI):
                     'max': None,
                 },
                 'amount': {
-                    'min': self.safe_number(response, 'min_order_size'),
+                    'min': minSize,
                     'max': None,
                 },
                 'price': {

ccxt/hitbtc.py

@@ -332,6 +332,7 @@ class hitbtc(Exchange, ImplicitAPI):
                     '2012': BadRequest,
                     '2020': BadRequest,
                     '2022': BadRequest,
+                    '2024': InvalidOrder,  # Invalid margin mode.
                     '10001': BadRequest,
                     '10021': AccountSuspended,
                     '10022': BadRequest,
@@ -349,6 +350,7 @@ class hitbtc(Exchange, ImplicitAPI):
                     '20012': ExchangeError,
                     '20014': ExchangeError,
                     '20016': ExchangeError,
+                    '20018': ExchangeError,  # Withdrawals are unavailable due to the current configuration. Any of: - internal withdrawals are disabled; - in-chain withdrawals are disabled.
                     '20031': ExchangeError,
                     '20032': ExchangeError,
                     '20033': ExchangeError,
@@ -359,10 +361,15 @@ class hitbtc(Exchange, ImplicitAPI):
                     '20043': ExchangeError,
                     '20044': PermissionDenied,
                     '20045': InvalidOrder,
+                    '20047': InvalidOrder,  # Order placing exceeds the central counterparty balance limit.
+                    '20048': InvalidOrder,  # Provided Time-In-Force instruction is invalid or the combination of the instruction and the order type is not allowed.
+                    '20049': InvalidOrder,  # Provided order type is invalid.
                     '20080': ExchangeError,
                     '21001': ExchangeError,
                     '21003': AccountSuspended,
                     '21004': AccountSuspended,
+                    '22004': ExchangeError,  # User is not found.
+                    '22008': ExchangeError,  # Gateway timeout exceeded.
                 },
                 'broad': {},
             },

ccxt/htx.py

@@ -485,6 +485,7 @@ class htx(Exchange, ImplicitAPI):
                             'v2/sub-user/api-key-modification': 1,
                             'v2/sub-user/api-key-deletion': 1,
                             'v1/subuser/transfer': 10,
+                            'v1/trust/user/active/credit': 10,
                             # Trading
                             'v1/order/orders/place': 0.2,
                             'v1/order/batch-orders': 0.4,