def create_deposit_address(self, code, params={}):
self.load_markets()
currency = self.currency(code)
accounts = self.safe_value(self.options, 'coinbaseAccounts')
if accounts is None:
accounts = self.privateGetCoinbaseAccounts()
self.options['coinbaseAccounts'] = accounts # cache it
self.options['coinbaseAccountsByCurrencyId'] = self.index_by(
accounts, 'currency')
currencyId = currency['id']
account = self.safe_value(self.options['coinbaseAccountsByCurrencyId'],
currencyId)
if account is None:
# eslint-disable-next-line quotes
raise InvalidAddress(
self.id +
" fetchDepositAddress() could not find currency code " + code +
" with id = " + currencyId +
" in self.options['coinbaseAccountsByCurrencyId']")
request = {
'id': account['id'],
}
response = self.privatePostCoinbaseAccountsIdAddresses(
self.extend(request, params))
address = self.safe_string(response, 'address')
tag = self.safe_string(response, 'destination_tag')
return {
'currency': code,
'address': self.check_address(address),
'tag': tag,
'info': response,
}
def fetch_balance_by_code(self, code, params={}):
if not self.walletAddress or (self.walletAddress.find('0x') != 0):
raise InvalidAddress(
self.id +
' fetchBalanceByCode() requires the .walletAddress to be a "0x"-prefixed hexstring like "0xbF2d65B3b2907214EEA3562f21B80f6Ed7220377"'
)
self.load_markets()
currency = self.currency(code)
request = {
'walletAddress': self.walletAddress.lower(),
'tokenAddress': currency['id'],
}
response = self.privateGetBalance(self.extend(request, params))
#
# {"available":"0","committed":"0","total":"0"}
#
decimals = self.safe_integer(self.options['decimals'], code, 18)
free = self.fromWei(self.safe_string(response, 'available'), 'ether',
decimals)
used = self.fromWei(self.safe_string(response, 'committed'), 'ether',
decimals)
total = self.fromWei(self.safe_string(response, 'total'), 'ether',
decimals)
return {
'free': free,
'used': used,
'total': total,
}
async def fetch_deposit_address(self, code, params={}):
method = self.safe_value(params, 'method')
if not method:
raise ExchangeError(
self.id +
' fetchDepositAddress() requires an extra `method` parameter')
await self.load_markets()
currency = self.currency(code)
request = {
'asset': currency['id'],
'method': method,
}
response = await self.privatePostDepositAddresses(
self.extend(request, params))
result = response['result']
numResults = len(result)
if numResults < 1:
raise InvalidAddress(
self.id +
' privatePostDepositAddresses() returned no addresses')
address = self.safe_string(result[0], 'address')
self.check_address(address)
return {
'currency': code,
'address': address,
'status': 'ok',
'info': response,
}
async def fetch_deposit_address(self, code, params={}):
await self.load_markets()
currency = self.currency(code)
# eslint-disable-next-line quotes
method = self.safe_string(params, 'method')
if method is None:
if self.options['cacheDepositMethodsOnFetchDepositAddress']:
# cache depositMethods
if not(code in list(self.options['depositMethods'].keys())):
self.options['depositMethods'][code] = await self.fetch_deposit_methods(code)
method = self.options['depositMethods'][code][0]['method']
else:
raise ExchangeError(self.id + ' fetchDepositAddress() requires an extra `method` parameter. Use fetchDepositMethods("' + code + '") to get a list of available deposit methods or enable the exchange property .options["cacheDepositMethodsOnFetchDepositAddress"] = True')
request = {
'asset': currency['id'],
'method': method,
}
response = await self.privatePostDepositAddresses(self.extend(request, params)) # overwrite methods
result = response['result']
numResults = len(result)
if numResults < 1:
raise InvalidAddress(self.id + ' privatePostDepositAddresses() returned no addresses')
address = self.safe_string(result[0], 'address')
self.check_address(address)
return {
'currency': code,
'address': address,
'info': response,
}
async def create_order(self, symbol, type, side, amount, price=None, params={}):
errorMessage = self.id + ' createOrder() requires `exchange.walletAddress` and `exchange.privateKey`. The .walletAddress should be a "0x"-prefixed hexstring like "0xbF2d65B3b2907214EEA3562f21B80f6Ed7220377". The .privateKey for that wallet should be a "0x"-prefixed hexstring like "0xe4f40d465efa94c98aec1a51f574329344c772c1bce33be07fa20a56795fdd09".'
if not self.walletAddress or (self.walletAddress.find('0x') != 0):
raise InvalidAddress(errorMessage)
if not self.privateKey or (self.privateKey.find('0x') != 0):
raise InvalidAddress(errorMessage)
orderParams = await self.fetch_order_params_to_sign(symbol, type, side, amount, price, params)
unsignedOrder = orderParams['unsignedZeroExOrder']
if unsignedOrder is None:
raise OrderNotFillable(self.id + ' ' + type + ' order to ' + side + ' ' + symbol + ' is not fillable at the moment')
signedOrder = await self.sign_zero_ex_order_v2(unsignedOrder, self.privateKey)
id = self.safe_string(signedOrder, 'orderHash')
await self.post_signed_order(signedOrder, orderParams, params)
order = await self.fetch_order(id)
order['type'] = type
return order
async def fetch_deposit_address(self, code, params={}):
await self.load_markets()
currency = self.currency(code)
request = {
'currency_id': currency['id'],
}
response = await self.privateGetDepositAddress(
self.extend(request, params))
#
# {
# "data":[
# {
# "currency_id":"ETH",
# "address":"0x12e2caf3c4051ba1146e612f532901a423a9898a",
# "destination_tag":null
# }
# ]
# }
#
data = self.safe_value(response, 'data', [])
firstAddress = self.safe_value(data, 0)
if firstAddress is None:
raise InvalidAddress(
self.id + ' fetchDepositAddress returned an empty response')
return self.parse_deposit_address(firstAddress, currency)
async def fetch_deposit_address(self, code, params={}):
await self.load_markets()
currency = self.currency(code)
request = {
'coin': currency['id'],
}
# https://github.com/UEX-OpenAPI/API_Docs_en/wiki/Query-deposit-address-of-assigned-token
response = await self.privateGetDepositAddressList(self.extend(request, params))
#
# {
# "code": "0",
# "msg": "suc",
# "data": {
# "addressList": [
# {
# "address": "0x198803ef8e0df9e8812c0105421885e843e6d2e2",
# "tag": "",
# },
# ],
# },
# }
#
data = self.safe_value(response, 'data')
if data is None:
raise InvalidAddress(self.id + ' privateGetDepositAddressList() returned no data')
addressList = self.safe_value(data, 'addressList')
if addressList is None:
raise InvalidAddress(self.id + ' privateGetDepositAddressList() returned no address list')
numAddresses = len(addressList)
if numAddresses < 1:
raise InvalidAddress(self.id + ' privatePostDepositAddresses() returned no addresses')
firstAddress = addressList[0]
address = self.safe_string(firstAddress, 'address')
tag = self.safe_string(firstAddress, 'tag')
self.check_address(address)
return {
'currency': code,
'address': address,
'tag': tag,
'info': response,
}
async def fetch_balance(self, params={}):
if not self.walletAddress or (self.walletAddress.find('0x') != 0):
raise InvalidAddress(self.id + ' fetchBalance() requires the .walletAddress to be a "0x"-prefixed hexstring like "0xbF2d65B3b2907214EEA3562f21B80f6Ed7220377"')
codes = self.safe_value(self.options, 'fetchBalanceCurrencies')
if codes is None:
codes = self.safe_value(params, 'codes')
if (codes is None) or (not isinstance(codes, list)):
raise ExchangeError(self.id + ' fetchBalance() requires a `codes` parameter(an array of currency codes)')
await self.load_markets()
result = {}
for i in range(0, len(codes)):
code = codes[i]
result[code] = await self.fetch_balance_by_code(code)
return self.parse_balance(result)
def query_deposit_address(self, method, currency, params={}):
method = 'privatePost' + method + 'Address'
response = getattr(self, method)(self.extend({
'currency': currency,
}, params))
address = None
if 'addr' in response:
address = self.safe_string(response, 'addr')
if (address is not None) and (address.find('address') >= 0):
raise InvalidAddress(self.id + ' queryDepositAddress ' + address)
return {
'currency': currency,
'address': address,
'status': 'ok' if (address is not None) else 'none',
'info': response,
}
def fetch_deposit_address(self, code, params={}):
self.load_markets()
currency = self.currency(code)
request = {
'DigiCurrency': currency['id'],
}
response = self.privateGetElectronicWalletDepositWalletsDigiCurrency(self.extend(request, params))
result = response['addresses']
numResults = len(result)
if numResults < 1:
raise InvalidAddress(self.id + ' privateGetElectronicWalletDepositWalletsDigiCurrency() returned no addresses')
address = self.safe_string(result[0], 'address')
self.check_address(address)
return {
'currency': code,
'address': address,
'info': response,
}
async def query_deposit_address(self, method, code, params={}):
await self.load_markets()
currency = self.currency(code)
method = 'privatePost' + method + 'Address'
response = await getattr(self, method)(self.extend({
'currency': currency['id'],
}, params))
address = self.safe_string(response, 'addr')
tag = None
if (address is not None) and(address.find('address') >= 0):
raise InvalidAddress(self.id + ' queryDepositAddress ' + address)
if code == 'XRP':
parts = address.split(' ')
address = parts[0]
tag = parts[1]
return {
'currency': currency,
'address': address,
'tag': tag,
'info': response,
}
def fetch_deposit_address(self, code, params={}):
self.load_markets()
currency = self.currency(code)
request = {
'asset': currency['id'],
}
response = self.wapiGetDepositAddress(self.extend(request, params))
success = self.safe_value(response, 'success')
if (success is None) or not success:
raise InvalidAddress(
self.id +
' fetchDepositAddress returned an empty response – create the deposit address in the user settings first.'
)
address = self.safe_string(response, 'address')
tag = self.safe_string(response, 'addressTag')
self.check_address(address)
return {
'currency': code,
'address': self.check_address(address),
'tag': tag,
'info': response,
}
