def GET_ACCOUNT_STATUS(LOG,out_file): LOG.write("GET_ACCOUNT_STATUS() " + TimeStamp() + "\n") try: client = Client(api_key, api_secret) except BinanceAPIException as e: print(e.status_code) print(e.message) try: data = client.get_account_status() # Account Info F1 = open(out_file,'w') S = "msg: \t%s\n" % (data['msg']) F1.write(S) S = "success \t%s\n" % (data['success']) F1.write(S) F1.close() except BinanceAPIException as e: print(e.status_code) print(e.message) LOG.write(e.message + "\n")
def bconnection(key,secrete): try: client = Client(key, secrete) status = client.get_account_status() print(status) return True except KeyError: return False
def __init__(self): apiKey = api secretKey = key if secretKey == '': client = Client(apiKey, '') print( "Se accedio a la cuenta sin llave secreta, no está habilitado para ejecutar trades " ) habilitado = False else: try: client = Client(apiKey, secretKey) client.get_account_status() self.client = client habilitado = True except Exception as e: habilitado = False print(e) setattr(self, 'habilitado', habilitado) setattr(self, 'cliente', self.client)
class account_api(object): def __init__(self): self.client = Client("KCl8UvtnFcrlEgpqiwJlA0dr2SM3DuhKHHxiRtHA8oe7yl0JZYqas8oN2XNK0Lfz", "2wj46v8IAKpXoeigAmzfPg1VEjYi3oItNTeeNcEkDrK1HIev4nZHJr1Cd8tiJ5L0", {"verify": True, "timeout": 20}) def get_account_info(self): return self.client.get_account() def get_account_balance(self,asset='BTC'): return self.client.get_asset_balance(asset=asset) def get_account_status(self): return self.client.get_account_status() def get_trades(self,symbol='VENETH'): return self.client.get_my_trades(symbol=symbol)
} """ # Get asset balance balance = client.get_asset_balance(asset='BTC') # Example response: """ { "asset": "BTC", "free": "4723846.89208129", "locked": "0.00000000" } """ # Get account status status = client.get_account_status() # Example response: """ { "msg": "Order failed:Low Order fill rate! Will be reactivated after 5 minutes.", "success": true, "objs": [ "5" ] } """ # Getting the open orders of a symbol (after getting the account info and the balance of the traded cryptos) orders = client.get_open_orders(symbol='BNBBTC') ## or of all the open orders: orders = client.get_open_orders()
class BinanceOrders(ExchangeOrders): '''Handle order calls to binance.''' def __init__(self, config=config.binance): self.client = Client(config['api_key'], config['api_secret']) def buy_order(self, symbol, quantity, test=True): """ Place a market buy order via the binance API. Parameters: ------------ symbol: string A valid binance cryptocurreny symbol. quantity: int | float The amount of <symbol> to buy. test: boolean True ---> Simulate a buy via the Binance API to check authorization. """ if test: order = self.client.create_test_order(symbol=symbol, side=SIDE_BUY, type=ORDER_TYPE_MARKET, quantity=quantity) else: order = self.client.create_order(symbol=symbol, side=SIDE_BUY, type=ORDER_TYPE_MARKET, quantity=quantity) # return True if order else False return order def sell_order(self, symbol, quantity, test=True): """ Place a market buy order via the binance API. Parameters: ------------ symbol: string A valid binance cryptocurreny symbol. quantity: int | float The amount of <symbol> to buy. test: boolean True ---> Simulate a buy via the Binance API to check authorization. """ if test: order = self.client.create_test_order(symbol=symbol, side=SIDE_SELL, type=ORDER_TYPE_MARKET, quantity=quantity) else: order = self.client.create_order(symbol=symbol, side=SIDE_sell, type=ORDER_TYPE_MARKET, quantity=quantity) # return True if order else False return order def account_balance(self): """Check account balance for all cryptocurrencies.""" return self.client.get_account()['balances'] def coin_balance(self, symbol): """Check balance for a given cryptocurreny""" return self.client.get_asset_balance(symbol) def account_status(self): """Check for normal account status.""" status = self.client.get_account_status() if status['msg'] == 'Normal' and status['success']: return True else: return False def all_orders(self, symbol): """Get records of all orders.""" return self.client.get_all_orders(symbol=symbol) def trades(self, symbol): """Get records of all trades.""" return self.client.get_my_trades(symbol=symbol)
from binance.client import Client from config import * client = Client(KEY, SECRET) status = client.get_account_status(recvWindow=36000)
class Binance: def __init__(self): self.__api_key = "#########" self.__secret_key = "############" self.__client = Client(self.__api_key, self.__secret_key) self._info = self.exchange_info() def exchange_info(self): return self.__client.get_exchange_info() def deposit_credentials(self, crypto): credentials = self.__client.get_deposit_address(asset=crypto) if credentials["success"]: return credentials else: return self.deposit_credentials(crypto) def coin_info(self, coin, base="btc"): coin_ex = coin.upper() + base.upper() return self.__client.get_symbol_info(coin_ex) def deposit_enable(self, coin): s = requests.get( "https://www.binance.com/assetWithdraw/getAllAsset.html") a = json.loads(s.text) for each in a: if each["assetCode"] == coin.upper(): return each["enableCharge"] def withdraw_enable(self, coin): s = requests.get( "https://www.binance.com/assetWithdraw/getAllAsset.html") a = json.loads(s.text) for each in a: if each["assetCode"] == coin.upper(): return each["enableWithdraw"] def system_status(self): return self.__client.get_system_status() def account_info(self): return self.__client.get_account() def account_status(self): return self.__client.get_account_status() def withdraw_crypto(self, crypto, withdraw_amount, crypto_address, crypto_tag=None): if (crypto.lower() == "neo"): withdraw_amount = int(float(withdraw_amount)) elif (crypto.lower() == "qtum"): withdraw_amount = int(float(withdraw_amount)) + float( self.withdrawal_fee(crypto)) if withdraw_amount > float(self.balance(crypto)): withdraw_amount = withdraw_amount - 1 if (crypto_tag == None): try: result = self.__client.withdraw(asset=crypto.upper(), address=crypto_address, amount=withdraw_amount) except BinanceAPIException as e: print(e) except BinanceWithdrawException as e: print(e) self.withdraw_crypto(crypto, withdraw_amount, crypto_address) else: print("Success") else: try: result = self.__client.withdraw(asset=crypto.upper(), address=crypto_address, addressTag=crypto_tag, amount=withdraw_amount) except BinanceAPIException as e: print(e) except BinanceWithdrawException as e: print(e) self.withdraw_crypto(crypto, withdraw_amount, crypto_address, crypto_tag) else: print("Success") def withdrawal_fee(self, crypto): return self.__client.get_withdraw_fee(asset=crypto) def get_balance(self, crypto): try: return self.__client.get_asset_balance(asset=crypto) except BinanceWithdrawException: self.balance(crypto) except BinanceAPIException: self.balance(crypto) def balance(self, crypto): bal = self.get_balance(crypto) if isinstance(bal, dict): return bal return self.balance(crypto) def withdraw_history(self): return self.__client.get_withdraw_history() def place_market_order(self, crypto, order_type, quantity, base="btc"): symbol = crypto + base lot_precision = self.format_specifics(crypto)[1] quantity = float(math.floor(float(quantity) * (10**lot_precision))) / (10**lot_precision) if order_type.lower() == "buy": order = self.__client.order_market_buy(symbol=symbol.upper(), quantity=str(quantity)) elif order_type.lower() == "sell": bal = float(self.balance(crypto)["free"]) if quantity > bal: quantity = quantity - lot_precision order = self.__client.order_market_sell(symbol=symbol.upper(), quantity=str(quantity)) return order def format_specifics(self, crypto, base="btc"): for coin in self._info["symbols"]: if coin["symbol"] == crypto.upper() + base.upper(): price_precision = -int( math.log10(float(coin["filters"][0]["tickSize"]))) lot_precision = -int( math.log10(float(coin["filters"][1]["stepSize"]))) return price_precision, lot_precision def place_limit_order(self, crypto, order_type, quantity, price, base="btc"): symbol = crypto + base price_precision, lot_precision = self.format_specifics(crypto) if order_type.lower() == "buy": order = self.__client.order_limit_buy( symbol=symbol.upper(), quantity=str( float(math.floor(float(quantity) * (10**lot_precision))) / (10**lot_precision)), price=str( float(math.floor(float(price) * (10**price_precision))) / (10**price_precision))) elif order_type.lower() == "sell": order = self.__client.order_limit_sell( symbol=symbol.upper(), quantity=str( float(math.floor(float(quantity) * (10**lot_precision))) / (10**lot_precision)), price=str( float(math.floor(float(price) * (10**price_precision))) / (10**price_precision))) return order def orderbook(self, crypto, base="btc"): symbol = crypto + base try: return self.__client.get_order_book(symbol=symbol.upper()) except: self.orderbook(crypto, base="btc") def buy_vol_decider(self, crypto, amount): cum_amount = 0 cum_vol = 0 for i, each in enumerate(self.orderbook(crypto)["asks"]): cum_amnt = cum_amount + float(each[0]) * float(each[1]) * 1.001 cum_vol = cum_vol + float(each[1]) if cum_amnt > amount: prev_amnt = cum_amnt - float(each[0]) * float(each[1]) * 1.001 cum_vol = cum_vol - float( each[1]) + (amount - prev_amnt) / (1.001 * float(each[0])) break return cum_vol def open_orders(self, crypto, base="btc"): symbol = crypto + base return self.__client.get_open_orders(symbol=symbol.upper()) def cancel_order(self, crypto, order_id, base="btc"): symbol = crypto + base return self.__client.cancel_order(symbol=symbol.upper(), orderId=order_id) def order_status(self, crypto, order_id, base="btc"): symbol = crypto + base return self.__client.get_order(symbol=symbol.upper(), orderId=order_id) def place_sell_order(self, crypto): vol = self.balance(crypto)["free"] self.place_market_order(crypto, "sell", vol) def place_buy_order(self, crypto): try: amount = float(self.balance("btc")["free"]) if amount > 0.001: vol = self.buy_vol_decider(crypto, amount) self.place_market_order(crypto, "buy", vol) except Exception as e: print(e) self.place_buy_order(crypto)
class TradingApiBinance(TradingApi): # override def __init__(self, param_pct_order_placed, stop_loss_pct): conf = Config() self.param_pct_order_placed = param_pct_order_placed self.API_KEY = conf.get_config('binance', 'api_key') self.API_SECRET = conf.get_config('binance', 'api_secret') self.MAX_DIFF_DATE_HOUR = int( conf.get_config('trading_module_params', 'max_diff_date_hour')) self.stop_loss_pct = stop_loss_pct self.client = Client(self.API_KEY, self.API_SECRET) # lib python-binance self.precision = int(conf.get_config('binance', 'api_amount_precision')) # override def is_fake_api(self): return False # override def check_status_api(self): authorized_trading_pairs = [] # test ping try: self.client.ping() except Exception as e: msg = "Error while trying to ping Binance API : " + str(e) logging.error(msg) slack.post_message_to_alert_error_trading(msg) return False, authorized_trading_pairs # Check system status try: status = self.client.get_system_status() if (status['msg'] == 'normal') and (status['status'] == 0): # Check account status status_client = self.client.get_account_status() if (status_client['msg'] == 'Normal') and (status_client['success']): # Check account status related to trading info_client = self.client.get_account() if not info_client['canTrade']: return False, authorized_trading_pairs except Exception as e: msg = "Error while trying to get system status from Binance API : " + str( e) logging.error(msg) slack.post_message_to_alert_error_trading(msg) return False, authorized_trading_pairs # Exchange info to verify which tradingpairs are tradable try: exchange_info = self.client.get_exchange_info() for symbol in exchange_info['symbols']: authorized_trading_pairs.append(symbol['symbol']) except Exception as e: msg = "Error while getting exchange info from binance : " + str(e) logging.error(msg) slack.post_message_to_alert_error_trading(msg) return False, authorized_trading_pairs return True, authorized_trading_pairs # override # allows to be sure that there is not to much time between predictions time and now def check_predictions_time_vs_server_time(self, dict_dates): tradable_trading_pairs = [] # Get server time server_time = self.client.get_server_time()['serverTime'] server_time_localized = localize_utc_date(server_time) logging.warning('server_time:' + str(server_time)) logging.warning('server_time_localized:' + str(server_time_localized)) for trading_pair, last_date in dict_dates.items(): logging.warning('trading_pair diff (' + trading_pair + ')' + str(server_time_localized - last_date)) if (server_time_localized - last_date) < timedelta(hours=self.MAX_DIFF_DATE_HOUR): tradable_trading_pairs.append(trading_pair) else: msg = 'Difference between server time (' + str( server_time_localized) + ') / prediction time (' + str( last_date ) + ') too big for trading pair: *' + trading_pair + '*' logging.error(msg) slack.post_message_to_alert_error_trading(msg) return tradable_trading_pairs # override # TODO V2 : parameter = tradingpair directly # WARNING : can raise uncatched errors def get_price_ticker(self, base_asset, quote_asset, key): prices = self.client.get_all_tickers() prices_dict = {value["symbol"]: value["price"] for value in prices} return float(prices_dict[base_asset + quote_asset]) # override # WARNING : can raise uncatched errors def get_buy_price(self, base_asset, quote_asset, key): buy_limit_price = 0 depth = self.client.get_order_book(symbol=base_asset + quote_asset) if 'asks' in depth: ask_price = float( depth['asks'][0][0]) # get first ask price in order book buy_limit_price = ask_price + (ask_price * self.param_pct_order_placed) else: msg = 'Error while getting price for trading_pair:' + base_asset + quote_asset slack.post_message_to_alert_error_trading(msg) raise Exception(msg) return buy_limit_price # override def get_sell_price(self, base_asset, quote_asset, key): sell_limit_price = 0 depth = self.client.get_order_book(symbol=base_asset + quote_asset) if 'bids' in depth: bid_price = float( depth['bids'][0][0]) # get first bid price in order book sell_limit_price = bid_price - (bid_price * self.param_pct_order_placed) else: msg = 'Error while getting price for trading_pair:' + base_asset + quote_asset slack.post_message_to_alert_error_trading(msg) raise Exception(msg) return sell_limit_price # override def get_available_amount_crypto(self, symbol): balance = 0 infos_balance = self.client.get_asset_balance(asset=symbol) if 'free' in infos_balance: balance = float(infos_balance['free']) else: msg = 'Error while getting balance for symbol:' + symbol slack.post_message_to_alert_error_trading(msg) raise Exception(msg) return balance # override # RESULT of order: # {'symbol': 'VETUSDT', # 'orderId': 9358183, # 'clientOrderId': 'ILNyxOioi7cPBDGkQSKtbH', # 'transactTime': 1545235888618, # 'price': '0.00550000', # 'origQty': '5000.00000000', # 'executedQty': '0.00000000', # 'cummulativeQuoteQty': '0.00000000', # 'status': 'NEW', # 'timeInForce': 'GTC', # 'type': 'LIMIT', # 'side': 'SELL', # 'fills': []} def create_order(self, base_asset, quote_asset, side, quantity_from, key): # ex: USDT, ETH, 1000, BUY order = {} try: # TODO V2 : Use stopPrice for stop loss genre -3-4% ? if side == ORDER_BUY: limit_price = self.get_buy_price(base_asset, quote_asset, key) # order = self.client.order_limit_buy( # symbol=base_asset + quote_asset, # quantity=quantity_from, # price=self.format_amount_order(limit_price)) # TODO [SIMULATION] : To be replaced with real order + stop loss order = self.client.create_test_order( symbol=base_asset + quote_asset, side=SIDE_BUY, type=ORDER_TYPE_LIMIT, timeInForce=TIME_IN_FORCE_GTC, quantity=quantity_from, price=self.format_amount_order(limit_price)) else: limit_price = self.get_sell_price(base_asset, quote_asset, key) # order = self.client.order_limit_sell( # symbol=base_asset + quote_asset, # quantity=quantity_from, # price=self.format_amount_order(limit_price)) # TODO [SIMULATION] : To be replaced with real order order = self.client.create_test_order( symbol=base_asset + quote_asset, side=SIDE_SELL, type=ORDER_TYPE_LIMIT, timeInForce=TIME_IN_FORCE_GTC, quantity=quantity_from, price=self.format_amount_order(limit_price)) msg = 'Order placed (' + str( side ) + ') on trading_pair: ' + base_asset + quote_asset + ' - Qty: ' + str( quantity_from) + ' - limit: ' + str( limit_price) + ' - order: ' + str(order) logging.warning(msg) slack.post_message_to_alert_actions_trading(msg) # Save order into DB dbconn = DbConnection() dbconn.exexute_query(TradingApiBinance.__create_query_order(order)) except Exception as e: msg = "Error while creating order on tradingPair: {}, side: {}, qty:{}" logging.error( msg.format(base_asset + quote_asset, side, quantity_from)) logging.error(str(e)) slack.post_message_to_alert_error_trading( msg.format(base_asset + quote_asset, side, quantity_from) + '\n' + str(e)) raise Exception(msg + str(e)) return order['orderId'] @staticmethod def __create_query_order(order): insertquery = 'INSERT INTO public.orders (orderId, symbol, clientOrderId, transactTime, price, origQty,' \ 'executedQty, cummulativeQuoteQty, status, timeInForce, typeorder, side, fills)' insertquery += ' VALUES(' insertquery += str(order['orderId']) + ', ' insertquery += "'" + order['symbol'] + "', " insertquery += "'" + order['clientOrderId'] + "', " insertquery += str(order['transactTime']) + ', ' insertquery += str(order['price']) + ', ' insertquery += str(order['origQty']) + ', ' insertquery += str(order['executedQty']) + ', ' insertquery += str(order['cummulativeQuoteQty']) + ', ' insertquery += "'" + order['status'] + "', " insertquery += "'" + order['timeInForce'] + "', " insertquery += "'" + order['type'] + "', " insertquery += "'" + order['side'] + "', " insertquery += "'" + str(order['fills']) + "')" return insertquery # override # {'symbol': 'VETUSDT', # 'origClientOrderId': 'ILNyxOioi7cPBDGkQSKtbH', # 'orderId': 9358183, # 'clientOrderId': '4ZPYz4mDfcTg6Ho0O1QhoA', # 'price': '0.00550000', # 'origQty': '5000.00000000', # 'executedQty': '0.00000000', # 'cummulativeQuoteQty': '0.00000000', # 'status': 'CANCELED', # 'timeInForce': 'GTC', # 'type': 'LIMIT', # 'side': 'SELL'} def get_order(self, id_order, trading_pair): order = self.client.get_order(symbol=trading_pair, orderId=id_order) return AlgOrderBinance(order) # override def get_orders(self): # Useless her, only for backtesting return 'N/A' # override def cancel_open_orders(self): orders = self.client.get_open_orders() logging.warning("Open orders to be cancelled " + str(orders)) for order in orders: try: result = self.client.cancel_order(symbol=order['symbol'], orderId=order['orderId']) msg = 'Order cancelled: ' + str(result) logging.warning(msg) slack.post_message_to_alert_actions_trading(msg) except Exception as e: msg = "Order cannot be cancelled " + str(e) logging.error(msg) slack.post_message_to_alert_error_trading(msg) def format_amount_order(self, amount): return "{:0.0{}f}".format(amount, self.precision)