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: fee = { 'cost': self.parse_number(dealFee), 'currency': market['quote'], } 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)
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, 'type': 'spot', 'spot': True, 'active': None, }, fee)) return result
def parse_trade(self, trade, market=None): # # fetchTrades(public aggregate trades) # # { # "a":1658318071, # "p":"0.02476", # "q":"0.0", # "T":1591001423382, # "m":false # } # # createOrder fills(private) # # { # "price": "9807.05", # "qty": "0.01", # "commission": "0", # "commissionAsset": "dUSD" # } # # fetchMyTrades # # { # "symbol": "BNBBTC", # "id": 28457, # "orderId": 100234, # "price": "4.00000100", # "qty": "12.00000000", # "commission": "10.10000000", # "commissionAsset": "BNB", # "time": 1499865549590, # "isBuyer": True, # "isMaker": False, # "isBestMatch": True # } # timestamp = self.safe_integer_2(trade, 'T', 'time') priceString = self.safe_string_2(trade, 'p', 'price') amountString = self.safe_string_2(trade, 'q', 'qty') price = self.parse_number(priceString) amount = self.parse_number(amountString) cost = self.parse_number(Precise.string_mul(priceString, amountString)) id = self.safe_string_2(trade, 'a', 'id') side = None orderId = self.safe_string(trade, 'orderId') if 'm' in trade: side = 'sell' if trade[ 'm'] else 'buy' # self is reversed intentionally elif 'isBuyerMaker' in trade: side = 'sell' if trade['isBuyerMaker'] else 'buy' else: if 'isBuyer' in trade: side = 'buy' if ( trade['isBuyer']) else 'sell' # self is a True side fee = None if 'commission' in trade: fee = { 'cost': self.safe_number(trade, 'commission'), 'currency': self.safe_currency_code( self.safe_string(trade, 'commissionAsset')), } takerOrMaker = None if 'isMaker' in trade: takerOrMaker = 'maker' if trade['isMaker'] else 'taker' marketId = self.safe_string(trade, 'symbol') symbol = self.safe_symbol(marketId, market) return { 'info': trade, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'symbol': symbol, 'id': id, 'order': orderId, 'type': None, 'takerOrMaker': takerOrMaker, 'side': side, 'price': price, 'amount': amount, 'cost': cost, 'fee': fee, }
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) 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_order(self, order, market=None): # # # fetchOrder # # { # "transaction_date": "1572497603668315", # "type": "bid", # "order_status": "Completed", # "order_currency": "BTC", # "payment_currency": "KRW", # "order_price": "8601000", # "order_qty": "0.007", # "cancel_date": "", # "cancel_type": "", # "contract": [ # { # "transaction_date": "1572497603902030", # "price": "8601000", # "units": "0.005", # "fee_currency": "KRW", # "fee": "107.51", # "total": "43005" # }, # ] # } # # { # order_date: '1603161798539254', # type: 'ask', # order_status: 'Cancel', # order_currency: 'BTC', # payment_currency: 'KRW', # watch_price: '0', # order_price: '13344000', # order_qty: '0.0125', # cancel_date: '1603161803809993', # cancel_type: '사용자취소', # contract: [ # { # transaction_date: '1603161799976383', # price: '13344000', # units: '0.0015', # fee_currency: 'KRW', # fee: '0', # total: '20016' # } # ], # } # # fetchOpenOrders # # { # "order_currency": "BTC", # "payment_currency": "KRW", # "order_id": "C0101000007408440032", # "order_date": "1571728739360570", # "type": "bid", # "units": "5.0", # "units_remaining": "5.0", # "price": "501000", # } # timestamp = self.safe_integer_product(order, 'order_date', 0.001) sideProperty = self.safe_value_2(order, 'type', 'side') side = 'buy' if (sideProperty == 'bid') else 'sell' status = self.parse_order_status(self.safe_string(order, 'order_status')) price = self.safe_string_2(order, 'order_price', 'price') type = 'limit' if Precise.string_equals(price, '0'): type = 'market' amount = self.safe_string_2(order, 'order_qty', 'units') remaining = self.safe_string(order, 'units_remaining') if remaining is None: if status == 'closed': remaining = '0' elif status != 'canceled': remaining = amount symbol = None baseId = self.safe_string(order, 'order_currency') quoteId = self.safe_string(order, 'payment_currency') base = self.safe_currency_code(baseId) quote = self.safe_currency_code(quoteId) if (base is not None) and (quote is not None): symbol = base + '/' + quote if symbol is None: market = self.safe_market(None, market) symbol = market['symbol'] id = self.safe_string(order, 'order_id') rawTrades = self.safe_value(order, 'contract', []) return self.safe_order({ 'info': order, 'id': id, 'clientOrderId': None, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'lastTradeTimestamp': None, 'symbol': symbol, 'type': type, 'timeInForce': None, 'postOnly': None, 'side': side, 'price': price, 'stopPrice': None, 'amount': amount, 'cost': None, 'average': None, 'filled': None, 'remaining': remaining, 'status': status, 'fee': None, 'trades': rawTrades, }, market)
def parse_trade(self, trade, market=None): # # fetchTrades(public) # # { # side: 'buy', # price: 0.33634, # amount: 0.01, # timestamp: 1564240008000 # milliseconds # } # # fetchMyTrades(private) # # { # id: '1564223032.892829.3.tg15', # orderId: '1564223032.671436.707548@1379:1', # commission: 0, # side: 'buy', # price: 0.32874, # amount: 0.607, # timestamp: 1564223033 # seconds # } # type = None timestamp = self.safe_integer_2(trade, 'timestamp', 'time') if timestamp is not None: # 03 Jan 2009 - first block if timestamp < 1230940800000: timestamp *= 1000 priceString = self.safe_string(trade, 'price') amountString = self.safe_string(trade, 'amount') price = self.parse_number(priceString) amount = self.parse_number(amountString) cost = self.parse_number(Precise.string_mul(priceString, amountString)) side = self.safe_string(trade, 'side') symbol = None if market is not None: symbol = market['symbol'] id = self.safe_string(trade, 'id') orderId = self.safe_string(trade, 'orderId') feeCost = self.safe_number(trade, 'commission') fee = None if feeCost is not None: fee = { 'cost': feeCost, 'currency': None, } return { 'info': trade, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'symbol': symbol, 'id': id, 'order': orderId, 'type': type, 'takerOrMaker': None, 'side': side, 'price': price, 'amount': amount, 'cost': cost, 'fee': fee, }
def parse_trade(self, trade, market=None): # # fetchTrades(public) # # { # "timestamp": "1416893212", # "price": "420000.0", # "qty": "0.1", # "is_ask": "1" # } # # fetchMyTrades(private) # # { # "timestamp": "1416561032", # "price": "419000.0", # "type": "bid", # "qty": "0.001", # "feeRate": "-0.0015", # "fee": "-0.0000015", # "orderId": "E84A1AC2-8088-4FA0-B093-A3BCDB9B3C85" # } # timestamp = self.safe_timestamp(trade, 'timestamp') symbol = market['symbol'] if (market is not None) else None is_ask = self.safe_string(trade, 'is_ask') side = self.safe_string(trade, 'type') if is_ask is not None: if is_ask == '1': side = 'sell' elif is_ask == '0': side = 'buy' else: if side == 'ask': side = 'sell' elif side == 'bid': side = 'buy' priceString = self.safe_string(trade, 'price') amountString = self.safe_string(trade, 'qty') price = self.parse_number(priceString) amount = self.parse_number(amountString) cost = self.parse_number(Precise.string_mul(priceString, amountString)) orderId = self.safe_string(trade, 'orderId') feeCost = self.safe_number(trade, 'fee') fee = None if feeCost is not None: feeCost = abs(feeCost) feeRate = self.safe_number(trade, 'feeRate') feeRate = abs(feeRate) feeCurrencyCode = None if market is not None: feeCurrencyCode = market['quote'] if ( side == 'sell') else market['base'] fee = { 'cost': feeCost, 'currency': feeCurrencyCode, 'rate': feeRate, } return { 'id': self.safe_string(trade, 'id'), 'info': trade, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'order': orderId, 'symbol': symbol, 'type': None, 'side': side, 'takerOrMaker': None, 'price': price, 'amount': amount, 'cost': cost, 'fee': fee, }
def parse_trade(self, trade, market=None): # # fetchTrades(public) # # { # id: 1584948803298490, # amount: "2.737", # price: "0.021209", # direction: "sell", # ts: 1584948803 # } # # fetchOrder trades # # { # "id":null, # "ctime":"2020-03-23 20:07:17", # "price":"123.9", # "number":"0.010688626311541565", # "total_price":"1.324320799999999903", # "fee":"0.000021377252623083" # } # id = self.safe_string(trade, 'id') ctime = self.parse8601(self.safe_string(trade, 'ctime')) timestamp = self.safe_timestamp(trade, 'ts', ctime) - 28800000 # 8 hours, adjust to UTC symbol = None if (symbol is None) and (market is not None): symbol = market['symbol'] side = self.safe_string(trade, 'direction') priceString = self.safe_string(trade, 'price') amountString = self.safe_string_2(trade, 'amount', 'number') price = self.parse_number(priceString) amount = self.parse_number(amountString) cost = self.safe_number(trade, 'total_price') if cost is None: cost = self.parse_number(Precise.string_mul(priceString, amountString)) feeCost = self.safe_number(trade, 'fee') fee = None if feeCost is not None: feeCurrencyCode = None if market is not None: if side == 'buy': feeCurrencyCode = market['base'] elif side == 'sell': feeCurrencyCode = market['quote'] fee = { 'cost': feeCost, 'currency': feeCurrencyCode, } return { 'id': id, 'info': trade, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'symbol': symbol, 'order': None, 'type': None, 'side': side, 'takerOrMaker': None, 'price': price, 'amount': amount, 'cost': cost, 'fee': fee, }
def parse_trade(self, trade, market=None): # # fetchTrades(public) # # { # "book": "btc_usdt", # "created_at": "2021-11-24T12:14:53+0000", # "amount": "0.00026562", # "maker_side": "sell", # "price": "56471.55", # "tid": "52557338" # } # # fetchMyTrades(private) # # { # "book": "btc_usdt", # "created_at": "2021-11-24T12:31:03+0000", # "minor": "11.30356000", # "major": "-0.00020000", # "fees_amount": "0.01119052", # "fees_currency": "usdt", # "minor_currency": "usdt", # "major_currency": "btc", # "oid": "djTzMIWx2Vi3iMjl", # "tid": "52559051", # "price": "56517.80", # "side": "sell", # "maker_side": "buy" # } # # fetchOrderTrades(private) # # { # "book": "btc_usdt", # "created_at": "2021-11-24T12:30:52+0000", # "minor": "-11.33047916", # "major": "0.00020020", # "fees_amount": "0.00000020", # "fees_currency": "btc", # "minor_currency": "usdt", # "major_currency": "btc", # "oid": "O0D2zcljjjQF5xlG", # "tid": "52559030", # "price": "56595.80", # "side": "buy", # "maker_side": "sell" # } # timestamp = self.parse8601(self.safe_string(trade, 'created_at')) marketId = self.safe_string(trade, 'book') symbol = self.safe_symbol(marketId, market, '_') side = self.safe_string_2(trade, 'side', 'maker_side') makerSide = self.safe_string(trade, 'maker_side') takerOrMaker = None if side == makerSide: takerOrMaker = 'maker' else: takerOrMaker = 'taker' amount = self.safe_string_2(trade, 'amount', 'major') if amount is not None: amount = Precise.string_abs(amount) fee = None feeCost = self.safe_string(trade, 'fees_amount') if feeCost is not None: feeCurrencyId = self.safe_string(trade, 'fees_currency') feeCurrency = self.safe_currency_code(feeCurrencyId) fee = { 'cost': feeCost, 'currency': feeCurrency, } cost = self.safe_string(trade, 'minor') if cost is not None: cost = Precise.string_abs(cost) price = self.safe_string(trade, 'price') orderId = self.safe_string(trade, 'oid') id = self.safe_string(trade, 'tid') return self.safe_trade({ 'id': id, 'info': trade, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'symbol': symbol, 'order': orderId, 'type': None, 'side': side, 'takerOrMaker': takerOrMaker, 'price': price, 'amount': amount, 'cost': cost, 'fee': fee, }, market)
def parse_order(self, order, market=None): # # createOrder # # { # "result": "success", # "errorCode": "0", # "orderId": "8a82c561-40b4-4cb3-9bc0-9ac9ffc1d63b" # } # # fetchOrder # # { # "status": "live", # injected in fetchOrder # "orderId": "32FF744B-D501-423A-8BA1-05BB6BE7814A", # "currency": "BTC", # "type": "bid", # "price": "2922000.0", # "qty": "115.4950", # "remainQty": "45.4950", # "feeRate": "0.0003", # "fee": "0", # "timestamp": "1499340941" # } # # fetchOpenOrders # # { # "index": "0", # "orderId": "68665943-1eb5-4e4b-9d76-845fc54f5489", # "timestamp": "1449037367", # "price": "444000.0", # "qty": "0.3456", # "type": "ask", # "feeRate": "-0.0015" # } # id = self.safe_string(order, 'orderId') priceString = self.safe_string(order, 'price') timestamp = self.safe_timestamp(order, 'timestamp') side = self.safe_string(order, 'type') if side == 'ask': side = 'sell' elif side == 'bid': side = 'buy' remainingString = self.safe_string(order, 'remainQty') amountString = self.safe_string(order, 'qty') status = self.safe_string(order, 'status') # https://github.com/ccxt/ccxt/pull/7067 if status == 'live': if (remainingString is not None) and (amountString is not None): isLessThan = Precise.string_lt(remainingString, amountString) if isLessThan: status = 'canceled' status = self.parse_order_status(status) symbol = None base = None quote = None marketId = self.safe_string_lower(order, 'currency') if marketId is not None: if marketId in self.markets_by_id: market = self.markets_by_id[marketId] else: base = self.safe_currency_code(marketId) quote = 'KRW' symbol = base + '/' + quote if (symbol is None) and (market is not None): symbol = market['symbol'] base = market['base'] quote = market['quote'] fee = None feeCostString = self.safe_string(order, 'fee') if feeCostString is not None: feeCurrencyCode = quote if (side == 'sell') else base fee = { 'cost': feeCostString, 'rate': self.safe_string(order, 'feeRate'), 'currency': feeCurrencyCode, } return self.safe_order({ 'info': order, 'id': id, 'clientOrderId': None, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'lastTradeTimestamp': None, 'symbol': symbol, 'type': 'limit', 'timeInForce': None, 'postOnly': None, 'side': side, 'price': priceString, 'stopPrice': None, 'cost': None, 'average': None, 'amount': amountString, 'filled': None, 'remaining': remainingString, 'status': status, 'fee': fee, 'trades': None, }, market)
async def fetch_markets(self, params={}): response = await self.marketsGetSpotPairs(params) # # { # "success": 1, # "data": { # "pairs": [ # { # "name": "btc_jpy", # "base_asset": "btc", # "quote_asset": "jpy", # "maker_fee_rate_base": "0", # "taker_fee_rate_base": "0", # "maker_fee_rate_quote": "-0.0002", # "taker_fee_rate_quote": "0.0012", # "unit_amount": "0.0001", # "limit_max_amount": "1000", # "market_max_amount": "10", # "market_allowance_rate": "0.2", # "price_digits": 0, # "amount_digits": 4, # "is_enabled": True, # "stop_order": False, # "stop_order_and_cancel": False # } # ] # } # } # data = self.safe_value(response, 'data') pairs = self.safe_value(data, 'pairs', []) result = [] for i in range(0, len(pairs)): entry = pairs[i] id = self.safe_string(entry, 'name') baseId = self.safe_string(entry, 'base_asset') quoteId = self.safe_string(entry, 'quote_asset') base = self.safe_currency_code(baseId) quote = self.safe_currency_code(quoteId) symbol = base + '/' + quote maker = self.safe_number(entry, 'maker_fee_rate_quote') taker = self.safe_number(entry, 'taker_fee_rate_quote') pricePrecisionString = self.safe_string(entry, 'price_digits') priceLimit = self.parse_precision(pricePrecisionString) precision = { 'price': int(pricePrecisionString), 'amount': self.safe_integer(entry, 'amount_digits'), } active = self.safe_value(entry, 'is_enabled') minAmountString = self.safe_string(entry, 'unit_amount') minCost = Precise.string_mul(minAmountString, priceLimit) limits = { 'amount': { 'min': self.safe_number(entry, 'unit_amount'), 'max': self.safe_number(entry, 'limit_max_amount'), }, 'price': { 'min': self.parse_number(priceLimit), 'max': None, }, 'cost': { 'min': self.parse_number(minCost), 'max': None, }, } result.append({ 'info': entry, 'id': id, 'symbol': symbol, 'baseId': baseId, 'quoteId': quoteId, 'base': base, 'quote': quote, 'precision': precision, 'limits': limits, 'active': active, 'maker': maker, 'taker': taker, }) 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) 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.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
async def fetch_markets(self, params={}): markets = await 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 = await 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, 'type': 'spot', 'spot': True, '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': self.extend(market, precision), }) return result
def parse_trade(self, trade, market=None): # # public fetchTrades, private fetchMyTrades # # { # "created_at":1601322501, # "amount":"0.00276", # "price":"10850.020000", # "side":"SELL", # "pair":"BTC_USDC", # "taker_fee":"0", # "taker_side":"SELL", # "maker_fee":"0", # "taker":2577953, # "maker":2577937 # } # # createOrder fills # # { # "pair":"BTC_USDC", # "exchanged":0.002, # "match_price":10593.99, # "maker_fee":0.0, # "taker_fee":0.0, # "timestamp":1601730306942 # } # id = self.safe_string(trade, 'id') timestamp = self.safe_integer(trade, 'timestamp') timestamp = self.safe_timestamp(trade, 'created_at', timestamp) side = self.safe_string(trade, 'side') takerSide = self.safe_string(trade, 'taker_side') takerOrMaker = 'taker' if (takerSide == side) else 'maker' if side is not None: side = side.lower() priceString = self.safe_string_2(trade, 'price', 'match_price') amountString = self.safe_string_2(trade, 'amount', 'exchanged') price = self.parse_number(priceString) amount = self.parse_number(amountString) cost = self.parse_number(Precise.string_mul(priceString, amountString)) marketId = self.safe_string(trade, 'pair') market = self.safe_market(marketId, market) feeCost = self.safe_number(trade, takerOrMaker + '_fee') orderId = self.safe_string(trade, takerOrMaker) fee = None if feeCost is not None: fee = { 'cost': feeCost, 'currency': market['base'] if (side == 'buy') else market['quote'], } return { 'id': id, 'order': orderId, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'symbol': market['symbol'], 'type': None, 'side': side, 'price': price, 'amount': amount, 'cost': cost, 'takerOrMaker': takerOrMaker, 'fee': fee, 'info': trade, }
def parse_trade(self, trade, market=None): # # fetchTrades(public) # # { # "id": 38199941, # "price": "3378.67", # "amount": "0.019812", # "taker_side": "ASK", # "created_at": "2019-01-29T06:05:56Z" # } # # fetchMyTrades(private) # # { # "id": 10854280, # "asset_pair_name": "XIN-USDT", # "price": "70", # "amount": "1", # "taker_side": "ASK", # "maker_order_id": 58284908, # "taker_order_id": 58284909, # "maker_fee": "0.0008", # "taker_fee": "0.07", # "side": "SELF_TRADING", # "inserted_at": "2019-04-16T12:00:01Z" # }, # # { # "id": 10854263, # "asset_pair_name": "XIN-USDT", # "price": "75.7", # "amount": "12.743149", # "taker_side": "BID", # "maker_order_id": null, # "taker_order_id": 58284888, # "maker_fee": null, # "taker_fee": "0.0025486298", # "side": "BID", # "inserted_at": "2019-04-15T06:20:57Z" # } # timestamp = self.parse8601(self.safe_string_2(trade, 'created_at', 'inserted_at')) priceString = self.safe_string(trade, 'price') amountString = self.safe_string(trade, 'amount') price = self.parse_number(priceString) amount = self.parse_number(amountString) cost = self.parse_number(Precise.string_mul(priceString, amountString)) marketId = self.safe_string(trade, 'asset_pair_name') symbol = self.safe_symbol(marketId, market, '-') side = self.safe_string(trade, 'side') takerSide = self.safe_string(trade, 'taker_side') takerOrMaker = None if (takerSide is not None) and (side is not None) and (side != 'SELF_TRADING'): takerOrMaker = 'taker' if (takerSide == side) else 'maker' if side is None: # taker side is not related to buy/sell side # the following code is probably a mistake side = 'sell' if (takerSide == 'ASK') else 'buy' else: if side == 'BID': side = 'buy' elif side == 'ASK': side = 'sell' makerOrderId = self.safe_string(trade, 'maker_order_id') takerOrderId = self.safe_string(trade, 'taker_order_id') orderId = None if makerOrderId is not None: if takerOrderId is not None: orderId = [makerOrderId, takerOrderId] else: orderId = makerOrderId elif takerOrderId is not None: orderId = takerOrderId id = self.safe_string(trade, 'id') result = { 'id': id, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'symbol': symbol, 'order': orderId, 'type': 'limit', 'side': side, 'takerOrMaker': takerOrMaker, 'price': price, 'amount': amount, 'cost': float(cost), 'info': trade, } makerCurrencyCode = None takerCurrencyCode = None if (market is not None) and (takerOrMaker is not None): if side == 'buy': if takerOrMaker == 'maker': makerCurrencyCode = market['base'] takerCurrencyCode = market['quote'] else: makerCurrencyCode = market['quote'] takerCurrencyCode = market['base'] else: if takerOrMaker == 'maker': makerCurrencyCode = market['quote'] takerCurrencyCode = market['base'] else: makerCurrencyCode = market['base'] takerCurrencyCode = market['quote'] elif side == 'SELF_TRADING': if takerSide == 'BID': makerCurrencyCode = market['quote'] takerCurrencyCode = market['base'] elif takerSide == 'ASK': makerCurrencyCode = market['base'] takerCurrencyCode = market['quote'] makerFeeCost = self.safe_number(trade, 'maker_fee') takerFeeCost = self.safe_number(trade, 'taker_fee') if makerFeeCost is not None: if takerFeeCost is not None: result['fees'] = [ {'cost': makerFeeCost, 'currency': makerCurrencyCode}, {'cost': takerFeeCost, 'currency': takerCurrencyCode}, ] else: result['fee'] = {'cost': makerFeeCost, 'currency': makerCurrencyCode} elif takerFeeCost is not None: result['fee'] = {'cost': takerFeeCost, 'currency': takerCurrencyCode} else: result['fee'] = None return result
def parse_trade(self, trade, market=None): # # public fetchTrades # # { # "amount":"0.0632", # "price":"0.037288", # "side":"BUY", # "timestamp":1599279694576 # } # # private fetchOrderTrades # # { # "id": "608717046691139584", # "orderId": "608716957545402368", # "symbol": "BTC_BRL", # "side": "BUY", # "amount": "0.0988", # "price": "45514.76", # "fee": "0.0000988 BTC", # "role": "MAKER", # "timestamp": 1565171053345 # } # # private fetchMyTrades # # { # "id": "608717046691139584", # "orderId": "608716957545402368", # "symbol": "BTC_BRL", # "side": "BUY", # "amount": "0.0988", # "price": "45514.76", # "fee": "0.0000988 BTC", # "feeAmount": "0.0000988", # "feeCurrency": "BTC", # "role": "MAKER", # "timestamp": 1565171053345 # } # id = self.safe_string(trade, 'id') orderId = self.safe_string(trade, 'orderId') timestamp = self.safe_integer(trade, 'timestamp') side = self.safe_string_lower(trade, 'side') priceString = self.safe_string(trade, 'price') amountString = self.safe_string(trade, 'amount') price = self.parse_number(priceString) amount = self.parse_number(amountString) cost = self.safe_number(trade, 'volume') if cost is None: cost = self.parse_number( Precise.string_mul(priceString, amountString)) marketId = self.safe_string(trade, 'symbol') symbol = self.safe_symbol(marketId, market, '_') takerOrMaker = self.safe_string_lower(trade, 'role') feeString = self.safe_string(trade, 'fee') fee = None if feeString is not None: parts = feeString.split(' ') feeCurrencyId = self.safe_string(parts, 1) feeCurrencyCode = self.safe_currency_code(feeCurrencyId) fee = { 'cost': self.safe_number(parts, 0), 'currency': feeCurrencyCode, } return { 'id': id, 'order': orderId, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'symbol': symbol, 'type': None, 'side': side, 'price': price, 'amount': amount, 'cost': cost, 'takerOrMaker': takerOrMaker, 'fee': fee, 'info': trade, }
def parse_bid_ask(self, bidask, priceKey=0, amountKey=1): price = self.safe_string(bidask, priceKey) amount = Precise.string_abs(self.safe_string(bidask, amountKey)) return [self.parse_number(price), self.parse_number(amount)]
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) 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') makerString = self.safe_string(fee, 'maker', '0.2') makerString = Precise.string_div(makerString, '100') status = self.safe_string(entry, 'status') result.append({ 'id': id, 'symbol': base + '/' + quote, 'base': base, 'quote': quote, 'settle': None, 'baseId': baseId, 'quoteId': quoteId, 'settleId': None, 'type': 'spot', 'spot': isSpot, 'margin': False, 'swap': False, 'future': False, 'option': False, 'active': (status == 'trading'), 'contract': False, 'linear': None, 'inverse': None, 'taker': self.parse_number(takerString), 'maker': self.parse_number(makerString), 'contractSize': None, 'expiry': None, 'expiryDatetime': None, 'strike': None, 'optionType': None, 'precision': { 'amount': self.safe_integer(entry, 'baseAssetPrecision'), 'price': self.safe_integer(entry, 'quoteAssetPrecision'), }, 'limits': { 'leverage': { 'min': None, 'max': None, }, 'price': { 'min': minPrice, 'max': None, }, 'amount': { 'min': None, 'max': None, }, 'cost': { 'min': None, 'max': None, }, }, 'info': entry, }) return result
def fetch_markets(self, params={}): # # "USDC-GBP": { # "base_currency": "USDC", # "base_currency_scale": 6, # "counter_currency": "GBP", # "counter_currency_scale": 2, # "min_price_increment": 10000, # "min_price_increment_scale": 8, # "min_order_size": 500000000, # "min_order_size_scale": 8, # "max_order_size": 0, # "max_order_size_scale": 8, # "lot_size": 10000, # "lot_size_scale": 8, # "status": "open", # "id": 68, # "auction_price": 0, # "auction_size": 0, # "auction_time": "", # "imbalance": 0 # } # markets = self.publicGetSymbols(params) marketIds = list(markets.keys()) result = [] for i in range(0, len(marketIds)): marketId = marketIds[i] market = self.safe_value(markets, marketId) baseId = self.safe_string(market, 'base_currency') quoteId = self.safe_string(market, 'counter_currency') base = self.safe_currency_code(baseId) quote = self.safe_currency_code(quoteId) numericId = self.safe_number(market, 'id') active = None marketState = self.safe_string(market, 'status') if marketState == 'open': active = 'true' else: active = 'false' # price precision minPriceIncrementString = self.safe_string(market, 'min_price_increment') minPriceIncrementScaleString = self.safe_string( market, 'min_price_increment_scale') minPriceScalePrecisionString = self.parse_precision( minPriceIncrementScaleString) pricePrecisionString = Precise.string_mul( minPriceIncrementString, minPriceScalePrecisionString) pricePrecision = self.parse_number(pricePrecisionString) # amount precision lotSizeString = self.safe_string(market, 'lot_size') lotSizeScaleString = self.safe_string(market, 'lot_size_scale') lotSizeScalePrecisionString = self.parse_precision( lotSizeScaleString) amountPrecisionString = Precise.string_mul( lotSizeString, lotSizeScalePrecisionString) amountPrecision = self.parse_number(amountPrecisionString) # minimum order size minOrderSizeString = self.safe_string(market, 'min_order_size') minOrderSizeScaleString = self.safe_string(market, 'min_order_size_scale') minOrderSizeScalePrecisionString = self.parse_precision( minOrderSizeScaleString) minOrderSizePreciseString = Precise.string_mul( minOrderSizeString, minOrderSizeScalePrecisionString) minOrderSize = self.parse_number(minOrderSizePreciseString) # maximum order size maxOrderSize = None maxOrderSize = self.safe_string(market, 'max_order_size') if maxOrderSize != '0': maxOrderSizeScaleString = self.safe_string( market, 'max_order_size_scale') maxOrderSizeScalePrecisionString = self.parse_precision( maxOrderSizeScaleString) maxOrderSizeString = Precise.string_mul( maxOrderSize, maxOrderSizeScalePrecisionString) maxOrderSize = self.parse_number(maxOrderSizeString) else: maxOrderSize = None result.append({ 'info': market, 'id': marketId, 'numericId': numericId, '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': active, 'contract': False, 'linear': None, 'inverse': None, 'contractSize': None, 'expiry': None, 'expiryDatetime': None, 'strike': None, 'optionType': None, 'precision': { 'amount': amountPrecision, 'price': pricePrecision, }, 'limits': { 'leverage': { 'min': None, 'max': None, }, 'amount': { 'min': minOrderSize, 'max': maxOrderSize, }, 'price': { 'min': None, 'max': None, }, 'cost': { 'min': None, 'max': None, }, }, }) return result
def parse_trade(self, trade, market=None): # # fetchTrades # { # "pair": "BTCUSDT", # "pairNormalized": "BTC_USDT", # "numerator": "BTC", # "denominator": "USDT", # "date": "1618916879083", # "tid": "637545136790672520", # "price": "55774", # "amount": "0.27917100", # "side": "buy" # } # # fetchMyTrades # { # "price": "56000", # "numeratorSymbol": "BTC", # "denominatorSymbol": "USDT", # "orderType": "buy", # "orderId": "2606935102", # "id": "320874372", # "timestamp": "1618916479593", # "amount": "0.00020000", # "fee": "0", # "tax": "0" # } # timestamp = self.safe_integer_2(trade, 'date', 'timestamp') id = self.safe_string_2(trade, 'tid', 'id') order = self.safe_string(trade, 'orderId') priceString = self.safe_string(trade, 'price') amountString = Precise.string_abs(self.safe_string(trade, 'amount')) marketId = self.safe_string(trade, 'pair') symbol = self.safe_symbol(marketId, market) side = self.safe_string_2(trade, 'side', 'orderType') fee = None feeAmountString = self.safe_string(trade, 'fee') if feeAmountString is not None: feeCurrency = self.safe_string(trade, 'denominatorSymbol') fee = { 'cost': Precise.string_abs(feeAmountString), 'currency': self.safe_currency_code(feeCurrency), } return self.safe_trade( { 'info': trade, 'id': id, 'order': order, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'symbol': symbol, 'type': None, 'side': side, 'takerOrMaker': None, 'price': priceString, 'amount': amountString, 'cost': None, 'fee': fee, }, market)
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 parse_order(self, order, market): # # fetchOrders / fetchOpenOrders # { # "id": 2605984008, # "price": "55000", # "amount": "0.00050000", # "quantity": "0.00050000", # "stopPrice": "0", # "pairSymbol": "BTCUSDT", # "pairSymbolNormalized": "BTC_USDT", # "type": "buy", # "method": "limit", # "orderClientId": "f479bdb6-0965-4f03-95b5-daeb7aa5a3a5", # "time": 0, # "updateTime": 1618913083543, # "status": "Untouched", # "leftAmount": "0.00050000" # } # # createOrder # { # "id": "2606935102", # "quantity": "0.0002", # "price": "56000", # "stopPrice": null, # "newOrderClientId": "98e5c491-7ed9-462b-9666-93553180fb28", # "type": "buy", # "method": "limit", # "pairSymbol": "BTCUSDT", # "pairSymbolNormalized": "BTC_USDT", # "datetime": "1618916479523" # } # id = self.safe_string(order, 'id') price = self.safe_string(order, 'price') amountString = self.safe_string_2(order, 'amount', 'quantity') amount = Precise.string_abs(amountString) remaining = self.safe_string(order, 'leftAmount') marketId = self.safe_number(order, 'pairSymbol') symbol = self.safe_symbol(marketId, market) side = self.safe_string(order, 'type') type = self.safe_string(order, 'method') clientOrderId = self.safe_string(order, 'orderClientId') timestamp = self.safe_integer_2(order, 'updateTime', 'datetime') rawStatus = self.safe_string(order, 'status') status = self.parse_order_status(rawStatus) return self.safe_order( { 'info': order, 'id': id, 'price': price, 'amount': amount, 'remaining': remaining, 'filled': None, 'cost': None, 'average': None, 'status': status, 'side': side, 'type': type, 'clientOrderId': clientOrderId, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'symbol': symbol, 'fee': None, }, market)
async def fetch_markets(self, params={}): response = await 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, 'type': 'spot', 'spot': True, 'active': active, 'taker': takerFee, 'precision': precision, 'limits': limits, 'info': market, }) return result
def parse_trade(self, trade, market=None): # # fetchTrades(public) # # { # timestamp: "2015-05-22T17:45:34.7570000Z", # matchNumber: "5CR1JEUBBM8J", # price: "351.45000000", # amount: "0.00010000" # } # # fetchMyTrades(private) # # { # "orderId": "248ffda4-83a0-4033-a5bb-8929d523f59f", # "timestamp": "2015-05-11T14:48:01.9870000Z", # "instrument": "XBTUSD", # "direction": "buy", # buy or sell # "currency1": "XBT", # base currency # "currency1Amount": "0.00010000", # order amount in base currency # "currency2": "USD", # quote currency # "currency2Amount": "0.0250530000000000", # order cost in quote currency # "rate": "250.53000000", # "commissionPaid": "0.00000000", # net trade fee paid after using any available rebate balance # "commissionCurrency": "USD", # "rebatesApplied": "-0.000125265", # negative values represent amount of rebate balance used for trades removing liquidity from order book; positive values represent amount of rebate balance earned from trades adding liquidity to order book # "rebateCurrency": "USD", # "executionId": "23132" # } # id = self.safe_string_2(trade, 'executionId', 'matchNumber') timestamp = self.parse8601(self.safe_string(trade, 'timestamp')) side = self.safe_string(trade, 'direction') orderId = self.safe_string(trade, 'orderId') feeCost = self.safe_number(trade, 'commissionPaid') feeCurrencyId = self.safe_string(trade, 'commissionCurrency') feeCurrency = self.safe_currency_code(feeCurrencyId) rebatesApplied = self.safe_number(trade, 'rebatesApplied') if rebatesApplied is not None: rebatesApplied = -rebatesApplied rebateCurrencyId = self.safe_string(trade, 'rebateCurrency') rebateCurrency = self.safe_currency_code(rebateCurrencyId) priceString = self.safe_string_2(trade, 'price', 'rate') amountString = self.safe_string_2(trade, 'currency1Amount', 'amount') price = self.parse_number(priceString) amount = self.parse_number(amountString) cost = self.parse_number(Precise.string_mul(priceString, amountString)) symbol = None marketId = self.safe_string(trade, 'instrument') if marketId is not None: if marketId in self.markets_by_id: market = self.markets_by_id[marketId] else: baseId = self.safe_string(trade, 'currency1') quoteId = self.safe_string(trade, 'currency2') base = self.safe_currency_code(baseId) quote = self.safe_currency_code(quoteId) symbol = base + '/' + quote if symbol is None: if market is not None: symbol = market['symbol'] result = { 'info': trade, 'id': id, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'symbol': symbol, 'order': orderId, 'type': None, 'side': side, 'takerOrMaker': None, 'price': price, 'amount': amount, 'cost': cost, 'fee': None, } if feeCost is not None: if rebatesApplied is not None: if feeCurrency == rebateCurrency: feeCost = self.sum(feeCost, rebatesApplied) result['fee'] = { 'cost': feeCost, 'currency': feeCurrency, } else: result['fees'] = [ { 'cost': feeCost, 'currency': feeCurrency, }, { 'cost': rebatesApplied, 'currency': rebateCurrency, }, ] else: result['fee'] = { 'cost': feeCost, 'currency': feeCurrency, } if not ('fee' in result): if not ('fees' in result): result['fee'] = None return result
async def fetch_markets(self, params={}): markets = await self.publicGetCurrencyPairsAll(params) # # [ # { # "aux_unit_point": 0, # "item_japanese": "\u30d3\u30c3\u30c8\u30b3\u30a4\u30f3", # "aux_unit_step": 5.0, # "description": "\u30d3\u30c3\u30c8\u30b3\u30a4\u30f3\u30fb\u65e5\u672c\u5186\u306e\u53d6\u5f15\u3092\u884c\u3046\u3053\u3068\u304c\u3067\u304d\u307e\u3059", # "item_unit_min": 0.001, # "event_number": 0, # "currency_pair": "btc_jpy", # "is_token": False, # "aux_unit_min": 5.0, # "aux_japanese": "\u65e5\u672c\u5186", # "id": 1, # "item_unit_step": 0.0001, # "name": "BTC/JPY", # "seq": 0, # "title": "BTC/JPY" # } # ] # result = [] for i in range(0, len(markets)): market = markets[i] id = self.safe_string(market, 'currency_pair') name = self.safe_string(market, 'name') baseId, quoteId = name.split('/') base = self.safe_currency_code(baseId) quote = self.safe_currency_code(quoteId) symbol = base + '/' + quote fees = self.safe_value(self.options['fees'], symbol, self.fees['trading']) itemUnitStep = self.safe_string(market, 'item_unit_step') result.append({ 'id': id, 'symbol': symbol, 'base': base, 'quote': quote, 'settle': None, 'baseId': baseId, 'quoteId': quoteId, 'settleId': None, 'type': 'spot', 'spot': True, 'margin': None, 'swap': False, 'future': False, 'option': False, 'active': None, # can trade or not 'contract': False, 'linear': None, 'inverse': None, 'taker': fees['taker'], 'maker': fees['maker'], 'contractSize': None, 'expiry': None, 'expiryDatetime': None, 'strike': None, 'optionType': None, 'precision': { 'amount': Precise.string_mul(itemUnitStep, '-1e10'), 'price': self.safe_integer(market, 'aux_unit_point'), }, 'limits': { 'leverage': { 'min': None, 'max': None, }, 'amount': { 'min': self.safe_number(market, 'item_unit_min'), 'max': None, }, 'price': { 'min': self.safe_number(market, 'aux_unit_min'), 'max': None, }, 'cost': { 'min': None, 'max': None, }, }, 'info': market, }) return result
def parse_trade(self, trade, market): # # public fetchTrades # # { # "id": "d5983ab8-e9ec-48c9-bdd0-1b18f8e80a71", # "assetPairId": "BTCUSD", # "dateTime": "2019-05-15T06:52:02.147Z", # "volume": 0.00019681, # "index": 0, # "price": 8023.333, # "action": "Buy" # } # # private fetchMyTrades # { # Id: '3500b83c-9963-4349-b3ee-b3e503073cea', # OrderId: '83b50feb-8615-4dc6-b606-8a4168ecd708', # DateTime: '2020-05-19T11:17:39.31+00:00', # Timestamp: '2020-05-19T11:17:39.31+00:00', # State: null, # Amount: -0.004, # BaseVolume: -0.004, # QuotingVolume: 39.3898, # Asset: 'BTC', # BaseAssetId: 'BTC', # QuotingAssetId: 'USD', # AssetPair: 'BTCUSD', # AssetPairId: 'BTCUSD', # Price: 9847.427, # Fee: {Amount: null, Type: 'Unknown', FeeAssetId: null} # }, marketId = self.safe_string(trade, 'AssetPairId') symbol = self.safe_symbol(marketId, market) id = self.safe_string_2(trade, 'id', 'Id') orderId = self.safe_string(trade, 'OrderId') timestamp = self.parse8601(self.safe_string_2(trade, 'dateTime', 'DateTime')) priceString = self.safe_string_2(trade, 'price', 'Price') amountString = self.safe_string_2(trade, 'volume', 'Amount') side = self.safe_string_lower(trade, 'action') if side is None: side = 'sell' if (amountString[0] == '-') else 'buy' amountString = Precise.string_abs(amountString) price = self.parse_number(priceString) amount = self.parse_number(amountString) cost = self.parse_number(Precise.string_mul(priceString, amountString)) fee = { 'cost': 0, # There are no fees for trading. https://www.lykke.com/wallet-fees-and-limits/ 'currency': market['quote'], } return { 'id': id, 'info': trade, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'symbol': symbol, 'type': None, 'order': orderId, 'side': side, 'takerOrMaker': None, 'price': price, 'amount': amount, 'cost': cost, 'fee': fee, }
def parse_transaction(self, transaction, currency=None): # # withdraw # # { # id: '1', # address: '1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2', # amount: '0.01', # state: 'pending', # currency: 'BTC', # withdrawal_fee: '0.0007', # created_at: '1626000533', # updated_at: '1626000533', # payment_id: null, # transaction_hash: null, # broadcasted_at: null, # wallet_label: null, # chain_name: 'Bitcoin', # network: null # }, # # fetchWithdrawals # # { # id: '2', # address: '1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2', # amount: '0.01', # state: 'processed', # currency: 'BTC', # withdrawal_fee: '0.0005', # created_at: '1614718276', # updated_at: '1614720926', # payment_id: '', # transaction_hash: 'xxxxxxxx...', # broadcasted_at: '1614720762', # wallet_label: 'btc', # chain_name: 'Bitcoin', # network: null # }, # # fetchDeposits # # ... # id = self.safe_string(transaction, 'id') address = self.safe_string(transaction, 'address') tag = self.safe_string_2(transaction, 'payment_id', 'memo_value') txid = self.safe_string(transaction, 'transaction_hash') currencyId = self.safe_string_2(transaction, 'currency', 'asset') code = self.safe_currency_code(currencyId, currency) timestamp = self.safe_timestamp(transaction, 'created_at') updated = self.safe_timestamp(transaction, 'updated_at') type = 'withdrawal' status = self.parse_transaction_status( self.safe_string(transaction, 'state')) amountString = self.safe_string(transaction, 'amount') feeCostString = self.safe_string(transaction, 'withdrawal_fee') amount = self.parse_number( Precise.string_sub(amountString, feeCostString)) return { 'info': transaction, 'id': id, 'txid': txid, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'address': address, 'tag': tag, 'type': type, 'amount': amount, 'currency': code, 'status': status, 'updated': updated, 'fee': { 'currency': code, 'cost': self.parse_number(feeCostString), }, }
def parse_trade(self, trade, market=None): # public trades # { # fillId: 'b5467d00-b13e-3fa9-8216-dd66735550fc', # price: '0.09771286', # quantity: '1.45340410', # quoteQuantity: '0.14201627', # time: 1598345638994, # makerSide: 'buy', # sequence: 3853 # } # private trades # { # fillId: '48582d10-b9bb-3c4b-94d3-e67537cf2472', # price: '0.09905990', # quantity: '0.40000000', # quoteQuantity: '0.03962396', # time: 1598873478762, # makerSide: 'sell', # sequence: 5053, # market: 'DIL-ETH', # orderId: '7cdc8e90-eb7d-11ea-9e60-4118569f6e63', # side: 'buy', # fee: '0.00080000', # feeAsset: 'DIL', # gas: '0.00857497', # liquidity: 'taker', # txId: '0xeaa02b112c0b8b61bc02fa1776a2b39d6c614e287c1af90df0a2e591da573e65', # txStatus: 'mined' # } id = self.safe_string(trade, 'fillId') priceString = self.safe_string(trade, 'price') amountString = self.safe_string(trade, 'quantity') price = self.parse_number(priceString) amount = self.parse_number(amountString) cost = self.safe_number(trade, 'quoteQuantity') if cost is None: cost = self.parse_number( Precise.string_mul(priceString, amountString)) timestamp = self.safe_integer(trade, 'time') marketId = self.safe_string(trade, 'market') symbol = self.safe_symbol(marketId, market, '-') # self code handles the duality of public vs private trades makerSide = self.safe_string(trade, 'makerSide') oppositeSide = 'sell' if (makerSide == 'buy') else 'buy' side = self.safe_string(trade, 'side', oppositeSide) takerOrMaker = self.safe_string(trade, 'liquidity', 'taker') feeCost = self.safe_number(trade, 'fee') fee = None if feeCost is not None: feeCurrencyId = self.safe_string(trade, 'feeAsset') fee = { 'cost': feeCost, 'currency': self.safe_currency_code(feeCurrencyId), } orderId = self.safe_string(trade, 'orderId') return { 'info': trade, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'symbol': symbol, 'id': id, 'order': orderId, 'type': 'limit', 'side': side, 'takerOrMaker': takerOrMaker, 'price': price, 'amount': amount, 'cost': cost, 'fee': fee, }
def parse_trade(self, trade, market=None): # # fetchTrades(public) # # { # "transaction_date":"2020-04-23 22:21:46", # "type":"ask", # "units_traded":"0.0125", # "price":"8667000", # "total":"108337" # } # # fetchOrder(private) # # { # "transaction_date": "1572497603902030", # "price": "8601000", # "units": "0.005", # "fee_currency": "KRW", # "fee": "107.51", # "total": "43005" # } # # a workaround for their bug in date format, hours are not 0-padded timestamp = None transactionDatetime = self.safe_string(trade, 'transaction_date') if transactionDatetime is not None: parts = transactionDatetime.split(' ') numParts = len(parts) if numParts > 1: transactionDate = parts[0] transactionTime = parts[1] if len(transactionTime) < 8: transactionTime = '0' + transactionTime timestamp = self.parse8601(transactionDate + ' ' + transactionTime) else: timestamp = self.safe_integer_product(trade, 'transaction_date', 0.001) if timestamp is not None: timestamp -= 9 * 3600000 # they report UTC + 9 hours, server in Korean timezone type = None side = self.safe_string(trade, 'type') side = 'sell' if (side == 'ask') else 'buy' id = self.safe_string(trade, 'cont_no') symbol = None if market is not None: symbol = market['symbol'] priceString = self.safe_string(trade, 'price') amountString = self.safe_string_2(trade, 'units_traded', 'units') price = self.parse_number(priceString) amount = self.parse_number(amountString) cost = self.safe_number(trade, 'total') if cost is None: cost = self.parse_number( Precise.string_mul(priceString, amountString)) fee = None feeCost = self.safe_number(trade, 'fee') if feeCost is not None: feeCurrencyId = self.safe_string(trade, 'fee_currency') feeCurrencyCode = self.common_currency_code(feeCurrencyId) fee = { 'cost': feeCost, 'currency': feeCurrencyCode, } return { 'id': id, 'info': trade, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'symbol': symbol, 'order': None, 'type': type, 'side': side, 'takerOrMaker': None, 'price': price, 'amount': amount, 'cost': cost, 'fee': fee, }
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, }