def parse_trade(self, trade, market=None):
id = self.safe_string(trade, 'trade_id')
timestamp = self.safe_integer(trade, 'date')
priceString = self.safe_string(trade, 'price_int')
priceString = Precise.string_div(priceString, '100000')
amountString = self.safe_string(trade, 'amount_int')
amountString = Precise.string_div(amountString, '100000000')
price = self.parse_number(priceString)
amount = self.parse_number(amountString)
cost = self.parse_number(Precise.string_mul(priceString, amountString))
symbol = None
if market is not None:
symbol = market['symbol']
return {
'id': id,
'info': trade,
'timestamp': timestamp,
'datetime': self.iso8601(timestamp),
'symbol': symbol,
'type': None,
'side': None,
'order': None,
'takerOrMaker': None,
'price': price,
'amount': amount,
'cost': cost,
'fee': None,
}
async def fetch_trading_fees(self, params={}):
await self.load_markets()
response = await self.privateGetUserFees(params)
#
# {
# data: {
# maker_fee: '0.0',
# taker_fee: '0.2',
# btc_volume_30d: '0.0'
# }
# }
#
data = self.safe_value(response, 'data', {})
makerString = self.safe_string(data, 'maker_fee')
takerString = self.safe_string(data, 'taker_fee')
maker = self.parse_number(Precise.string_div(makerString, '100'))
taker = self.parse_number(Precise.string_div(takerString, '100'))
result = {}
for i in range(0, len(self.symbols)):
symbol = self.symbols[i]
result[symbol] = {
'info': response,
'symbol': symbol,
'maker': maker,
'taker': taker,
'percentage': True,
'tierBased': True,
}
return result
def fetch_balance(self, params={}):
self.load_markets()
request = {
'BalanceReqID': self.nonce(),
}
response = self.privatePostU2(self.extend(request, params))
balances = self.safe_value(response['Responses'],
self.options['brokerId'])
result = {'info': response}
if balances is not None:
currencyIds = list(self.currencies_by_id.keys())
for i in range(0, len(currencyIds)):
currencyId = currencyIds[i]
code = self.safe_currency_code(currencyId)
# we only set the balance for the currency if that currency is present in response
# otherwise we will lose the info if the currency balance has been funded or traded or not
if currencyId in balances:
account = self.account()
used = self.safe_string(balances, currencyId + '_locked')
used = Precise.string_div(used, '1e8')
total = self.safe_string(balances, currencyId)
total = Precise.string_div(total, '1e8')
account['used'] = used
account['total'] = total
result[code] = account
return self.parse_balance(result, False)
def fetch_trading_fee(self, symbol, params={}):
"""
fetch the trading fees for a market
:param str symbol: unified market symbol
:param dict params: extra parameters specific to the coinmate api endpoint
:returns dict: a `fee structure <https://docs.ccxt.com/en/latest/manual.html#fee-structure>`
"""
self.load_markets()
market = self.market(symbol)
request = {
'currencyPair': market['id'],
}
response = self.privatePostTraderFees(self.extend(request, params))
#
# {
# error: False,
# errorMessage: null,
# data: {maker: '0.3', taker: '0.35', timestamp: '1646253217815'}
# }
#
data = self.safe_value(response, 'data', {})
makerString = self.safe_string(data, 'maker')
takerString = self.safe_string(data, 'taker')
maker = self.parse_number(Precise.string_div(makerString, '100'))
taker = self.parse_number(Precise.string_div(takerString, '100'))
return {
'info': data,
'symbol': market['symbol'],
'maker': maker,
'taker': taker,
'percentage': True,
'tierBased': True,
}
async def fetch_trading_fee(self, symbol, params={}):
await self.load_markets()
market = self.market(symbol)
request = {
'currencyPair': market['id'],
}
response = await self.privatePostTraderFees(
self.extend(request, params))
#
# {
# error: False,
# errorMessage: null,
# data: {maker: '0.3', taker: '0.35', timestamp: '1646253217815'}
# }
#
data = self.safe_value(response, 'data', {})
makerString = self.safe_string(data, 'maker')
takerString = self.safe_string(data, 'taker')
maker = self.parse_number(Precise.string_div(makerString, '100'))
taker = self.parse_number(Precise.string_div(takerString, '100'))
return {
'info': data,
'symbol': symbol,
'maker': maker,
'taker': taker,
'percentage': True,
'tierBased': True,
}
async def fetch_trading_fees(self, params={}):
"""
fetch the trading fees for multiple markets
:param dict params: extra parameters specific to the coinfalcon api endpoint
:returns dict: a dictionary of `fee structures <https://docs.ccxt.com/en/latest/manual.html#fee-structure>` indexed by market symbols
"""
await self.load_markets()
response = await self.privateGetUserFees(params)
#
# {
# data: {
# maker_fee: '0.0',
# taker_fee: '0.2',
# btc_volume_30d: '0.0'
# }
# }
#
data = self.safe_value(response, 'data', {})
makerString = self.safe_string(data, 'maker_fee')
takerString = self.safe_string(data, 'taker_fee')
maker = self.parse_number(Precise.string_div(makerString, '100'))
taker = self.parse_number(Precise.string_div(takerString, '100'))
result = {}
for i in range(0, len(self.symbols)):
symbol = self.symbols[i]
result[symbol] = {
'info': response,
'symbol': symbol,
'maker': maker,
'taker': taker,
'percentage': True,
'tierBased': True,
}
return result
def fetch_trading_fees(self, params={}):
self.load_markets()
response = self.privatePostV1Notionalvolume(params)
#
# {
# "web_maker_fee_bps": 25,
# "web_taker_fee_bps": 35,
# "web_auction_fee_bps": 25,
# "api_maker_fee_bps": 10,
# "api_taker_fee_bps": 35,
# "api_auction_fee_bps": 20,
# "fix_maker_fee_bps": 10,
# "fix_taker_fee_bps": 35,
# "fix_auction_fee_bps": 20,
# "block_maker_fee_bps": 0,
# "block_taker_fee_bps": 50,
# "notional_30d_volume": 150.00,
# "last_updated_ms": 1551371446000,
# "date": "2019-02-28",
# "notional_1d_volume": [
# {
# "date": "2019-02-22",
# "notional_volume": 75.00
# },
# {
# "date": "2019-02-14",
# "notional_volume": 75.00
# }
# ]
# }
#
makerBps = self.safe_string(response, 'api_maker_fee_bps')
takerBps = self.safe_string(response, 'api_taker_fee_bps')
makerString = Precise.string_div(makerBps, '10000')
takerString = Precise.string_div(takerBps, '10000')
maker = self.parse_number(makerString)
taker = self.parse_number(takerString)
result = {}
for i in range(0, len(self.symbols)):
symbol = self.symbols[i]
result[symbol] = {
'info': response,
'symbol': symbol,
'maker': maker,
'taker': taker,
'percentage': True,
'tierBased': True,
}
return result
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"
# }
#
market = self.safe_market(None, market)
orderId = self.safe_string(trade, 'id')
timestamp = self.parse8601(self.safe_string(trade, 'date'))
amountString = self.safe_string(trade, 'amount')
priceString = self.safe_string(trade, 'rate')
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')
if side.find('sell') >= 0:
side = 'sell'
elif side.find('buy') >= 0:
side = 'buy'
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': None,
'order': orderId,
'type': None,
'side': side,
'takerOrMaker': None,
'price': price,
'amount': amount,
'cost': cost,
'fee': fee,
}
def fetch_trading_fees(self, params={}):
"""
fetch the trading fees for multiple markets
:param dict params: extra parameters specific to the bit2c api endpoint
:returns dict: a dictionary of `fee structures <https://docs.ccxt.com/en/latest/manual.html#fee-structure>` indexed by market symbols
"""
self.load_markets()
response = self.privateGetAccountBalance(params)
#
# {
# "AVAILABLE_NIS": 0.0,
# "NIS": 0.0,
# "LOCKED_NIS": 0.0,
# "AVAILABLE_BTC": 0.0,
# "BTC": 0.0,
# "LOCKED_BTC": 0.0,
# ...
# "Fees": {
# "BtcNis": {"FeeMaker": 1.0, "FeeTaker": 1.0},
# "EthNis": {"FeeMaker": 1.0, "FeeTaker": 1.0},
# ...
# }
# }
#
fees = self.safe_value(response, 'Fees', {})
keys = list(fees.keys())
result = {}
for i in range(0, len(keys)):
marketId = keys[i]
symbol = self.safe_symbol(marketId)
fee = self.safe_value(fees, marketId)
makerString = self.safe_string(fee, 'FeeMaker')
takerString = self.safe_string(fee, 'FeeTaker')
maker = self.parse_number(Precise.string_div(makerString, '100'))
taker = self.parse_number(Precise.string_div(takerString, '100'))
result[symbol] = {
'info': fee,
'symbol': symbol,
'taker': taker,
'maker': maker,
'percentage': True,
'tierBased': False,
}
return result
async def fetch_trading_fees(self, params={}):
await self.load_markets()
response = await 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
# },
# ...
# },
# }
#
pairs = self.safe_value(response, 'pairs')
marketIds = list(pairs.keys())
result = {}
for i in range(0, len(marketIds)):
marketId = marketIds[i]
pair = self.safe_value(pairs, marketId, {})
symbol = self.safe_symbol(marketId, None, '_')
takerString = self.safe_string(pair, 'fee_buyer')
makerString = self.safe_string(pair, 'fee_seller')
taker = self.parse_number(Precise.string_div(takerString, '100'))
maker = self.parse_number(Precise.string_div(makerString, '100'))
result[symbol] = {
'info': pair,
'symbol': symbol,
'taker': taker,
'maker': maker,
'percentage': True,
'tierBased': False,
}
return result
def parse_trade(self, trade, market=None):
id = self.safe_string(trade, 'trade_id')
timestamp = self.safe_integer(trade, 'date')
price = self.safe_string(trade, 'price_int')
amount = self.safe_string(trade, 'amount_int')
market = self.safe_market(None, market)
return self.safe_trade({
'id': id,
'info': trade,
'timestamp': timestamp,
'datetime': self.iso8601(timestamp),
'symbol': market['symbol'],
'type': None,
'side': None,
'order': None,
'takerOrMaker': None,
'price': Precise.string_div(price, '100000'),
'amount': Precise.string_div(amount, '100000000'),
'cost': None,
'fee': None,
}, market)
async def fetch_trading_fees(self, params={}):
await self.load_markets()
response = await self.privateGetAccountBalance(params)
#
# {
# "AVAILABLE_NIS": 0.0,
# "NIS": 0.0,
# "LOCKED_NIS": 0.0,
# "AVAILABLE_BTC": 0.0,
# "BTC": 0.0,
# "LOCKED_BTC": 0.0,
# ...
# "Fees": {
# "BtcNis": {"FeeMaker": 1.0, "FeeTaker": 1.0},
# "EthNis": {"FeeMaker": 1.0, "FeeTaker": 1.0},
# ...
# }
# }
#
fees = self.safe_value(response, 'Fees', {})
keys = list(fees.keys())
result = {}
for i in range(0, len(keys)):
marketId = keys[i]
symbol = self.safe_symbol(marketId)
fee = self.safe_value(fees, marketId)
makerString = self.safe_string(fee, 'FeeMaker')
takerString = self.safe_string(fee, 'FeeTaker')
maker = self.parse_number(Precise.string_div(makerString, '100'))
taker = self.parse_number(Precise.string_div(takerString, '100'))
result[symbol] = {
'info': fee,
'symbol': symbol,
'taker': taker,
'maker': maker,
'percentage': True,
'tierBased': False,
}
return result
def fetch_trading_fees(self, params={}):
"""
fetch the trading fees for multiple markets
:param dict params: extra parameters specific to the bl3p api endpoint
:returns dict: a dictionary of `fee structures <https://docs.ccxt.com/en/latest/manual.html#fee-structure>` indexed by market symbols
"""
self.load_markets()
response = self.privatePostGENMKTMoneyInfo(params)
#
# {
# result: 'success',
# data: {
# user_id: '13396',
# wallets: {
# BTC: {
# balance: {
# value_int: '0',
# display: '0.00000000 BTC',
# currency: 'BTC',
# value: '0.00000000',
# display_short: '0.00 BTC'
# },
# available: {
# value_int: '0',
# display: '0.00000000 BTC',
# currency: 'BTC',
# value: '0.00000000',
# display_short: '0.00 BTC'
# }
# },
# ...
# },
# trade_fee: '0.25'
# }
# }
#
data = self.safe_value(response, 'data', {})
feeString = self.safe_string(data, 'trade_fee')
fee = self.parse_number(Precise.string_div(feeString, '100'))
result = {}
for i in range(0, len(self.symbols)):
symbol = self.symbols[i]
result[symbol] = {
'info': data,
'symbol': symbol,
'maker': fee,
'taker': fee,
'percentage': True,
'tierBased': False,
}
return result
async def fetch_trading_fees(self, params={}):
response = await self.v4PublicGetAssets(params)
#
# {
# '1INCH': {
# name: '1inch',
# unified_cryptoasset_id: '8104',
# can_withdraw: True,
# can_deposit: True,
# min_withdraw: '33',
# max_withdraw: '0',
# maker_fee: '0.1',
# taker_fee: '0.1',
# min_deposit: '30',
# max_deposit: '0'
# },
# ...
# }
#
result = {}
for i in range(0, len(self.symbols)):
symbol = self.symbols[i]
market = self.market(symbol)
fee = self.safe_value(response, market['baseId'], {})
makerFee = self.safe_string(fee, 'maker_fee')
takerFee = self.safe_string(fee, 'taker_fee')
makerFee = Precise.string_div(makerFee, '100')
takerFee = Precise.string_div(takerFee, '100')
result[symbol] = {
'info': fee,
'symbol': market['symbol'],
'percentage': True,
'tierBased': False,
'maker': self.parse_number(makerFee),
'taker': self.parse_number(takerFee),
}
return result
async def fetch_trading_fees(self, params={}):
await self.load_markets()
response = await self.privatePostGENMKTMoneyInfo(params)
#
# {
# result: 'success',
# data: {
# user_id: '13396',
# wallets: {
# BTC: {
# balance: {
# value_int: '0',
# display: '0.00000000 BTC',
# currency: 'BTC',
# value: '0.00000000',
# display_short: '0.00 BTC'
# },
# available: {
# value_int: '0',
# display: '0.00000000 BTC',
# currency: 'BTC',
# value: '0.00000000',
# display_short: '0.00 BTC'
# }
# },
# ...
# },
# trade_fee: '0.25'
# }
# }
#
data = self.safe_value(response, 'data', {})
feeString = self.safe_string(data, 'trade_fee')
fee = self.parse_number(Precise.string_div(feeString, '100'))
result = {}
for i in range(0, len(self.symbols)):
symbol = self.symbols[i]
result[symbol] = {
'info': data,
'symbol': symbol,
'maker': fee,
'taker': fee,
'percentage': True,
'tierBased': False,
}
return result
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,
'active': None,
}, fee))
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
def fetch_markets(self, params={}):
markets = 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 = 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,
'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': market,
})
return result
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)
symbol = base + '/' + quote
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')
taker = self.parse_number(takerString)
makerString = self.safe_string(fee, 'maker', '0.2')
makerString = Precise.string_div(makerString, '100')
maker = self.parse_number(makerString)
status = self.safe_string(entry, 'status')
active = status == 'trading'
limits = {
'price': {
'min': minPrice,
'max': None,
},
'amount': {
'min': None,
'max': None,
},
'cost': {
'min': None,
'max': None,
},
}
precision = {
'price': self.safe_integer(entry, 'quoteAssetPrecision'),
'amount': self.safe_integer(entry, 'baseAssetPrecision'),
}
result.append({
'info': entry,
'symbol': symbol,
'id': id,
'base': base,
'quote': quote,
'baseId': baseId,
'maker': maker,
'taker': taker,
'quoteId': quoteId,
'limits': limits,
'precision': precision,
'type': 'spot',
'spot': isSpot,
'active': active,
})
return result
async def fetch_markets(self, params={}):
"""
retrieves data on all markets for buda
:param dict params: extra parameters specific to the exchange api endpoint
:returns [dict]: an array of objects representing market data
"""
marketsResponse = await self.publicGetMarkets(params)
#
# {
# "markets": [
# {
# "id": "BTC-CLP",
# "name": "btc-clp",
# "base_currency": "BTC",
# "quote_currency": "CLP",
# "minimum_order_amount": [
# "0.00002",
# "BTC"
# ],
# "disabled": False,
# "illiquid": False,
# "rpo_disabled": null,
# "taker_fee": "0.8",
# "maker_fee": "0.4",
# "max_orders_per_minute": 50,
# "maker_discount_percentage": "0.0",
# "taker_discount_percentage": "0.0"
# },
# ]
# }
#
markets = self.safe_value(marketsResponse, 'markets', [])
currenciesResponse = await self.publicGetCurrencies()
currencies = self.safe_value(currenciesResponse, 'currencies')
result = []
for i in range(0, len(markets)):
market = markets[i]
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)
baseInfo = await self.fetch_currency_info(baseId, currencies)
quoteInfo = await self.fetch_currency_info(quoteId, currencies)
minimumOrderAmount = self.safe_value(market,
'minimum_order_amount', [])
taker_fee = self.safe_string(market, 'taker_fee')
maker_fee = self.safe_string(market, 'maker_fee')
result.append({
'id':
self.safe_string(market, '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,
'taker':
self.parse_number(Precise.string_div(taker_fee, '1000')),
'maker':
self.parse_number(Precise.string_div(maker_fee, '1000')),
'precision': {
'amount':
self.parse_number(
self.parse_precision(
self.safe_string(baseInfo, 'input_decimals'))),
'price':
self.parse_number(
self.parse_precision(
self.safe_string(quoteInfo, 'input_decimals'))),
},
'limits': {
'leverage': {
'min': None,
'max': None,
},
'amount': {
'min': self.safe_number(minimumOrderAmount, 0),
'max': None,
},
'price': {
'min': None,
'max': None,
},
'cost': {
'min': None,
'max': None,
},
},
'info':
market,
})
return 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'
async def fetch_markets(self, params={}):
response = await 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_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 fetch_markets(self, params={}):
"""
retrieves data on all markets for tidex
:param dict params: extra parameters specific to the exchange api endpoint
:returns [dict]: an array of objects representing market data
"""
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.parse_number(
self.parse_precision(
self.safe_string(market, 'decimal_places'))),
'price':
self.parse_number(
self.parse_precision(
self.safe_string(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
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)
hidden = self.safe_integer(market, 'hidden')
feeString = self.safe_string(market, 'fee')
feeString = Precise.string_div(feeString, '100')
# yobit maker = taker
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(feeString),
'maker': self.parse_number(feeString),
'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
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:
feeCurrencyCode = None
if market is not None:
feeCurrencyCode = market['quote']
fee = {
'cost': self.parse_number(dealFee),
'currency': feeCurrencyCode,
}
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)
# ---------------------------------------------------------------------------- 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' assert Precise.string_sub(x, w) == '0.000001143' assert Precise.string_sub(w, x) == '-0.000001143' assert Precise.string_div(x, w) == '-0.017809439002671415' assert Precise.string_div(w, x) == '-56.15'
def fetch_markets(self, params={}):
response = self.publicGetMarket(params)
#
# {
# "data":[
# {
# "id":"MONA-USDT",
# "base_currency_id":"MONA",
# "quote_currency_id":"USDT",
# "min_price":"0.001",
# "max_price":"9999999999999999",
# "price_increment":"0.001",
# "min_quantity":"0.0001",
# "max_quantity":"9999999999999999",
# "quantity_precision":4,
# "min_cost":"1",
# "max_cost":"9999999999999999",
# "cost_precision":8,
# "taker_fee_rate":"0.2",
# "maker_fee_rate":"0.2",
# "show_in_ui":true,
# "closed":false
# },
# ]
# }
#
markets = self.safe_value(response, 'data', [])
result = []
for i in range(0, len(markets)):
market = markets[i]
id = self.safe_string(market, 'id')
baseId = self.safe_string(market, 'base_currency_id')
quoteId = self.safe_string(market, 'quote_currency_id')
base = self.safe_currency_code(baseId)
quote = self.safe_currency_code(quoteId)
symbol = base + '/' + quote
closed = self.safe_value(market, 'closed', False)
active = not closed
amountPrecision = self.safe_string(market, 'quantity_precision')
costPrecision = self.safe_string(market, 'cost_precision')
amountTickSize = self.parse_precision(amountPrecision)
costTickSize = self.parse_precision(costPrecision)
precision = {
'amount': self.parse_number(amountTickSize),
'price': self.safe_number(market, 'price_increment'),
'cost': self.parse_number(costTickSize),
}
takerFeeRate = self.safe_string(market, 'taker_fee_rate')
taker = Precise.string_div(takerFeeRate, '100')
makerFeeRate = self.safe_string(market, 'maker_fee_rate')
maker = Precise.string_div(makerFeeRate, '100')
result.append({
'id': id,
'info': market,
'symbol': symbol,
'base': base,
'quote': quote,
'baseId': baseId,
'quoteId': quoteId,
'active': active,
'precision': precision,
'taker': self.parse_number(taker),
'maker': self.parse_number(maker),
'limits': {
'amount': {
'min': self.safe_number(market, 'min_quantity'),
'max': self.safe_number(market, 'max_quantity'),
},
'price': {
'min': self.safe_number(market, 'min_price'),
'max': self.safe_number(market, 'max_price'),
},
'cost': {
'min': self.safe_number(market, 'min_cost'),
'max': self.safe_number(market, 'max_cost'),
},
},
})
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)
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,
'active': active,
'taker': takerFee,
'precision': precision,
'limits': limits,
'info': market,
})
return result
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,
}
