def handle_errors(self, code, reason, url, method, headers, body):
response = None
try:
response = json.loads(body)
except Exception as e:
# syntax error, resort to default error handler
return
if 'error' in response:
error = response['error']
feedback = self.id + ' ' + self.json(response)
if error == 'Invalid order number, or you are not the person who placed the order.':
raise OrderNotFound(feedback)
elif error == 'Internal error. Please try again.':
raise ExchangeNotAvailable(feedback)
elif error == 'Order not found, or you are not the person who placed it.':
raise OrderNotFound(feedback)
elif error == 'Invalid API key/secret pair.':
raise AuthenticationError(feedback)
elif error == 'Please do not make more than 8 API calls per second.':
raise DDoSProtection(feedback)
elif error.find('Total must be at least') >= 0:
raise InvalidOrder(feedback)
elif error.find('Not enough') >= 0:
raise InsufficientFunds(feedback)
elif error.find('Nonce must be greater') >= 0:
raise InvalidNonce(feedback)
elif error.find(
'You have already called cancelOrder or moveOrder on self order.'
) >= 0:
raise CancelPending(feedback)
else:
raise ExchangeError(self.id + ': unknown error: ' +
self.json(response))
def fetch_order(self, id, symbol=None, params={}):
filter = {'filter': {'orderID': id}}
result = self.fetch_orders(symbol, None, None, self.deep_extend(filter, params))
numResults = len(result)
if numResults == 1:
return result[0]
raise OrderNotFound(self.id + ': The order ' + id + ' not found.')
def fetch_order(self, id, symbol=None, params={}):
if not symbol:
raise ExchangeError(self.id +
' fetchOrder requires a symbol parameter')
self.load_markets()
market = self.market(symbol)
method = 'privatePost'
request = {
'order_id': id,
'symbol': market['id'],
# 'status': 0, # 0 for unfilled orders, 1 for filled orders
# 'current_page': 1, # current page number
# 'page_length': 200, # number of orders returned per page, maximum 200
}
if market['future']:
method += 'Future'
if not params.get('contract_type'):
raise ExchangeError(
self.id +
' futureOrderInfo requires a contract_type parameter in params'
)
request['contract_type'] = params.get('contract_type')
method += 'OrderInfo'
response = getattr(self, method)(self.extend(request, params))
ordersField = self.get_orders_field()
numOrders = len(response[ordersField])
if numOrders > 0:
return self.parse_order(response[ordersField][0])
raise OrderNotFound(self.id + ' order ' + id + ' not found')
async def fetch_order(self, id, symbol=None, params={}):
if symbol is None:
raise ExchangeError(self.id +
' fetchOrder requires a symbol argument')
orderType = self.safe_value(params, 'type')
if orderType is None:
raise ExchangeError(
self.id +
' fetchOrder requires a type parameter("BUY" or "SELL")')
await self.load_markets()
market = self.market(symbol)
request = {
'symbol': market['id'],
'type': orderType,
'orderOid': id,
}
response = await self.privateGetOrderDetail(
self.extend(request, params))
if not response['data']:
raise OrderNotFound(self.id + ' ' + self.json(response))
#
# the caching part to be removed
#
# order = self.parse_order(response['data'], market)
# orderId = order['id']
# if orderId in self.orders:
# order['status'] = self.orders[orderId]['status']
# self.orders[orderId] = order
#
return self.parse_order(response['data'], market)
async def cancel_order(self, id, symbol=None, params={}):
await self.load_markets()
result = await self.privatePostOrderDelete({'id': id})
order = self.parse_order(result)
status = order['status']
if status == 'closed' or status == 'canceled':
raise OrderNotFound(self.id + ' ' + self.json(order))
return order
def fetch_order(self, id, symbol=None, params={}):
if symbol is None:
raise ExchangeError(self.id + ' fetchOrder() requires a symbol argument')
orders = self.fetch_orders(symbol)
ordersById = self.index_by(orders, 'id')
if id in ordersById:
return ordersById[id]
raise OrderNotFound(self.id + ' No order found with id ' + id)
async def fetch_order(self, id, symbol=None, params={}):
await self.load_markets()
response = await self.privateGetHistoryOrder(self.extend({
'clientOrderId': id,
}, params))
numOrders = len(response)
if numOrders > 0:
return self.parse_order(response[0])
raise OrderNotFound(self.id + ' order ' + id + ' not found')
async def cancel_order(self, id, symbol=None, params={}):
await self.load_markets()
result = await self.privatePutOrdersIdCancel(self.extend({
'id': id,
}, params))
order = self.parse_order(result)
if order['status'] == 'closed':
raise OrderNotFound(self.id + ' ' + self.json(order))
return order
async def fetch_order(self, id, symbol=None, params={}):
await self.load_markets()
response = await self.tradingGetOrder(
self.extend({
'clientOrderId': id,
}, params))
if response['orders'][0]:
return self.parse_order(response['orders'][0])
raise OrderNotFound(self.id + ' fetchOrder() error: ' + self.response)
def cancel_order(self, id, symbol=None, params={}):
self.load_markets()
response = self.privateDeleteOrder(self.extend({'orderID': id}, params))
order = response[0]
error = self.safe_string(order, 'error')
if error is not None:
if error.find('Unable to cancel order due to existing state') >= 0:
raise OrderNotFound(self.id + ' cancelOrder() failed: ' + error)
order = self.parse_order(order)
self.orders[order['id']] = order
return self.extend({'info': response}, order)
def fetch_order(self, id, symbol=None, params={}):
self.load_markets()
ids = [int(id)]
response = self.privatePostOrderDetail(
self.extend({
'orderIds': ids,
}, params))
numOrders = len(response['orders'])
if numOrders < 1:
raise OrderNotFound(self.id + ' No matching order found: ' + id)
order = response['orders'][0]
return self.parse_order(order)
def fetch_order(self, id, symbol=None, params={}):
self.load_markets()
try:
response = self.privatePostOrderTrades({
'order_id': str(id),
})
return self.parse_order(response)
except Exception as e:
if isinstance(e, OrderNotFound):
if id in self.orders:
return self.orders[id]
raise OrderNotFound(self.id + ' fetchOrder order id ' + str(id) + ' not found in cache.')
async def fetch_order_trades(self, id, symbol=None, since=None, limit=None, params={}):
# The id needed here is the exchange's id, and not the clientOrderID, which is
# the id that is stored in the unified api order id. In order the get the exchange's id,
# you need to grab it from order['info']['id']
await self.load_markets()
market = None
if symbol is not None:
market = self.market(symbol)
response = await self.privateGetHistoryOrderIdTrades(self.extend({
'id': id,
}, params))
numOrders = len(response)
if numOrders > 0:
return self.parse_trades(response, market, since, limit)
raise OrderNotFound(self.id + ' order ' + id + ' not found, ' + self.id + '.fetchOrderTrades() requires an exchange-specific order id, you need to grab it from order["info"]["id"]')
async def cancel_order(self, id, symbol=None, params={}):
await self.load_markets()
response = None
try:
response = await self.privatePostCancelOrder(
self.extend({
'txid': id,
}, params))
except Exception as e:
if self.last_http_response:
if self.last_http_response.find('EOrder:Unknown order') >= 0:
raise OrderNotFound(self.id + ' cancelOrder() error ' +
self.last_http_response)
raise e
return response
def fetch_order(self, id, symbol=None, params={}):
self.load_markets()
response = None
try:
orderIdField = self.get_order_id_field()
request = {}
request[orderIdField] = id
response = self.accountGetOrder(self.extend(request, params))
except Exception as e:
if self.last_json_response:
message = self.safe_string(self.last_json_response, 'message')
if message == 'UUID_INVALID':
raise OrderNotFound(self.id + ' fetchOrder() error: ' +
self.last_http_response)
raise e
return self.parse_order(response['result'])
def handle_errors(self, code, reason, url, method, headers, body):
if code == 400:
if body[0] == '{':
response = json.loads(body)
if 'error' in response:
if 'message' in response['error']:
message = response['error']['message']
if message == 'Order not found':
raise OrderNotFound(self.id + ' order not found in active orders')
elif message == 'Quantity not a valid number':
raise InvalidOrder(self.id + ' ' + body)
elif message == 'Insufficient funds':
raise InsufficientFunds(self.id + ' ' + body)
elif message == 'Duplicate clientOrderId':
raise InvalidOrder(self.id + ' ' + body)
raise ExchangeError(self.id + ' ' + body)
def handle_errors(self,
code,
reason,
url,
method,
headers,
body,
response=None):
# {success: 0, error: "invalid order."}
# or
# [{data, ...}, {...}, ...]
if response is None:
if body[0] == '{' or body[0] == '[':
response = json.loads(body)
if isinstance(response, list):
return # public endpoints may return []-arrays
if not ('success' in list(response.keys())):
return # no 'success' property on public responses
if response['success'] == 1:
# {success: 1, return: {orders: []}}
if not ('return' in list(response.keys())):
raise ExchangeError(self.id + ': malformed response: ' +
self.json(response))
else:
return
message = response['error']
feedback = self.id + ' ' + self.json(response)
if message == 'Insufficient balance.':
raise InsufficientFunds(feedback)
elif message == 'invalid order.':
raise OrderNotFound(feedback) # cancelOrder(1)
elif message.find('Minimum price ') >= 0:
raise InvalidOrder(
feedback
) # price < limits.price.min, on createLimitBuyOrder('ETH/BTC', 1, 0)
elif message.find('Minimum order ') >= 0:
raise InvalidOrder(
feedback
) # cost < limits.cost.min on createLimitBuyOrder('ETH/BTC', 0, 1)
elif message == 'Invalid credentials. API not found or session has expired.':
raise AuthenticationError(feedback) # on bad apiKey
elif message == 'Invalid credentials. Bad sign.':
raise AuthenticationError(feedback) # on bad secret
raise ExchangeError(self.id + ': unknown error: ' +
self.json(response))
def handle_errors(self, code, reason, url, method, headers, body):
if (code == 400) or (code == 404):
if body[0] == '{':
response = json.loads(body)
message = response['message']
error = self.id + ' ' + message
if message.find('price too small') >= 0:
raise InvalidOrder(error)
elif message.find('price too precise') >= 0:
raise InvalidOrder(error)
elif message == 'Insufficient funds':
raise InsufficientFunds(error)
elif message == 'NotFound':
raise OrderNotFound(error)
elif message == 'Invalid API Key':
raise AuthenticationError(error)
raise ExchangeError(self.id + ' ' + message)
raise ExchangeError(self.id + ' ' + body)
def cancel_order(self, id, symbol=None, params={}):
if not symbol:
raise ExchangeError(self.id + ' cancelOrder requires a symbol argument')
self.load_markets()
market = self.market(symbol)
currencyPair = market['id']
response = self.privatePostExchangeCancellimit(self.extend({
'orderId': id,
'currencyPair': currencyPair,
}, params))
message = self.safe_string(response, 'message', self.json(response))
if 'success' in response:
if not response['success']:
raise InvalidOrder(message)
elif 'cancelled' in response:
if response['cancelled']:
return response
else:
raise OrderNotFound(message)
raise ExchangeError(self.id + ' cancelOrder() failed: ' + self.json(response))
def cancel_order(self, id, symbol=None, params={}):
self.load_markets()
response = None
try:
response = self.privatePostCancelTrade(
self.extend({
'Type': 'Trade',
'OrderId': id,
}, params))
if id in self.orders:
self.orders[id]['status'] = 'canceled'
except Exception as e:
if self.last_json_response:
message = self.safe_string(self.last_json_response, 'Error')
if message:
if message.find('does not exist') >= 0:
raise OrderNotFound(self.id +
' cancelOrder() error: ' +
self.last_http_response)
raise e
return response
