def parse_trade(self, trade, market=None): id = self.safe_string(trade, 'trade_id') timestamp = self.safe_integer(trade, 'date') priceString = self.safe_string(trade, 'price_int') priceString = Precise.string_div(priceString, '100000') amountString = self.safe_string(trade, 'amount_int') amountString = Precise.string_div(amountString, '100000000') price = self.parse_number(priceString) amount = self.parse_number(amountString) cost = self.parse_number(Precise.string_mul(priceString, amountString)) symbol = None if market is not None: symbol = market['symbol'] return { 'id': id, 'info': trade, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'symbol': symbol, 'type': None, 'side': None, 'order': None, 'takerOrMaker': None, 'price': price, 'amount': amount, 'cost': cost, 'fee': None, }
async def fetch_trading_fees(self, params={}): await self.load_markets() response = await self.privateGetUserFees(params) # # { # data: { # maker_fee: '0.0', # taker_fee: '0.2', # btc_volume_30d: '0.0' # } # } # data = self.safe_value(response, 'data', {}) makerString = self.safe_string(data, 'maker_fee') takerString = self.safe_string(data, 'taker_fee') maker = self.parse_number(Precise.string_div(makerString, '100')) taker = self.parse_number(Precise.string_div(takerString, '100')) result = {} for i in range(0, len(self.symbols)): symbol = self.symbols[i] result[symbol] = { 'info': response, 'symbol': symbol, 'maker': maker, 'taker': taker, 'percentage': True, 'tierBased': True, } return result
def fetch_balance(self, params={}): self.load_markets() request = { 'BalanceReqID': self.nonce(), } response = self.privatePostU2(self.extend(request, params)) balances = self.safe_value(response['Responses'], self.options['brokerId']) result = {'info': response} if balances is not None: currencyIds = list(self.currencies_by_id.keys()) for i in range(0, len(currencyIds)): currencyId = currencyIds[i] code = self.safe_currency_code(currencyId) # we only set the balance for the currency if that currency is present in response # otherwise we will lose the info if the currency balance has been funded or traded or not if currencyId in balances: account = self.account() used = self.safe_string(balances, currencyId + '_locked') used = Precise.string_div(used, '1e8') total = self.safe_string(balances, currencyId) total = Precise.string_div(total, '1e8') account['used'] = used account['total'] = total result[code] = account return self.parse_balance(result, False)
def fetch_trading_fee(self, symbol, params={}): """ fetch the trading fees for a market :param str symbol: unified market symbol :param dict params: extra parameters specific to the coinmate api endpoint :returns dict: a `fee structure <https://docs.ccxt.com/en/latest/manual.html#fee-structure>` """ self.load_markets() market = self.market(symbol) request = { 'currencyPair': market['id'], } response = self.privatePostTraderFees(self.extend(request, params)) # # { # error: False, # errorMessage: null, # data: {maker: '0.3', taker: '0.35', timestamp: '1646253217815'} # } # data = self.safe_value(response, 'data', {}) makerString = self.safe_string(data, 'maker') takerString = self.safe_string(data, 'taker') maker = self.parse_number(Precise.string_div(makerString, '100')) taker = self.parse_number(Precise.string_div(takerString, '100')) return { 'info': data, 'symbol': market['symbol'], 'maker': maker, 'taker': taker, 'percentage': True, 'tierBased': True, }
async def fetch_trading_fee(self, symbol, params={}): await self.load_markets() market = self.market(symbol) request = { 'currencyPair': market['id'], } response = await self.privatePostTraderFees( self.extend(request, params)) # # { # error: False, # errorMessage: null, # data: {maker: '0.3', taker: '0.35', timestamp: '1646253217815'} # } # data = self.safe_value(response, 'data', {}) makerString = self.safe_string(data, 'maker') takerString = self.safe_string(data, 'taker') maker = self.parse_number(Precise.string_div(makerString, '100')) taker = self.parse_number(Precise.string_div(takerString, '100')) return { 'info': data, 'symbol': symbol, 'maker': maker, 'taker': taker, 'percentage': True, 'tierBased': True, }
async def fetch_trading_fees(self, params={}): """ fetch the trading fees for multiple markets :param dict params: extra parameters specific to the coinfalcon api endpoint :returns dict: a dictionary of `fee structures <https://docs.ccxt.com/en/latest/manual.html#fee-structure>` indexed by market symbols """ await self.load_markets() response = await self.privateGetUserFees(params) # # { # data: { # maker_fee: '0.0', # taker_fee: '0.2', # btc_volume_30d: '0.0' # } # } # data = self.safe_value(response, 'data', {}) makerString = self.safe_string(data, 'maker_fee') takerString = self.safe_string(data, 'taker_fee') maker = self.parse_number(Precise.string_div(makerString, '100')) taker = self.parse_number(Precise.string_div(takerString, '100')) result = {} for i in range(0, len(self.symbols)): symbol = self.symbols[i] result[symbol] = { 'info': response, 'symbol': symbol, 'maker': maker, 'taker': taker, 'percentage': True, 'tierBased': True, } return result
def fetch_trading_fees(self, params={}): self.load_markets() response = self.privatePostV1Notionalvolume(params) # # { # "web_maker_fee_bps": 25, # "web_taker_fee_bps": 35, # "web_auction_fee_bps": 25, # "api_maker_fee_bps": 10, # "api_taker_fee_bps": 35, # "api_auction_fee_bps": 20, # "fix_maker_fee_bps": 10, # "fix_taker_fee_bps": 35, # "fix_auction_fee_bps": 20, # "block_maker_fee_bps": 0, # "block_taker_fee_bps": 50, # "notional_30d_volume": 150.00, # "last_updated_ms": 1551371446000, # "date": "2019-02-28", # "notional_1d_volume": [ # { # "date": "2019-02-22", # "notional_volume": 75.00 # }, # { # "date": "2019-02-14", # "notional_volume": 75.00 # } # ] # } # makerBps = self.safe_string(response, 'api_maker_fee_bps') takerBps = self.safe_string(response, 'api_taker_fee_bps') makerString = Precise.string_div(makerBps, '10000') takerString = Precise.string_div(takerBps, '10000') maker = self.parse_number(makerString) taker = self.parse_number(takerString) result = {} for i in range(0, len(self.symbols)): symbol = self.symbols[i] result[symbol] = { 'info': response, 'symbol': symbol, 'maker': maker, 'taker': taker, 'percentage': True, 'tierBased': True, } return result
def parse_trade(self, trade, market=None): # # fetchMyTrades # # { # "type": "BTC Sell order executed", # "typeI": 6, # "crypto": 5000, # "amount": 35.4, # "rate": 709800, # "date": "2020-05-22T15:05:34.000Z", # "unit": "INR", # "factor": 100000000, # "fee": 0.09, # "delh_btc": -5000, # "delh_inr": 0, # "del_btc": 0, # "del_inr": 35.4, # "id": "2938823" # } # market = self.safe_market(None, market) orderId = self.safe_string(trade, 'id') timestamp = self.parse8601(self.safe_string(trade, 'date')) amountString = self.safe_string(trade, 'amount') priceString = self.safe_string(trade, 'rate') price = self.parse_number(priceString) factor = self.safe_string(trade, 'factor') amountScaled = Precise.string_div(amountString, factor) amount = self.parse_number(amountScaled) cost = self.parse_number(Precise.string_mul(priceString, amountScaled)) symbol = market['symbol'] side = self.safe_string_lower(trade, 'type') if side.find('sell') >= 0: side = 'sell' elif side.find('buy') >= 0: side = 'buy' fee = None feeCost = self.safe_number(trade, 'fee') if feeCost is not None: feeCurrencyCode = market['quote'] fee = { 'cost': feeCost, 'currency': feeCurrencyCode, } return { 'info': trade, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'symbol': symbol, 'id': None, 'order': orderId, 'type': None, 'side': side, 'takerOrMaker': None, 'price': price, 'amount': amount, 'cost': cost, 'fee': fee, }
def fetch_trading_fees(self, params={}): """ fetch the trading fees for multiple markets :param dict params: extra parameters specific to the bit2c api endpoint :returns dict: a dictionary of `fee structures <https://docs.ccxt.com/en/latest/manual.html#fee-structure>` indexed by market symbols """ self.load_markets() response = self.privateGetAccountBalance(params) # # { # "AVAILABLE_NIS": 0.0, # "NIS": 0.0, # "LOCKED_NIS": 0.0, # "AVAILABLE_BTC": 0.0, # "BTC": 0.0, # "LOCKED_BTC": 0.0, # ... # "Fees": { # "BtcNis": {"FeeMaker": 1.0, "FeeTaker": 1.0}, # "EthNis": {"FeeMaker": 1.0, "FeeTaker": 1.0}, # ... # } # } # fees = self.safe_value(response, 'Fees', {}) keys = list(fees.keys()) result = {} for i in range(0, len(keys)): marketId = keys[i] symbol = self.safe_symbol(marketId) fee = self.safe_value(fees, marketId) makerString = self.safe_string(fee, 'FeeMaker') takerString = self.safe_string(fee, 'FeeTaker') maker = self.parse_number(Precise.string_div(makerString, '100')) taker = self.parse_number(Precise.string_div(takerString, '100')) result[symbol] = { 'info': fee, 'symbol': symbol, 'taker': taker, 'maker': maker, 'percentage': True, 'tierBased': False, } return result
async def fetch_trading_fees(self, params={}): await self.load_markets() response = await self.publicGetInfo(params) # # { # "server_time":1615856752, # "pairs":{ # "ltc_btc":{ # "decimal_places":8, # "min_price":0.00000001, # "max_price":10000, # "min_amount":0.0001, # "min_total":0.0001, # "hidden":0, # "fee":0.2, # "fee_buyer":0.2, # "fee_seller":0.2 # }, # ... # }, # } # pairs = self.safe_value(response, 'pairs') marketIds = list(pairs.keys()) result = {} for i in range(0, len(marketIds)): marketId = marketIds[i] pair = self.safe_value(pairs, marketId, {}) symbol = self.safe_symbol(marketId, None, '_') takerString = self.safe_string(pair, 'fee_buyer') makerString = self.safe_string(pair, 'fee_seller') taker = self.parse_number(Precise.string_div(takerString, '100')) maker = self.parse_number(Precise.string_div(makerString, '100')) result[symbol] = { 'info': pair, 'symbol': symbol, 'taker': taker, 'maker': maker, 'percentage': True, 'tierBased': False, } return result
def parse_trade(self, trade, market=None): id = self.safe_string(trade, 'trade_id') timestamp = self.safe_integer(trade, 'date') price = self.safe_string(trade, 'price_int') amount = self.safe_string(trade, 'amount_int') market = self.safe_market(None, market) return self.safe_trade({ 'id': id, 'info': trade, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'symbol': market['symbol'], 'type': None, 'side': None, 'order': None, 'takerOrMaker': None, 'price': Precise.string_div(price, '100000'), 'amount': Precise.string_div(amount, '100000000'), 'cost': None, 'fee': None, }, market)
async def fetch_trading_fees(self, params={}): await self.load_markets() response = await self.privateGetAccountBalance(params) # # { # "AVAILABLE_NIS": 0.0, # "NIS": 0.0, # "LOCKED_NIS": 0.0, # "AVAILABLE_BTC": 0.0, # "BTC": 0.0, # "LOCKED_BTC": 0.0, # ... # "Fees": { # "BtcNis": {"FeeMaker": 1.0, "FeeTaker": 1.0}, # "EthNis": {"FeeMaker": 1.0, "FeeTaker": 1.0}, # ... # } # } # fees = self.safe_value(response, 'Fees', {}) keys = list(fees.keys()) result = {} for i in range(0, len(keys)): marketId = keys[i] symbol = self.safe_symbol(marketId) fee = self.safe_value(fees, marketId) makerString = self.safe_string(fee, 'FeeMaker') takerString = self.safe_string(fee, 'FeeTaker') maker = self.parse_number(Precise.string_div(makerString, '100')) taker = self.parse_number(Precise.string_div(takerString, '100')) result[symbol] = { 'info': fee, 'symbol': symbol, 'taker': taker, 'maker': maker, 'percentage': True, 'tierBased': False, } return result
def fetch_trading_fees(self, params={}): """ fetch the trading fees for multiple markets :param dict params: extra parameters specific to the bl3p api endpoint :returns dict: a dictionary of `fee structures <https://docs.ccxt.com/en/latest/manual.html#fee-structure>` indexed by market symbols """ self.load_markets() response = self.privatePostGENMKTMoneyInfo(params) # # { # result: 'success', # data: { # user_id: '13396', # wallets: { # BTC: { # balance: { # value_int: '0', # display: '0.00000000 BTC', # currency: 'BTC', # value: '0.00000000', # display_short: '0.00 BTC' # }, # available: { # value_int: '0', # display: '0.00000000 BTC', # currency: 'BTC', # value: '0.00000000', # display_short: '0.00 BTC' # } # }, # ... # }, # trade_fee: '0.25' # } # } # data = self.safe_value(response, 'data', {}) feeString = self.safe_string(data, 'trade_fee') fee = self.parse_number(Precise.string_div(feeString, '100')) result = {} for i in range(0, len(self.symbols)): symbol = self.symbols[i] result[symbol] = { 'info': data, 'symbol': symbol, 'maker': fee, 'taker': fee, 'percentage': True, 'tierBased': False, } return result
async def fetch_trading_fees(self, params={}): response = await self.v4PublicGetAssets(params) # # { # '1INCH': { # name: '1inch', # unified_cryptoasset_id: '8104', # can_withdraw: True, # can_deposit: True, # min_withdraw: '33', # max_withdraw: '0', # maker_fee: '0.1', # taker_fee: '0.1', # min_deposit: '30', # max_deposit: '0' # }, # ... # } # result = {} for i in range(0, len(self.symbols)): symbol = self.symbols[i] market = self.market(symbol) fee = self.safe_value(response, market['baseId'], {}) makerFee = self.safe_string(fee, 'maker_fee') takerFee = self.safe_string(fee, 'taker_fee') makerFee = Precise.string_div(makerFee, '100') takerFee = Precise.string_div(takerFee, '100') result[symbol] = { 'info': fee, 'symbol': market['symbol'], 'percentage': True, 'tierBased': False, 'maker': self.parse_number(makerFee), 'taker': self.parse_number(takerFee), } return result
async def fetch_trading_fees(self, params={}): await self.load_markets() response = await self.privatePostGENMKTMoneyInfo(params) # # { # result: 'success', # data: { # user_id: '13396', # wallets: { # BTC: { # balance: { # value_int: '0', # display: '0.00000000 BTC', # currency: 'BTC', # value: '0.00000000', # display_short: '0.00 BTC' # }, # available: { # value_int: '0', # display: '0.00000000 BTC', # currency: 'BTC', # value: '0.00000000', # display_short: '0.00 BTC' # } # }, # ... # }, # trade_fee: '0.25' # } # } # data = self.safe_value(response, 'data', {}) feeString = self.safe_string(data, 'trade_fee') fee = self.parse_number(Precise.string_div(feeString, '100')) result = {} for i in range(0, len(self.symbols)): symbol = self.symbols[i] result[symbol] = { 'info': data, 'symbol': symbol, 'maker': fee, 'taker': fee, 'percentage': True, 'tierBased': False, } return result
def fetch_markets(self, params={}): response = self.publicGetAvailableBooks(params) # # { # "success":true, # "payload":[ # { # "book":"btc_mxn", # "minimum_price":"500", # "maximum_price":"10000000", # "minimum_amount":"0.00005", # "maximum_amount":"500", # "minimum_value":"5", # "maximum_value":"10000000", # "tick_size":"0.01", # "fees":{ # "flat_rate":{"maker":"0.500","taker":"0.650"}, # "structure":[ # {"volume":"1500000","maker":"0.00500","taker":"0.00650"}, # {"volume":"2000000","maker":"0.00490","taker":"0.00637"}, # {"volume":"5000000","maker":"0.00480","taker":"0.00624"}, # {"volume":"7000000","maker":"0.00440","taker":"0.00572"}, # {"volume":"10000000","maker":"0.00420","taker":"0.00546"}, # {"volume":"15000000","maker":"0.00400","taker":"0.00520"}, # {"volume":"35000000","maker":"0.00370","taker":"0.00481"}, # {"volume":"50000000","maker":"0.00300","taker":"0.00390"}, # {"volume":"150000000","maker":"0.00200","taker":"0.00260"}, # {"volume":"250000000","maker":"0.00100","taker":"0.00130"}, # {"volume":"9999999999","maker":"0.00000","taker":"0.00130"}, # ] # } # }, # ] # } markets = self.safe_value(response, 'payload') result = [] for i in range(0, len(markets)): market = markets[i] id = self.safe_string(market, 'book') baseId, quoteId = id.split('_') base = baseId.upper() quote = quoteId.upper() base = self.safe_currency_code(base) quote = self.safe_currency_code(quote) symbol = base + '/' + quote limits = { 'amount': { 'min': self.safe_number(market, 'minimum_amount'), 'max': self.safe_number(market, 'maximum_amount'), }, 'price': { 'min': self.safe_number(market, 'minimum_price'), 'max': self.safe_number(market, 'maximum_price'), }, 'cost': { 'min': self.safe_number(market, 'minimum_value'), 'max': self.safe_number(market, 'maximum_value'), }, } defaultPricePrecision = self.safe_number( self.options['precision'], quote, self.options['defaultPrecision']) pricePrecision = self.safe_number(market, 'tick_size', defaultPricePrecision) precision = { 'amount': self.safe_number(self.options['precision'], base, self.options['defaultPrecision']), 'price': pricePrecision, } fees = self.safe_value(market, 'fees', {}) flatRate = self.safe_value(fees, 'flat_rate', {}) makerString = self.safe_string(flatRate, 'maker') takerString = self.safe_string(flatRate, 'taker') maker = self.parse_number(Precise.string_div(makerString, '100')) taker = self.parse_number(Precise.string_div(takerString, '100')) feeTiers = self.safe_value(fees, 'structure', []) fee = { 'taker': taker, 'maker': maker, 'percentage': True, 'tierBased': True, } takerFees = [] makerFees = [] for j in range(0, len(feeTiers)): tier = feeTiers[j] volume = self.safe_number(tier, 'volume') takerFee = self.safe_number(tier, 'taker') makerFee = self.safe_number(tier, 'maker') takerFees.append([volume, takerFee]) makerFees.append([volume, makerFee]) if j == 0: fee['taker'] = takerFee fee['maker'] = makerFee tiers = { 'taker': takerFees, 'maker': makerFees, } fee['tiers'] = tiers result.append( self.extend( { 'id': id, 'symbol': symbol, 'base': base, 'quote': quote, 'baseId': baseId, 'quoteId': quoteId, 'info': market, 'limits': limits, 'precision': precision, 'active': None, }, fee)) return result
def fetch_markets(self, params={}): response = self.publicGetMarketinfo(params) # # { # "result":"true", # "pairs":[ # { # "usdt_cnyx":{ # "decimal_places":3, # "amount_decimal_places":3, # "min_amount":1, # "min_amount_a":1, # "min_amount_b":3, # "fee":0.02, # "trade_disabled":0, # "buy_disabled":0, # "sell_disabled":0 # } # }, # ] # } # markets = self.safe_value(response, 'pairs') if not markets: raise ExchangeError(self.id + ' fetchMarkets got an unrecognized response') result = [] for i in range(0, len(markets)): market = markets[i] keys = list(market.keys()) id = self.safe_string(keys, 0) details = market[id] # all of their symbols are separated with an underscore # but not boe_eth_eth(BOE_ETH/ETH) which has two underscores # https://github.com/ccxt/ccxt/issues/4894 parts = id.split('_') numParts = len(parts) baseId = parts[0] quoteId = parts[1] if numParts > 2: baseId = parts[0] + '_' + parts[1] quoteId = parts[2] base = self.safe_currency_code(baseId) quote = self.safe_currency_code(quoteId) symbol = base + '/' + quote pricePrecisionString = self.safe_string(details, 'decimal_places') priceLimit = self.parse_precision(pricePrecisionString) precision = { 'amount': self.safe_integer(details, 'amount_decimal_places'), 'price': int(pricePrecisionString), } amountLimit = self.safe_string(details, 'min_amount') amountLimits = { 'min': self.parse_number(amountLimit), 'max': None, } priceLimits = { 'min': self.parse_number(priceLimit), 'max': None, } defaultCost = self.parse_number( Precise.string_mul(amountLimit, priceLimit)) minCost = self.safe_number(self.options['limits']['cost']['min'], quote, defaultCost) costLimits = { 'min': minCost, 'max': None, } limits = { 'amount': amountLimits, 'price': priceLimits, 'cost': costLimits, } disabled = self.safe_integer(details, 'trade_disabled') active = not disabled uppercaseId = id.upper() feeString = self.safe_string(details, 'fee') feeScaled = Precise.string_div(feeString, '100') result.append({ 'id': id, 'uppercaseId': uppercaseId, 'symbol': symbol, 'base': base, 'quote': quote, 'baseId': baseId, 'quoteId': quoteId, 'info': market, 'active': active, 'maker': self.parse_number(feeScaled), 'taker': self.parse_number(feeScaled), 'precision': precision, 'limits': limits, }) return result
def fetch_markets(self, params={}): markets = self.publicGetMarketSymbols(params) # # { # errno: 0, # errmsg: 'success', # result: [ # { # id: 2, # symbol: 'BTC-USDT', # base_currency: 'BTC', # quote_currency: 'USDT', # min_size: 0.00008, # max_size: 1300, # min_price: 1000, # max_price: 110000, # maker_fee: 1, # taker_fee: 1, # isHot: null, # isNew: null, # crown: null # }, # ] # } # precisions = self.publicGetMarketPrecision() # # { # errno: 0, # errmsg: 'success', # result: { # 'MANA-USDT': { # amount: '2', # minQuantity: '32', # maxQuantity: '46000000', # price: '4', # minPrice: '0.003', # maxPrice: '0.35' # }, # } # } # precisions = self.safe_value(precisions, 'result', {}) markets = self.safe_value(markets, 'result', []) result = [] for i in range(0, len(markets)): market = markets[i] id = self.safe_string(market, 'symbol') baseId = self.safe_string(market, 'base_currency') quoteId = self.safe_string(market, 'quote_currency') base = self.safe_currency_code(baseId) quote = self.safe_currency_code(quoteId) symbol = base + '/' + quote numericId = self.safe_integer(market, 'id') precision = self.safe_value(precisions, id, {}) makerFeeString = self.safe_string(market, 'maker_fee') takerFeeString = self.safe_string(market, 'taker_fee') makerFee = self.parse_number(Precise.string_div(makerFeeString, '1000')) takerFee = self.parse_number(Precise.string_div(takerFeeString, '1000')) result.append({ 'id': id, 'numericId': numericId, 'symbol': symbol, 'baseId': baseId, 'quoteId': quoteId, 'base': base, 'quote': quote, 'active': None, 'maker': makerFee, 'taker': takerFee, 'precision': { 'amount': self.safe_integer(precision, 'amount'), 'price': self.safe_integer(precision, 'price'), }, 'limits': { 'amount': { 'min': self.safe_number(market, 'min_size'), 'max': self.safe_number(market, 'max_size'), }, 'price': { 'min': self.safe_number(market, 'min_price'), 'max': self.safe_number(market, 'max_price'), }, 'cost': { 'min': None, 'max': None, }, }, 'info': market, }) return result
def fetch_markets(self, params={}): response = self.publicGetExchangeInfo(params) # # { # "timezone":"UTC", # "serverTime":1641336850932, # "symbols":[ # { # "symbol":"btcinr", # "status":"trading", # "baseAsset":"btc", # "quoteAsset":"inr", # "baseAssetPrecision":5, # "quoteAssetPrecision":0, # "orderTypes":[ # "limit", # "stop_limit" # ], # "isSpotTradingAllowed":true, # "filters":[ # { # "filterType":"PRICE_FILTER", # "minPrice":"1", # "tickSize":"1" # } # ] # }, # markets = self.safe_value(response, 'symbols', []) result = [] for i in range(0, len(markets)): entry = markets[i] id = self.safe_string(entry, 'symbol') baseId = self.safe_string(entry, 'baseAsset') quoteId = self.safe_string(entry, 'quoteAsset') base = self.safe_currency_code(baseId) quote = self.safe_currency_code(quoteId) symbol = base + '/' + quote isSpot = self.safe_value(entry, 'isSpotTradingAllowed') filters = self.safe_value(entry, 'filters') minPrice = None for j in range(0, len(filters)): filter = filters[j] filterType = self.safe_string(filter, 'filterType') if filterType == 'PRICE_FILTER': minPrice = self.safe_number(filter, 'minPrice') fee = self.safe_value(self.fees, quote, {}) takerString = self.safe_string(fee, 'taker', '0.2') takerString = Precise.string_div(takerString, '100') taker = self.parse_number(takerString) makerString = self.safe_string(fee, 'maker', '0.2') makerString = Precise.string_div(makerString, '100') maker = self.parse_number(makerString) status = self.safe_string(entry, 'status') active = status == 'trading' limits = { 'price': { 'min': minPrice, 'max': None, }, 'amount': { 'min': None, 'max': None, }, 'cost': { 'min': None, 'max': None, }, } precision = { 'price': self.safe_integer(entry, 'quoteAssetPrecision'), 'amount': self.safe_integer(entry, 'baseAssetPrecision'), } result.append({ 'info': entry, 'symbol': symbol, 'id': id, 'base': base, 'quote': quote, 'baseId': baseId, 'maker': maker, 'taker': taker, 'quoteId': quoteId, 'limits': limits, 'precision': precision, 'type': 'spot', 'spot': isSpot, 'active': active, }) return result
async def fetch_markets(self, params={}): """ retrieves data on all markets for buda :param dict params: extra parameters specific to the exchange api endpoint :returns [dict]: an array of objects representing market data """ marketsResponse = await self.publicGetMarkets(params) # # { # "markets": [ # { # "id": "BTC-CLP", # "name": "btc-clp", # "base_currency": "BTC", # "quote_currency": "CLP", # "minimum_order_amount": [ # "0.00002", # "BTC" # ], # "disabled": False, # "illiquid": False, # "rpo_disabled": null, # "taker_fee": "0.8", # "maker_fee": "0.4", # "max_orders_per_minute": 50, # "maker_discount_percentage": "0.0", # "taker_discount_percentage": "0.0" # }, # ] # } # markets = self.safe_value(marketsResponse, 'markets', []) currenciesResponse = await self.publicGetCurrencies() currencies = self.safe_value(currenciesResponse, 'currencies') result = [] for i in range(0, len(markets)): market = markets[i] baseId = self.safe_string(market, 'base_currency') quoteId = self.safe_string(market, 'quote_currency') base = self.safe_currency_code(baseId) quote = self.safe_currency_code(quoteId) baseInfo = await self.fetch_currency_info(baseId, currencies) quoteInfo = await self.fetch_currency_info(quoteId, currencies) minimumOrderAmount = self.safe_value(market, 'minimum_order_amount', []) taker_fee = self.safe_string(market, 'taker_fee') maker_fee = self.safe_string(market, 'maker_fee') result.append({ 'id': self.safe_string(market, 'id'), 'symbol': base + '/' + quote, 'base': base, 'quote': quote, 'settle': None, 'baseId': baseId, 'quoteId': quoteId, 'settleId': None, 'type': 'spot', 'spot': True, 'margin': False, 'swap': False, 'future': False, 'option': False, 'active': True, 'contract': False, 'linear': None, 'inverse': None, 'contractSize': None, 'expiry': None, 'expiryDatetime': None, 'strike': None, 'optionType': None, 'taker': self.parse_number(Precise.string_div(taker_fee, '1000')), 'maker': self.parse_number(Precise.string_div(maker_fee, '1000')), 'precision': { 'amount': self.parse_number( self.parse_precision( self.safe_string(baseInfo, 'input_decimals'))), 'price': self.parse_number( self.parse_precision( self.safe_string(quoteInfo, 'input_decimals'))), }, 'limits': { 'leverage': { 'min': None, 'max': None, }, 'amount': { 'min': self.safe_number(minimumOrderAmount, 0), 'max': None, }, 'price': { 'min': None, 'max': None, }, 'cost': { 'min': None, 'max': None, }, }, 'info': market, }) return result
# decimal_to_precision('foo'), # "invalid number(contains an illegal character 'f')") # # throws(() => # decimal_to_precision('0.01', TRUNCATE, -1, TICK_SIZE), # "TICK_SIZE cant be used with negative numPrecisionDigits") # ---------------------------------------------------------------------------- w = '-1.123e-6' x = '0.00000002' y = '69696900000' assert Precise.string_mul(x, y) == '1393.938' assert Precise.string_mul(y, x) == '1393.938' assert Precise.string_add(x, y) == '69696900000.00000002' assert Precise.string_add(y, x) == '69696900000.00000002' assert Precise.string_sub(x, y) == '-69696899999.99999998' assert Precise.string_sub(y, x) == '69696899999.99999998' assert Precise.string_div(x, y) == '0.000000000000028695' assert Precise.string_div(y, x) == '34848450000' assert Precise.string_mul(x, w) == '-0.00000000000002246' assert Precise.string_mul(w, x) == '-0.00000000000002246' assert Precise.string_add(x, w) == '-0.000001103' assert Precise.string_add(w, x) == '-0.000001103' assert Precise.string_sub(x, w) == '0.000001143' assert Precise.string_sub(w, x) == '-0.000001143' assert Precise.string_div(x, w) == '-0.000000000017809439' assert Precise.string_div(w, x) == '-0.0000005615'
async def fetch_markets(self, params={}): response = await self.publicGetInfo(params) # # { # "server_time":1615856752, # "pairs":{ # "ltc_btc":{ # "decimal_places":8, # "min_price":0.00000001, # "max_price":10000, # "min_amount":0.0001, # "min_total":0.0001, # "hidden":0, # "fee":0.2, # "fee_buyer":0.2, # "fee_seller":0.2 # }, # }, # } # markets = self.safe_value(response, 'pairs') keys = list(markets.keys()) result = [] for i in range(0, len(keys)): id = keys[i] market = markets[id] baseId, quoteId = id.split('_') base = baseId.upper() quote = quoteId.upper() base = self.safe_currency_code(base) quote = self.safe_currency_code(quote) symbol = base + '/' + quote precision = { 'amount': self.safe_integer(market, 'decimal_places'), 'price': self.safe_integer(market, 'decimal_places'), } amountLimits = { 'min': self.safe_number(market, 'min_amount'), 'max': self.safe_number(market, 'max_amount'), } priceLimits = { 'min': self.safe_number(market, 'min_price'), 'max': self.safe_number(market, 'max_price'), } costLimits = { 'min': self.safe_number(market, 'min_total'), } limits = { 'amount': amountLimits, 'price': priceLimits, 'cost': costLimits, } hidden = self.safe_integer(market, 'hidden') active = (hidden == 0) feeString = self.safe_string(market, 'fee') feeString = Precise.string_div(feeString, '100') # yobit maker = taker takerFee = self.parse_number(feeString) makerFee = self.parse_number(feeString) result.append({ 'id': id, 'symbol': symbol, 'base': base, 'quote': quote, 'baseId': baseId, 'quoteId': quoteId, 'active': active, 'taker': takerFee, 'maker': makerFee, 'precision': precision, 'limits': limits, 'info': market, }) return result
def parse_trade(self, trade, market=None): # # fetchMyTrades # # { # "type": "BTC Sell order executed", # "typeI": 6, # "crypto": 5000, # "amount": 35.4, # "rate": 709800, # "date": "2020-05-22T15:05:34.000Z", # "unit": "INR", # "factor": 100000000, # "fee": 0.09, # "delh_btc": -5000, # "delh_inr": 0, # "del_btc": 0, # "del_inr": 35.4, # "id": "2938823" # } # # fetchTrades # # { # "tradeId":"1909151", # "price":"61904.6300", # "quote_volume":1618.05, # "base_volume":0.02607254, # "timestamp":1634548602000, # "type":"buy" # } # market = self.safe_market(None, market) orderId = self.safe_string_2(trade, 'id', 'tradeId') timestamp = self.parse8601(self.safe_string(trade, 'date')) timestamp = self.safe_integer(trade, 'timestamp', timestamp) priceString = self.safe_string_2(trade, 'rate', 'price') amountString = self.safe_string(trade, 'amount') side = self.safe_string_lower(trade, 'type') if side is not None: if side.find('buy') >= 0: side = 'buy' elif side.find('sell') >= 0: side = 'sell' factor = self.safe_string(trade, 'factor') costString = None if factor is not None: amountString = Precise.string_div(amountString, factor) else: amountString = self.safe_string(trade, 'base_volume') costString = self.safe_string(trade, 'quote_volume') symbol = market['symbol'] fee = None feeCostString = self.safe_string(trade, 'fee') if feeCostString is not None: feeCurrencyCode = market['quote'] fee = { 'cost': feeCostString, 'currency': feeCurrencyCode, } return self.safe_trade( { 'info': trade, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'symbol': symbol, 'id': orderId, 'order': orderId, 'type': None, 'side': side, 'takerOrMaker': None, 'price': priceString, 'amount': amountString, 'cost': costString, 'fee': fee, }, market)
def fetch_markets(self, params={}): """ retrieves data on all markets for tidex :param dict params: extra parameters specific to the exchange api endpoint :returns [dict]: an array of objects representing market data """ response = self.publicGetInfo(params) # # { # "server_time":1615861869, # "pairs":{ # "ltc_btc":{ # "decimal_places":8, # "min_price":0.00000001, # "max_price":3.0, # "min_amount":0.001, # "max_amount":1000000.0, # "min_total":0.0001, # "hidden":0, # "fee":0.1, # }, # }, # } # markets = response['pairs'] keys = list(markets.keys()) result = [] for i in range(0, len(keys)): id = keys[i] market = markets[id] baseId, quoteId = id.split('_') base = self.safe_currency_code(baseId) quote = self.safe_currency_code(quoteId) hidden = self.safe_integer(market, 'hidden') takerFeeString = self.safe_string(market, 'fee') takerFeeString = Precise.string_div(takerFeeString, '100') result.append({ 'id': id, 'symbol': base + '/' + quote, 'base': base, 'quote': quote, 'settle': None, 'baseId': baseId, 'quoteId': quoteId, 'settleId': None, 'type': 'spot', 'spot': True, 'margin': False, 'swap': False, 'future': False, 'option': False, 'active': (hidden == 0), 'contract': False, 'linear': None, 'inverse': None, 'taker': self.parse_number(takerFeeString), 'contractSize': None, 'expiry': None, 'expiryDatetime': None, 'strike': None, 'optionType': None, 'precision': { 'amount': self.parse_number( self.parse_precision( self.safe_string(market, 'decimal_places'))), 'price': self.parse_number( self.parse_precision( self.safe_string(market, 'decimal_places'))), }, 'limits': { 'leverage': { 'min': None, 'max': None, }, 'amount': { 'min': self.safe_number(market, 'min_amount'), 'max': self.safe_number(market, 'max_amount'), }, 'price': { 'min': self.safe_number(market, 'min_price'), 'max': self.safe_number(market, 'max_price'), }, 'cost': { 'min': self.safe_number(market, 'min_total'), 'max': None, }, }, 'info': market, }) return result
def fetch_markets(self, params={}): response = self.publicGetInfo(params) # # { # "server_time":1615856752, # "pairs":{ # "ltc_btc":{ # "decimal_places":8, # "min_price":0.00000001, # "max_price":10000, # "min_amount":0.0001, # "min_total":0.0001, # "hidden":0, # "fee":0.2, # "fee_buyer":0.2, # "fee_seller":0.2 # }, # }, # } # markets = self.safe_value(response, 'pairs') keys = list(markets.keys()) result = [] for i in range(0, len(keys)): id = keys[i] market = markets[id] baseId, quoteId = id.split('_') base = baseId.upper() quote = quoteId.upper() base = self.safe_currency_code(base) quote = self.safe_currency_code(quote) hidden = self.safe_integer(market, 'hidden') feeString = self.safe_string(market, 'fee') feeString = Precise.string_div(feeString, '100') # yobit maker = taker result.append({ 'id': id, 'symbol': base + '/' + quote, 'base': base, 'quote': quote, 'settle': None, 'baseId': baseId, 'quoteId': quoteId, 'settleId': None, 'type': 'spot', 'spot': True, 'margin': False, 'swap': False, 'future': False, 'option': False, 'active': (hidden == 0), 'contract': False, 'linear': None, 'inverse': None, 'taker': self.parse_number(feeString), 'maker': self.parse_number(feeString), 'contractSize': None, 'expiry': None, 'expiryDatetime': None, 'strike': None, 'optionType': None, 'precision': { 'amount': self.safe_integer(market, 'decimal_places'), 'price': self.safe_integer(market, 'decimal_places'), }, 'limits': { 'leverage': { 'min': None, 'max': None, }, 'amount': { 'min': self.safe_number(market, 'min_amount'), 'max': self.safe_number(market, 'max_amount'), }, 'price': { 'min': self.safe_number(market, 'min_price'), 'max': self.safe_number(market, 'max_price'), }, 'cost': { 'min': self.safe_number(market, 'min_total'), 'max': None, }, }, 'info': market, }) return result
def parse_order(self, order, market=None): # # createOrder, fetchOpenOrders # # { # "orderId": 4180284841, # "clientOrderId": "order1987111", # "market": "BTC_USDT", # "side": "buy", # "type": "stop limit", # "timestamp": 1595792396.165973, # "dealMoney": "0", # if order finished - amount in money currency that finished # "dealStock": "0", # if order finished - amount in stock currency that finished # "amount": "0.001", # "takerFee": "0.001", # "makerFee": "0.001", # "left": "0.001", # remaining amount # "dealFee": "0", # fee in money that you pay if order is finished # "price": "40000", # "activation_price": "40000" # activation price -> only for stopLimit, stopMarket # } # # fetchClosedOrders # # { # "market": "BTC_USDT" # "amount": "0.0009", # "price": "40000", # "type": "limit", # "id": 4986126152, # "clientOrderId": "customId11", # "side": "sell", # "ctime": 1597486960.311311, # timestamp of order creation # "takerFee": "0.001", # "ftime": 1597486960.311332, # executed order timestamp # "makerFee": "0.001", # "dealFee": "0.041258268", # paid fee if order is finished # "dealStock": "0.0009", # amount in stock currency that finished # "dealMoney": "41.258268" # amount in money currency that finished # } # marketId = self.safe_string(order, 'market') market = self.safe_market(marketId, market, '_') symbol = market['symbol'] side = self.safe_string(order, 'side') filled = self.safe_string(order, 'dealStock') remaining = self.safe_string(order, 'left') clientOrderId = self.safe_string(order, 'clientOrderId') if clientOrderId == '': clientOrderId = None price = self.safe_string(order, 'price') stopPrice = self.safe_string(order, 'activation_price') orderId = self.safe_string_2(order, 'orderId', 'id') type = self.safe_string(order, 'type') amount = self.safe_string(order, 'amount') cost = None if price == '0': # api error to be solved price = None if side == 'buy' and type.find('market') >= 0: # in these cases the amount is in the quote currency meaning it's the cost cost = amount amount = None if price is not None: # if the price is available we can do self conversion # from amount in quote currency to base currency amount = Precise.string_div(cost, price) dealFee = self.safe_string(order, 'dealFee') fee = None if dealFee is not None: feeCurrencyCode = None if market is not None: feeCurrencyCode = market['quote'] fee = { 'cost': self.parse_number(dealFee), 'currency': feeCurrencyCode, } timestamp = self.safe_timestamp_2(order, 'ctime', 'timestamp') lastTradeTimestamp = self.safe_timestamp(order, 'ftime') return self.safe_order( { 'info': order, 'id': orderId, 'symbol': symbol, 'clientOrderId': clientOrderId, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'lastTradeTimestamp': lastTradeTimestamp, 'timeInForce': None, 'postOnly': None, 'status': None, 'side': side, 'price': price, 'type': type, 'stopPrice': stopPrice, 'amount': amount, 'filled': filled, 'remaining': remaining, 'average': None, 'cost': cost, 'fee': fee, 'trades': None, }, market)
# ---------------------------------------------------------------------------- w = '-1.123e-6' x = '0.00000002' y = '69696900000' z = '0' a = '1e8' assert Precise.string_mul(x, y) == '1393.938' assert Precise.string_mul(y, x) == '1393.938' assert Precise.string_add(x, y) == '69696900000.00000002' assert Precise.string_add(y, x) == '69696900000.00000002' assert Precise.string_sub(x, y) == '-69696899999.99999998' assert Precise.string_sub(y, x) == '69696899999.99999998' assert Precise.string_div(x, y, 1) == '0' assert Precise.string_div(x, y) == '0' assert Precise.string_div(x, y, 19) == '0.0000000000000000002' assert Precise.string_div(x, y, 20) == '0.00000000000000000028' assert Precise.string_div(x, y, 21) == '0.000000000000000000286' assert Precise.string_div(x, y, 22) == '0.0000000000000000002869' assert Precise.string_div(y, x) == '3484845000000000000' assert Precise.string_mul(x, w) == '-0.00000000000002246' assert Precise.string_mul(w, x) == '-0.00000000000002246' assert Precise.string_add(x, w) == '-0.000001103' assert Precise.string_add(w, x) == '-0.000001103' assert Precise.string_sub(x, w) == '0.000001143' assert Precise.string_sub(w, x) == '-0.000001143' assert Precise.string_div(x, w) == '-0.017809439002671415' assert Precise.string_div(w, x) == '-56.15'
def fetch_markets(self, params={}): response = self.publicGetMarket(params) # # { # "data":[ # { # "id":"MONA-USDT", # "base_currency_id":"MONA", # "quote_currency_id":"USDT", # "min_price":"0.001", # "max_price":"9999999999999999", # "price_increment":"0.001", # "min_quantity":"0.0001", # "max_quantity":"9999999999999999", # "quantity_precision":4, # "min_cost":"1", # "max_cost":"9999999999999999", # "cost_precision":8, # "taker_fee_rate":"0.2", # "maker_fee_rate":"0.2", # "show_in_ui":true, # "closed":false # }, # ] # } # markets = self.safe_value(response, 'data', []) result = [] for i in range(0, len(markets)): market = markets[i] id = self.safe_string(market, 'id') baseId = self.safe_string(market, 'base_currency_id') quoteId = self.safe_string(market, 'quote_currency_id') base = self.safe_currency_code(baseId) quote = self.safe_currency_code(quoteId) symbol = base + '/' + quote closed = self.safe_value(market, 'closed', False) active = not closed amountPrecision = self.safe_string(market, 'quantity_precision') costPrecision = self.safe_string(market, 'cost_precision') amountTickSize = self.parse_precision(amountPrecision) costTickSize = self.parse_precision(costPrecision) precision = { 'amount': self.parse_number(amountTickSize), 'price': self.safe_number(market, 'price_increment'), 'cost': self.parse_number(costTickSize), } takerFeeRate = self.safe_string(market, 'taker_fee_rate') taker = Precise.string_div(takerFeeRate, '100') makerFeeRate = self.safe_string(market, 'maker_fee_rate') maker = Precise.string_div(makerFeeRate, '100') result.append({ 'id': id, 'info': market, 'symbol': symbol, 'base': base, 'quote': quote, 'baseId': baseId, 'quoteId': quoteId, 'active': active, 'precision': precision, 'taker': self.parse_number(taker), 'maker': self.parse_number(maker), 'limits': { 'amount': { 'min': self.safe_number(market, 'min_quantity'), 'max': self.safe_number(market, 'max_quantity'), }, 'price': { 'min': self.safe_number(market, 'min_price'), 'max': self.safe_number(market, 'max_price'), }, 'cost': { 'min': self.safe_number(market, 'min_cost'), 'max': self.safe_number(market, 'max_cost'), }, }, }) return result
def fetch_markets(self, params={}): response = self.publicGetInfo(params) # # { # "server_time":1615861869, # "pairs":{ # "ltc_btc":{ # "decimal_places":8, # "min_price":0.00000001, # "max_price":3.0, # "min_amount":0.001, # "max_amount":1000000.0, # "min_total":0.0001, # "hidden":0, # "fee":0.1, # }, # }, # } # markets = response['pairs'] keys = list(markets.keys()) result = [] for i in range(0, len(keys)): id = keys[i] market = markets[id] baseId, quoteId = id.split('_') base = self.safe_currency_code(baseId) quote = self.safe_currency_code(quoteId) symbol = base + '/' + quote precision = { 'amount': self.safe_integer(market, 'decimal_places'), 'price': self.safe_integer(market, 'decimal_places'), } limits = { 'amount': { 'min': self.safe_number(market, 'min_amount'), 'max': self.safe_number(market, 'max_amount'), }, 'price': { 'min': self.safe_number(market, 'min_price'), 'max': self.safe_number(market, 'max_price'), }, 'cost': { 'min': self.safe_number(market, 'min_total'), }, } hidden = self.safe_integer(market, 'hidden') active = (hidden == 0) takerFeeString = self.safe_string(market, 'fee') takerFeeString = Precise.string_div(takerFeeString, '100') takerFee = self.parse_number(takerFeeString) result.append({ 'id': id, 'symbol': symbol, 'base': base, 'quote': quote, 'baseId': baseId, 'quoteId': quoteId, 'active': active, 'taker': takerFee, 'precision': precision, 'limits': limits, 'info': market, }) return result
async def create_order(self, symbol, type, side, amount, price=None, params={}): self.check_required_dependencies() if self.apiKey is None: raise ArgumentsRequired( 'createOrder() requires self.apiKey or userid in params') await self.load_markets() market = self.market(symbol) sideNum = None typeNum = None if side == 'sell': sideNum = 1 else: sideNum = 2 if type == 'limit': typeNum = 1 else: typeNum = 2 price = 0 normalSymbol = market['normalSymbol'] baseId = market['baseId'] baseCurrency = self.currency(market['base']) amountTruncated = self.amount_to_precision(symbol, amount) amountTruncatedPrecise = Precise(amountTruncated) amountTruncatedPrecise.reduce() amountTruncatedPrecise.decimals -= baseCurrency['precision'] amountChain = str(amountTruncatedPrecise) amountChainString = self.number_to_string(amountChain) quoteId = market['quoteId'] quoteCurrency = self.currency(market['quote']) priceRounded = self.price_to_precision(symbol, price) priceRoundedPrecise = Precise(priceRounded) priceRoundedPrecise.reduce() priceRoundedPrecise.decimals -= quoteCurrency['precision'] priceChain = str(priceRoundedPrecise) priceChainString = self.number_to_string(priceChain) now = self.milliseconds() expiryDelta = self.safe_integer(self.options, 'orderExpiration', 31536000000) expiration = self.milliseconds() + expiryDelta datetime = self.iso8601(now) datetime = datetime.split('.')[0] expirationDatetime = self.iso8601(expiration) expirationDatetime = expirationDatetime.split('.')[0] defaultDappId = 'Sagittarius' dappId = self.safe_string(params, 'dappId', defaultDappId) defaultFee = self.safe_string(self.options, 'fee', '300000000000000') totalFeeRate = self.safe_string(params, 'totalFeeRate', 8) chainFeeRate = self.safe_string(params, 'chainFeeRate', 1) fee = self.safe_string(params, 'fee', defaultFee) eightBytes = '18446744073709551616' # 2 ** 64 allByteStringArray = [ self.number_to_be(1, 32), self.number_to_le(int(math.floor(now / 1000)), 4), self.number_to_le(1, 1), self.number_to_le(int(math.floor(expiration / 1000)), 4), self.number_to_le(1, 1), self.number_to_le(32, 1), self.number_to_le(0, 8), self.number_to_le(fee, 8), # string for 32 bit php self.number_to_le(len(self.apiKey), 1), self.encode(self.apiKey), self.number_to_le(sideNum, 1), self.number_to_le(typeNum, 1), self.number_to_le(len(normalSymbol), 1), self.encode(normalSymbol), self.number_to_le( Precise.string_div(amountChainString, eightBytes, 0), 8), self.number_to_le( Precise.string_mod(amountChainString, eightBytes), 8), self.number_to_le( Precise.string_div(priceChainString, eightBytes, 0), 8), self.number_to_le(Precise.string_mod(priceChainString, eightBytes), 8), self.number_to_le(0, 2), self.number_to_le(int(math.floor(now / 1000)), 4), self.number_to_le(int(math.floor(expiration / 1000)), 4), self.number_to_le(1, 1), self.number_to_le(int(chainFeeRate), 2), self.number_to_le(1, 1), self.number_to_le(int(totalFeeRate), 2), self.number_to_le(int(quoteId), 4), self.number_to_le(int(baseId), 4), self.number_to_le(0, 1), self.number_to_le(1, 1), self.number_to_le(len(dappId), 1), self.encode(dappId), self.number_to_le(0, 1), ] txByteStringArray = [ self.number_to_le(int(math.floor(now / 1000)), 4), self.number_to_le(1, 1), self.number_to_le(int(math.floor(expiration / 1000)), 4), self.number_to_le(1, 1), self.number_to_le(32, 1), self.number_to_le(0, 8), self.number_to_le(fee, 8), # string for 32 bit php self.number_to_le(len(self.apiKey), 1), self.encode(self.apiKey), self.number_to_le(sideNum, 1), self.number_to_le(typeNum, 1), self.number_to_le(len(normalSymbol), 1), self.encode(normalSymbol), self.number_to_le( Precise.string_div(amountChainString, eightBytes, 0), 8), self.number_to_le( Precise.string_mod(amountChainString, eightBytes), 8), self.number_to_le( Precise.string_div(priceChainString, eightBytes, 0), 8), self.number_to_le(Precise.string_mod(priceChainString, eightBytes), 8), self.number_to_le(0, 2), self.number_to_le(int(math.floor(now / 1000)), 4), self.number_to_le(int(math.floor(expiration / 1000)), 4), self.number_to_le(1, 1), self.number_to_le(int(chainFeeRate), 2), self.number_to_le(1, 1), self.number_to_le(int(totalFeeRate), 2), self.number_to_le(int(quoteId), 4), self.number_to_le(int(baseId), 4), self.number_to_le(0, 1), self.number_to_le(1, 1), self.number_to_le(len(dappId), 1), self.encode(dappId), self.number_to_le(0, 1), ] txbytestring = self.binary_concat_array(txByteStringArray) txidhash = self.hash(txbytestring, 'sha256', 'hex') txid = txidhash[0:40] orderidByteStringArray = [ self.number_to_le(len(txid), 1), self.encode(txid), self.number_to_be(0, 4), ] orderidbytestring = self.binary_concat_array(orderidByteStringArray) orderidhash = self.hash(orderidbytestring, 'sha256', 'hex') orderid = orderidhash[0:40] bytestring = self.binary_concat_array(allByteStringArray) hash = self.hash(bytestring, 'sha256', 'hex') signature = self.ecdsa(hash, self.secret, 'secp256k1', None, True) recoveryParam = self.binary_to_base16( self.number_to_le(self.sum(signature['v'], 31), 1)) mySignature = recoveryParam + signature['r'] + signature['s'] operation = { 'now': datetime, 'expiration': expirationDatetime, 'fee': fee, 'creator': self.apiKey, 'side': sideNum, 'order_type': typeNum, 'market_name': normalSymbol, 'amount': amountChain, 'price': priceChain, 'use_btt_as_fee': False, 'money_id': int(quoteId), 'stock_id': int(baseId), 'custom_no_btt_fee_rate': int(totalFeeRate), 'custom_btt_fee_rate': int(chainFeeRate), } fatty = { 'timestamp': datetime, 'expiration': expirationDatetime, 'operations': [ [ 32, operation, ], ], 'validate_type': 0, 'dapp': dappId, 'signatures': [ mySignature, ], } request = { 'trObj': self.json(fatty), } response = await self.publicPostTransactionCreateorder(request) timestamp = self.milliseconds() statusCode = self.safe_string(response, 'code') status = 'open' if (statusCode == '0') else 'failed' return { 'info': response, 'id': orderid, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'lastTradeTimestamp': None, 'status': status, 'symbol': None, 'type': None, 'side': None, 'price': None, 'amount': None, 'filled': None, 'remaining': None, 'cost': None, 'trades': None, 'fee': None, 'clientOrderId': None, 'average': None, }