async def create_order(self,
symbol,
type,
side,
amount,
price=None,
params={}):
await self.load_markets()
if symbol is None:
raise ArgumentsRequired(
'createOrder requires the symbol parameter')
request = {
'type': type.upper(),
'pair': self.market_id(symbol),
'action': side.upper(),
'amount': amount,
'timestamp': self.nonce(),
}
if type.lower() == 'limit':
request['price'] = price
response = await self.privatePostOrdersPair(
self.extend(request, params), params)
return self.parse_order_execution(response)
async def fetch_withdrawals(self,
code=None,
since=None,
limit=None,
params={}):
await self.load_markets()
if not ('userid' in params) and (self.apiKey is None):
raise ArgumentsRequired(
'fetchWithdrawals() requires self.apiKey or userid argument')
currency = None
request = {
'userid': self.apiKey,
}
if code is not None:
currency = self.currency(code)
request['currency'] = currency['id']
if since is not None:
request['since'] = since
if limit is not None:
request['limit'] = limit
response = await self.publicGetWithdrawals(self.extend(
request, params))
return self.parse_transactions(response, currency, since, limit)
async def fetch_closed_orders(self,
symbol=None,
since=None,
limit=None,
params={}):
if not ('userid' in params) and (self.apiKey is None):
raise ArgumentsRequired(
'fetchClosedOrders() requires self.apiKey or userid argument')
await self.load_markets()
market = None
request = {
'userid': self.apiKey,
}
if symbol is not None:
market = self.market(symbol)
request['symbol'] = market['id']
if limit is not None:
request['limit'] = limit
if since is not None:
request['since'] = since
response = await self.publicGetOrdersClosed(
self.extend(request, params))
return self.parse_orders(response, market, since, limit)
async def fetch_transactions(self,
code=None,
since=None,
limit=None,
params={}):
await self.load_markets()
request = self.extend(
{
'venueId': self.options['venueId'],
'accountId': await self.get_active_account(),
}, params)
if not request['accountId']:
raise ArgumentsRequired(
self.id +
" fetchTransactions requires either the 'accountId' extra parameter or exchange.options['accountId'] = 'YOUR_ACCOUNT_ID'."
)
response = await self.privateGetVenuesVenueIdAccountsAccountIdTransactions(
request)
currency = None
if code is not None:
currency = self.currency(code)
return self.parse_transactions(response['result'], currency, since,
limit)
async def fetch_orders(self, symbol=None, since=None, limit=None, params={}):
if symbol is None:
raise ArgumentsRequired(self.id + ' fetchOrders requires a `symbol` argument')
await self.load_markets()
market = self.market(symbol)
states = self.safe_value(params, 'states', ['wait', 'done', 'cancel'])
query = self.omit(params, 'states')
request = {
'market': market['id'],
'states': states,
'need_price': 'True',
}
if limit is not None:
request['limit'] = limit
response = await self.privateGetOrdersFilter(self.extend(request, query))
data = self.safe_value(response, 'data', [])
result = []
for i in range(0, len(data)):
orders = self.safe_value(data[i], 'orders', [])
status = self.parse_order_status(self.safe_value(data[i], 'state'))
parsedOrders = self.parse_orders(orders, market, since, limit, {'status': status})
result = self.array_concat(result, parsedOrders)
return result
def fetch_open_orders(self,
symbol=None,
since=None,
limit=None,
params={}):
if symbol is None:
raise ArgumentsRequired(self.id +
' fetchOpenOrders requires a symbol param')
self.load_markets()
market = self.market(symbol)
request = {
'id': market['id'],
}
response = self.privatePostIdOpenOrders(self.extend(request, params))
# {
# "amount": "1.0000",
# "datetime": "2019-07-12 13:28:16",
# "id": 233123443,
# "price": "1000.00",
# "type": 0
# }
return self.parse_orders(response, market, since, limit,
{'status': 'open'})
def fetch_my_trades(self, symbol=None, since=None, limit=None, params={}):
"""
fetch all trades made by the user
:param str symbol: unified market symbol
:param int|None since: the earliest time in ms to fetch trades for
:param int|None limit: the maximum number of trades structures to retrieve
:param dict params: extra parameters specific to the mercado api endpoint
:returns [dict]: a list of `trade structures <https://docs.ccxt.com/en/latest/manual.html#trade-structure>`
"""
if symbol is None:
raise ArgumentsRequired(self.id + ' fetchMyTrades() requires a symbol argument')
self.load_markets()
market = self.market(symbol)
request = {
'coin_pair': market['id'],
'has_fills': True,
}
response = self.privatePostListOrders(self.extend(request, params))
responseData = self.safe_value(response, 'response_data', {})
ordersRaw = self.safe_value(responseData, 'orders', [])
orders = self.parse_orders(ordersRaw, market, since, limit)
trades = self.orders_to_trades(orders)
return self.filter_by_symbol_since_limit(trades, market['symbol'], since, limit)
def fetch_deposit_address(self, code, params={}):
self.load_markets()
if not ('userid' in params) and (self.apiKey is None):
raise ArgumentsRequired(
'fetchDepositAddress() requires self.apiKey or userid argument'
)
currency = self.currency(code)
request = {
'userid': self.apiKey,
'code': currency['id'],
}
response = self.publicGetDepositaddress(request)
address = self.safe_string(response[0], 'address')
tag = self.safe_string(response[0], 'tag')
chainType = self.safe_string(response[0], 'chainType')
self.check_address(address)
return {
'currency': code,
'address': address,
'tag': tag,
'network': chainType,
'info': response,
}
async def fetch_orders(self,
symbol=None,
since=None,
limit=None,
params={}):
if symbol is None:
raise ArgumentsRequired(self.id +
' fetchOrders requires a symbol argument')
await self.load_markets()
request = {}
market = None
if symbol is not None:
market = self.market(symbol)
request['pair'] = market['id']
response = await self.privatePostActiveOrders(
self.extend(request, params))
# can only return 'open' orders(i.e. no way to fetch 'closed' orders)
openOrders = []
if 'return' in response:
openOrders = self.parse_orders(response['return'], market)
allOrders = self.update_cached_orders(openOrders, symbol)
result = self.filter_by_symbol(allOrders, symbol)
return self.filter_by_since_limit(result, since, limit)
async def fetch_orders(self,
symbol=None,
since=None,
limit=None,
params={}):
if symbol is None:
raise ArgumentsRequired(self.id +
' fetchOrders requires a symbol argument')
await self.load_markets()
market = self.market(symbol)
request = {
'symbol_id': market['symbol_id'],
'statuses': params['status'],
}
if since is not None:
request['start'] = since
if limit is not None:
request['count'] = limit
response = await self.privatePostApiV1OrderHistory2(
self.extend(request, params))
data = self.safe_value(self.safe_value(response, 'data', {}), 'list',
[])
return self.parse_orders(data, market, since, limit)
async def fetch_orders_by_states_v2(self,
states,
symbol=None,
since=None,
limit=None,
params={}):
if symbol is None:
raise ArgumentsRequired(self.id +
' fetchOrders requires a symbol argument')
await self.load_markets()
market = self.market(symbol)
if limit is None:
limit = 50
request = {
'symbol': market['id'],
# 'types': 'buy-market,sell-market,buy-limit,sell-limit',
'states': states, # 'new,part_filled,filled,canceled,expired'
# 'from': '0', # id
'direct': 'next', # or 'prev'
'size': limit,
}
response = await self.v2GetOrderOrders(self.extend(request, params))
return self.parse_orders(response['data'], market, since, limit)
def fetch_withdrawals(self, code=None, since=None, limit=None, params={}):
# https://www.kraken.com/en-us/help/api#withdraw-status
if code is None:
raise ArgumentsRequired(self.id + ' fetchWithdrawals requires a currency code argument')
currency = self.currency(code)
request = {
'asset': currency['id'],
}
response = self.privatePostWithdrawStatus(self.extend(request, params))
#
# { error: [],
# result: [{method: "Ether",
# aclass: "currency",
# asset: "XETH",
# refid: "A2BF34S-O7LBNQ-UE4Y4O",
# txid: "0x288b83c6b0904d8400ef44e1c9e2187b5c8f7ea3d838222d53f701a15b5c274d",
# info: "0x7cb275a5e07ba943fee972e165d80daa67cb2dd0",
# amount: "9.9950000000",
# fee: "0.0050000000",
# time: 1530481750,
# status: "Success" }]}
#
return self.parse_transactions_by_type('withdrawal', response['result'], code, since, limit)
async def fetch_my_trades(self,
symbol=None,
since=None,
limit=None,
params={}):
# their docs does not mention it, but if you don't supply a symbol
# their API will return an empty response as if you don't have any trades
# therefore we make it required here as calling it without a symbol is useless
if symbol is None:
raise ArgumentsRequired(
self.id + ' fetchMyTrades() requires a symbol argument')
await self.load_markets()
market = self.market(symbol)
request = {
'pair': market['id'],
}
if limit is not None:
request['limit'] = limit
response = await self.privatePostUserTrades(
self.extend(request, params))
if market is not None:
response = response[market['id']]
return self.parse_trades(response, market, since, limit)
def fetch_order(self, id, symbol=None, params={}):
if symbol is None:
raise ArgumentsRequired(self.id + ' fetchOrder() requires a symbol argument')
self.load_markets()
request = {
'id': str(id),
'currency': self.market_id(symbol),
}
response = self.privateGetGetOrder(self.extend(request, params))
#
# {
# 'total_amount': 0.01,
# 'id': '20180910244276459',
# 'price': 180.0,
# 'trade_date': 1536576744960,
# 'status': 2,
# 'trade_money': '1.96742',
# 'trade_amount': 0.01,
# 'type': 0,
# 'currency': 'eth_usdt'
# }
#
return self.parse_order(response, None)
def fetch_orders(self, symbol=None, since=None, limit=50, params={}):
if symbol is None:
raise ArgumentsRequired(self.id +
'fetchOrders() requires a symbol argument')
self.load_markets()
market = self.market(symbol)
request = {
'currency': market['id'],
'pageIndex': 1, # default pageIndex is 1
'pageSize': limit, # default pageSize is 50
}
method = 'privateGetGetOrdersIgnoreTradeType'
# tradeType 交易类型1/0[buy/sell]
if 'tradeType' in params:
method = 'privateGetGetOrdersNew'
response = None
try:
response = getattr(self, method)(self.extend(request, params))
except Exception as e:
if isinstance(e, OrderNotFound):
return []
raise e
return self.parse_orders(response, market, since, limit)
def cancel_order(self, id, symbol=None, params={}):
if symbol is None:
raise ArgumentsRequired(self.id + ' cancelOrder requires a symbol argument')
self.load_markets()
market = self.market(symbol)
request = {
'orderId': id,
'currencyPair': market['id'],
}
response = self.privatePostExchangeCancellimit(self.extend(request, 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 {
'status': 'canceled',
'info': response,
}
else:
raise OrderNotFound(message)
raise ExchangeError(self.id + ' cancelOrder() failed: ' + self.json(response))
def cancel_orders(self, ids, symbol=None, params={}):
if not isinstance(ids, list):
raise ArgumentsRequired(
self.id + ' cancelOrders() ids argument should be an array')
self.load_markets()
request = {
'orders': self.json(ids),
}
response = self.privatePostUOrderBatchCancel(
self.extend(request, params))
# {
# "code": 0,
# "msg": "success",
# "data": {
# "success": 2,
# "fail": 0,
# "results": ["2019062312313131231"," 2019063123131312313"]
# }
# }
data = self.safe_value(response, 'data')
results = self.safe_value(data, 'results')
market = self.market(symbol) if (symbol is not None) else None
return self.parse_orders(results, market, None, None, params)
def fetch_deposits(self, code=None, since=None, limit=None, params={}):
# https://www.kraken.com/en-us/help/api#deposit-status
if code is None:
raise ArgumentsRequired(self.id + ' fetchDeposits requires a currency code argument')
currency = self.currency(code)
request = {
'asset': currency['id'],
}
response = self.privatePostDepositStatus(self.extend(request, params))
#
# { error: [],
# result: [{method: "Ether(Hex)",
# aclass: "currency",
# asset: "XETH",
# refid: "Q2CANKL-LBFVEE-U4Y2WQ",
# txid: "0x57fd704dab1a73c20e24c8696099b695d596924b401b261513cfdab23…",
# info: "0x615f9ba7a9575b0ab4d571b2b36b1b324bd83290",
# amount: "7.9999257900",
# fee: "0.0000000000",
# time: 1529223212,
# status: "Success" }]}
#
return self.parse_transactions_by_type('deposit', response['result'], code, since, limit)
async def fetch_deposit_addresses_by_network(self, code, params={}):
await self.load_markets()
network = self.safe_string(params, 'network')
if network is None:
raise ArgumentsRequired(
self.id +
'fetchDepositAddressesByNetwork() requires a network parameter'
)
params = self.omit(params, 'network')
networks = self.safe_value(self.options, 'networks', {})
networkId = self.safe_string(networks, network, network)
networkIds = self.safe_value(self.options, 'networkIds', {})
networkCode = self.safe_string(networkIds, networkId, network)
request = {
'network': networkId,
}
response = await self.privatePostV1AddressesNetwork(
self.extend(request, params))
results = self.parse_deposit_addresses(response, [code], False, {
'network': networkCode,
'currency': code
})
return self.group_by(results, 'network')
async def fetch_transactions(self, code=None, since=None, limit=None, params={}):
await self.load_markets()
await self.loadAccounts()
currency = None
id = self.safe_string(params, 'id') # account id
if id is None:
if code is None:
raise ArgumentsRequired(self.id + ' fetchTransactions() requires a currency code argument if no account id specified in params')
currency = self.currency(code)
accountsByCurrencyCode = self.index_by(self.accounts, 'currency')
account = self.safe_value(accountsByCurrencyCode, code)
if account is None:
raise ExchangeError(self.id + ' fetchTransactions() could not find account id for ' + code)
id = account['id']
request = {
'id': id,
}
if limit is not None:
request['limit'] = limit
response = await self.privateGetAccountsIdTransfers(self.extend(request, params))
for i in range(0, len(response)):
response[i]['currency'] = code
return self.parseTransactions(response, currency, since, limit)
async def fetch_deposit_address(self, code, params={}):
await self.load_markets()
if not ('userid' in list(params.keys())) and (self.apiKey is None):
raise ArgumentsRequired('fetchDepositAddress requires self.apiKey or userid argument')
currency = self.currency(code)
request = {}
if 'userid' in params:
request['userid'] = params['userid']
else:
request['userid'] = self.apiKey
request['code'] = currency['id']
response = await self.publicGetDepositaddress(request)
address = self.safe_string(response[0], 'address')
tag = self.safe_string(response[0], 'addressTag')
chainType = self.safe_string(response[0], 'chainType')
self.check_address(address)
return {
'currency': code,
'address': address,
'tag': tag,
'chainType': chainType,
'info': response,
}
def cancel_order(self, id, symbol=None, params={}):
if symbol is None:
raise ArgumentsRequired(self.id +
' CancelOrder requires a symbol argument')
self.load_markets()
market = self.market(symbol)
request = {
'symbol': market['id'],
'order_id': id,
'time': self.milliseconds(),
}
response = self.privatePostOpenApiCancelOrder(
self.extend(request, params))
# Exchange response
# {
# "code": "0",
# "msg": "suc",
# "data": {}
# }
code = self.safe_string(response, 'code')
if code != '0':
raise InvalidOrder(response['msg'] + ' ' + self.json(response))
return self.fetch_order(id, symbol)
async def fetch_open_orders(self,
symbol=None,
since=None,
limit=None,
params={}):
if symbol is None:
raise ArgumentsRequired(
self.id + ' fetchOrders() requires a symbol argument')
await self.load_markets()
market = self.market(symbol)
quoteSide = 'usdtListOpenOrders' if (market['quoteId']
== 'USDT') else 'listOpenOrders'
request = {
'symbol': market['uppercaseId'],
'side': quoteSide,
'page': 0,
}
response = await self.v2PostGetordersnew(self.extend(request, params))
#
# {
# "data":[
# {
# "entry_id":5424475,
# "btc":0.01,
# "rate":2000,
# "time":"2021-04-25T17:05:42.000Z",
# "type":0,
# "status":0
# }
# ],
# "status":1,
# "error":null,
# "code":200
# }
#
data = self.safe_value(response, 'data', [])
return self.parse_orders(data, market, since, limit)
async def fetch_order(self, id, symbol=None, params={}):
if symbol is None:
raise ArgumentsRequired(self.id +
' fetchOrder requires a symbol argument')
await self.load_markets()
market = self.market(symbol)
request = {
'trading_pair': market['id'],
'ids': id,
}
response = await self.traderGetOrdersTradingPairIds(
self.extend(request, params))
#
# response = {
# "status": {
# "success": 1,
# "message": "SUC_LIST_AVTICE_ORDERS"
# },
# "result": [
# {
# "id": 4180528,
# "quantity": 20000000,
# "rest": 20000000,
# "limit": 1000000,
# "price": null,
# "side": "BUY",
# "created": 1496005693738
# }
# ]
# }
#
orders = self.parse_orders(response['result'], market)
ordersById = self.index_by(orders, 'id')
if not (id in list(ordersById.keys())):
raise OrderNotFound(self.id + ' fetchOrder could not find order ' +
str(id) + ' in open orders.')
return ordersById[id]
def cancel_order(self, id, symbol=None, params={}):
if symbol is None:
raise ArgumentsRequired(
self.id + ' cancelOrder() requires a symbol argument')
self.load_markets()
market = self.market(symbol)
request = {
'coin_pair': market['id'],
'order_id': id,
}
response = self.privatePostCancelOrder(self.extend(request, params))
#
# {
# response_data: {
# order: {
# order_id: 2176769,
# coin_pair: 'BRLBCH',
# order_type: 2,
# status: 3,
# has_fills: False,
# quantity: '0.10000000',
# limit_price: '1996.15999',
# executed_quantity: '0.00000000',
# executed_price_avg: '0.00000',
# fee: '0.00000000',
# created_timestamp: '1536956488',
# updated_timestamp: '1536956499',
# operations: []
# }
# },
# status_code: 100,
# server_unix_timestamp: '1536956499'
# }
#
responseData = self.safe_value(response, 'response_data', {})
order = self.safe_value(responseData, 'order', {})
return self.parse_order(order, market)
async def withdraw(self, code, amount, address, tag=None, params={}):
self.check_address(address)
await self.load_markets()
currency = self.currency(code)
commission = self.safe_value(params, 'commission')
if commission is None:
raise ArgumentsRequired(
self.id +
' withdraw() requires a `commission`(withdrawal fee) parameter(string)'
)
params = self.omit(params, commission)
request = {
'currency': currency['id'],
'amount': float(amount),
'address': address,
'commission': commission,
}
if tag is not None:
request['address'] += ':' + tag
response = await self.dwapiPostWithdrawCrypto(
self.extend(request, params))
#
# [
# {
# "success": 1,
# "return": {
# "transactionId": 2863073
# }
# }
# ]
#
data = self.safe_value(response, 'return', {})
id = self.safe_string(data, 'transactionId')
return {
'info': response,
'id': id,
}
async def fetch_orders(self, symbol=None, since=None, limit=None, params={}):
if symbol is None:
raise ArgumentsRequired(self.id + ' fetchOrders() requires a symbol argument')
await self.load_markets()
market = self.market(symbol)
request = {
'asset_pair_name': market['id'],
# 'page_token': 'dxzef', # request page after self page token
# 'side': 'ASK', # 'ASK' or 'BID', optional
# 'state': 'FILLED', # 'CANCELLED', 'FILLED', 'PENDING'
# 'limit' 20, # default 20, max 200
}
if limit is not None:
request['limit'] = limit # default 20, max 200
response = await self.privateGetOrders(self.extend(request, params))
#
# {
# "code":0,
# "data": [
# {
# "id": 10,
# "asset_pair_name": "ETH-BTC",
# "price": "10.00",
# "amount": "10.00",
# "filled_amount": "9.0",
# "avg_deal_price": "12.0",
# "side": "ASK",
# "state": "FILLED",
# "created_at":"2019-01-29T06:05:56Z",
# "updated_at":"2019-01-29T06:05:56Z",
# },
# ],
# "page_token":"dxzef",
# }
#
orders = self.safe_value(response, 'data', [])
return self.parse_orders(orders, market, since, limit)
async def fetch_my_trades(self,
symbol=None,
since=None,
limit=None,
params={}):
if symbol is None:
raise ArgumentsRequired(
self.id + ' fetchMyTrades() requires a symbol argument')
await self.load_markets()
market = self.market(symbol)
request = {
'currency': market['id'],
}
response = await self.privatePostOrderCompleteOrders(
self.extend(request, params))
#
# despite the name of the endpoint it returns trades which may have a duplicate orderId
# https://github.com/ccxt/ccxt/pull/7067
#
# {
# "result": "success",
# "errorCode": "0",
# "completeOrders": [
# {
# "timestamp": "1416561032",
# "price": "419000.0",
# "type": "bid",
# "qty": "0.001",
# "feeRate": "-0.0015",
# "fee": "-0.0000015",
# "orderId": "E84A1AC2-8088-4FA0-B093-A3BCDB9B3C85"
# }
# ]
# }
#
completeOrders = self.safe_value(response, 'completeOrders', [])
return self.parse_trades(completeOrders, market, since, limit)
def fetch_orders_with_method(self,
method,
symbol=None,
since=None,
limit=None,
params={}):
if symbol is None:
raise ArgumentsRequired(
self.id + ' fetchOrdersWithMethod requires a symbol argument')
self.load_markets()
market = self.market(symbol)
request = {
'symbol': market['id'],
}
if limit is not None:
request['limit'] = limit # default 100
response = getattr(self, method)(self.extend(request, params))
#
# [
# {
# "orderId": "1555492358.126073.126767@0502:2",
# "cliOrdId": "myNewOrder",
# "pairId": 502,
# "symbol": "LAETH",
# "side": "buy",
# "orderType": "limit",
# "price": 136.2,
# "amount": 0.57,
# "orderStatus": "partiallyFilled",
# "executedAmount": 0.27,
# "reaminingAmount": 0.3,
# "timeCreated": 155551580736,
# "timeFilled": 0
# }
# ]
#
return self.parse_orders(response, market, since, limit)
async def fetch_transactions(self,
code=None,
since=None,
limit=None,
params={}):
if code is None:
raise ArgumentsRequired(
self.id +
' fetchTransactions() requires a currency `code` argument')
await self.load_markets()
currency = self.currency(code)
request = {
'currency': currency['id'],
}
if since is not None:
request['since'] = int(since / 1000)
response = await self.privatePostHistoryMovements(
self.extend(request, params))
#
# [
# {
# "id":581183,
# "txid": 123456,
# "currency":"BTC",
# "method":"BITCOIN",
# "type":"WITHDRAWAL",
# "amount":".01",
# "description":"3QXYWgRGX2BPYBpUDBssGbeWEa5zq6snBZ, offchain transfer ",
# "address":"3QXYWgRGX2BPYBpUDBssGbeWEa5zq6snBZ",
# "status":"COMPLETED",
# "timestamp":"1443833327.0",
# "timestamp_created": "1443833327.1",
# "fee": 0.1,
# }
# ]
#
return self.parse_transactions(response, currency, since, limit)
