def check_params(self, params, arr=["spot", "future"]):
if self.options["defaultType"] not in ["spot", "future"]:
raise BadRequest("defaultType must be spot or future")
if params and params.get("type"):
type = params.get("type")
if type not in arr:
raise BadRequest(f"params type must be {arr}")
def _convert_float_or_raise(f, msg):
try:
val = _convert_float(f)
except InvalidOperation:
raise BadRequest('{} needs to be a number'.format(msg))
if not val.is_finite():
raise BadRequest('{} needs to be finite'.format(msg))
return val
def fetch_tickers(self, symbols=None, params={}):
self.load_markets()
symbols = self.deal_symbol(symbols, params)
response = self.publicGetMarketTickers()
if not isinstance(symbols, list):
raise BadRequest("Bad request params with symbols.")
sybo = self.market() if not symbols else {
self.market(i)["id"]: self.market(i)
for i in symbols
}
ticket = [i for i in response.get("tickers") if i["s"] in sybo.keys()]
# sybo = {self.markets(i)["s"]: self.market(i) for i in symbols}
# ticket = response.get("tickers")
result = []
for i in ticket:
if sybo.get(i["s"]):
i.update({"at": response["t"]})
# TODO using original method the self.extand have some errror.
ticket = i
result.append(self.parse_ticker(ticket))
return result
def handle_errors(self,
code,
reason,
url,
method,
headers,
body,
response=None):
if code == 429:
raise DDoSProtection(self.id + ' ' + body)
if code >= 400:
if body:
if body[0] == '{':
response = json.loads(body)
error = self.safe_value(response, 'error', {})
message = self.safe_string(error, 'message')
feedback = self.id + ' ' + body
exact = self.exceptions['exact']
if message in exact:
raise exact[message](feedback)
broad = self.exceptions['broad']
broadKey = self.findBroadlyMatchedKey(broad, message)
if broadKey is not None:
raise broad[broadKey](feedback)
if code == 400:
raise BadRequest(feedback)
raise ExchangeError(feedback) # unknown message
def fetch_balance(self, params={}):
self.check_required_credentials()
self.load_markets()
nonce1 = self.uuidv1()
request = {
'nonce': nonce1,
'wallet': self.walletAddress,
}
# [
# {
# asset: 'DIL',
# quantity: '0.00000000',
# availableForTrade: '0.00000000',
# locked: '0.00000000',
# usdValue: null
# }, ...
# ]
extendedRequest = self.extend(request, params)
if extendedRequest['wallet'] is None:
raise BadRequest(
self.id +
' wallet is None, set self.walletAddress or "address" in params'
)
response = None
try:
response = self.privateGetBalances(extendedRequest)
except Exception as e:
if isinstance(e, InvalidAddress):
walletAddress = extendedRequest['wallet']
self.associate_wallet(walletAddress)
response = self.privateGetBalances(extendedRequest)
else:
raise e
return self.parse_balance(response)
def handle_errors(self, httpCode, reason, url, method, headers, body,
response, requestHeaders, requestBody):
if not response:
return # fallback to default error handler
#
# {
# "code": 0,
# "data": {
# ...
# },
# "message": "A short message ONLY WHEN the request is not successful"
# }
#
errorCode = self.safe_value(response, 'code')
if errorCode is not None:
if errorCode != 0:
feedback = self.id + ' ' + body
self.throw_exactly_matched_exception(self.exceptions['exact'],
errorCode, feedback)
raise ExchangeError(feedback) # unknown message
else:
status = self.safe_value(response, 'status')
if status == 400:
feedback = self.id + ' ' + body
raise BadRequest(feedback)
def handle_errors(self, code, reason, url, method, headers, body,
response):
if not self.is_json_encoded_object(body):
return # fallback to default error handler
if (code >= 200) and (code < 300):
return # no error
message = self.safe_string(response, 'errorDescription')
feedback = self.id + ' ' + self.json(response)
exact = self.exceptions['exact']
if message in exact:
raise exact[message](feedback)
broad = self.exceptions['broad']
broadKey = self.findBroadlyMatchedKey(broad, message)
if broadKey is not None:
raise broad[broadKey](feedback)
if code == 400:
raise BadRequest(feedback)
elif code == 401:
raise AuthenticationError(feedback)
elif code == 403:
raise AuthenticationError(feedback)
elif code == 429:
raise DDoSProtection(feedback)
elif code == 500:
raise ExchangeError(feedback)
elif code == 503:
raise ExchangeNotAvailable(feedback)
elif code == 504:
raise RequestTimeout(feedback)
raise ExchangeError(feedback) # unknown message
async def fetch_deposit_address(self, code, params={}):
await self.load_markets()
currencies = await self.fetch_currencies()
currency = self.safe_value(currencies, code)
if currency is None:
raise BadRequest(self.id + ' fetchDepositAddress() error invalid currency')
request = {
'currency': currency['id'],
}
separator = currency['info']['addressSeparator'].lower()
response = await self.privatePostGenerateAddress(request) # overwrite methods
result = response['data']
address = self.safe_string(result, 'Address')
tag = ''
if separator is not None and separator != '':
s = address.lower().split(separator)
tag = s[1]
address = address.substr(
0,
len(s[0])
)
self.check_address(address)
return {
'currency': code,
'address': address,
'tag': tag,
'info': response,
}
def cancel_order(self, id, symbol=None):
self._update_orders()
closed_order = self._closed_orders.get(id)
if closed_order is not None:
raise BadRequest('ExchangeAccount: cannot cancel {} order {}'
.format(closed_order['status'], id))
open_order = self._open_orders.get(id)
if open_order is None:
raise OrderNotFound('ExchangeAccount: order {} does not exist'
.format(id))
else:
open_order.update({
'status': 'canceled',
})
private = self._private_order_info[id]
self._remove_used_balance(amount=open_order['amount'],
price=private['price'],
base=private['base'],
quote=private['quote'],
buy=private['buy'])
self._move_to_closed_orders(id)
if private == self._next_private_order_to_update:
self._update_next_private_order_to_update()
return {'id': id,
'info': {}}
def edit_order(self,
id,
symbol=None,
amount=None,
price=None,
stopPrice=None,
params={}):
if not all([id]):
raise Exception(self.id + "editOrder need orderId argument")
self.load_markets()
request = {
'orderID': id,
}
request.update(params)
symbol = self.deal_symbol(symbol, params)
if symbol:
request["symbol"] = self.market_id(symbol)
if amount:
request['orderQty'] = amount
if price:
request['price'] = price
if stopPrice:
request['stopPrice'] = stopPrice
self.check_params(params)
option_type = params.get("type") or self.options["defaultType"]
response = self.privatePutSpotOrders(self.extend(request,
params)) if option_type == "spot" \
else self.privatePutFuturesOrders(
self.extend(request, params))
if not response or response["code"] != 1:
raise BadRequest("Bad response: " + response["message"])
order = self.extend(response["data"], {"ts": response["ts"]})
return self.parse_order(order)
def handle_errors(self, httpCode, reason, url, method, headers, body,
response):
if not isinstance(body, basestring):
return # fallback to default error handler
if len(body) < 2:
return # fallback to default error handler
if (body[0] == '{') or (body[0] == '['):
response = json.loads(body)
if 'code' in response:
#
# {"code": "100005", "msg": "request sign illegal", "data": null}
#
code = self.safe_string(response, 'code')
if code is not None:
message = self.safe_string(response, 'msg')
feedback = self.id + ' ' + self.json(response)
if code != '0':
exceptions = self.exceptions
if code in exceptions:
if code == '1':
#
# {"code":"1","msg":"系统错误","data":null}
# {“code”:“1",“msg”:“Balance insufficient,余额不足“,”data”:null}
#
if message.find('Balance insufficient') >= 0:
raise InsufficientFunds(feedback)
elif code == '2':
if message == 'offsetNot Null':
raise ExchangeError(feedback)
elif message == 'api_keyNot EXIST':
raise AuthenticationError(feedback)
elif message == 'price precision exceed the limit':
raise InvalidOrder(feedback)
elif message == 'Parameter error':
raise BadRequest(feedback)
raise exceptions[code](feedback)
else:
raise ExchangeError(self.id +
' unknown "error" value: ' +
self.json(response))
else:
#
# Google Translate:
# 订单状态不能取消,订单取消失败 = Order status cannot be canceled
# 根据订单号没有查询到订单,订单取消失败 = The order was not queried according to the order number
#
# {"code":"0","msg":"suc","data":{"success":[],"failed":[{"err-msg":"订单状态不能取消,订单取消失败","order-id":32857051,"err-code":"8"}]}}
# {"code":"0","msg":"suc","data":{"success":[],"failed":[{"err-msg":"Parameter error","order-id":32857050,"err-code":"2"},{"err-msg":"订单状态不能取消,订单取消失败","order-id":32857050,"err-code":"8"}]}}
# {"code":"0","msg":"suc","data":{"success":[],"failed":[{"err-msg":"Parameter error","order-id":98549677,"err-code":"2"},{"err-msg":"根据订单号没有查询到订单,订单取消失败","order-id":98549677,"err-code":"8"}]}}
#
if feedback.find('订单状态不能取消,订单取消失败') >= 0:
if feedback.find('Parameter error') >= 0:
raise OrderNotFound(feedback)
else:
raise InvalidOrder(feedback)
elif feedback.find('根据订单号没有查询到订单,订单取消失败') >= 0:
raise OrderNotFound(feedback)
async def fetch_market_leverage_tiers(self, symbol, params={}):
if self.has['fetchLeverageTiers']:
market = await self.market(symbol)
if (not market['contract']):
raise BadRequest(self.id + ' fetch_leverage_tiers() supports contract markets only')
tiers = await self.fetch_leverage_tiers([symbol])
return self.safe_value(tiers, symbol)
else:
raise NotSupported(self.id + 'fetch_market_leverage_tiers() is not supported yet')
def fetch_ohlcv_dataframe(self,
symbol,
timeframe='1m',
since=None,
limit=None,
params={}):
# Exchanges in the real world have different behaviour, when there is
# no since parameter provided. (some use data from the beginning,
# some from the end)
# We return data from the beginning, because this is most likely not
# what the user wants, so this will force the user to provide the
# parameters, which will work with every exchange. This is a bug
# prevention mechanism.
ohlcv = self._ohlcvs.get(symbol)
if ohlcv is None:
raise BadSymbol('ExchangeBackend: no prices for {}'.format(symbol))
pd_current_date = self._timeframe.date().floor('1T')
if limit is None:
limit = 5
timeframe_sec = Exchange.parse_timeframe(timeframe)
pd_timeframe = pandas.Timedelta(timeframe_sec, unit='s')
ohlcv_start_date = ohlcv.index[0]
if since is None:
pd_since = ohlcv_start_date
else:
pd_since = pandas.Timestamp(since, unit='ms', tz='UTC')
pd_since = pd_since.ceil(pd_timeframe)
if pd_since < ohlcv_start_date:
raise BadRequest('ExchangeBackend: fetch_ohlcv: no date availabe '
'at since')
pd_until = pd_since + limit * pd_timeframe - pandas.Timedelta('1m')
if pd_until >= pd_current_date + pd_timeframe:
raise BadRequest('ExchangeBackend: fetch_ohlcv:'
' since.ceil(timeframe) + limit * timeframe'
' needs to be in the past')
pd_until = min(pd_until, pd_current_date)
data = ohlcv[pd_since:pd_until]
return data.resample(pd_timeframe).agg({
'open': 'first',
'high': 'max',
'low': 'min',
'close': 'last',
'volume': 'sum'
})
async def fetch_my_trades(self,
symbol=None,
since=None,
limit=None,
params={}):
self.check_required_credentials()
await self.load_markets()
market = None
request = {
'nonce': self.uuidv1(),
'wallet': self.walletAddress,
}
if symbol is not None:
market = self.market(symbol)
request['market'] = market['id']
if since is not None:
request['start'] = since
if limit is not None:
request['limit'] = limit
# [
# {
# 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'
# }
# ]
extendedRequest = self.extend(request, params)
if extendedRequest['wallet'] is None:
raise BadRequest(
self.id +
' walletAddress is None, set self.walletAddress or "address" in params'
)
response = None
try:
response = await self.privateGetFills(extendedRequest)
except Exception as e:
if isinstance(e, InvalidAddress):
walletAddress = extendedRequest['wallet']
await self.associate_wallet(walletAddress)
response = await self.privateGetFills(extendedRequest)
else:
raise e
return self.parse_trades(response, market, since, limit)
async def fetch_tickers(self, symbols=None, params={}):
await self.load_markets()
request = {}
if symbols is not None:
if not isinstance(symbols, list):
raise BadRequest(self.id + ' fetchTickers() symbols argument should be an array')
if symbols is not None:
marketIds = self.market_ids(symbols)
request['symbol'] = ','.join(marketIds)
response = await self.publicGetQTickers(self.extend(request, params))
tickers = self.safe_value(response, 'data')
return self.parse_tickers(tickers, symbols, params)
def set_leverage(self, symbol, leverage, params={}):
# WARNING: THIS WILL INCREASE LIQUIDATION PRICE FOR OPEN ISOLATED LONG POSITIONS
# AND DECREASE LIQUIDATION PRICE FOR OPEN ISOLATED SHORT POSITIONS
if (leverage < 1) or (leverage > 125):
raise BadRequest(self.id + ' leverage should be between 1 and 125')
self.load_markets()
market = self.market(symbol)
request = {
'symbol': market['id'],
'leverage': leverage,
}
return self.dapiPrivatePostLeverage(self.extend(request, params))
def handle_errors(self, code, reason, url, method, headers, body, response, requestHeaders, requestBody):
if response is None:
return
if code == 429:
raise DDoSProtection(self.id + ' ' + body)
if code >= 400:
error = self.safe_value(response, 'error', {})
message = self.safe_string(error, 'message')
feedback = self.id + ' ' + body
self.throw_exactly_matched_exception(self.exceptions['exact'], message, feedback)
self.throw_broadly_matched_exception(self.exceptions['broad'], message, feedback)
if code == 400:
raise BadRequest(feedback)
raise ExchangeError(feedback) # unknown message
async def fetch_balance(self, params={}):
self.check_required_credentials()
await self.load_markets()
nonce1 = self.uuidv1()
request = {
'nonce': nonce1,
'wallet': self.walletAddress,
}
# [
# {
# asset: 'DIL',
# quantity: '0.00000000',
# availableForTrade: '0.00000000',
# locked: '0.00000000',
# usdValue: null
# }, ...
# ]
extendedRequest = self.extend(request, params)
if extendedRequest['wallet'] is None:
raise BadRequest(
self.id +
' wallet is None, set self.walletAddress or "address" in params'
)
response = None
try:
response = await self.privateGetBalances(extendedRequest)
except Exception as e:
if isinstance(e, InvalidAddress):
walletAddress = extendedRequest['wallet']
await self.associate_wallet(walletAddress)
response = await self.privateGetBalances(extendedRequest)
else:
raise e
result = {
'info': response,
}
for i in range(0, len(response)):
entry = response[i]
currencyId = self.safe_string(entry, 'asset')
code = self.safe_currency_code(currencyId)
total = self.safe_float(entry, 'quantity')
free = self.safe_float(entry, 'availableForTrade')
used = self.safe_float(entry, 'locked')
result[code] = {
'free': free,
'used': used,
'total': total,
}
return self.parse_balance(result)
def fetch_order_book(self, symbol, limit=None, params={}):
symbol = self.deal_symbol(symbol, params)
self.load_markets()
market = self.market(symbol)
request = {'symbol': market['id'], "level": limit or 20}
# XXX add error mmessage level must be 20, 50
if limit is not None:
request['limit'] = int(limit) # default = 300
limit = int(limit)
if limit != 20 and limit != 50:
raise BadRequest("limit must be 20 or 50.")
orderbook = self.publicGetMarketOrderbook(self.extend(request, params))
# TODO add get orderbook "t"
timestamp = self.safe_timestamp(orderbook, 't') // 1000
return self.parse_order_book(orderbook, timestamp)
def fetch_tickers(self, symbols=None, params={}):
self.load_markets()
request = {}
if symbols is not None:
if not isinstance(symbols, list):
raise BadRequest(
self.id +
' fetchTickers() symbols argument should be an array')
if symbols is not None:
marketIds = []
for i in range(0, len(symbols)):
market = self.market(symbols[i])
marketIds.append(market['id'])
request['symbol'] = ','.join(marketIds)
response = self.publicGetQTickers(self.extend(request, params))
tickers = self.safe_value(response, 'data')
return self.parse_tickers(tickers, symbols, params)
async def fetch_ohlcv(self,
symbol,
timeframe='1m',
since=None,
limit=None,
params={}):
self._check_has('fetchOHLCV')
if timeframe not in self.timeframes:
raise BadRequest(
'Timeframe {} not supported by exchange'.format(timeframe))
data = self._exchange_backend.fetch_ohlcv_dataframe(
symbol=symbol, timeframe=timeframe, since=since, limit=limit)
result = [[
int(values.Index.value / 10**6), values.open, values.high,
values.low, values.close, values.volume
] for values in data.itertuples()]
return result
async def set_margin_mode(self, symbol, marginType, params={}):
#
# {"code": -4048 , "msg": "Margin type cannot be changed if there exists position."}
#
# or
#
# {"code": 200, "msg": "success"}
#
marginType = marginType.upper()
if (marginType != 'ISOLATED') and (marginType != 'CROSSED'):
raise BadRequest(self.id + ' marginType must be either isolated or crossed')
await self.load_markets()
market = self.market(symbol)
request = {
'symbol': market['id'],
'marginType': marginType,
}
return await self.dapiPrivatePostMarginType(self.extend(request, params))
async def fetch_ohlcv(self,
symbol,
timeframe='1m',
since=None,
limit=None,
params={}):
await self.load_markets()
market = self.market(symbol)
if self.timeframes[timeframe] is None:
raise BadRequest(self.id + ': timeframe ' + timeframe +
' is not supported') # eslint-disable-line quotes
request = self.extend(
{
'pairId': market['id'],
'timespan': self.timeframes[timeframe],
}, params)
response = await self.publicGetGetChart(self.extend(request, params))
results = self.safe_value(response, 'chart', [])
return self.parse_ohlcvs(results, market, timeframe, since, limit)
def create_order(self, symbol, type, side, amount, price=None, params={}):
self.load_markets()
if not all([symbol, type, side, amount]):
raise Exception(self.id + "createOrder lack of arguments")
type = type.upper()
side = side.upper()
symbol = self.deal_symbol(symbol, params)
if type not in ['MARKET', 'LIMIT', 'STOP', 'STOP-LIMIT']:
raise BadRequest('type must be MARKET, LIMIT, STOP or STOP-LIMIT')
request = {
'symbol': self.market_id(symbol),
'side': side,
'timeInForce': params.get("timeInForce", "GTC"),
'stopPric': params.get("stopPrice", None),
'orderQty': str(amount),
'orderType': type,
}
# TODO and STOP, MARKET
if type == 'LIMIT' or type == "STOP-LIMIT":
if not price:
raise ArgumentsRequired(
self.id +
"createOrder LIMIT or STOP-LIMIT need price argument")
request['price'] = str(price)
self.check_params(params)
# response = self.privatePostOrders(self.extend(request, params))
option_type = params.get("type") or self.options["defaultType"]
response = self.privatePostSpotOrders(self.extend(request, params)) if option_type == "spot" else \
self.privatePostFuturesOrders(self.extend(request, params))
if not response or response["code"] != 1:
raise ExchangeError(self.id + response["message"])
# marketId = self.safe_value(response, 'market')
# market = self.safe_value(self.markets_by_id, marketId)
order = self.extend(response["data"], {"ts": response["ts"]})
return self.parse_order(order)
async def watch_order_book(self, symbol, limit=None, params={}):
limit = 25 if (limit is None) else limit # 25 by default
if (limit != 1) and (limit != 25) and (limit != 500):
raise BadRequest(
self.id +
' watchOrderBook() limit argument must be None, 1, 25 or 500, default is 25'
)
await self.load_markets()
negotiate = self.negotiate()
#
# 1. Subscribe to the relevant socket streams
# 2. Begin to queue up messages without processing them
# 3. Call the equivalent v3 REST API and record both the results and the value of the returned Sequence header. Refer to the descriptions of individual streams to find the corresponding REST API. Note that you must call the REST API with the same parameters as you used to subscribed to the stream to get the right snapshot. For example, orderbook snapshots of different depths will have different sequence numbers.
# 4. If the Sequence header is less than the sequence number of the first queued socket message received(unlikely), discard the results of step 3 and then repeat step 3 until self check passes.
# 5. Discard all socket messages where the sequence number is less than or equal to the Sequence header retrieved from the REST call
# 6. Apply the remaining socket messages in order on top of the results of the REST call. The objects received in the socket deltas have the same schemas as the objects returned by the REST API. Each socket delta is a snapshot of an object. The identity of the object is defined by a unique key made up of one or more fields in the message(see documentation of individual streams for details). To apply socket deltas to a local cache of data, simply replace the objects in the cache with those coming from the socket where the keys match.
# 7. Continue to apply messages as they are received from the socket as long as sequence number on the stream is always increasing by 1 each message(Note: for private streams, the sequence number is scoped to a single account or subaccount).
# 8. If a message is received that is not the next in order, return to step 2 in self process
#
future = self.after_async(negotiate, self.subscribe_to_order_book,
symbol, limit, params)
return await self.after(future, self.limit_order_book, symbol, limit,
params)
def handle_errors(self, code, reason, url, method, headers, body, response, requestHeaders, requestBody):
if not self.is_json_encoded_object(body):
return # fallback to default error handler
if (code >= 200) and (code < 300):
return # no error
message = self.safe_string(response, 'errorDescription')
feedback = self.id + ' ' + body
self.throw_exactly_matched_exception(self.exceptions['exact'], message, feedback)
self.throw_broadly_matched_exception(self.exceptions['broad'], message, feedback)
if code == 400:
raise BadRequest(feedback)
elif code == 401:
raise AuthenticationError(feedback)
elif code == 403:
raise AuthenticationError(feedback)
elif code == 429:
raise DDoSProtection(feedback)
elif code == 500:
raise ExchangeError(feedback)
elif code == 503:
raise ExchangeNotAvailable(feedback)
elif code == 504:
raise RequestTimeout(feedback)
raise ExchangeError(feedback) # unknown message
async def create_order(self,
symbol,
type,
side,
amount,
price=None,
params={}):
# https://docs.idex.io/#create-order
self.check_required_credentials()
await self.load_markets()
market = self.market(symbol)
nonce = self.uuidv1()
typeEnum = None
stopLossTypeEnums = {
'stopLoss': 3,
'stopLossLimit': 4,
'takeProfit': 5,
'takeProfitLimit': 6,
}
stopPriceString = None
if (type == 'stopLossLimit') or (type
== 'takeProfitLimit') or ('stopPrice'
in params):
if not ('stopPrice' in params):
raise BadRequest(self.id +
' stopPrice is a required parameter for ' +
type + 'orders')
stopPriceString = self.price_to_precision(symbol,
params['stopPrice'])
limitTypeEnums = {
'limit': 1,
'limitMaker': 2,
}
priceString = None
typeLower = type.lower()
limitOrder = typeLower.find('limit') > -1
if type in limitTypeEnums:
typeEnum = limitTypeEnums[type]
priceString = self.price_to_precision(symbol, price)
elif type in stopLossTypeEnums:
typeEnum = stopLossTypeEnums[type]
priceString = self.price_to_precision(symbol, price)
elif type == 'market':
typeEnum = 0
else:
raise BadRequest(self.id + ' ' + type +
' is not a valid order type')
amountEnum = 0 # base quantity
if 'quoteOrderQuantity' in params:
if type != 'market':
raise NotSupported(
self.id + ' quoteOrderQuantity is not supported for ' +
type + ' orders, only supported for market orders')
amountEnum = 1
amount = self.safe_number(params, 'quoteOrderQuantity')
sideEnum = 0 if (side == 'buy') else 1
walletBytes = self.remove0x_prefix(self.walletAddress)
network = self.safe_string(self.options, 'network', 'ETH')
orderVersion = 1 if (network == 'ETH') else 2
amountString = self.amount_to_precision(symbol, amount)
# https://docs.idex.io/#time-in-force
timeInForceEnums = {
'gtc': 0,
'ioc': 2,
'fok': 3,
}
defaultTimeInForce = self.safe_string(self.options,
'defaultTimeInForce', 'gtc')
timeInForce = self.safe_string(params, 'timeInForce',
defaultTimeInForce)
timeInForceEnum = None
if timeInForce in timeInForceEnums:
timeInForceEnum = timeInForceEnums[timeInForce]
else:
allOptions = list(timeInForceEnums.keys())
asString = ', '.join(allOptions)
raise BadRequest(
self.id + ' ' + timeInForce +
' is not a valid timeInForce, please choose one of ' +
asString)
# https://docs.idex.io/#self-trade-prevention
selfTradePreventionEnums = {
'dc': 0,
'co': 1,
'cn': 2,
'cb': 3,
}
defaultSelfTradePrevention = self.safe_string(
self.options, 'defaultSelfTradePrevention', 'cn')
selfTradePrevention = self.safe_string(params, 'selfTradePrevention',
defaultSelfTradePrevention)
selfTradePreventionEnum = None
if selfTradePrevention in selfTradePreventionEnums:
selfTradePreventionEnum = selfTradePreventionEnums[
selfTradePrevention]
else:
allOptions = list(selfTradePreventionEnums.keys())
asString = ', '.join(allOptions)
raise BadRequest(
self.id + ' ' + selfTradePrevention +
' is not a valid selfTradePrevention, please choose one of ' +
asString)
byteArray = [
self.number_to_be(orderVersion, 1),
self.base16_to_binary(nonce),
self.base16_to_binary(walletBytes),
self.encode(
market['id']
), # TODO: refactor to remove either encode or stringToBinary
self.number_to_be(typeEnum, 1),
self.number_to_be(sideEnum, 1),
self.encode(amountString),
self.number_to_be(amountEnum, 1),
]
if limitOrder:
encodedPrice = self.encode(priceString)
byteArray.append(encodedPrice)
if type in stopLossTypeEnums:
encodedPrice = self.encode(stopPriceString or priceString)
byteArray.append(encodedPrice)
clientOrderId = self.safe_string(params, 'clientOrderId')
if clientOrderId is not None:
byteArray.append(self.encode(clientOrderId))
after = [
self.number_to_be(timeInForceEnum, 1),
self.number_to_be(selfTradePreventionEnum, 1),
self.number_to_be(0, 8), # unused
]
allBytes = self.array_concat(byteArray, after)
binary = self.binary_concat_array(allBytes)
hash = self.hash(binary, 'keccak', 'hex')
signature = self.sign_message_string(hash, self.privateKey)
request = {
'parameters': {
'nonce': nonce,
'market': market['id'],
'side': side,
'type': type,
'wallet': self.walletAddress,
'timeInForce': timeInForce,
'selfTradePrevention': selfTradePrevention,
},
'signature': signature,
}
if limitOrder:
request['parameters']['price'] = priceString
if type in stopLossTypeEnums:
request['parameters']['stopPrice'] = stopPriceString or priceString
if amountEnum == 0:
request['parameters']['quantity'] = amountString
else:
request['parameters']['quoteOrderQuantity'] = amountString
if clientOrderId is not None:
request['parameters']['clientOrderId'] = clientOrderId
# {
# market: 'DIL-ETH',
# orderId: '7cdc8e90-eb7d-11ea-9e60-4118569f6e63',
# wallet: '0x0AB991497116f7F5532a4c2f4f7B1784488628e1',
# time: 1598873478650,
# status: 'filled',
# type: 'limit',
# side: 'buy',
# originalQuantity: '0.40000000',
# executedQuantity: '0.40000000',
# cumulativeQuoteQuantity: '0.03962396',
# price: '1.00000000',
# fills: [
# {
# fillId: '48582d10-b9bb-3c4b-94d3-e67537cf2472',
# price: '0.09905990',
# quantity: '0.40000000',
# quoteQuantity: '0.03962396',
# time: 1598873478650,
# makerSide: 'sell',
# sequence: 5053,
# fee: '0.00080000',
# feeAsset: 'DIL',
# gas: '0.00857497',
# liquidity: 'taker',
# txStatus: 'pending'
# }
# ],
# avgExecutionPrice: '0.09905990'
# }
# we don't use self.extend here because it is a signed endpoint
response = await self.privatePostOrders(request)
return self.parse_order(response, market)
def create_order(self, market, type, price, side, amount):
self._update_orders()
type_market = False
type_limit = False
if type == 'market':
if price is not None:
raise InvalidOrder(
'ExchangeAccount: market order has no price')
type_market = True
elif type == 'limit':
price = _convert_float_or_raise(price, 'ExchangeAccount: price')
type_limit = True
if price <= 0:
raise BadRequest('ExchangeAccount: price needs to be positive')
else:
raise InvalidOrder(
'ExchangeAccount: only market and limit order supported')
if market is None:
raise InvalidOrder('ExchangeAccount: market is None')
symbol = market.get('symbol')
ohlcv = self._ohlcvs.get(symbol)
if ohlcv is None:
raise InvalidOrder('ExchangeAccount: no prices available for {}'
.format(symbol))
if side not in ['buy', 'sell']:
raise InvalidOrder('ExchangeAccount: side {} not supported'
.format(side))
buy = side == 'buy'
amount = _convert_float_or_raise(amount, 'ExchangeAccount: amount')
if amount <= 0:
raise BadRequest('ExchangeAccount: amount needs to be positive')
base = market.get('base')
quote = market.get('quote')
if base is None:
raise BadRequest('ExchangeAccount: market has no base')
if quote is None:
raise BadRequest('ExchangeAccount: market has no quote')
self._last_order_id += 1
order_id = str(self._last_order_id)
date = self._timeframe.date()
timestamp = int(date.value / 10e5)
order = {
'info': {},
'id': order_id,
'timestamp': timestamp,
'datetime': Exchange.iso8601(timestamp),
'lastTradeTimestamp': None,
'symbol': symbol,
'type': type,
'side': side,
'price': None,
'amount': amount,
'cost': None,
'average': None,
'filled': 0,
'remaining': amount,
'status': 'open',
'fee': {'currency': base if buy else quote,
'cost': None,
'rate': None},
'trades': None,
}
if type_market:
# Determinie the price of the market order
# We could use the next low/high to fill the order, but then we
# need to wait for the next date to fill the order, otherwise we
# would introduce a possibility to see the future price
# (Look-Ahead Bias)
# If we wait for the next date, we would return a market order that
# is pending, but this should never happen in reality
# Maybe the factor should depend on the volume
factor = Decimal('0.0015')
if buy:
price = (1 + factor) * _convert_float(ohlcv['high'][date])
else:
price = (1 - factor) * _convert_float(ohlcv['low'][date])
fee_percentage = market.get('taker', 0)
fee_percentage = _convert_float_or_raise(fee_percentage,
'ExchangeAccount: fee')
self._update_balance(price, amount, base, quote, buy,
fee_percentage)
self._fill_order(order, buy, price, timestamp, fee_percentage)
self._closed_orders[order_id] = order
if type_limit:
# TODO Probably use taker fee, if the order can be filled now
fee_percentage = market.get('maker', 0)
fee_percentage = _convert_float_or_raise(fee_percentage,
'ExchangeAccount: fee')
if buy:
self._balances[quote].change_used(price * amount)
else:
self._balances[base].change_used(amount)
self._open_orders[order_id] = order
self._private_order_info[order_id] = {
'id': order_id,
'base': base,
'quote': quote,
'price': price,
'buy': buy,
'fee_percentage': fee_percentage,
'fillable_date': self._limit_order_fillable_date(
symbol, buy, price),
}
self._update_next_private_order_to_update()
return {'id': order_id,
'info': {}}
def deal_timeframe(self, timeframe):
date_scale = self.timeframes.get(timeframe)
if not date_scale:
raise BadRequest(f"params type must be {self.timeframes}")
return date_scale
