def parse_trade(self, trade, market=None):
side = self.safe_string_lower(trade, 'side')
if side is not None:
if len(side) < 1:
side = None
order = None
if side is not None:
id = side + '_child_order_acceptance_id'
if id in trade:
order = trade[id]
if order is None:
order = self.safe_string(trade, 'child_order_acceptance_id')
timestamp = self.parse8601(self.safe_string(trade, 'exec_date'))
priceString = self.safe_string(trade, 'price')
amountString = self.safe_string(trade, 'size')
price = self.parse_number(priceString)
amount = self.parse_number(amountString)
cost = self.parse_number(Precise.string_mul(priceString, amountString))
id = self.safe_string(trade, 'id')
symbol = None
if market is not None:
symbol = market['symbol']
return {
'id': id,
'info': trade,
'timestamp': timestamp,
'datetime': self.iso8601(timestamp),
'symbol': symbol,
'order': order,
'type': None,
'side': side,
'takerOrMaker': None,
'price': price,
'amount': amount,
'cost': cost,
'fee': None,
}
def parse_trade(self, trade, market=None):
timestamp = self.parse8601(self.safe_string(trade, 'created_at'))
symbol = None
if market:
symbol = market['symbol']
side = self.safe_string_2(trade, 'side', 'trend')
if side is not None:
sideMap = {
'ask': 'sell',
'bid': 'buy',
}
side = self.safe_string(sideMap, side, side)
priceString = self.safe_string(trade, 'price')
amountString = self.safe_string(trade, 'volume')
price = self.parse_number(priceString)
amount = self.parse_number(amountString)
cost = self.safe_number(trade, 'funds')
if cost is None:
cost = self.parse_number(
Precise.string_mul(priceString, amountString))
orderId = self.safe_string(trade, 'order_id')
id = self.safe_string(trade, 'id')
return {
'id': id,
'info': trade,
'timestamp': timestamp,
'datetime': self.iso8601(timestamp),
'symbol': symbol,
'type': None,
'side': side,
'order': orderId,
'takerOrMaker': None,
'price': price,
'amount': amount,
'cost': cost,
'fee': None,
}
def parse_trade(self, trade, market=None):
timestamp = self.parse8601(trade['TradeTimestampUtc'])
id = self.safe_string(trade, 'TradeGuid')
orderId = self.safe_string(trade, 'OrderGuid')
priceString = self.safe_string_2(trade, 'Price', 'SecondaryCurrencyTradePrice')
amountString = self.safe_string_2(trade, 'VolumeTraded', 'PrimaryCurrencyAmount')
price = self.parse_number(priceString)
amount = self.parse_number(amountString)
cost = self.parse_number(Precise.string_mul(priceString, amountString))
baseId = self.safe_string(trade, 'PrimaryCurrencyCode')
quoteId = self.safe_string(trade, 'SecondaryCurrencyCode')
marketId = None
if (baseId is not None) and (quoteId is not None):
marketId = baseId + '/' + quoteId
symbol = self.safe_symbol(marketId, market, '/')
side = self.safe_string(trade, 'OrderType')
if side is not None:
if side.find('Bid') >= 0:
side = 'buy'
elif side.find('Offer') >= 0:
side = 'sell'
return {
'id': id,
'info': trade,
'timestamp': timestamp,
'datetime': self.iso8601(timestamp),
'symbol': symbol,
'order': orderId,
'type': None,
'side': side,
'takerOrMaker': None,
'price': price,
'amount': amount,
'cost': cost,
'fee': None,
}
def parse_trade(self, trade, market):
timestamp = self.safe_timestamp(trade, 'unixtime')
side = 'buy' if (trade['incomingOrderSide'] == 0) else 'sell'
id = self.safe_string(trade, 'tid')
priceString = self.safe_string(trade, 'px')
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))
return {
'info': trade,
'timestamp': timestamp,
'datetime': self.iso8601(timestamp),
'symbol': market['symbol'],
'id': id,
'order': None,
'type': None,
'side': side,
'price': price,
'amount': amount,
'cost': cost,
'takerOrMaker': None,
'fee': None,
}
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):
#
# 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_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):
# 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):
#
# 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 fetch_markets(self, params={}):
response = self.publicGetPairs(params)
#
# [
# {
# "name": "1INCH_USDT",
# "currency1": "1INCH",
# "currency2": "USDT",
# "price_precision": 4,
# "amount_precision": 2,
# "minimum_order_size": "0.01000000",
# "maximum_order_size": "900000.00000000",
# "minimum_order_value": "10.00000000",
# "liquidity_type": 10
# },
# ]
#
result = []
for i in range(0, len(response)):
market = response[i]
id = self.safe_string(market, 'name')
baseId = self.safe_string(market, 'currency1')
quoteId = self.safe_string(market, 'currency2')
base = self.safe_currency_code(baseId)
quote = self.safe_currency_code(quoteId)
pricePrecision = self.safe_string(market, 'price_precision')
priceLimit = self.parse_precision(pricePrecision)
amountLimit = self.safe_string(market, 'minimum_order_size')
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': True,
'contract': False,
'linear': None,
'inverse': None,
'contractSize': None,
'expiry': None,
'expiryDatetime': None,
'strike': None,
'optionType': None,
'precision': {
'amount': int('8'),
'price': int(pricePrecision),
},
'limits': {
'leverage': {
'min': None,
'max': None,
},
'amount': {
'min': self.parse_number(amountLimit),
'max': self.safe_number(market, 'maximum_order_size'),
},
'price': {
'min': self.parse_number(priceLimit),
'max': None,
},
'cost': {
'min': self.parse_number(Precise.string_mul(priceLimit, amountLimit)),
'max': None,
},
},
'info': market,
})
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 parse_trade(self, trade, market=None):
#
# fetchTrades(public)
#
# {
# "id":"ETH-BTC:3331886",
# "price":"0.022981",
# "quantity":"12.337",
# "time":"2020-04-12T20:55:42.371Z",
# "side":"sell",
# "tick_direction":"down"
# }
#
# fetchMyTrades(private)
#
# {
# "id":"BTC-USDT:183566",
# "order_id":"17209376",
# "side":"sell",
# "fee_amount":"0.657396569175",
# "fee_currency_id":"USDT",
# "status":"settled",
# "price":"6573.96569175",
# "quantity":"0.1",
# "cost":"657.396569175",
# "time":"2018-08-10T06:06:46.000Z",
# "market_id":"BTC-USDT"
# }
#
timestamp = self.parse8601(self.safe_string(trade, 'time'))
id = self.safe_string(trade, 'id')
marketId = None
if id is not None:
parts = id.split(':')
marketId = self.safe_string(parts, 0)
marketId = self.safe_string(trade, 'market_id', marketId)
symbol = self.safe_symbol(marketId, market, '-')
side = self.safe_string(trade, 'side')
priceString = self.safe_string(trade, 'price')
amountString = self.safe_string(trade, 'quantity')
price = self.parse_number(priceString)
amount = self.parse_number(amountString)
cost = self.parse_number(Precise.string_mul(priceString, amountString))
orderId = self.safe_string(trade, 'order_id')
feeCost = self.safe_number(trade, 'fee_amount')
fee = None
if feeCost is not None:
feeCurrencyId = self.safe_string(trade, 'fee_currency_id')
feeCurrencyCode = self.safe_currency_code(feeCurrencyId)
fee = {
'cost': feeCost,
'currency': feeCurrencyCode,
}
return {
'id': id,
'info': trade,
'timestamp': timestamp,
'datetime': self.iso8601(timestamp),
'symbol': symbol,
'order': orderId,
'type': None,
'side': side,
'takerOrMaker': None,
'price': price,
'amount': amount,
'cost': cost,
'fee': fee,
}
# decimal_to_precision('foo'),
# "invalid number(contains an illegal character 'f')")
#
# throws(() =>
# decimal_to_precision('0.01', TRUNCATE, -1, TICK_SIZE),
# "TICK_SIZE cant be used with negative numPrecisionDigits")
# ----------------------------------------------------------------------------
w = '-1.123e-6'
x = '0.00000002'
y = '69696900000'
z = '0'
a = '1e8'
assert Precise.string_mul(x, y) == '1393.938'
assert Precise.string_mul(y, x) == '1393.938'
assert Precise.string_add(x, y) == '69696900000.00000002'
assert Precise.string_add(y, x) == '69696900000.00000002'
assert Precise.string_sub(x, y) == '-69696899999.99999998'
assert Precise.string_sub(y, x) == '69696899999.99999998'
assert Precise.string_div(x, y, 1) == '0'
assert Precise.string_div(x, y) == '0'
assert Precise.string_div(x, y, 19) == '0.0000000000000000002'
assert Precise.string_div(x, y, 20) == '0.00000000000000000028'
assert Precise.string_div(x, y, 21) == '0.000000000000000000286'
assert Precise.string_div(x, y, 22) == '0.0000000000000000002869'
assert Precise.string_div(y, x) == '3484845000000000000'
assert Precise.string_mul(x, w) == '-0.00000000000002246'
assert Precise.string_mul(w, x) == '-0.00000000000002246'
def parse_trade(self, trade, market=None):
#
# {
# type: 'match',
# trade_id: 82047307,
# maker_order_id: '0f358725-2134-435e-be11-753912a326e0',
# taker_order_id: '252b7002-87a3-425c-ac73-f5b9e23f3caf',
# order_id: 'd50ec984-77a8-460a-b958-66f114b0de9b',
# side: 'sell',
# size: '0.00513192',
# price: '9314.78',
# product_id: 'BTC-USD',
# profile_id: '6244401d-c078-40d9-b305-7ad3551bc3b0',
# sequence: 12038915443,
# time: '2020-01-31T20:03:41.158814Z'
# created_at: '2014-11-07T22:19:28.578544Z',
# liquidity: 'T',
# fee: '0.00025',
# settled: True,
# usd_volume: '0.0924556000000000',
# user_id: '595eb864313c2b02ddf2937d'
# }
#
timestamp = self.parse8601(
self.safe_string_2(trade, 'time', 'created_at'))
marketId = self.safe_string(trade, 'product_id')
symbol = self.safe_symbol(marketId, market, '-')
feeRate = None
feeCurrency = None
takerOrMaker = None
cost = None
if market is not None:
feeCurrencyId = self.safe_string_lower(market, 'quoteId')
costField = feeCurrencyId + '_value'
cost = self.safe_number(trade, costField)
feeCurrency = market['quote']
liquidity = self.safe_string(trade, 'liquidity')
if liquidity is not None:
takerOrMaker = 'taker' if (liquidity == 'T') else 'maker'
feeRate = market[takerOrMaker]
feeCost = self.safe_number_2(trade, 'fill_fees', 'fee')
fee = {
'cost': feeCost,
'currency': feeCurrency,
'rate': feeRate,
}
type = None
id = self.safe_string(trade, 'trade_id')
side = 'sell' if (trade['side'] == 'buy') else 'buy'
orderId = self.safe_string(trade, 'order_id')
# Coinbase Pro returns inverted side to fetchMyTrades vs fetchTrades
if orderId is not None:
side = 'buy' if (trade['side'] == 'buy') else 'sell'
priceString = self.safe_string(trade, 'price')
amountString = self.safe_string(trade, 'size')
price = self.parse_number(priceString)
amount = self.parse_number(amountString)
if cost is None:
cost = self.parse_number(
Precise.string_mul(priceString, amountString))
return {
'id': id,
'order': orderId,
'info': trade,
'timestamp': timestamp,
'datetime': self.iso8601(timestamp),
'symbol': symbol,
'type': type,
'takerOrMaker': takerOrMaker,
'side': side,
'price': price,
'amount': amount,
'fee': fee,
'cost': cost,
}
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 parse_trade(self, trade, market=None):
#
# fetchTrades, fetchOrder trades
#
# { id: 4493548,
# fund_id: "ETHBTC",
# amount: 0.203,
# price: 0.02783576,
# side: "buy",
# dark: False,
# date: "2018-11-30T08:19:18.236Z"}
#
# fetchMyTrades
#
# { id: 237338,
# fund_id: "BTCEUR",
# amount: 0.348,
# price: 348,
# side: "sell",
# dark: False,
# order_id: 14920648,
# date: "2015-06-03T00:49:49.000Z",
# transactions: [{ id: 2770768,
# date: "2015-06-03T00:49:49.000Z",
# type: "sold_currency_to_fund",
# price: 121.1,
# currency: "EUR" },
# { id: 2770769,
# date: "2015-06-03T00:49:49.000Z",
# type: "released_currency_to_fund",
# price: 0.348,
# currency: "BTC" },
# { id: 2770772,
# date: "2015-06-03T00:49:49.000Z",
# type: "paid_commission",
# price: 0.06,
# currency: "EUR",
# trade_id: 440492 } ]}
#
marketId = self.safe_string(trade, 'fund_id')
symbol = self.safe_symbol(marketId, market)
timestamp = self.parse8601(self.safe_string(trade, 'date'))
id = self.safe_string(trade, 'id')
orderId = self.safe_string(trade, 'order_id')
side = self.safe_string(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.parse_number(Precise.string_mul(priceString, amountString))
fee = None
feeCost = None
transactions = self.safe_value(trade, 'transactions', [])
transactionsByType = self.group_by(transactions, 'type')
feeTransactions = self.safe_value(transactionsByType,
'paid_commission', [])
for i in range(0, len(feeTransactions)):
if feeCost is None:
feeCost = 0
feeCost = self.sum(feeCost,
self.safe_number(feeTransactions[i], 'price'))
if feeCost is not None:
fee = {
'cost': feeCost,
'currency': market['quote'],
}
return {
'info': trade,
'id': id,
'order': orderId,
'timestamp': timestamp,
'datetime': self.iso8601(timestamp),
'symbol': symbol,
'type': None,
'side': side,
'takerOrMaker': None,
'price': price,
'amount': amount,
'cost': cost,
'fee': fee,
}
def parse_trade(self, trade, market=None):
#
# fetchMyTrades(private)
#
# {
# transactionId: 2671819,
# createdTimestamp: 1529649127605,
# currencyPair: 'LTC_BTC',
# type: 'BUY',
# orderType: 'LIMIT',
# orderId: 101810227,
# amount: 0.01,
# price: 0.01406,
# fee: 0,
# feeType: 'MAKER'
# }
#
# fetchTrades(public)
#
# {
# "timestamp":1561598833416,
# "transactionId":"4156303",
# "price":10950.41,
# "amount":0.004,
# "currencyPair":"BTC_EUR",
# "tradeType":"BUY"
# }
#
marketId = self.safe_string(trade, 'currencyPair')
market = self.safe_market(marketId, market, '_')
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_lower_2(trade, 'type', 'tradeType')
type = self.safe_string_lower(trade, 'orderType')
orderId = self.safe_string(trade, 'orderId')
id = self.safe_string(trade, 'transactionId')
timestamp = self.safe_integer_2(trade, 'timestamp', 'createdTimestamp')
fee = None
feeCost = self.safe_number(trade, 'fee')
if feeCost is not None:
fee = {
'cost': feeCost,
'currency': market['quote'],
}
takerOrMaker = self.safe_string(trade, 'feeType')
takerOrMaker = 'maker' if (takerOrMaker == 'MAKER') else 'taker'
return {
'id': id,
'info': trade,
'timestamp': timestamp,
'datetime': self.iso8601(timestamp),
'symbol': market['symbol'],
'type': type,
'side': side,
'order': orderId,
'takerOrMaker': takerOrMaker,
'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):
timestamp = None
id = None
priceString = None
amountString = None
orderId = None
feeCost = None
side = None
reference = self.safe_string(trade, 'reference')
if reference is not None:
timestamp = self.safe_timestamp(trade, 'ticks')
priceString = self.safe_string(trade, 'price')
amountString = self.safe_string(trade, 'firstAmount')
reference_parts = reference.split('|') # reference contains 'pair|orderId|tradeId'
if market is None:
marketId = self.safe_string(trade, 'pair')
if marketId in self.markets_by_id[marketId]:
market = self.markets_by_id[marketId]
elif reference_parts[0] in self.markets_by_id:
market = self.markets_by_id[reference_parts[0]]
orderId = reference_parts[1]
id = reference_parts[2]
side = self.safe_integer(trade, 'action')
if side == 0:
side = 'buy'
elif side == 1:
side = 'sell'
feeCost = self.safe_number(trade, 'feeAmount')
else:
timestamp = self.safe_timestamp(trade, 'date')
id = self.safe_string(trade, 'tid')
priceString = self.safe_string(trade, 'price')
amountString = self.safe_string(trade, 'amount')
side = self.safe_value(trade, 'isBid')
if side is not None:
if side:
side = 'buy'
else:
side = 'sell'
symbol = None
if market is not None:
symbol = market['symbol']
price = self.parse_number(priceString)
amount = self.parse_number(amountString)
cost = self.parse_number(Precise.string_mul(priceString, amountString))
return {
'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': {
'cost': feeCost,
'currency': 'NIS',
'rate': None,
},
}
def parse_trade(self, trade, market=None):
# createMarketOrder
#
# { fee: "0.0004644",
# id: 386394956,
# price: "0.4644",
# quantity: "1",
# timestamp: "2018-10-25T16:41:44.780Z"}
#
# fetchTrades
#
# {id: 974786185,
# price: '0.032462',
# quantity: '0.3673',
# side: 'buy',
# timestamp: '2020-10-16T12:57:39.846Z'}
#
# fetchMyTrades
#
# {id: 277210397,
# clientOrderId: '6e102f3e7f3f4e04aeeb1cdc95592f1a',
# orderId: 28102855393,
# symbol: 'ETHBTC',
# side: 'sell',
# quantity: '0.002',
# price: '0.073365',
# fee: '0.000000147',
# timestamp: '2018-04-28T18:39:55.345Z'}
timestamp = self.parse8601(trade['timestamp'])
marketId = self.safe_string(trade, 'symbol')
market = self.safe_market(marketId, market)
symbol = market['symbol']
fee = None
feeCost = self.safe_number(trade, 'fee')
if feeCost is not None:
feeCurrencyCode = market['feeCurrency'] if market else None
fee = {
'cost': feeCost,
'currency': feeCurrencyCode,
}
# we use clientOrderId as the order id with self exchange intentionally
# because most of their endpoints will require clientOrderId
# explained here: https://github.com/ccxt/ccxt/issues/5674
orderId = self.safe_string(trade, 'clientOrderId')
priceString = self.safe_string(trade, 'price')
amountString = self.safe_string(trade, 'quantity')
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')
id = self.safe_string(trade, 'id')
return {
'info': trade,
'id': id,
'order': orderId,
'timestamp': timestamp,
'datetime': self.iso8601(timestamp),
'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)
#
# {
# 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
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 fetch_markets(self, params={}):
response = self.publicGetSymbol(params)
#
# [
# {
# "id":"BCNBTC",
# "baseCurrency":"BCN",
# "quoteCurrency":"BTC",
# "quantityIncrement":"100",
# "tickSize":"0.00000000001",
# "takeLiquidityRate":"0.002",
# "provideLiquidityRate":"0.001",
# "feeCurrency":"BTC"
# }
# ]
#
result = []
for i in range(0, len(response)):
market = response[i]
id = self.safe_string(market, 'id')
baseId = self.safe_string(market, 'baseCurrency')
quoteId = self.safe_string(market, 'quoteCurrency')
base = self.safe_currency_code(baseId)
quote = self.safe_currency_code(quoteId)
symbol = base + '/' + quote
# bequant fix
if id.find('_') >= 0:
symbol = id
lotString = self.safe_string(market, 'quantityIncrement')
stepString = self.safe_string(market, 'tickSize')
lot = self.parse_number(lotString)
step = self.parse_number(stepString)
precision = {
'price': step,
'amount': lot,
}
taker = self.safe_number(market, 'takeLiquidityRate')
maker = self.safe_number(market, 'provideLiquidityRate')
feeCurrencyId = self.safe_string(market, 'feeCurrency')
feeCurrencyCode = self.safe_currency_code(feeCurrencyId)
result.append(
self.extend(
self.fees['trading'], {
'info': market,
'id': id,
'symbol': symbol,
'base': base,
'quote': quote,
'baseId': baseId,
'quoteId': quoteId,
'active': True,
'taker': taker,
'maker': maker,
'precision': precision,
'feeCurrency': feeCurrencyCode,
'limits': {
'amount': {
'min': lot,
'max': None,
},
'price': {
'min': step,
'max': None,
},
'cost': {
'min':
self.parse_number(
Precise.string_mul(lotString, stepString)),
'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'))
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')
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': self.parse_number(Precise.string_abs(feeAmountString)),
'currency': self.safe_currency_code(feeCurrency),
}
return {
'info': trade,
'id': id,
'order': order,
'timestamp': timestamp,
'datetime': self.iso8601(timestamp),
'symbol': symbol,
'type': None,
'side': side,
'takerOrMaker': None,
'price': price,
'amount': amount,
'cost': cost,
'fee': fee,
}
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)
amountString = self.safe_string_2(trade, 'amount', 'base_volume')
priceString = self.safe_string_2(trade, 'rate', 'price')
price = self.parse_number(priceString)
factor = self.safe_string(trade, 'factor')
amountScaled = Precise.string_div(amountString, factor)
amount = self.parse_number(amountScaled)
cost = self.parse_number(Precise.string_mul(priceString, amountScaled))
symbol = market['symbol']
side = self.safe_string_lower(trade, 'type')
fee = None
feeCost = self.safe_number(trade, 'fee')
if feeCost is not None:
feeCurrencyCode = market['quote']
fee = {
'cost': feeCost,
'currency': feeCurrencyCode,
}
return {
'info': trade,
'timestamp': timestamp,
'datetime': self.iso8601(timestamp),
'symbol': symbol,
'id': orderId,
'order': orderId,
'type': None,
'side': side,
'takerOrMaker': None,
'price': price,
'amount': amount,
'cost': cost,
'fee': fee,
}
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_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,
}
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 fetch_markets(self, params={}):
response = self.publicGetMarketinfo(params)
#
# {
# "result":"true",
# "pairs":[
# {
# "usdt_cnyx":{
# "decimal_places":3,
# "amount_decimal_places":3,
# "min_amount":1,
# "min_amount_a":1,
# "min_amount_b":3,
# "fee":0.02,
# "trade_disabled":0,
# "buy_disabled":0,
# "sell_disabled":0
# }
# },
# ]
# }
#
markets = self.safe_value(response, 'pairs')
if not markets:
raise ExchangeError(self.id +
' fetchMarkets got an unrecognized response')
result = []
for i in range(0, len(markets)):
market = markets[i]
keys = list(market.keys())
id = self.safe_string(keys, 0)
details = market[id]
# all of their symbols are separated with an underscore
# but not boe_eth_eth(BOE_ETH/ETH) which has two underscores
# https://github.com/ccxt/ccxt/issues/4894
parts = id.split('_')
numParts = len(parts)
baseId = parts[0]
quoteId = parts[1]
if numParts > 2:
baseId = parts[0] + '_' + parts[1]
quoteId = parts[2]
base = self.safe_currency_code(baseId)
quote = self.safe_currency_code(quoteId)
symbol = base + '/' + quote
pricePrecisionString = self.safe_string(details, 'decimal_places')
priceLimit = self.parse_precision(pricePrecisionString)
precision = {
'amount': self.safe_integer(details, 'amount_decimal_places'),
'price': int(pricePrecisionString),
}
amountLimit = self.safe_string(details, 'min_amount')
amountLimits = {
'min': self.parse_number(amountLimit),
'max': None,
}
priceLimits = {
'min': self.parse_number(priceLimit),
'max': None,
}
defaultCost = self.parse_number(
Precise.string_mul(amountLimit, priceLimit))
minCost = self.safe_number(self.options['limits']['cost']['min'],
quote, defaultCost)
costLimits = {
'min': minCost,
'max': None,
}
limits = {
'amount': amountLimits,
'price': priceLimits,
'cost': costLimits,
}
disabled = self.safe_integer(details, 'trade_disabled')
active = not disabled
uppercaseId = id.upper()
feeString = self.safe_string(details, 'fee')
feeScaled = Precise.string_div(feeString, '100')
result.append({
'id': id,
'uppercaseId': uppercaseId,
'symbol': symbol,
'base': base,
'quote': quote,
'baseId': baseId,
'quoteId': quoteId,
'info': market,
'active': active,
'maker': self.parse_number(feeScaled),
'taker': self.parse_number(feeScaled),
'precision': precision,
'limits': limits,
})
return result
#
# throws(() =>
# decimal_to_precision('foo'),
# "invalid number(contains an illegal character 'f')")
#
# throws(() =>
# decimal_to_precision('0.01', TRUNCATE, -1, TICK_SIZE),
# "TICK_SIZE cant be used with negative numPrecisionDigits")
# ----------------------------------------------------------------------------
w = '-1.123e-6'
x = '0.00000002'
y = '69696900000'
assert Precise.string_mul(x, y) == '1393.938'
assert Precise.string_mul(y, x) == '1393.938'
assert Precise.string_add(x, y) == '69696900000.00000002'
assert Precise.string_add(y, x) == '69696900000.00000002'
assert Precise.string_sub(x, y) == '-69696899999.99999998'
assert Precise.string_sub(y, x) == '69696899999.99999998'
assert Precise.string_div(x, y) == '0.000000000000028695'
assert Precise.string_div(y, x) == '34848450000'
assert Precise.string_mul(x, w) == '-0.00000000000002246'
assert Precise.string_mul(w, x) == '-0.00000000000002246'
assert Precise.string_add(x, w) == '-0.000001103'
assert Precise.string_add(w, x) == '-0.000001103'
assert Precise.string_sub(x, w) == '0.000001143'
assert Precise.string_sub(w, x) == '-0.000001143'
assert Precise.string_div(x, w) == '-0.000000000017809439'