def fetch_balance(self, params={}):
self.load_markets()
response = self.privateGetBalance(params)
#
# {
# 'balance': [
# {'account_id': '119...1336','asset': 'XBT','balance': '0.00','reserved': '0.00','unconfirmed': '0.00'},
# {'account_id': '66...289','asset': 'XBT','balance': '0.00','reserved': '0.00','unconfirmed': '0.00'},
# {'account_id': '718...5300','asset': 'ETH','balance': '0.00','reserved': '0.00','unconfirmed': '0.00'},
# {'account_id': '818...7072','asset': 'ZAR','balance': '0.001417','reserved': '0.00','unconfirmed': '0.00'}]}
# ]
# }
#
wallets = self.safe_value(response, 'balance', [])
result = {'info': response}
for i in range(0, len(wallets)):
wallet = wallets[i]
currencyId = self.safe_string(wallet, 'asset')
code = self.safe_currency_code(currencyId)
reserved = self.safe_string(wallet, 'reserved')
unconfirmed = self.safe_string(wallet, 'unconfirmed')
balance = self.safe_string(wallet, 'balance')
reservedUnconfirmed = Precise.string_add(reserved, unconfirmed)
balanceUnconfirmed = Precise.string_add(balance, unconfirmed)
if code in result:
result[code]['used'] = Precise.string_add(
result[code]['used'], reservedUnconfirmed)
result[code]['total'] = Precise.string_add(
result[code]['total'], balanceUnconfirmed)
else:
account = self.account()
account['used'] = reservedUnconfirmed
account['total'] = balanceUnconfirmed
result[code] = account
return self.parse_balance(result, False)
def parse_balance(self, response):
wallets = self.safe_value(response, 'balance', [])
result = {
'info': response,
'timestamp': None,
'datetime': None,
}
for i in range(0, len(wallets)):
wallet = wallets[i]
currencyId = self.safe_string(wallet, 'asset')
code = self.safe_currency_code(currencyId)
reserved = self.safe_string(wallet, 'reserved')
unconfirmed = self.safe_string(wallet, 'unconfirmed')
balance = self.safe_string(wallet, 'balance')
reservedUnconfirmed = Precise.string_add(reserved, unconfirmed)
balanceUnconfirmed = Precise.string_add(balance, unconfirmed)
if code in result:
result[code]['used'] = Precise.string_add(
result[code]['used'], reservedUnconfirmed)
result[code]['total'] = Precise.string_add(
result[code]['total'], balanceUnconfirmed)
else:
account = self.account()
account['used'] = reservedUnconfirmed
account['total'] = balanceUnconfirmed
result[code] = account
return self.safe_balance(result)
async def fetch_balance(self, params={}):
await self.load_markets()
lowercaseCurrencies = []
currencies = list(self.currencies.keys())
for i in range(0, len(currencies)):
currency = currencies[i]
lowercaseCurrencies.append(currency.lower())
request = {
'currencies': ','.join(lowercaseCurrencies),
}
response = await self.userPostBalance(self.extend(request, params))
result = {'info': response}
for i in range(0, len(response)):
balance = response[i]
currencyId = self.safe_string(balance['currency'], 'name')
code = self.safe_currency_code(currencyId)
account = self.account()
account['free'] = self.safe_string(balance, 'available')
blocked = self.safe_string(balance, 'blocked')
inOrders = self.safe_string(balance, 'inOrders')
withdrawing = self.safe_string(balance, 'withdrawing')
account['used'] = Precise.string_add(
Precise.string_add(blocked, inOrders), withdrawing)
result[code] = account
return self.parse_balance(result, False)
def fetch_balance(self, params={}):
self.load_markets()
response = self.privateGetAccountBalances(params)
#
# [
# {
# "currencyId": 102,
# "symbol": "LA",
# "name": "Latoken",
# "amount": 1054.66,
# "available": 900.66,
# "frozen": 154,
# "pending": 0
# }
# ]
#
result = {
'info': response,
'timestamp': None,
'datetime': None,
}
for i in range(0, len(response)):
balance = response[i]
currencyId = self.safe_string(balance, 'symbol')
code = self.safe_currency_code(currencyId)
frozen = self.safe_string(balance, 'frozen')
pending = self.safe_string(balance, 'pending')
account = self.account()
account['used'] = Precise.string_add(frozen, pending)
account['free'] = self.safe_string(balance, 'available')
account['total'] = self.safe_string(balance, 'amount')
result[code] = account
return self.parse_balance(result)
def parse_ticker(self, ticker, market=None):
#
# [
# [1640789101000, 1292663.0, 1311823.61303, 1295794.252, 1311823.61303, 0.030175],
# [1640790902000, 1311823.61303, 1310820.96, 1290000.0, 1290000.0, 0.042533],
# ],
#
symbol = self.safe_symbol(None, market)
timestamp = self.milliseconds()
result = {
'symbol': symbol,
'timestamp': timestamp,
'datetime': self.iso8601(timestamp),
'high': None,
'low': None,
'bid': None,
'bidVolume': None,
'ask': None,
'askVolume': None,
'vwap': None,
'open': None,
'close': None,
'last': None,
'previousClose': None,
'change': None,
'percentage': None,
'average': None,
'baseVolume': None,
'quoteVolume': None,
'info': ticker,
}
tickerLength = len(ticker)
if tickerLength > 0:
start = max(tickerLength - 48, 0)
for i in range(start, len(ticker)):
candle = ticker[i]
if result['open'] is None:
result['open'] = self.safe_string(candle, 1)
high = self.safe_string(candle, 2)
if (result['high'] is None) or (
(high is not None)
and Precise.string_lt(result['high'], high)):
result['high'] = high
low = self.safe_string(candle, 3)
if (result['low'] is None) or (
(low is not None)
and Precise.string_lt(result['low'], low)):
result['low'] = low
baseVolume = self.safe_string(candle, 5)
if result['baseVolume'] is None:
result['baseVolume'] = baseVolume
else:
result['baseVolume'] = Precise.string_add(
result['baseVolume'], baseVolume)
last = tickerLength - 1
result['last'] = self.safe_string(ticker[last], 4)
result['close'] = result['last']
return self.safe_ticker(result, market, False)
async def fetch_balance(self, params={}):
await self.load_markets()
response = await self.privatePostListBalances(params)
result = {'info': response}
for i in range(0, len(response)):
balance = response[i]
currencyId = self.safe_string(balance, 'Currency')
code = self.safe_currency_code(currencyId)
deposited = self.safe_string(balance, 'Deposited')
unconfirmed = self.safe_string(balance, 'Unconfirmed')
account = self.account()
account['free'] = self.safe_string(balance, 'Available')
account['total'] = Precise.string_add(deposited, unconfirmed)
result[code] = account
return self.parse_balance(result, False)
def parse_balance(self, response):
result = {
'info': response,
'timestamp': None,
'datetime': None,
}
for i in range(0, len(response)):
balance = response[i]
currencyId = self.safe_string(balance, 'symbol')
code = self.safe_currency_code(currencyId)
frozen = self.safe_string(balance, 'frozen')
pending = self.safe_string(balance, 'pending')
account = self.account()
account['used'] = Precise.string_add(frozen, pending)
account['free'] = self.safe_string(balance, 'available')
account['total'] = self.safe_string(balance, 'amount')
result[code] = account
return self.safe_balance(result)
# decimal_to_precision('foo'),
# "invalid number(contains an illegal character 'f')")
#
# throws(() =>
# decimal_to_precision('0.01', TRUNCATE, -1, TICK_SIZE),
# "TICK_SIZE cant be used with negative numPrecisionDigits")
# ----------------------------------------------------------------------------
w = '-1.123e-6'
x = '0.00000002'
y = '69696900000'
assert Precise.string_mul(x, y) == '1393.938'
assert Precise.string_mul(y, x) == '1393.938'
assert Precise.string_add(x, y) == '69696900000.00000002'
assert Precise.string_add(y, x) == '69696900000.00000002'
assert Precise.string_sub(x, y) == '-69696899999.99999998'
assert Precise.string_sub(y, x) == '69696899999.99999998'
assert Precise.string_div(x, y) == '0.000000000000028695'
assert Precise.string_div(y, x) == '34848450000'
assert Precise.string_mul(x, w) == '-0.00000000000002246'
assert Precise.string_mul(w, x) == '-0.00000000000002246'
assert Precise.string_add(x, w) == '-0.000001103'
assert Precise.string_add(w, x) == '-0.000001103'
assert Precise.string_sub(x, w) == '0.000001143'
assert Precise.string_sub(w, x) == '-0.000001143'
assert Precise.string_div(x, w) == '-0.000000000017809439'
assert Precise.string_div(w, x) == '-0.0000005615'
#
# 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'
assert Precise.string_add(x, w) == '-0.000001103'
assert Precise.string_add(w, x) == '-0.000001103'
def parse_order(self, order, market=None):
#
# {
# id: string,
# user_id: string,
# market_id: string,
# type: 'orderType',
# side: 'side',
# quantity: string,
# limit_price: string,
# time_in_force: 'timeInForce',
# filled_cost: string,
# filled_quantity: string,
# open_quantity: string,
# cancelled_quantity: string,
# status: 'orderStatus',
# time: 'date',
# client_order_id: string,
# }
#
status = self.parse_order_status(self.safe_string(order, 'status'))
id = self.safe_string(order, 'id')
type = self.safe_string(order, 'type')
side = self.safe_string(order, 'side')
marketId = self.safe_string(order, 'market_id')
symbol = self.safe_symbol(marketId, market, '-')
timestamp = self.parse8601(self.safe_string(order, 'time'))
price = self.safe_string(order, 'limit_price')
filled = self.safe_string(order, 'filled_quantity')
remaining = self.safe_string(order, 'open_quantity')
canceledAmount = self.safe_string(order, 'cancelled_quantity')
if canceledAmount is not None:
remaining = Precise.string_add(remaining, canceledAmount)
amount = self.safe_string(order, 'quantity', Precise.string_add(filled, remaining))
cost = self.safe_string_2(order, 'filled_cost', 'cost')
if type == 'market':
price = None
clientOrderId = self.safe_string(order, 'client_order_id')
if clientOrderId == '':
clientOrderId = None
timeInForce = self.safe_string_upper(order, 'time_in_force')
return self.safe_order({
'id': id,
'info': order,
'clientOrderId': clientOrderId,
'timestamp': timestamp,
'datetime': self.iso8601(timestamp),
'lastTradeTimestamp': None,
'symbol': symbol,
'type': type,
'timeInForce': timeInForce,
'side': side,
'status': status,
'price': price,
'stopPrice': None,
'amount': amount,
'filled': filled,
'remaining': remaining,
'average': None,
'cost': cost,
'fee': None,
'trades': None,
}, market)
