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)