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,
}
