class Broker:
def __init__(self, api_key, api_secret):
self.client = Client(api_key, api_secret)
def buy(self, coin, quantity):
test_buy = self.client.create_test_order(symbol=coin, side=self.client.SIDE_BUY,\
type=self.client.ORDER_TYPE_MARKET, quantity=quantity)
def sell(self, coin, quantity):
test_sell = self.client.create_test_order(symbol=coin, side=self.client.SIDE_SELL,\
type=self.client.ORDER_TYPE_MARKET, quantity=quantity)
class BinanceUSDCConnector:
def __init__(self):
self.config = configparser.ConfigParser()
self.config.read('setting.ini')
self.api_key = self.config.get('binance_api', 'api_key')
self.api_secret = self.config.get('binance_api', 'api_secret')
self.client = Client(self.api_key, self.api_secret)
def test_connect(self):
"""Test connectivity to the Rest API."""
return self.client.ping()
def get_exchange_info(self):
"""Return rate limits and list of symbols"""
return self.client.get_exchange_info()
def get_order_book(self, **kwargs):
"""Get the Order Book for the market"""
return self.client.get_order_book(data=kwargs)
def get_ticker(self, **kwargs):
"""24 hour price change statistics."""
return self.client.get_ticker(data=kwargs)
def get_24h_price_change(self, **kwargs):
"""24 hour price change statistics."""
return self.client.get_ticker(data=kwargs)
def get_latest_price(self, **kwargs):
"""Latest price for a symbol or symbols."""
return self.client.get_symbol_ticker(data=kwargs)
def test_new_order(self, **kwargs):
"""Test new order creation and signature/recvWindow long."""
return self.client.create_test_order(data=kwargs)
def create_order(self, order_type, **kwargs):
"""Send in a new order"""
if order_type == 'limit':
pass
elif order_type == 'limit_buy':
pass
elif order_type == 'limit_sell':
pass
elif order_type == 'market':
pass
elif order_type == 'market_buy':
pass
elif order_type == 'market_sell':
pass
def check_order:
def cancel_order:
def get_open_order:
def'''
class order_api(object):
def __init__(self):
self.client = Client("KCl8UvtnFcrlEgpqiwJlA0dr2SM3DuhKHHxiRtHA8oe7yl0JZYqas8oN2XNK0Lfz", "2wj46v8IAKpXoeigAmzfPg1VEjYi3oItNTeeNcEkDrK1HIev4nZHJr1Cd8tiJ5L0", {"verify": True, "timeout": 20})
def get_all_orders(self,symbol='VENETH',limit=10):
return self.get_all_orders(symbol,limit)
# def create_order(self, symbol='VENETH', side='BUY', type=ORDER_TYPE_LIMIT, timeInForce=TIME_IN_FORCE_GTC, quantity=100, price='0.00001'):
# self.client.create_order(symbol,side,type,timeInForce,quantity,price)
# def create_sell_limit_order(self):
# self.order = client.order_limit_buy(symbol,quantity,price)
# def create_market_order(self):
# pass
def create_test_order(self,symbol,quantity,price):
return self.client.create_test_order(symbol=symbol,quantity=quantity,price=price,side='BUY',type='LIMIT',timeInForce='GTC')
def get_all_orders(self,symbol='VENETH'):
return self.client.get_all_orders(symbol=symbol)
def get_open_orders(self,symbol='VENETH'):
return self.client.get_open_orders(symbol=symbol)
def cancel_order(self,symbol='VENETH',orderId=0):
return self.client.cancel_order(symbol=symbol,orderId=orderId)
def order_status(self,symbol='VENETH',orderId=0):
return self.client.get_order(symbol=symbol,orderId=orderId)
class BinanceAPIClient(BaseClient):
"""
Wrapper for Binance API Python client
"""
def __init__(self, *kwargs, **args):
super().__init__(*kwargs, **args)
api_key = os.getenv('binance_key')
api_secret = os.getenv('binance_secret')
self.client = Client(api_key, api_secret)
def open_order(self, direction, price, quantity):
return self.client.create_test_order(
symbol=self.symbol,
side=direction,
type=ORDER_TYPE_LIMIT,
timeInForce=TIME_IN_FORCE_GTC,
quantity=quantity,
price=price)
def close_order(self):
pass
def get_orderbook(self):
return self.client.get_order_book(symbol=self.symbol, limit=5)
def get_balance(self):
balance_response = self.client.get_asset_balance('EUR')
return float(balance_response.get('free', 0))
class exchange:
"""
建構式
Args:
apiKey (str): API金鑰
apiSecret (str): API密鑰
Returns:
void
"""
def __init__(self, apiKey: str, apiSecret: str):
self.client = Client(apiKey, apiSecret)
"""
取得當前價格
Args:
symbol (str): 要取得價格的標的，例BTCUSDT
Returns:
float: 當前的價格
"""
def getSymbolPrice(self, symbol: str) -> float:
prices = self.client.get_all_tickers()
num = len(prices)
price = 0
for i in range(num):
if symbol == prices[i]['symbol']:
price = prices[i]['price']
return price
"""
進行交易
Args:
symbol (str): 要取得價格的標的，例BTCUSDT
side (str): 要買進用buy，要賣出用sell
quantity (float): 要買進的數量
Returns:
str: API response
"""
def doExchange(self, symbol: str, side: str, quantity: float):
sides = {'buy': Client.SIDE_BUY, 'sell': Client.SIDE_SELL}
order = self.client.create_test_order(symbol=symbol,
side=sides[side],
type=Client.ORDER_TYPE_MARKET,
quantity=quantity)
return order
def binance_create_test_order(chat_id, **params):
full_api = getbinanceapi(chat_id)['binance_api']
api_key = full_api.split(':')[0].strip()
api_secret = full_api.split(':')[1].strip()
client = Client(api_key, api_secret)
try:
binance_timesync(client)
js_info = client.create_test_order(**params)
print(js_info)
except Exception as e:
print(e)
return None
def connectClient(self):
client = Client(self.api_key, self.api_secret)
# get market depth
depth = client.get_order_book(symbol='BNBBTC')
# place a test market buy order, to place an actual order use the create_order function
order = client.create_test_order(
symbol='BNBBTC',
side=Client.SIDE_BUY,
type=Client.ORDER_TYPE_MARKET,
quantity=100)
# get all symbol prices
prices = client.get_all_tickers()
# withdraw 100 ETH
# check docs for assumptions around withdrawals
from binance.exceptions import BinanceAPIException, BinanceWithdrawException
try:
result = client.withdraw(
asset='ETH',
address='<eth_address>',
amount=100)
except BinanceAPIException as e:
print(e)
except BinanceWithdrawException as e:
print(e)
else:
print("Success")
# fetch list of withdrawals
withdraws = client.get_withdraw_history()
# fetch list of ETH withdrawals
eth_withdraws = client.get_withdraw_history(asset='ETH')
# get a deposit address for BTC
address = client.get_deposit_address(asset='BTC')
class binance_data():
def __init__(self, api_key, api_secret):
self.api_key = api_key
self.api_secret = api_secret
self.client = Client(api_key,api_secret)
def get_order_book(self, symbol):
order_book = self.client.get_order_book(symbol = symbol)
bids = pd.DataFrame.from_dict(order_book["bids"]).iloc[:, 0:2]
bids.columns = ['bid_price', 'bid_qty']
asks = pd.DataFrame.from_dict(order_book["asks"]).iloc[:, 0:2]
asks.columns = ['ask_price', 'ask_qty']
data = pd.concat([asks, bids])
return data
def get_historical_klines(self, symbol, interval, start_str, end_str):
return self.client.get_historical_klines(symbol, interval, start_str, end_str)
def get_transactions(self, symbol):
if isinstance(symbol,str):
return self.client.get_recent_trades(symbol=symbol)
else:
raise Exception("Symbol should be an instance of string.")
def test_order(self, symbol, quantity):
test_order = self.client.create_test_order(
symbol=symbol,
side=Client.SIDE_BUY,
type=Client.ORDER_TYPE_MARKET,
quantity=quantity)
return test_order
class BnOrder():
def __init__(self) -> None:
self.chat_id = BN_CHAT_ID_GROUP
# self.chat_id = BN_CHAT_ID
self.client = Client(BN_API_KEY, BN_API_SECRET)
# self.client = Client(BN_TEST_API_KEY, BN_TEST_API_SECRET)
# self.client.API_URL = 'https://testnet.binance.vision/api'
self.client.PUBLIC_API_VERSION = "v3"
self.bm = bn_UserSocket(self.client)
self.tso = None
def process_message(self, msg):
try:
self.send_chat_message("Account Update:\n" + json.dumps(msg))
except Exception as e:
logging.error("Process Account Update Error:" + str(e))
self.send_chat_message("Process Account Update Error: " + str(e))
def create_test_order(self, chat_id, symbol, buy_price, amount):
try:
if self.is_authorized(chat_id):
symbol = symbol.strip().upper() + "BTC"
logging.error("SYMBOL: " + symbol)
order = self.client.create_test_order(
symbol=symbol,
side=SIDE_BUY,
type=ORDER_TYPE_LIMIT,
timeInForce=TIME_IN_FORCE_GTC,
quantity=amount,
price=buy_price)
text = "TEST ORDER CREATED: " + json.dumps(order)
self.send_chat_message(text)
except Exception as e:
logging.error("Test Order Failed error:" + str(e))
self.send_chat_message("CREATE TEST ORDER FAILED: " + str(e))
def create_market_buy(self, chat_id, symbol, amount, to_currency="BTC"):
try:
if self.is_authorized(chat_id):
symbol = symbol.strip().upper() + to_currency.strip().upper()
amount = round(amount, 8)
order = self.client.order_market_buy(symbol=symbol,
quantity=amount)
text = "REAL BUY CREATED: " + json.dumps(order)
self.send_chat_message(text)
except Exception as e:
logging.error("Test Order Failed error:" + str(e))
self.send_chat_message("CREATE ORDER FAILED: " + str(e))
raise e
def get_exchange_symbol(self, sell_coin, buy_coin):
try:
symbol = buy_coin.strip().upper() + sell_coin.strip().upper()
info = self.client.get_symbol_info(symbol)
if info is not None:
result = self.client.get_symbol_ticker(symbol=symbol)
s, t = self.get_step_size(info)
return symbol, "BUY", result["price"], info, s, t
except Exception as e:
logging.error("Symbol fail:" + str(e))
try:
symbol = sell_coin.strip().upper() + buy_coin.strip().upper()
info = self.client.get_symbol_info(symbol)
if info is not None:
result = self.client.get_symbol_ticker(symbol=symbol)
s, t = self.get_step_size(info)
return symbol, "SELL", result["price"], info, s, t
except Exception as e:
logging.error("Symbol fail:" + str(e))
raise e
def get_step_size(self, info):
step_size = 0.0
tick_size = 0.0
logging.error("INFO:" + json.dumps(info))
for f in info['filters']:
if f['filterType'] == 'LOT_SIZE':
step_size = float(f['stepSize'])
if f['filterType'] == 'PRICE_FILTER':
tick_size = float(f['tickSize'])
return step_size, tick_size
def create_market_conversion(self, chat_id, sell_coin, total_spend,
buy_coin):
try:
if self.is_authorized(chat_id):
symbol, sale_type, price, _, step_size, _ = self.get_exchange_symbol(
sell_coin, buy_coin)
precision = int(round(-math.log(step_size, 10), 0))
logging.error("AMOUNT:" + str(total_spend))
logging.error("step_size:" + str(step_size))
logging.error("precision:" + str(precision))
logging.error("SALE TYPE:" + str(sale_type))
if sale_type == "SELL":
amt_str = "{:0.0{}f}".format(total_spend, precision)
logging.error("QUANTITY:" + str(amt_str))
order = self.client.order_market_sell(symbol=symbol,
quantity=amt_str)
text = "SELL " + str(
amt_str) + " of " + symbol + "\nOrderId:" + str(
order["orderId"]) + " STATUS:" + str(
order["status"]) + "\nFILLS:\n" + json.dumps(
order["fills"])
else:
amount = total_spend / float(price)
amt_str = "{:0.0{}f}".format(amount, precision)
logging.error("QUANTITY:" + str(amt_str))
order = self.client.order_market_buy(symbol=symbol,
quantity=amt_str)
text = "BUY " + str(
amt_str) + " of " + symbol + "\nOrderId:" + str(
order["orderId"]) + " STATUS:" + str(
order["status"]) + "\nFILLS:\n" + json.dumps(
order["fills"])
self.send_chat_message(text)
return amt_str, sale_type, symbol, buy_coin, sell_coin
except Exception as e:
logging.error("Order Failed error:" + str(e))
self.send_chat_message("CREATE ORDER FAILED: " + str(e))
raise e
def create_trailing_stop_limit(self, market, buy_coin, sell_coin, type,
stop_percentage, interval):
try:
if self.tso is not None and self.tso.running is True:
self.send_chat_message(
"OPEN Trailing Stop Limit, Cancel First. ")
else:
self.tso = TrailingStopLimit(chat_id=self.chat_id,
client=self.client,
market=market,
buy_coin=buy_coin,
sell_coin=sell_coin,
type=type,
stop_percentage=stop_percentage,
interval=interval)
run(self.tso)
except Exception as e:
logging.error("Order Failed error:" + str(e))
self.send_chat_message("CREATE ORDER FAILED: " + str(e))
raise e
def create_oco_conversion(self, chat_id, sell_coin, amount, buy_coin):
try:
if self.is_authorized(chat_id):
symbol, sale_type, price, info, step_size, price_tick_size = self.get_exchange_symbol(
sell_coin, buy_coin)
precision = int(round(-math.log(step_size, 10), 0))
amt_str = "{:0.0{}f}".format(float(amount), precision)
price_precision = int(round(-math.log(price_tick_size, 10), 0))
logging.error("QUANTITY:" + str(amt_str))
if sale_type == "SELL":
# BUY Orders: Limit Price < Last Price < Stop Price
sell_price = "{:0.0{}f}".format(
float(price) * 0.97, price_precision)
stop_price = "{:0.0{}f}".format(
float(price) * 1.01, price_precision)
stop_limit_price = "{:0.0{}f}".format(
float(price) * 1.01, price_precision)
order_oco = self.client.create_oco_order(
symbol=symbol,
side='BUY',
quantity=amt_str,
price=sell_price,
stopPrice=stop_price,
stopLimitPrice=stop_limit_price,
stopLimitTimeInForce='GTC')
else:
# TODO check filters
# quantity >= minQty
# quantity <= maxQty
# (quantity-minQty) % stepSize == 0
# SELL Orders: Limit Price > Last Price > Stop Price
sell_price = "{:0.0{}f}".format(
float(price) * 1.03, price_precision)
stop_price = "{:0.0{}f}".format(
float(price) * 0.99, price_precision)
stop_limit_price = "{:0.0{}f}".format(
float(price) * 0.989, price_precision)
logging.error("CURRENT PRICE: " + str(price) +
" SELL PRICE: " + str(sell_price) +
" STOP PRICE:" + str(stop_price) +
" STOP LIMIT PRICE:" +
str(stop_limit_price))
order_oco = self.client.create_oco_order(
symbol=symbol,
side='SELL',
quantity=amt_str,
price=sell_price,
stopPrice=stop_price,
stopLimitPrice=stop_limit_price,
stopLimitTimeInForce='GTC')
oco_text = order_oco[
"listOrderStatus"] + " " + self.format_orders(
order_oco["orderReports"])
self.send_chat_message(oco_text)
except Exception as e:
logging.error("OCO Failed error:" + str(e))
self.send_chat_message("CREATE OCO FAILED: " + str(e))
raise e
def format_orders(self, orders):
oco_text = "OPEN ORDERS:\n"
for o in orders:
if o["type"] == "STOP_LOSS_LIMIT":
oco_text = oco_text + "\nSTOP LOSS:\n" + o["side"] + " " + o[
"symbol"] + "- Stop Limit: " + o[
"stopPrice"] + " Price: " + o["price"] + " Qty:" + o[
"origQty"] + "\n"
elif o["type"] == "LIMIT_MAKER":
oco_text = oco_text + "\nPROFIT:\n" + o["side"] + " " + o[
"symbol"] + "- Price: " + o["price"] + " Qty:" + o[
"origQty"] + "\n"
else:
oco_text = oco_text + "\n" + json.dumps(o) + "\n"
oco_text = oco_text + "\nCheck Order Status with: /checkorders\n"
oco_text = oco_text + "\nCancel All Orders with: /cancelorders\n"
return oco_text
def create_order(self, chat_id, selling_coin, buying_coin, price, amount):
try:
if self.is_authorized(chat_id):
symbol, sale_type, price, info, step_size = self.get_exchange_symbol(
selling_coin, buying_coin)
precision = int(round(-math.log(step_size, 10), 0))
if sale_type == "SELL":
amt_str = "{:0.0{}f}".format(float(amount), precision)
order = self.client.order_limit_sell(symbol=symbol,
quantity=amt_str,
price=round(
float(price), 5))
else:
amt_str = "{:0.0{}f}".format(float(amount), precision)
order = self.client.order_limit_buy(symbol=symbol,
quantity=amt_str,
price=round(
float(price), 5))
text = "LIMIT ORDER CREATED:\n" + json.dumps(order)
self.send_chat_message(text)
# self.last_order_id = order['orderId']
# saved_orders = r.get(LIVE_ORDER_KEY.format(self.chat_id))
# if saved_orders is None:
# r.set(LIVE_ORDER_KEY.format(self.chat_id), json.dumps({"orders": [order]}))
# else:
# ar = json.loads(saved_orders.decode("utf-8"))
# ar["orders"].append(order)
# r.set(LIVE_ORDER_KEY.format(self.chat_id), json.dumps(ar))
self.check_orders(chat_id=chat_id)
except Exception as e:
logging.error("Test Order Failed error:" + str(e))
self.send_chat_message("CREATE ORDER FAILED: " + str(e))
def check_orders(self, chat_id):
try:
if self.is_authorized(chat_id):
orders = self.client.get_open_orders()
self.send_chat_message(self.format_orders(orders))
# saved_orders = r.get(LIVE_ORDER_KEY.format(self.chat_id))
# if saved_orders is not None:
# ar = json.loads(saved_orders.decode("utf-8"))
# self.send_chat_message("SAVED ORDERS: " + json.dumps(ar))
except Exception as e:
logging.error("Check Order Failed error:" + str(e))
self.send_chat_message("CHECK ORDERS FAILED: " + str(e))
def cancel_open_orders(self, chat_id):
try:
if self.is_authorized(chat_id):
if self.tso is not None:
self.tso.running = False
FORCE_STOP = True
orders = self.client.get_open_orders()
for order in orders:
result = self.client.cancel_order(symbol=order['symbol'],
orderId=order["orderId"])
text = "CANCEL RESULT:\n" + json.dumps(result)
self.send_chat_message(text)
except Exception as e:
logging.error("Cancel Order Failed error:" + str(e))
orders = self.client.get_open_orders()
if len(orders) > 0:
self.send_chat_message("FAILED TO CANCEL ORDER: " + str(e))
def get_usd_price(self, symbol):
usd_price = 0
try:
usd_price = self.client.get_symbol_ticker(symbol=symbol.upper() +
"USDT")
return usd_price["price"]
except Exception as e:
logging.error("USD Price Failed error:" + symbol + " -- " + str(e))
return usd_price
def get_btc_price(self, symbol):
btc_price = 0
try:
btc_price = self.client.get_symbol_ticker(symbol=symbol.upper() +
"BTC")
return btc_price["price"]
except Exception as e:
logging.error("BTC Price Failed error:" + symbol + " -- " + str(e))
return btc_price
def round_sense(self, price):
price = float(price)
if price is None or price == 0:
return 0
if price > 1000:
return int(price)
if price > 100:
return round(price, 1)
if price > 10:
return round(price, 2)
if price > 0.01:
return round(price, 4)
if price > 0.001:
return round(price, 5)
return round(price, 8)
def get_user_balance(self, symbol):
try:
balance = self.client.get_asset_balance(asset=symbol)
logging.error("CHeck" + json.dumps(balance))
return float(balance["free"])
except Exception as e:
logging.error("Account settings error:" + str(e))
self.send_chat_message("FAILED TO GET BALANCE: " + str(e))
return 0
def get_wallet(self, chat_id):
try:
if self.is_authorized(chat_id):
info = self.client.get_account()
balances = info["balances"]
# "balances": [{"asset": "BNB", "free": "1014.21000000", "locked": "0.00000000"}, {"asset": "BTC", "free": "0.92797152", "locked": "0.00000000"}, {"asset": "BUSD", "free": "10000.00000000", "locked": "0.00000000"}, {"asset": "ETH", "free": "100.00000000", "locked": "0.00000000"}, {"asset": "LTC", "free": "500.00000000", "locked": "0.00000000"}, {"asset": "TRX", "free": "500000.00000000", "locked": "0.00000000"}, {"asset": "USDT", "free": "10000.00000000", "locked": "0.00000000"}, {"asset": "XRP", "free": "50000.00000000", "locked": "0.00000000"}]
out = "<pre>FREE LOCKED BTC USD\n"
val = 0
btc_val = 0
for b in balances:
quantity = float(b["free"]) + float(b["locked"])
if quantity > 0:
if b["asset"].upper() != "BETH":
usd_price = float(self.get_usd_price(b["asset"]))
btc_price = float(self.get_btc_price(b["asset"]))
if b["asset"].upper() in ["BUSD", "USDT"]:
usd_value = float(b["free"]) + float(
b["locked"])
if btc_price > 0:
btc_value = usd_value / btc_price
else:
btc_value = 0
else:
usd_value = usd_price * quantity
if b["asset"].upper() == "BTC":
btc_price = 1
btc_value = float(b["free"]) + float(
b["locked"])
else:
btc_value = btc_price * quantity
val = val + usd_value
btc_val = btc_val + btc_value
out = out + "\n" + b["asset"] + " @ $" + str(
round(usd_price,
2)) + " BTC" + str(btc_price) + "\n"
out = out + str(self.round_sense(b["free"])).ljust(
10, ' ') + " " + str(
self.round_sense(b["locked"])).ljust(
8, ' ') + " " + str(
self.round_sense(btc_value)
).ljust(8, ' ') + " " + str(
self.round_sense(usd_value)) + "\n"
out = out + "</pre>\n$" + str(round(val, 2)) + "\n₿" + str(
round(btc_val, 6))
self.send_chat_message(out)
except Exception as e:
logging.error("Account settings error:" + str(e))
self.send_chat_message("FAILED TO GET WALLET: " + str(e))
def send_chat_message(self, text):
try:
bot_key = TELEGRAM_BOT
send_message_url = f'https://api.telegram.org/bot{bot_key}/sendMessage?chat_id={self.chat_id}&text={text}&parse_mode=HTML'
resp = requests.post(send_message_url)
except Exception as e:
logging.error("Failed to send chat message:" + str(e))
def is_authorized(self, chat_id):
if self.chat_id is None or int(self.chat_id) != int(chat_id):
raise Exception("Unauthorized Chat, use only correct chat.")
starter = self.bm.start_user_socket(self.process_message)
logging.error("Stream resp:" + str(starter))
return True
def get_symbol_trades(self, chat_id, symbol):
try:
if self.is_authorized(chat_id):
trades = self.client.get_my_trades(symbol=symbol.upper() +
'BTC')
if len(trades) > 0:
sorted_trades = sorted(trades,
key=lambda k: k['time'],
reverse=True)
out = "<pre>DATE TIME SYMBOL SIDE PRICE QUANTITY\n"
for t in sorted_trades:
if t["isBuyer"] == True:
action = "BUY"
else:
action = "SELL"
time_str = datetime.datetime.fromtimestamp(
int(t["time"]) / 1000).strftime('%d-%m %H:%M')
out = out + time_str + " " + t[
"symbol"] + " " + action + " " + t[
"price"] + " " + t["qty"] + "\n"
out = "TRADES vs BTC:\n" + out + "</pre>"
self.send_chat_message(out)
trades = self.client.get_my_trades(symbol=symbol.upper() +
'USDT')
if len(trades) > 0:
sorted_trades = sorted(trades,
key=lambda k: k['time'],
reverse=True)
out = "<pre>DATE TIME SYMBOL SIDE PRICE QUANTITY\n"
for t in sorted_trades:
if t["isBuyer"] == True:
action = "BUY"
else:
action = "SELL"
time_str = datetime.datetime.fromtimestamp(
int(t["time"]) / 1000).strftime('%d-%m %H:%M')
out = out + time_str + " " + t[
"symbol"] + " " + action + " " + t[
"price"] + " " + t["qty"] + "\n"
out = "TRADES vs USDT:\n" + out + "</pre>"
self.send_chat_message(out)
except Exception as e:
logging.error("Failed to get trades for symbol chat message:" +
str(e))
self.send_chat_message("Failed to get trades for " + symbol +
" -- " + str(e))
def create_test_order(self, pair, side, type, quantity):
return _Client.create_test_order(self,
symbol=pair[0] + pair[1],
side=side,
type=type,
quantity=quantity)
class BinanceAPI:
def __init__(self, api_key, api_secret):
API_KEY = api_key
API_SECRET = api_secret
self.client = Client(API_KEY, API_SECRET)
def get_ticker(self, pair):
try:
value = self.client.get_ticker(symbol=pair)
return value
except Exception as e:
print("Exception : " + str(e))
def get_current_price(self, pair):
try:
ticker = self.client.get_symbol_ticker(symbol=pair)
value = ticker["price"]
return float(value)
except Exception as e:
print("Exception : " + str(e))
def get_klines(self, pair, number):
try:
klines = pd.DataFrame(self.client.get_klines(symbol=pair, interval=Client.KLINE_INTERVAL_30MINUTE, limit=number),columns = ["OpenTime","Open","High","Low","Close","Volume","CloseTime","QuoteVolume","TradeCount","TakerVolume","TakerQuoteVolume","Ignore"])
value = klines[["OpenTime","Close","High","Low","Volume","QuoteVolume","TakerVolume","TakerQuoteVolume","TradeCount"]].copy()
value.loc[:, "OpenTime"] = pd.to_datetime(value["OpenTime"].apply(lambda x: datetime.fromtimestamp(int(x/1000))))
value = value.set_index("OpenTime")
return value
except Exception as e:
print("Exception : " + str(e))
def get_historical_klines(self, pair, start, end):
try:
klines = pd.DataFrame(self.client.get_historical_klines(start_str = start,end_str = end,symbol=pair, interval=Client.KLINE_INTERVAL_30MINUTE, limit=500),columns = ["OpenTime","Open","High","Low","Close","Volume","CloseTime","QuoteVolume","TradeCount","TakerVolume","TakerQuoteVolume","Ignore"])
value = klines[["OpenTime","Close","High","Low","Volume","QuoteVolume","TakerVolume","TakerQuoteVolume","TradeCount"]].copy()
value.loc[:, "OpenTime"] = pd.to_datetime(value["OpenTime"].apply(lambda x: datetime.fromtimestamp(int(x/1000))))
value = value.set_index("OpenTime")
return value
except Exception as e:
print("Exception : " + str(e))
def get_balance(self, symbol):
try:
value = self.client.get_asset_balance(asset=symbol)
return value
except Exception as e:
print('Exception : {}'.format(e))
def get_free_balance(self, symbol):
try:
value = self.client.get_asset_balance(asset=symbol)
return float(value["free"])
except Exception as e:
print('Exception : {}'.format(e))
def get_futures_balance(self, symbol):
try:
value = self.client.futures_account_balance()
balance = [balance["balance"] for balance in value if balance["asset"] == symbol]
return float(str(*balance))
except Exception as e:
print('Exception : {}'.format(e))
def create_limit_order(self, symbol, price, quantity, side_str):
try:
if side_str == "BUY":
side = self.client.SIDE_BUY
elif side_str == "SELL":
side = self.client.SIDE_SELL
order = self.client.order_limit(
symbol=symbol,
side=side,
timeInForce=self.client.TIME_IN_FORCE_IOC,
price=price,
quantity=quantity)
print(order)
print("buy order created.\nSymbol:{0:5}\nPrice:{1:5}\nQuantity:{2:5}",symbol,price,quantity)
except Exception as e:
print("Exception : " + str(e))
def create_market_order(self, symbol, quantity, side_str):
try:
if side_str == "BUY":
side = self.client.SIDE_BUY
elif side_str == "SELL":
side = self.client.SIDE_SELL
order = self.client.order_market(
symbol=symbol,
side=side,
quantity=quantity)
print(order)
print("buy order created.\nSymbol:{0:5}\nPrice:{1:5}\nQuantity:{2:5}",symbol,price,quantity)
except Exception as e:
print("Exception : " + str(e))
def create_test_order(self, symbol, quantity, side_str):
try:
if side_str == "BUY":
side = self.client.SIDE_BUY
elif side_str == "SELL":
side = self.client.SIDE_SELL
order = self.client.create_test_order(
symbol=symbol,
side=side,
type=self.client.ORDER_TYPE_MARKET,
quantity=quantity)
print(order)
print("buy order created.\nSymbol:{0:5}\nQuantity:{1:5}".format(symbol,quantity))
except Exception as e:
print("Exception : " + str(e))
def create_futures_order(self, symbol, quantity, side_str):
try:
if side_str == "BUY":
side = self.client.SIDE_BUY
elif side_str == "SELL":
side = self.client.SIDE_SELL
order = self.client.futures_create_order(
symbol=symbol,
side=side,
type=self.client.ORDER_TYPE_MARKET,
quantity=quantity)
#print(order)
print("buy order created.\nSymbol:{0:5}\nQuantity:{1:5}".format(symbol,quantity))
except Exception as e:
print("Exception : " + str(e))
def get_base_asset(self, symbol):
try:
return self.client.get_symbol_info(symbol)["baseAsset"];
except Exception as e:
print("Exception : " + str(e))
def get_quote_asset(self, symbol):
try:
return self.client.get_symbol_info(symbol)["quoteAsset"];
except Exception as e:
print("Exception : " + str(e))
def get_all_tickers(self):
try:
return self.client.get_all_tickers();
except Exception as e:
print("Exception : " + str(e))
def get_all_orders(self):
try:
return self.client.get_all_orders();
except Exception as e:
print("Exception : " + str(e))
class FXConnector(Logger):
ORDER_STATUS_NEW = 'NEW'
ORDER_STATUS_PARTIALLY_FILLED = 'PARTIALLY_FILLED'
ORDER_STATUS_FILLED = 'FILLED'
ORDER_STATUS_CANCELED = 'CANCELED'
ORDER_STATUS_PENDING_CANCEL = 'PENDING_CANCEL'
ORDER_STATUS_REJECTED = 'REJECTED'
ORDER_STATUS_EXPIRED = 'EXPIRED'
SIDE_BUY = 'BUY'
SIDE_SELL = 'SELL'
ORDER_TYPE_LIMIT = 'LIMIT'
ORDER_TYPE_MARKET = 'MARKET'
ORDER_TYPE_STOP_LOSS = 'STOP_LOSS'
ORDER_TYPE_STOP_LOSS_LIMIT = 'STOP_LOSS_LIMIT'
ORDER_TYPE_TAKE_PROFIT = 'TAKE_PROFIT'
ORDER_TYPE_TAKE_PROFIT_LIMIT = 'TAKE_PROFIT_LIMIT'
ORDER_TYPE_LIMIT_MAKER = 'LIMIT_MAKER'
TIME_IN_FORCE_GTC = 'GTC' # Good till cancelled
TIME_IN_FORCE_IOC = 'IOC' # Immediate or cancel
TIME_IN_FORCE_FOK = 'FOK' # Fill or kill
ORDER_RESP_TYPE_ACK = 'ACK'
ORDER_RESP_TYPE_RESULT = 'RESULT'
ORDER_RESP_TYPE_FULL = 'FULL'
def __init__(self, key=None, secret=None):
super().__init__()
self.__key = key
self.__secret = secret
self.client = Client(key, secret)
self.bs: BinanceWebsocket = None
# self.connection = None
self.ticker_connection = None
self.user_data_connection = None
def listen_symbols(self, symbols, on_ticker_received, user_data_handler):
self.bs = BinanceWebsocket(self.client)
self.bs.start_ticker(symbols, on_ticker_received)
self.bs.start_user_info(user_data_handler)
self.logInfo('Ticker and User WS initialized')
def start_listening(self):
self.bs.start()
self.logInfo('WS listening started')
def stop_listening(self):
self.bs.stop_sockets()
self.logInfo('Socket stopped')
@retry(**DEFAULT_RETRY_SETTINGS)
def cancel_order(self, sym, id):
return self.client.cancel_order(symbol=sym, orderId=id)
@retry(**DEFAULT_RETRY_SETTINGS)
def cancel_open_orders(self, sym):
orders = self.get_open_orders(sym)
if orders:
for order_id in orders:
self.client.cancel_order(symbol=sym, orderId=order_id)
def get_server_time(self):
return self.client.get_server_time()
@retry(**DEFAULT_RETRY_SETTINGS)
def get_open_orders(self, sym):
return [o['orderId'] for o in self.client.get_open_orders(symbol=sym)]
@retry(**DEFAULT_RETRY_SETTINGS)
def get_all_orders(self, sym, limit=500):
return {
o['orderId']: {
'status': o['status'],
'price': o['price'],
'stop_price': o['stopPrice'],
'vol': o['origQty'],
'vol_exec': o['executedQty']
}
for o in self.client.get_all_orders(symbol=sym, limit=limit)
}
@retry(**DEFAULT_RETRY_SETTINGS)
def get_all_tickers(self):
return self.client.get_all_tickers()
@retry(**DEFAULT_RETRY_SETTINGS)
def get_orderbook_tickers(self):
return self.client.get_orderbook_tickers()
@retry(**DEFAULT_RETRY_SETTINGS)
def get_order_status(self, sym, id):
return self.client.get_order(symbol=sym, orderId=id)
# @retry(stop_max_attempt_number=MAX_ATTEMPTS, wait_fixed=DELAY)
def create_makret_order(self, sym, side, volume):
return self.client.create_order(
symbol=sym,
side=side,
type=FXConnector.ORDER_TYPE_MARKET,
quantity=FXConnector.format_number(volume))
# @retry(stop_max_attempt_number=MAX_ATTEMPTS, wait_fixed=DELAY)
def create_limit_order(self, sym, side, price, volume):
return self.client.create_order(
symbol=sym,
side=side,
type=FXConnector.ORDER_TYPE_LIMIT,
timeInForce=FXConnector.TIME_IN_FORCE_GTC,
quantity=FXConnector.format_number(volume),
price=FXConnector.format_number(price))
# @retry(stop_max_attempt_number=MAX_ATTEMPTS, wait_fixed=DELAY)
def create_stop_order(self, sym, side, stop_price, price, volume):
return self.client.create_order(
symbol=sym,
side=side,
type=FXConnector.ORDER_TYPE_STOP_LOSS_LIMIT,
timeInForce=FXConnector.TIME_IN_FORCE_GTC,
quantity=FXConnector.format_number(volume),
stopPrice=FXConnector.format_number(stop_price),
price=FXConnector.format_number(price))
# @retry(stop_max_attempt_number=MAX_ATTEMPTS, wait_fixed=DELAY)
def create_test_stop_order(self, sym, side, price, volume):
return self.client.create_test_order(
symbol=sym,
side=side,
type=FXConnector.ORDER_TYPE_STOP_LOSS_LIMIT,
timeInForce=FXConnector.TIME_IN_FORCE_GTC,
quantity=FXConnector.format_number(volume),
stopPrice=FXConnector.format_number(price),
price=FXConnector.format_number(price))
@retry(**DEFAULT_RETRY_SETTINGS)
def get_balance(self, asset):
bal = self.client.get_asset_balance(asset=asset)
return float(bal['free']), float(bal['locked'])
@retry(**DEFAULT_RETRY_SETTINGS)
def get_all_balances(self, assets: dict):
res = self.client.get_account()
if 'balances' in res:
for bal in res['balances']:
if bal['asset'] in assets:
assets[bal['asset']] = {
'f': float(bal['free']),
'l': float(bal['locked'])
}
@retry(**DEFAULT_RETRY_SETTINGS)
def get_all_balances_dict(self):
res = self.client.get_account()
if 'balances' in res:
return {
bal['asset']: {
'f': float(bal['free']),
'l': float(bal['locked'])
}
for bal in res['balances']
}
return {}
@retry(**DEFAULT_RETRY_SETTINGS)
def get_exchange_info(self):
return self.client.get_exchange_info()
# info = self.client.get_exchange_info()
#
# symbol_info = None
# for s in info['symbols']:
# if s['symbol'] == sym:
# symbol_info = s
# break
#
# props = {}
# for f in symbol_info['filters']:
# props.update(f)
#
# props.pop('filterType', None)
#
# return FXConnector.ExchangeInfo(**props)
@classmethod
def format_number(cls, num):
return '{:.08f}'.format(num)
class Interface:
def __init__(self):
self.binanceClient = BinanceClient(BinanceSettings.api_key,
BinanceSettings.api_secret)
self.gdax_public_client = GdaxPublicClient()
self.gdax_authenticated_client = GdaxAuthenticatedClient(
key=GdaxSettings.api_key,
b64secret=GdaxSettings.api_secret,
passphrase=GdaxSettings.api_passphrase)
self.sandbox_gdax_authenticated_client = GdaxAuthenticatedClient(
key=GdaxSettings.sandbox_key,
b64secret=GdaxSettings.sandbox_secret,
passphrase=GdaxSettings.sandbox_passphrase,
api_url='https://api-public.sandbox.gdax.com')
self.kraken_public_client = KrakenAPI()
self.MARKET_BINANCE = 'binance'
self.MARKET_GDAX = 'gdax'
self.MARKET_KRAKEN = 'kraken'
def get_prices(self, exchange):
if exchange == self.MARKET_BINANCE:
market_books = self.binanceClient.get_products_and_prices()
elif exchange == self.MARKET_GDAX:
market_books = self.gdax_public_client.get_products_with_prices()
elif exchange == self.MARKET_KRAKEN:
market_books = self.kraken_public_client.get_market_tickers()
else:
print("No exchange found with name: " + exchange)
# TODO throw exception
return market_books
def create_test_order(self,
exchange,
symbol,
side,
limit_market,
quantity,
price=0.0):
if exchange == self.MARKET_BINANCE:
response = self.binanceClient.create_test_order(symbol=symbol,
side=side,
type=limit_market,
quantity=quantity,
price=price,
timeInForce="GTC")
print("order is filled")
# The binance test order does not actually get passed to the matching engine, so we're unable to test this.
if exchange == self.MARKET_GDAX:
symbol_reformatted = symbol[:3] + "-" + symbol[
3:] # TODO is this correct?
response = self.sandbox_gdax_authenticated_client.create_order(
symbol=symbol_reformatted,
side=side,
limit_market=limit_market,
quantity=quantity,
price=price)
order_id = response["id"]
order_filled = False
while not order_filled:
order = self.sandbox_gdax_authenticated_client.get_order(
order_id)
if order["status"] == "done":
print("order is filled!")
order_filled = True
else:
print("order not yet filled")
time.sleep(5)
def create_order(self,
exchange,
symbol,
side,
limit_market,
quantity,
price=0.0):
if exchange == self.MARKET_BINANCE:
order = self.binanceClient.create_order(symbol,
side,
quantity,
price,
type=limit_market)
elif exchange == self.MARKET_GDAX:
order = self.gdax_authenticated_client.create_order(
symbol, side, limit_market, quantity, price)
else:
print("No exchange found with name: " + exchange)
# TODO throw exception
print(order)
def order_filled(self, exchange, order_id):
if exchange == self.MARKET_BINANCE:
return self.binanceClient.get_order(order_id)['status'] == 'done'
elif exchange == self.MARKET_GDAX:
return self.gdax_authenticated_client.get_order(
order_id)['status'] == 'done'
else:
return ''
Tradingpair=Symbol, Timeinterval=Timeframe))
print("Price = " + str(ClosePriceVector[-1]))
print("RSI = " + str(RSI))
print("StochRSIK = " + str(StochRSIK))
print("StochRSID = " + str(StochRSID))
print("Money Flow = " + str(MoneyFlow))
print("Time = " + str(TimeVector[-1]))
print("")
if BuyVariable == 1 and LiveTrades == 1:
for i in key:
if i == Symbol[:len(i)]:
print("Buy Order Placed")
try:
order = client.create_test_order(
symbol=Symbol,
side=Client.SIDE_BUY,
type=client.ORDER_TYPE_MARKET,
quantity=ExtraUsefulCode.quantity(
Symbol[:len(i)], Symbol, client))
print("Quantity being bought: " +
ExtraUsefulCode.quantity(
Symbol[:len(i)], Symbol, client))
except:
order = client.create_test_order(
symbol=Symbol,
side=Client.SIDE_BUY,
type=client.ORDER_TYPE_MARKET,
quantity=1000 * float(
client.get_symbol_info(symbol=Symbol)
['filters'][2]['stepSize']))
print("Quantity being bought: " + 1000 * float(
client.get_symbol_info(
class Binance(object):
def __init__(self):
print("-- Connecting to binance ...")
self.client = Client(os.environ['BINANCE_API_KEY'],
os.environ['BINANCE_API_SECRET'])
def get_balance(self, coin):
print("-- Getting balance for " + coin)
assetJSON = self.client.get_asset_balance(coin)
return float(assetJSON['free'])
def get_price(self, coin, coinfrom):
priceJSON = self.client.get_symbol_ticker(symbol=coin + coinfrom)
return float(priceJSON['price'])
def buy_market(self, coin, coinfrom, ignored, quantity, testmode):
print("-- Buying market " + str(quantity) + " " + coin + " from " +
coinfrom)
self.symbol = coin + coinfrom
if testmode:
print("[TEST] " + str(quantity) + " " + coin + " buy at : " +
str(ignored) + " " + coinfrom +
" (price is ignored on Binance)")
else:
orderBuy = self.client.create_order(
symbol=coin + coinfrom,
side=self.client.SIDE_BUY,
type=self.client.ORDER_TYPE_MARKET,
# timeInForce=clientBinance.TIME_IN_FORCE_GTC,
quantity=quantity,
# price=repr(originalPrice)
)
completed = False
while not completed:
time.sleep(0.2)
self.orderID = orderBuy['clientOrderId']
orderBuySt = self.client.get_order(symbol=coin + coinfrom,
orderId=self.orderID)
print("+ Order buy status : " + orderBuySt['status'] +
" at : " + orderBuySt['price'])
if not orderBuySt == self.client.ORDER_STATUS_NEW:
completed = True
def sell_market(self, coin, coinTo, ignored, quantity, testmode):
print("-- Selling market " + str(quantity) + " " + coin + " to " +
coinTo)
if testmode:
print("[TEST] " + str(quantity) + " " + coin + " sell at : " +
str(ignored) + " " + coinTo +
" (price is ignored on Binance)")
else:
orderSell = self.client.create_test_order(
symbol=coin + coinTo,
side=self.client.SIDE_SELL,
type=self.client.ORDER_TYPE_MARKET,
# timeInForce=clientBinance.TIME_IN_FORCE_GTC,
quantity=quantity,
# price=repr(newPrice)
)
completed = False
while not completed:
time.sleep(0.2)
orderSellId = orderSell['clientOrderId']
orderSellSt = self.client.get_order(symbol=coin + coinTo,
orderId=orderSellId)
print("+ Order sell status : " + orderSellSt['status'] +
" at : " + orderSellSt['price'])
if not orderSellSt == self.client.ORDER_STATUS_NEW:
completed = True
def cancel_order(self):
print("-- Canceling order")
self.client.cancel_order(symbol=self.symbol, orderId=self.orderID)
self.symbol = None
self.orderID = None
# df_orderbook.to_csv('orderbook.csv')
# transform traders to dataframe
df_traders = pd.DataFrame(traders)
df_traders.columns = [
'Aggregated TradeId', 'Price', 'Quantity', 'First TradeId', 'Last TradeId',
'Timestamp', 'Was the buyer the maker?',
'Was the trade the best price match?'
]
print(df_traders.head())
# df_traders.to_csv('traders.csv')
df_candle = pd.DataFrame(candle)
df_candle.columns = [
'Open time', 'Open', 'High', 'Low', 'Close', 'Volume', 'Closetime',
'Quote Asset Volume', 'Number of Traders', 'Taker Buy Base Asset Volume',
'Taker Buy Quote Asset Volume', 'a'
]
df_candle.drop(['a'], axis=1)
print(df_candle.head())
# df_candle.to_csv('candle.csv')
test_order = client.create_test_order(symbol='BNBBTC',
side='BUY',
type='LIMIT',
timeInForce='GTC',
quantity=1,
price='0.007856',
timestamp='1591839251')
print(test_order)
mov_dx = tp.derivative_ratio(open_price, 10)
current_price = float(client.get_symbol_ticker(symbol=token+asset)['price'])
open_price.append(current_price)
# BUY
if(((current_price > res_trend[-1] and (current_price > res_01[-1]))
# or (mov_dx_01[-1] < 1 - (40/10000))
) and
(int(funds) > 10)):
buybool = True
#client.order_market_buy(symbol=token+asset, quantity=int(10*funds/current_price)/10)
order = client.create_test_order(symbol=token+asset,
side=Client.SIDE_BUY,
type=Client.ORDER_TYPE_MARKET,
quantity=int(10*funds/current_price)/10)
tokens = tokens + (1-0.001)*(int(10*funds/current_price)/10)
buy_val_list.append(tokens)
buy_price_list.append(current_price)
# print("Epoch: " +
# str(count) +
# ", Buy Made @ price: " +
# str(current_price) +
# ", Quantity Bought: " +
# str(int(10*funds/current_price)/10) +
# ", Gain: " +
# init
api_key = os.environ.get('binance_api')
api_secret = os.environ.get('binance_secret')
client = Client(
'MIPFco456I2i3nSBeV6NnZUSYP3Bb8r4zejs9cHYf5dOAyxHDMo4bYbURkQGlaMn',
'fdYtZD0hNqfQbMqKrcM5e5viqb8TYTV8AotCdGoRPxuvQcFtU5URoxeKah58z3sW',
)
## main
# create order
# make a test order first. This will raise an exception if the order is incorrect.
buy_order_limit = client.create_test_order(symbol='ETHUSDT',
side='BUY',
type='LIMIT',
timeInForce='GTC',
quantity=100,
price='3.444')
buy_order = client.create_test_order(symbol='ETHUSDT',
side='BUY',
type='MARKET',
quantity=100)
# create a real order if the test orders did not raise an exception
try:
buy_limit = client.create_order(symbol='ETHUSDT',
side='BUY',
type='LIMIT',
timeInForce='GTC',
quantity=100,
class BinBot(object):
def __init__(self):
self.client = Client(binance_config.api_key, binance_config.api_secret)
self.fee = 0.0005 #if user has BNB tokens
self.orderbook = self.get_orderbook_total()
self.bit_rate = self.extract_btc_eth_rate(self.orderbook)
self.update_orderbook()
self.symbol_keys = self.get_keys(self.orderbook)
self.current_btc, self.current_eth = self.update_account()
def get_orderbook_total(self):
""" Returns orderbook from binance package. """
return self.client.get_orderbook_tickers()
def update_orderbook(self):
""" Updates orderbook by analyzing exchange rates in BTC and removing
coins in no_trade in binance_config.
"""
try:
self.orderbook = self.get_orderbook_total()
self.bit_rate = self.extract_btc_eth_rate(self.orderbook)
self.orderbook = self.modify_orderbook(self.orderbook)
except binexc.BinanceAPIException as e:
print(e.status_code)
print(e.message)
time.sleep(10)
self.update_orderbook()
def update_account(self):
""" Returns the amount of BTC or ETH in the account. """
flag = False
#If local time compared to Binance NTP server time is offset by +1000ms then API will throw error
while (flag == False):
try:
acc = self.client.get_account(
recvWindow=binance_config.recv_window)
flag = True
except binexc.BinanceAPIException as e:
print(str(e.status_code) + " : " + e.message)
time.sleep(1)
btc_eth = []
for k in acc['balances']:
if (k['asset'] == 'BTC' or k['asset'] == 'ETH'):
btc_eth.append(k['free'])
if (len(btc_eth) == 2):
break
if (btc_eth[0] >= btc_eth[1]):
return btc_eth[0], btc_eth[1]
else:
return btc_eth[1], btc_eth[0]
def alt_asset_amount(self, symbol, symbol_length=3):
""" Returns the total amount of an altcoin on the account.
Keyword Arguments:
symbol -- the symbol of the altcoin e.g. 'NEO'
symbol_length -- 'NEO' will have symbol_length of 3
'LINK' will have symbol_length of 4
Work around for the API
(default 3)
"""
acc = self.client.get_account(recvWindow=binance_config.recv_window)
for k in acc['balances']:
if (k['asset'] == symbol[0, symbol_length]):
return k['free']
return "Symbol Not Found"
def get_keys(self, orderbook):
""" Returns symbols of all coins on Binance """
_keys = []
for k in orderbook:
_keys.append(list(k.keys())[0])
return _keys
def extract_btc_eth_rate(self, orderbook):
""" Returns ETHBTC exchange rate """
for i in range(0, len(orderbook)):
if (orderbook[i]['symbol'][0:6] == 'ETHBTC'):
odbk = orderbook[i]
odbk['btc_one'] = 1 / float(odbk['askPrice'])
return orderbook[i]
def modify_orderbook(self, orderbook):
""" Helper function to modify orderbook to remove trading pairs that
are not involved eg BTCUSDT """
ob_sorted = sorted(orderbook, key=lambda k: k['symbol'])
ob_sorted = self.del_non_pair_coins(ob_sorted)
ob_dict = self.transform_data_list(ob_sorted)
return ob_dict
def del_non_pair_coins(self, orders):
""" Deletes coins that are no longer listed on Binance as well as coins
listed on the binance_config.no_trade list
"""
i = 0
orders_to_return = []
while (i < len(orders) - 1):
if (orders[i]['symbol'][0:3] == orders[i + 1]['symbol'][0:3]):
if (orders[i]['symbol'] == 'ETC'
or orders[i]['symbol'][-4:] == 'USDT'
or orders[i]['symbol'][0:4] in binance_config.no_trade
or orders[i]['symbol'][0:3] in binance_config.no_trade
or orders[i]['symbol'][-3:] == 'BNB'):
i += 1
elif (orders[i + 1]['symbol'][-4:] == 'USDT'):
i += 1
else:
orders_to_return.append(orders[i])
orders_to_return.append(orders[i + 1])
i += 2
else:
i += 1
return orders_to_return
def transform_data_list(self, orders):
""" Transforms data from dictionary into list(BTC=0, ETH=1) """
transform = []
for i in range(0, len(orders), 2):
transform.append(
{orders[i]['symbol'][0:3]: [orders[i], orders[i + 1]]})
return transform
def orderbook_btc_eth(self, orderbook):
""" Looks for viable trading pairs in the BTC --> ETH direction """
btc_to_eth = {}
btc_pos = 0
eth_pos = 1
for k in orderbook:
try:
btc_to_eth[list(k.keys())[0]] = 1 / float(k[list(
k.keys())[0]][btc_pos]['askPrice']) * float(k[list(
k.keys())[0]][eth_pos]['bidPrice'])
except ZeroDivisionError as e:
print(e)
return sorted(btc_to_eth.items(),
key=operator.itemgetter(1),
reverse=True)
def orderbook_eth_btc(self, orderbook):
""" Looks for viable trading pairs in the ETH --> BTC direction """
eth_to_btc = {}
btc_pos = 0
eth_pos = 1
for k in orderbook:
try:
eth_to_btc[list(k.keys())[0]] = 1 / float(k[list(
k.keys())[0]][eth_pos]['askPrice']) * float(k[list(
k.keys())[0]][btc_pos]['bidPrice'])
except ZeroDivisionError as e:
print(e)
return sorted(eth_to_btc.items(),
key=operator.itemgetter(1),
reverse=True)
#Without client validation - no google authenticator
#symbol - string, quantity = int, price = string -- must be 0.0002
def order_buy_alt(self, _symbol, _quantity, _price, order_rank, attempt=1):
""" Buys an altcoin using Binance package
Keyword Arguments:
_symbol -- String: Symbol name of trading pair eg NEOBTC
_quantity -- Integer: Quantity to buy
_price -- String: Price to buy at
order_rank -- Integer: The order of buy/sell exection
attempt -- Integer: Total of attempts to buy at the price
"""
try:
self.client.create_order(symbol=_symbol,
side=enum.SIDE_BUY,
type=enum.ORDER_TYPE_LIMIT,
timeInForce=enum.TIME_IN_FORCE_GTC,
quantity=_quantity,
price=_price,
disable_validation=True)
return True
except binexc.BinanceAPIException as e:
print(e.status_code, e.message, " | order_buy_alt")
return False
def order_sell_alt(self,
_symbol,
_quantity,
_price,
order_rank,
attempt=1):
""" Sells an altcoin using Binance package
Keyword Arguments:
_symbol -- String: Symbol name of trading pair eg NEOBTC
_quantity -- Integer: Quantity to buy
_price -- String: Price to buy at
order_rank -- Integer: The order of buy/sell exection
attempt -- Integer: Total of attempts to buy at the price
"""
try:
self.client.create_order(symbol=_symbol,
side=enum.SIDE_SELL,
type=enum.ORDER_TYPE_LIMIT,
timeInForce=enum.TIME_IN_FORCE_GTC,
quantity=_quantity,
price=_price,
disable_validation=True)
except binexc.BinanceAPIException as e:
#print(e.message, e.status_code, " | order_sell_alt")
if (order_rank is 4 or order_rank is 2):
if (attempt <= 25):
attempt += 1
self.order_sell_alt(_symbol, _quantity, _price, order_rank,
attempt)
time.sleep(0.02)
else:
print("Went to market price | order_sell_alt", e.message,
e.status_code)
self.order_sell_market(_symbol, _quantity)
def order_sell_market(self, _symbol, _quantity):
"""Sells coins into either ETH or BTC at MARKET VALUE.
Use for upgrades for flexibility of binbot
Say the order you originally placed was bought before your order arrived
on the binance servers. This will immediately sell your coins and depending
on the fluctuation of the market could still result in a (most likely milder)
profit.
"""
try:
self.crypto_storage.client.create_order(
symbol=_symbol,
side=enum.SIDE_SELL,
type=enum.ORDER_TYPE_MARKET,
quantity=_quantity)
except binexc.BinanceAPIException as e:
print(e.status_code)
print(e.message)
self.order_sell_market(_symbol, _quantity)
def test_order_buy_alt(self, _symbol, _quantity, _price):
""" FOR TESTING BINBOT BEFORE YOU LOSE MONEY
Important to test if your orders will execute in time.
Buys an altcoin using Binance package
Keyword Arguments:
_symbol -- String: Symbol name of trading pair eg NEOBTC
_quantity -- Integer: Quantity to buy
_price -- String: Price to buy at
order_rank -- Integer: The order of buy/sell exection
attempt -- Integer: Total of attempts to buy at the price
"""
try:
self.client.create_test_order(symbol=_symbol,
side=enum.SIDE_BUY,
type=enum.ORDER_TYPE_LIMIT,
timeInForce=enum.TIME_IN_FORCE_GTC,
quantity=_quantity,
price=_price,
disable_validation=True)
except binexc.BinanceAPIException as e:
print(e.status_code)
print(e.message)
def test_order_sell_alt(self, _symbol, _quantity, _price):
""" FOR TESTING BINBOT BEFORE YOU LOSE MONEY
Important to test if your orders will execute in time.
Sells an altcoin using Binance package
Keyword Arguments:
_symbol -- String: Symbol name of trading pair eg NEOBTC
_quantity -- Integer: Quantity to buy
_price -- String: Price to buy at
order_rank -- Integer: The order of buy/sell exection
attempt -- Integer: Total of attempts to buy at the price
"""
try:
self.client.create_test_order(symbol=_symbol,
side=enum.SIDE_SELL,
type=enum.ORDER_TYPE_LIMIT,
timeInForce=enum.TIME_IN_FORCE_GTC,
quantity=_quantity,
price=_price,
disable_validation=True)
except binexc.BinanceAPIException as e:
print(e.status_code)
print(e.message)
def hunt(self, trials=10000, sleep_time=0.1):
""" This is the main function of BinBot.
This function will search for arbitrage opportunities and execute orders
if it finds an inefficient pair.
Keyword Arguments:
trials -- Integer: how many loops the bot will run (default 10,000)
sleep_time -- Float: The Binance API (since I last checked) will only allow
you to access it 18 times per second. So need a sleep time
to avoid this problem. Remember the longer the sleep time
the less likely your arbitrage oppurtunity will still be
available. (default 0.1)
"""
num_runs = 0
pre_arbitrage_assets = self.load_arbitrage_assets()
time.sleep(sleep_time)
while (num_runs < trials):
try:
self.update_orderbook()
except ConnectionError as e:
print(e + "will suspend bot for 10 seconds")
time.sleep(10)
continue
#Search for inefficiency
orderbook_btc = self.orderbook_btc_eth(self.orderbook)
orderbook_eth = self.orderbook_eth_btc(self.orderbook)
if (orderbook_btc[0][1] -
(self.fee * orderbook_btc[0][1]) > self.bit_rate['btc_one']
and orderbook_eth[0][1] - (self.fee * orderbook_eth[0][1])
> float(self.bit_rate['askPrice'])):
#print('found' + orderbook_btc[0][0] + orderbook_eth[0][0] + str(num_runs))
num_runs += 1
purchase = []
for k in self.orderbook:
if (list(k.keys())[0] == orderbook_btc[0][0]):
purchase.insert(0, k)
if (list(k.keys())[0] == orderbook_eth[0][0]):
purchase.insert(1, k)
btc_limit = binance_config.btc_trade_limit
while (btc_limit > 0.001):
if (self.determine_feasibility(
orderbook_btc[0][0], orderbook_eth[0][0], purchase,
btc_limit) is True):
self.execute_trade(orderbook_btc[0][0],
orderbook_eth[0][0], purchase,
btc_limit)
break
else:
btc_limit = btc_limit - 0.001
num_runs += 1
if (num_runs % 100 == 0):
print(str(num_runs))
post_arbitrage_assets = self.load_arbitrage_assets()
#Print results
time_delta = datetime.datetime.now().replace(
microsecond=0) - pre_arbitrage_assets['datetime']
print('Initial: BTC:', pre_arbitrage_assets['BTC'], 'ETH:',
pre_arbitrage_assets['ETH'], 'BNB:', pre_arbitrage_assets['BNB'])
print('After__: BTC:', post_arbitrage_assets['BTC'], 'ETH:',
post_arbitrage_assets['ETH'], 'BNB:',
post_arbitrage_assets['BNB'])
print(
'Diff___: BTC:',
float(post_arbitrage_assets['BTC']) -
float(pre_arbitrage_assets['BTC']), 'ETH:',
float(post_arbitrage_assets['ETH']) -
float(pre_arbitrage_assets['ETH']), 'BNB:',
float(post_arbitrage_assets['BNB']) -
float(pre_arbitrage_assets['BNB']), 'TIME:',
divmod(time_delta.total_seconds(), 60))
def determine_feasibility(self, btc_sym, eth_sym, purchase,
btc_trade_limit):
""" Determines if an arbitrage opportunity is profitable. """
if (btc_trade_limit / float(purchase[0][btc_sym][0]['askPrice']) <=
float(purchase[0][btc_sym][0]['askQty']) and
btc_trade_limit / float(purchase[0][btc_sym][0]['askPrice']) <=
float(purchase[0][btc_sym][1]['bidQty'])):
eth_capital = (btc_trade_limit /
float(purchase[0][btc_sym][0]['askPrice'])) * float(
purchase[0][btc_sym][1]['bidPrice'])
if (eth_capital / float(purchase[1][eth_sym][1]['askPrice']) <=
float(purchase[1][eth_sym][1]['askQty']) and
eth_capital / float(purchase[1][eth_sym][1]['askPrice']) <=
float(purchase[1][eth_sym][0]['bidQty'])):
#and eth_capital / float(purchase[1][eth_sym][1]['askPrice']) >= 1):
return True
else:
return False
else:
return False
def execute_trade(self, btc_sym, eth_sym, purchase, btc_trade_limit):
""" Executes trade in BTC-->ALT_1-->ETH-->ALT_2-->BTC order.
Side note: Making threads will improve likelihood of success.
This implementation is inefficient.
"""
amount_btc = math.floor(btc_trade_limit /
float(purchase[0][btc_sym][0]['askPrice']))
eth_capital = (btc_trade_limit /
float(purchase[0][btc_sym][0]['askPrice'])) * float(
purchase[0][btc_sym][1]['bidPrice'])
amount_eth = math.floor(eth_capital /
float(purchase[1][eth_sym][1]['askPrice']))
if (amount_btc * float(purchase[0][btc_sym][0]['askPrice']) > 0.001
and amount_eth * float(purchase[1][eth_sym][0]['bidPrice']) >
0.001):
if self.order_buy_alt(
purchase[0][btc_sym][0]['symbol'], amount_btc,
purchase[0][btc_sym][0]['askPrice'], 1) is True:
print("1: " + purchase[0][btc_sym][0]['symbol'] + " " +
str(amount_btc) + " " +
purchase[0][btc_sym][0]['askPrice'])
self.order_sell_alt(purchase[0][btc_sym][1]['symbol'],
amount_btc,
purchase[0][btc_sym][1]['bidPrice'], 2)
print("2: " + purchase[0][btc_sym][1]['symbol'] + " " +
str(amount_btc) + " " +
purchase[0][btc_sym][1]['bidPrice'])
if self.order_buy_alt(
purchase[1][eth_sym][1]['symbol'], amount_eth,
purchase[1][eth_sym][1]['askPrice'], 3) is True:
print("3: " + purchase[1][eth_sym][1]['symbol'] + " " +
str(amount_eth) + " " +
purchase[1][eth_sym][1]['askPrice'])
self.order_sell_alt(purchase[1][eth_sym][0]['symbol'],
amount_eth,
purchase[1][eth_sym][0]['bidPrice'], 4)
print("4: " + purchase[1][eth_sym][0]['symbol'] + " " +
str(amount_eth) + " " +
purchase[1][eth_sym][0]['bidPrice'])
self.remove_any_open_orders([
purchase[0][btc_sym][0]['symbol'],
purchase[0][btc_sym][1]['symbol'],
purchase[1][eth_sym][1]['symbol'],
purchase[1][eth_sym][0]['symbol']
])
def remove_any_open_orders(self, poss_orders=[]):
""" For upgrading flexibility of BinBot. Removes any open orders. """
for order in poss_orders:
open_orders = self.get_open_orders_symbol(_symbol=order)
if len(open_orders) is not 0:
self.order_sell_market(_symbol=open_orders[0]['symbol'],
_quantity=open_orders[0]['origQty'])
def check_server_time_difference(self):
""" Checks the amount of time it takes for your packets to reach Binance
servers and return to your computer.
VERY IMPORTANT: If your packets take too long, your trades will not execute
"""
for i in range(0, 10):
local_time_one = int(time.time() * 1000)
server_time = self.client.get_server_time()
diff_one = server_time['serverTime'] - local_time_one
local_time_two = int(time.time() * 1000)
diff_two = local_time_two - server_time['serverTime']
print("local1: %s server: %s local2: %s diff1: %s diff2: %s" %
(local_time_one, server_time['serverTime'], local_time_two,
diff_one, diff_two))
time.sleep(2)
def get_specific_symbol(self, coin_sym='ETH', trade_currency='BTC'):
"""Returns a specific trading pair to see what price it is at in the orderbook.
If no parameters are given, it will return the price of ETHBTC.
Keyword Arguments:
coin_sym -- This is the first symbol in the trading pair (default 'ETH')
trade_currency -- This is the second symbol in the trading pair (default 'BTC')
"""
if trade_currency != 'BTC' and trade_currency != 'ETH' and trade_currency != 'BNB':
print('Trade currency can only be BTC or ETH')
return {}
trade_pair = coin_sym + trade_currency
for k in self.orderbook:
if list(k.keys())[0] == coin_sym[0:3]:
for pair in k[list(k.keys())[0]]:
if pair['symbol'] == trade_pair:
return pair
print('Pair not in orderbook.')
return {}
def get_orderbook_symbol(self, _symbol='ETHBTC', _limit=10):
""" Returns the orderbook (buy/sell prices) of a given symbol.
Limit will hold the orderbook to only 10 prices of the buy/sell pair
Returns:
Dictionary of prices
"""
return self.client.get_order_book(symbol=_symbol, limit=_limit)
def get_open_order_symbol(self, _symbol='ETHBTC'):
"""Get all open orders of a symbol """
try:
return self.client.get_open_orders(symbol=_symbol)
except binexc.BinanceAPIException as e:
print(e.message)
self.get_open_orders_symbol(_symbol)
def get_past_orders(self, _symbol='ETHBTC'):
""" Get the user's past orders.
"""
return self.client.get_all_orders(symbol=_symbol)
def load_arbitrage_assets(self):
""" Loads the amount of coins in the user's account """
flag = False
btc_eth_bnb = {}
while (flag is False):
try:
acc = self.client.get_account(
recvWindow=binance_config.recv_window)
flag = True
except binexc.BinanceAPIException as e:
print(str(e.status_code) + " : " + e.message)
time.sleep(1)
#acc['balances']
for cryptoasset in acc['balances']:
if cryptoasset['asset'] == 'BTC':
btc_eth_bnb['BTC'] = cryptoasset['free']
if cryptoasset['asset'] == 'ETH':
btc_eth_bnb['ETH'] = cryptoasset['free']
if cryptoasset['asset'] == 'BNB':
btc_eth_bnb['BNB'] = cryptoasset['free']
if len(btc_eth_bnb) is 3:
break
btc_eth_bnb['datetime'] = datetime.datetime.now().replace(
microsecond=0)
return btc_eth_bnb
class BinanceExchange(Exchange):
def __init__(self, api_key: str, api_secret: str):
self.client = Client(api_key, api_secret)
self.symbols: dict = {} # Dictionary mapping symbol names to BinanceSymbol instances
self.update_symbols()
def update_symbols(self):
info = self.client.get_exchange_info()
for symbol_dict in info['symbols']:
# Create BinanceSymbol and store it in self.symbols, with the symbol name as the key
symbol = BinanceSymbol.from_dict(symbol_dict)
self.symbols[symbol.symbol_name] = symbol
pprint(self.symbols)
@staticmethod
def process_api_error(exception: exceptions.BinanceAPIException) -> APIError:
"""
Returns a more specific API exception class for the given BinanceAPIException, if available.
:param exception: A BinanceAPIException instance.
:return: Instance of an appropriate subclass of APIError, if available, else an instance of APIError.
"""
if 'MIN_NOTIONAL' in exception.message:
return OrderValueTooLow(message=exception.message)
else:
return APIError(message=exception.message)
def get_symbol_info(self, symbol: str) -> BinanceSymbol:
"""
Checks that the provided symbol is listed on the exchange.
:param symbol: Symbol to check.
:return: BinanceSymbol for the requested symbol name.
:raises UnknownSymbol: When symbol is not listed.
"""
symbol_info = self.symbols.get(symbol, None)
if not symbol_info:
raise UnknownSymbol(f"Unknown symbol \"{symbol:s}\"")
return symbol_info
def check_price(self, symbol: str, price: Decimal) -> Decimal:
"""
Checks that the provided price is valid for the provided symbol.
:param symbol: Symbol to check.
:param price: Price to check.
:return: Price, rounded to the correct step size.
:raises OrderPriceInvalid: When price is not valid.
"""
symbol_info = self.get_symbol_info(symbol)
# Check min/max bounds
if price < symbol_info.min_price:
raise OrderPriceInvalid(
f"Price {price} for symbol {symbol} is less than allowed minimum of {symbol_info.min_price}")
elif price > symbol_info.max_price:
raise OrderPriceInvalid(
f"Price {price} for symbol {symbol} is greater than allowed maximum of {symbol_info.max_price}")
# Constrain to step size and check rounding
rounded = price.quantize(symbol_info.price_step)
rounding_error = abs(rounded - price) / price
if rounding_error >= settings.TRADING_MAXIMUM_ROUNDING_ERROR:
raise ExcessiveRoundingError(
f"Rounding {price} to price step {symbol_info.price_step} for symbol {symbol} would cause"
"rounding error of {rounding_error:.1%}, which is larger than the allowed rounding error of "
"{settings.TRADING_MAXIMUM_ROUNDING_ERROR:.1%}")
else:
return rounded
def check_quantity(self, symbol: str, quantity: Decimal) -> Decimal:
"""
Checks that the provided quantity is valid for the provided symbol.
:param symbol: Symbol to check.
:param quantity: Quantity to check.
:return: Quantity, rounded to the correct step size.
:raises LotSizeInvalid: When quantity is not valid.
"""
symbol_info = self.get_symbol_info(symbol)
# Check min/max bounds
if quantity < symbol_info.min_quantity:
raise LotSizeInvalid(
f"Quantity {quantity} of symbol {symbol} is less than allowed minimum of {symbol_info.min_quantity}")
elif quantity > symbol_info.max_quantity:
raise LotSizeInvalid(
f"Quantity {quantity} of symbol {symbol} is greater than allowed maximum of {symbol_info.max_quantity}")
# Constrain to step size and check rounding
rounded = quantity.quantize(symbol_info.quantity_step)
rounding_error = abs(rounded - quantity) / quantity
if rounding_error >= settings.TRADING_MAXIMUM_ROUNDING_ERROR:
raise ExcessiveRoundingError(
f"Rounding {quantity} to quantity step {symbol_info.quantity_step} for symbol {symbol} would cause"
"rounding error of {rounding_error:.1%}, which is larger than the allowed rounding error of "
"{settings.TRADING_MAXIMUM_ROUNDING_ERROR:.1%}")
else:
return rounded
def get_last_price(self, symbol: str) -> Decimal:
try:
ticker = self.client.get_ticker(symbol=symbol)
return Decimal(ticker['lastPrice'])
except exceptions.BinanceAPIException as e:
raise self.process_api_error(e) from e
def get_bid_price(self, symbol: str) -> Decimal:
try:
ticker = self.client.get_ticker(symbol=symbol)
return Decimal(ticker['bidPrice'])
except exceptions.BinanceAPIException as e:
raise self.process_api_error(e) from e
def get_ask_price(self, symbol: str) -> Decimal:
try:
ticker = self.client.get_ticker(symbol=symbol)
return Decimal(ticker['askPrice'])
except exceptions.BinanceAPIException as e:
raise self.process_api_error(e) from e
def get_order_status(self, symbol: str, order_id: str, last_state: OrderState) -> ExchangeOrderStatus:
try:
response = self.client.get_order(symbol=symbol, orderId=order_id)
status = ExchangeOrderStatus()
status.price = Decimal(response['price'])
status.quantity = Decimal(response['origQty'])
status.quantity_filled = Decimal(response['executedQty'])
response_status = response['status']
if response_status == 'NEW':
status.status = OrderState.PLACED
elif response_status == 'PARTIALLY_FILLED':
status.status = OrderState.FILLING
elif response_status == 'FILLED':
status.status = OrderState.COMPLETED
elif response_status == 'CANCELED' or response_status == 'EXPIRED':
if last_state == OrderState.FILLING:
status.status = OrderState.CANCELLED_PARTIAL
else:
status.status = OrderState.CANCELLED
elif response_status == 'PENDING_CANCEL':
status.status = last_state
elif response_status == 'REJECTED':
status.status = OrderState.CANCELLED
else:
raise APIError(f"Unknown response status {response_status:s}")
return status
except exceptions.BinanceAPIException as e:
raise self.process_api_error(e) from e
def place_buy_limit_order(self, symbol: str, quantity: Decimal, price: Decimal, test: bool = False) -> str:
# Check and round parameters
price = self.check_price(symbol, price)
quantity = self.check_quantity(symbol, quantity)
try:
if test:
self.client.create_test_order(symbol=symbol, quantity=quantity, price=str(price),
side=enums.SIDE_BUY, type=enums.ORDER_TYPE_LIMIT,
timeInForce=enums.TIME_IN_FORCE_GTC)
return ""
else:
return self.client.order_limit_buy(symbol=symbol, quantity=quantity, price=str(price))['orderId']
except exceptions.BinanceAPIException as e:
raise self.process_api_error(e) from e
def place_buy_market_order(self, symbol: str, quantity: Decimal, test: bool = False) -> str:
# Check and round parameters
quantity = self.check_quantity(symbol, quantity)
try:
if test:
self.client.create_test_order(symbol=symbol, quantity=quantity,
side=enums.SIDE_BUY, type=enums.ORDER_TYPE_MARKET,
timeInForce=enums.TIME_IN_FORCE_GTC)
return ""
else:
return self.client.order_market_buy(symbol=symbol, quantity=quantity)['orderId']
except exceptions.BinanceAPIException as e:
raise self.process_api_error(e) from e
def place_sell_limit_order(self, symbol: str, quantity: Decimal, price: Decimal, test: bool = False) -> str:
# Check and round parameters
price = self.check_price(symbol, price)
quantity = self.check_quantity(symbol, quantity)
try:
if test:
self.client.create_test_order(symbol=symbol, quantity=quantity, price=str(price),
side=enums.SIDE_SELL, type=enums.ORDER_TYPE_LIMIT,
timeInForce=enums.TIME_IN_FORCE_GTC)
return ""
else:
return self.client.order_limit_sell(symbol=symbol, quantity=quantity, price=str(price))['orderId']
except exceptions.BinanceAPIException as e:
raise self.process_api_error(e) from e
def place_sell_market_order(self, symbol: str, quantity: Decimal, test: bool = False) -> str:
# Check and round parameters
quantity = self.check_quantity(symbol, quantity)
try:
if test:
self.client.create_test_order(symbol=symbol, quantity=quantity,
side=enums.SIDE_SELL, type=enums.ORDER_TYPE_MARKET,
timeInForce=enums.TIME_IN_FORCE_GTC)
return ""
else:
return self.client.order_market_sell(symbol=symbol, quantity=quantity)['orderId']
except exceptions.BinanceAPIException as e:
raise self.process_api_error(e) from e
def cancel_order(self, symbol: str, order_id: str) -> None:
try:
self.client.cancel_order(symbol=symbol, orderId=order_id)
except exceptions.BinanceAPIException as e:
raise self.process_api_error(e) from e
def get_balance(self, asset: str) -> Decimal:
try:
response = self.client.get_asset_balance(asset)
return Decimal(response['free'])
except exceptions.BinanceAPIException as e:
raise self.process_api_error(e) from e
for origin_jump in range(1, 5):
for second_jump in range(1, 5):
drop = 2
result[str(trading_algo(
origin_jump, second_jump, drop,
.5))] = "%d %d %d %d" % (origin_jump, second_jump, drop, .5)
for key in sorted(result.iterkeys()):
print key + " " + result[key]
#pprint(account.get_positions)
#pprint(account.get_balance())
#place a test market buy order, to place an actual order use the create_order function
order = client.create_test_order(symbol='ICXETH',
side=Client.SIDE_SELL,
type=Client.ORDER_TYPE_MARKET,
quantity=2)
#
# # get market depth
# depth = client.get_order_book(symbol='BNBBTC')
#
# # place a test market buy order, to place an actual order use the create_order function
# order = client.create_test_order(
# symbol='BNBBTC',
# side=Client.SIDE_BUY,
# type=Client.ORDER_TYPE_MARKET,
# quantity=100)
#
# # get all symbol prices
# prices = client.get_all_tickers()
def main():
arg = docopt(__doc__, version=version)
api_key = getenv('BINANCE_FUTURES_API')
sec_key = getenv('BINANCE_FUTURES_SEC')
if not api_key and not sec_key:
print('please set these environment variables:\n'\
' BINANCE_FUTURES_API\n'\
' BINANCE_FUTURES_SEC', file=stderr)
return 1
if not api_key:
print('environment variable not found: BINANCE_FUTURES_API',
file=stderr)
return 1
if not sec_key:
print('environment variable not found: BINANCE_FUTURES_SEC',
file=stderr)
return 1
client = Client(api_key, sec_key)
sides = {
'buy': Client.SIDE_BUY,
'long': Client.SIDE_BUY,
'sell': Client.SIDE_SELL,
'short': Client.SIDE_SELL,
}
types = {
'limit': Client.ORDER_TYPE_LIMIT,
'market': Client.ORDER_TYPE_MARKET
}
tifs = {
'gtc': Client.TIME_IN_FORCE_GTC,
'ioc': Client.TIME_IN_FORCE_IOC,
'fok': Client.TIME_IN_FORCE_FOK
}
if arg['--verbose']:
print(arg, file=stderr)
else:
sys.tracebacklimit = 0
if arg['--help']:
print(__doc__, file=stderr)
return 0
elif arg['status']:
return client.get_system_status()['status']
elif arg['balance']:
if arg['futures']:
print(dumps(client.futures_account_balance()))
elif arg['spot']:
print(dumps(client.get_account()['balances']))
elif arg['coin']:
print(dumps(client.futures_coin_account_balance()))
return 0
elif arg['show']:
if arg['spot']:
if arg['orders']:
# if arg['--all']:
# print(dumps(client.get_all_orders()))
# else:
print(dumps(client.get_open_orders()))
elif arg['order']:
symbol = arg['<symbol>'].upper()
if arg['futures'] and not symbol.endswith('USDT'):
symbol += 'USDT'
if arg['cancel']:
if arg['futures']:
print(
client.futures_cancel_order(symbol=symbol,
orderid=arg['<orderid>'],
timestamp=timemilli()))
elif arg['spot']:
print('not implemented', file=stderr)
else: # create order
tif = tifs[arg['--tif']]
if arg['<side>'].strip().lower() in sides:
side = sides[arg['<side>'].strip().lower()]
else: # side is wrong
print('error: side should be either "buy|long" or "sell|short"'\
' not', arg['side'], file=stderr)
quantity = float(arg['<quantity>'])
if arg['--limit']:
if arg['--limit']:
price = float(arg['--limit'])
type_ = types['limit']
if arg['--test']:
print(
client.create_test_order(symbol=symbol,
side=side,
quantity=quantity,
price=price,
timeInForce=tif,
type=type_))
else: # actually send the order
if arg['futures']:
print(
client.futures_create_order(
symbol=symbol,
side=side,
quantity=quantity,
price=price,
timeInForce=tif,
reduceOnly=arg['--reduce-only'],
timestamp=timemilli(),
type=type_))
elif arg['spot']:
print(
client.create_order(symbol=symbol,
side=side,
quantity=quantity,
price=price,
timeInForce=tif,
type=type_))
else: # limit given but price not
print('please provide --limit \033[33m<price>\033[0m.')
elif arg['--market']:
type_ = types['market']
if arg['--test']:
print(
client.create_test_order(symbol=symbol,
side=side,
quantity=quantity,
type=type_))
else: # actually send the order
if arg['futures']:
print(
client.futures_create_order(
symbol=symbol,
side=side,
quantity=quantity,
timestamp=timemilli(),
reduceOnly=arg['--reduce-only'],
type=type_))
elif arg['spot']:
print(
client.create_order(symbol=symbol,
side=side,
quantity=quantity,
price=price,
type=type_))
else: # limit or market not given
print('please provide either '\
'\033[33m --limit <price>\033[0m '\
'or \033[33m--market\033[0m', file=stderr)
else: # no arguments given
print(__doc__, file=stderr)
return 1
class Manualbot:
def __init__(self, args):
self.buy_mode = True
self.args = args
self.target_profits = [50, 30, 20]
self.targets_reached = [False, False, False]
self.stoploss_reached = False
config = ConfigParser()
config.read("config.ini")
self.config = config
def run(self):
self.client = Client(api_key=self.config['BINANCE']['KEY'],
api_secret=self.config['BINANCE']['SECRET'])
if self.args.mode == "trading":
logger.info(
"START TRADE | symbol: {}, btc amount: {}, targets: {}, stoploss price: {}, trailing: {}, trailing price: {}"
.format(self.args.symbol, self.args.btc_amount,
self.args.targets, self.args.immediate_stoploss,
self.args.use_trailing, self.args.trailing_stoploss))
bm = BinanceSocketManager(self.client)
self.conn_key = bm.start_symbol_ticker_socket(
self.args.symbol, self.process_message)
bm.start()
elif self.args.mode == "analysis":
alltickers = self.client.get_ticker()
interval = "1h"
exchange = ccxt.binance({
'apiKey': self.config['BINANCE']['KEY'],
'secret': self.config['BINANCE']['SECRET']
})
for ticker in alltickers:
if float(ticker['priceChangePercent']) > 2 and (
"BTC" in ticker['symbol']):
data_base = exchange.fetch_ohlcv(
ticker['symbol'].split("BTC")[0] + "/BTC",
interval,
limit=100)
df = pd.DataFrame(data_base,
columns=[
'date', 'open', 'high', 'low',
'close', 'volume'
])
df["date"] = pd.to_datetime(
df["date"], unit='ms').dt.strftime('%Y-%m-%d %H:%M')
self.save_analysis(df, ticker['symbol'], interval,
ticker['priceChangePercent'])
elif self.args.mode == "hamster":
mongo_client = MongoClient('mongodb://localhost:27017/')
db = mongo_client.projectlife
self.previous_response = "initial"
timeout = 30
exchanges = dict()
exchanges['binance'] = ccxt.binance({
'apiKey':
self.config['BINANCE']['KEY'],
'secret':
self.config['BINANCE']['SECRET']
})
exchanges['kucoin'] = ccxt.kucoin({
'apiKey':
self.config['KUCOIN']['KEY'],
'secret':
self.config['KUCOIN']['SECRET']
})
exchanges['bittrex'] = ccxt.bittrex({
'apiKey':
self.config['BITTREX']['KEY'],
'secret':
self.config['BITTREX']['SECRET']
})
exchanges['poloniex'] = ccxt.poloniex()
def doWork():
responses = []
try:
url = 'https://www.mininghamster.com/api/v2/' + self.config[
'HAMSTER']['API']
responses = requests.get(url).json()
if len(responses) > 0:
for response in responses:
symbol = response['market'].split(
"BTC-")[1] + "/BTC"
bid, ask = self.get_prices(
exchanges[response['exchange']], symbol)
if response['signalmode'] == "buy":
result_buy = db.hamster.find_one({
"signalID":
response['signalID'],
"signalmode":
"buy"
})
if result_buy == None:
response['buy_price'] = ask
db.hamster.insert_one(response)
self.send_telegram(str(response))
elif response['signalmode'] == "sell":
result_sell = db.hamster.find_one({
"signalID":
response['signalID'],
"signalmode":
"sell"
})
if result_sell == None:
result_buy = db.hamster.find_one({
"signalID":
response['signalID'],
"signalmode":
"buy"
})
if result_buy != None:
response['sell_price'] = bid
response['profit'] = self.pct_change(
result_buy['buy_price'], bid)
db.hamster.insert_one(response)
self.send_telegram(str(response))
except BaseException as e:
print(e)
pass
lx = task.LoopingCall(doWork)
lx.start(timeout)
reactor.run()
elif self.args.mode == "datacollect":
client = MongoClient('mongodb://localhost:27017/')
db = client.projectlife
self.db_collection = db[self.args.symbol]
bm = BinanceSocketManager(self.client)
self.conn_key = bm.start_symbol_ticker_socket(
self.args.symbol, self.process_datacollect_message)
bm.start()
def get_prices(self, exchange, symbol):
orderbook = exchange.fetch_order_book(symbol)
bid = orderbook['bids'][0][0] if len(orderbook['bids']) > 0 else None
ask = orderbook['asks'][0][0] if len(orderbook['asks']) > 0 else None
return bid, ask
def pct_change(self, first, second):
diff = second - first
change = 0
try:
if diff > 0:
change = (diff / first) * 100
elif diff < 0:
diff = first - second
change = -((diff / first) * 100)
except ZeroDivisionError:
return float('inf')
return change
def create_order(self, symbol, side, type, quantity, price, actual_type):
try:
order = self.client.create_test_order(symbol=symbol,
side=side,
type=type,
timeInForce='GTC',
quantity=quantity,
price=price)
print(order)
if order == {}:
#if order["status"] == "NEW":
log = "{} ORDER FILLED | symbol: {}, type: {}, quantity: {}, price: {}, actual_type: {}".format(
side, symbol, type, str(quantity), price, actual_type)
logger.info(log)
self.send_telegram(log)
return True
else:
log = "{} ORDER NOT FILLED | symbol: {}, type: {}, quantity: {}, price: {}, actual_type: {}".format(
side, symbol, type, str(quantity), price, actual_type)
logger.info(log)
self.send_telegram(log)
return False
except BaseException as e:
log = 'Error occured when creating order: ' + str(e)
logger.error(log)
self.send_telegram(log)
return False
def send_telegram(self, msg):
bot = telegram.Bot(token=self.config['TELEGRAM']['KEY'])
bot.sendMessage(chat_id=self.config['TELEGRAM']['CHATID'], text=msg)
def save_analysis(self, df, symbol, interval, percentchange):
last_date = df.iloc[-1].date
df["date"] = df.index.values
plt.cla()
fig, ax = plt.subplots(figsize=(16, 16))
candlestick_ohlc(ax,
df.values,
width=0.6,
colorup='green',
colordown='red')
df['sma5'] = talib.SMA(df['close'], 5)
df['sma8'] = talib.SMA(df['close'], 8)
df['sma13'] = talib.SMA(df['close'], 13)
plt.plot(df.index, df.sma5, color="orange")
plt.plot(df.index, df.sma8, color="blue")
plt.plot(df.index, df.sma13, color="red")
fig.suptitle(symbol + "-" + interval)
fn = "/Users/apple/Desktop/dev/projectlife/data/images/analysis/" + symbol + "-" + percentchange + "%-" + interval + "-" + last_date + ".png"
plt.savefig(fn, dpi=100)
def stop_trading(self):
bm = BinanceSocketManager(self.client)
bm.stop_socket(self.conn_key)
bm.close()
reactor.stop()
def process_message(self, msg):
if msg['e'] == 'error':
print("error on websocket. Restarting")
bm.stop_socket(self.conn_key)
bm.start()
else:
if self.buy_mode == True:
ask_price = msg['a']
self.buy_quantity = int(self.args.btc_amount /
float(ask_price))
self.latest_quantity = self.buy_quantity
response = self.create_order(self.args.symbol, "BUY", 'LIMIT',
self.buy_quantity, ask_price,
"IMMEDIATE BUY")
if response == True:
self.buy_mode = False
else:
bid_price = float(msg['b'])
trl_stoploss_price = bid_price - self.args.trailing_stoploss
imm_stoploss_price = self.args.immediate_stoploss
if imm_stoploss_price >= bid_price:
imm_stoploss_price = "{:.8f}".format(bid_price)
response = self.create_order(self.args.symbol, "SELL",
'LIMIT', self.latest_quantity,
imm_stoploss_price,
"IMMEDIATE STOPLOSS")
if response == True:
self.stop_trading()
if (trl_stoploss_price >= bid_price
and self.args.use_trailing == True
and self.targets_reached[0] == True):
trl_stoploss_price = "{:.8f}".format(bid_price)
response = self.create_order(self.args.symbol, "SELL",
'LIMIT', self.latest_quantity,
trl_stoploss_price,
"TRAILING STOPLOSS")
if response == True:
self.stop_trading()
for index, target_price in enumerate(self.args.targets):
target_quantity = int(
(self.buy_quantity * self.target_profits[index]) / 100)
if bid_price >= target_price and self.targets_reached[
index] == False:
target_price = "{:.8f}".format(target_price)
response = self.create_order(
self.args.symbol, "SELL", 'LIMIT', target_quantity,
target_price,
"TAKE PROFIT TARGET " + str(index + 1))
if response == True:
self.targets_reached[index] = True
self.latest_quantity = self.latest_quantity - target_quantity
break
if False not in self.targets_reached:
self.stop_trading()
class Binance_Connector:
def __init__(self, mode='test', symbol='BTCUSDT'):
self.mode = mode
self.symbol = symbol
self.binance_client = Client
self.precision = 8 # TODO get from binance_client.get_symbol_info('BTCUSDT')
self.step_size = 0.00000100 # TODO get from binance_client.get_symbol_info('BTCUSDT') LOT_SIZE
assert mode in [
'PROD', 'test', 'sim'
], 'mode should be PROD, test or sim' # TODO pasar a un exception general
self.base_asset = 'BTC' #TODO get from get_symbol_info
self.quoted_asset = 'USDT' #TODO get from get_symbol_info
def init_client(self):
with open('secrets/binance.secrets', 'r') as f:
secrets = json.loads(f.read())
status = False
while not status:
try:
self.binance_client = Client(api_key=secrets['api_key'],
api_secret=secrets['api_secret'])
status = True
except requests.exceptions.Timeout:
logging.info('init_client: Connection TimeOut')
time.sleep(60)
return self
def buy(self, percentage_trade=0.5):
if self.mode in ['PROD', 'test']:
logging.info('env buy: Buying')
self.init_client()
account = self.binance_client.get_account()
balance = float(account['balances'][np.argmax([
x['asset'] == self.quoted_asset for x in account['balances']
])]['free'])
logging.info('env buy: {} balance: {}'.format(
self.quoted_asset, balance))
depth = self.binance_client.get_order_book(symbol=self.symbol)
current_price = np.mean([float(x[0]) for x in depth['bids']])
logging.info('env buy: {} mean bids price: {}'.format(
self.symbol, current_price))
quantity = balance / current_price
logging.info('env buy: {} quantity: {}'.format(
self.symbol, quantity))
quantity_trade = np.floor(
(quantity * percentage_trade) *
10**6) / 10**6 #TODO ver esta division hardcodeada
logging.info('env buy: {} quantity to trade: {}'.format(
self.symbol, quantity_trade))
if self.mode == 'PROD':
order = self.binance_client.create_order(
symbol=self.symbol,
side=Client.SIDE_BUY,
type=Client.ORDER_TYPE_MARKET,
quantity=quantity_trade)
else:
order = self.binance_client.create_test_order(
symbol=self.symbol,
side=Client.SIDE_BUY,
type=Client.ORDER_TYPE_MARKET,
quantity=quantity_trade)
logging.info(order)
return True
else:
return False
def sell(self):
if self.mode in ['PROD', 'test']:
logging.info('env: Selling')
self.init_client()
account = self.binance_client.get_account()
quantity = float(account['balances'][np.argmax([
x['asset'] == self.base_asset for x in account['balances']
])]['free'])
quantity = np.floor(
quantity * 10**6) / 10**6 #TODO ver esta division hardcodeada
logging.info('env sell: {} quantity: {}'.format(
self.symbol, quantity))
if self.mode == 'PROD':
order = self.binance_client.create_order(
symbol=self.symbol,
side=Client.SIDE_SELL,
type=Client.ORDER_TYPE_MARKET,
quantity=quantity)
else:
order = self.binance_client.create_test_order(
symbol=self.symbol,
side=Client.SIDE_SELL,
type=Client.ORDER_TYPE_MARKET,
quantity=quantity)
logging.info(order)
return True
else:
return False
def get_current_price(self):
self.init_client()
depth = self.binance_client.get_order_book(symbol=self.symbol)
return np.mean([float(x[0]) for x in depth['bids']])
class Binance:
def __init__(self, api_key, api_secret):
self.client = Client(api_key, api_secret)
def get_candle(self, symbol, interval, start, end='now'):
# interval: eg:'1d','1h','30m' (str)
# start: start time (str)
# end: end time (str)
# default to now
client = Client("", "")
try:
klines = client.get_historical_klines(symbol, interval, start, end)
except BinanceAPIException as e:
print(e.message)
return
self.klines = klines
return klines
def format_candle(self):
df = pd.DataFrame(self.klines)
df.columns = [
'Open time', 'Open', 'High', 'Low', 'Close', 'BaseAsset Volume',
'Close time', 'QuoteAsset Volume', 'Number of trades',
'Taker buy baseAsset volume', 'Taker buy quoteAsset volume',
'Ignore'
]
df['Open time'] = pd.to_datetime(df['Open time'], unit='ms')
df['Close time'] = pd.to_datetime(df['Close time'], unit='ms')
closetime = df.pop('Close time')
df.insert(1, closetime.name, closetime)
df.pop('Ignore')
df.to_csv('section1/task2/CandleData.csv', index=0)
return
def get_transactions(self, symbol, number=500):
# number: # of trades wish to check (int)
# default:500 max:500
# most recent trades show first
client = Client("", "")
try:
trades = client.get_recent_trades(symbol=symbol, limit=number)
except BinanceAPIException as e:
print(e.message)
return
self.trades = trades
return trades
def format_trade(self):
df = pd.DataFrame(self.trades)
df.pop('id')
time = df.pop('time')
df.insert(0, time.name, time)
df = df.sort_values(by='time', ascending=False)
df['time'] = pd.to_datetime(df['time'], unit='ms')
df.to_csv('section1/task2/TradesData.csv', index=0)
return
def get_marketdepth(self, symbol, number=100):
# number: # wish to check (int)
# default:100 max:1000
client = Client("", "")
try:
depth = client.get_order_book(symbol=symbol, limit=number)
except BinanceAPIException as e:
print(e.message)
return
self.depth = depth
return depth
def formant_depth(self):
data = self.depth
bids, asks = pd.DataFrame(data['bids']), pd.DataFrame(data['asks'])
bids.columns, asks.columns = ['Bids Price',
'Bids Qty'], ['Ask Price', 'Ask Qty']
df = pd.concat([bids, asks], axis=1)
df.to_csv('section1/task2/MarketDepth.csv', index=0)
return
def test_order(self, symbol, action, type, **kwargs):
# action: SELL or BUY (str)
# type: LIMIT, MARKET, STOP_LOSS, STOP_LOSS_LIMIT, TAKE_PROFIT, TAKE_PROFIT_LIMIT, LIMIT_MAKER (str)
# timeInForce: GTC, IOC, FOK (str)
# quantity: (int)
# price: (str)
# quoteOrderQty: (int)
# newClientOrderId (str) – A unique id for the order. Automatically generated if not sent.
# icebergQty (decimal) – Used with iceberg orders
# newOrderRespType (str) – Set the response JSON. ACK, RESULT, or FULL; default: RESULT.
# recvWindow (int) – The number of milliseconds the request is valid for
# stopPrice: (int)
# LIMIT need: timeInForce, quantity, price
# MARKET need: quantity or quoteOrderQty
# STOP_LOSS need: quantity, stopPrice
# STOP_LOSS_LIMIT need: timeInForce, quantity, price, stopPrice
# TAKE_PROFIT need: quantity, stopPrice
# TAKE_PROFIT_LIMIT need: timeInForce, quantity, price, stopPrice
# LIMIT_MAKER need: quantity, price
try:
self.client.create_test_order(symbol=symbol,
side=action,
type=type,
**kwargs)
except BinanceAPIException as e:
print(e.message)
return
def main():
itchat.auto_login()
api_key = '*****'
api_secret = '*****'
client = Client(api_key, api_secret)
loop_count = 0
triangle_count = 0
exinfo = get_exinfo(client)
# print(f"[info]exinfo:{exinfo}")
while (True):
start_time = time()
prices = get_prices(client)
# print(f"[info]prices:{prices}")
prices_time = time()
download_time = prices_time - start_time
if (download_time > 0.5):
print(f"[info]downloaded in {download_time:.4f}s, Sleep 2s...")
sleep(2)
continue
else:
print(f"[info]downloaded in: {prices_time-start_time:.4f}s")
triangles = list(find_triangles(prices))
computing_time = time()
print(f"[info]computed in: {computing_time-prices_time:.4f}s")
if triangles:
sorted(triangles, key=itemgetter('profit'), reverse=True)
triangle = triangles[0]
triangle['coins'].reverse()
coins = triangle['coins']
describe_triangle(prices, coins, triangle)
status = NORMAL
for i_coin in range(len(coins) - 1):
base_coin = coins[i_coin]
quote_coin = coins[i_coin + 1]
symb = base_coin + quote_coin
symb_info = exinfo[symb]
side = symb_info['side']
tick = symb_info['tick']
colm = symb_info['colm']
pair = symb_info['pair']
asset = 0.0
price = prices[base_coin][quote_coin]
try:
while (asset < 0.01):
asset = float(
client.get_asset_balance(asset=base_coin)['free'])
if asset < 0.01:
sleep(0.1)
else:
break
if side == 'BUY':
asset = asset * price
sprice = f"{ceiling(1.0/price, tick):.8f}"
else:
sprice = f"{price:.8f}"
quan = ceiling(asset, colm)
print(
f"[info]sym:{symb},bas:{base_coin},{side},tic:{tick},col:{colm},ass:{asset:.4f},qua:{quan},pri:{sprice}"
)
order = client.create_test_order(symbol=pair,
side=side,
type='LIMIT',
quantity=quan,
price=sprice)
# order = client.order_limit(symbol=pair, side=side, quantity=quan, price=sprice)
# order = client.order_market(symbol=pair, side=side, quantity=quan)
except Exception as ex:
print(f"[info]exception:{ex}")
print(
f"[info]break at tri_count:{triangle_count}! as symbol:{symb}"
)
status = EXCEPTION
break
if status == EXCEPTION:
print(
f"[info]tri_count #{triangle_count} failed in {time()-computing_time:.4f}s@{datetime.datetime.today()}"
)
break
else:
print(
f"[info]tri_count #{triangle_count} succeeded in {time()-computing_time:.4f}s@{datetime.datetime.today()}"
)
triangle_count = triangle_count + 1
else:
sleep(0.2)
loop_count += 1
print(f"[info]tri_count/loop_count:{triangle_count}/{loop_count}")
itchat.send('[info]exception:tri_count/loop_count:' + str(triangle_count) +
'/' + str(loop_count),
toUserName='******')
# https://github.com/sammchardy/python-binance/blob/master/docs/websockets.rst
import time
api_key = 'a89RHztsZkykoOTazLHjM9HkZHML6j8UND0fUMaa1Thk731r9FgKjcttVlhWhuRh'
api_secret = 'OYxgsFpxeefBzFUmU4UDRLcFc790CCscFgWEU8pFSOFbHkvP4JSHUWBKMtQfPyC8'
from binance.client import Client
client = Client(api_key, api_secret)
# get market depth
depth = client.get_order_book(symbol='BNBBTC')
# place a test market buy order, to place an actual order use the create_order function
order = client.create_test_order(symbol='BNBBTC',
side=Client.SIDE_BUY,
type=Client.ORDER_TYPE_MARKET,
quantity=100,
recvWindow=100000)
# get all symbol prices
prices = client.get_all_tickers()
symbol = 'BTCUSDT'
def get_asset_balance(asset):
res_dict = client.get_asset_balance(asset=asset)
if not res_dict:
return 0.0
free_num = float(res_dict.get('free', 0.0))
path = os.getcwd()
klines = client.get_historical_klines("ETHBTC", Client.KLINE_INTERVAL_30MINUTE,
"1 Dec, 2017", "1 Jan, 2018")
k = pd.DataFrame([k[:6] for k in klines],
columns=['Time', 'Open', 'High', 'Low', 'Close', 'Volume'])
k['Time'] = [dateparser.parse(str(d)) for d in k.Time]
k.sort_values(by='Time', ascending=False, inplace=True, ignore_index=True)
k.to_csv(os.path.join(path, 'candle data.csv'), index=False)
mktdepth = client.get_order_book(symbol="BNBBTC")
depth = pd.DataFrame([[b[0], b[1]] for b in mktdepth['bids']],
columns=['bids', 'bids_size'])
depth[['asks',
'asks_size']] = pd.DataFrame([[a[0], a[1]] for a in mktdepth['asks']])
depth.to_csv(os.path.join(path, 'orderbook.csv'), index=False)
trade = client.get_recent_trades(symbol='BNBBTC')
trades = pd.DataFrame(trade)
trades = trades[['id', 'price', 'qty', 'time']]
trades['time'] = [dateparser.parse(str(d)) for d in trades.time]
trades.sort_values(by='time', ascending=False, inplace=True, ignore_index=True)
trades.to_csv(os.path.join(path, 'trade data.csv'), index=False)
client = Client(api_key=api_key, api_secret=api_secret)
order = client.create_test_order(symbol='ETHBTC',
side=Client.SIDE_BUY,
type=Client.ORDER_TYPE_MARKET,
quantity=100)
order
API_KEY = "i1s87G06vlhZTdKy7z3V0IRRKujhvps4umFTELYqre3awoeD4ZKpzWsCm8O3HklK"
API_SECRET = "mpZGQfH0SraheOvbJZMANJCWapD5xDo0HfbapGGmjm3YCXxsvrFj4a5zVxNOqdoP"
NUM_THREADS = 100
def truncate(f, n):
# Truncates/pads a float f to n decimal places without rounding
s = '{}'.format(f)
if 'e' in s or 'E' in s:
return '{0:.{1}f}'.format(f, n)
i, p, d = s.partition('.')
return '.'.join([i, (d + '0' * n)[:n]])
client = Client(API_KEY, API_SECRET, {"timeout": 60})
price = 0.001655552113213123
price = "%.4g" % price
newPrice = '{:.8f}'.format(float(price))
print(newPrice)
print("BUYING BTGBTC AT {0}", newPrice)
secondOrder = client.create_test_order(symbol="BTGBTC",
side=Client.SIDE_BUY,
type=ORDER_TYPE_LIMIT,
timeInForce=TIME_IN_FORCE_GTC,
quantity=1000,
price=newPrice)
class trade_realtime():
def __init__(self, api_key, api_secret, total_list=None):
self.coin_list = total_list
self.api_key = api_key
self.api_secret = api_secret
self.client = Client(api_key, api_secret)
def get_time(self):
server_time = self.client.get_server_time()
# {
# "serverTime": 1499827319559
# }
return int(server_time['serverTime'])
def get_exchange_status(self):
return self.client.get_system_status()
def get_coin_price(self, coin_list):
# kwargs = {'data': coin}
output_data = []
for coin in coin_list:
price_d = ast.literal_eval(
json.dumps(self.client.get_symbol_ticker(symbol=coin)))
print(price_d)
price = float(price_d['price'])
output_data.append(price)
return output_data
def get_trade(self, start, end):
output_data = []
for coin in self.coin_list:
output_data.append(
self.client.get_aggregate_trades(symbol=coin,
startTime=start,
endTime=end))
return output_data
def get_kline(self, start, end):
output_data = []
for coin in self.coin_list:
output_data.append(
self.client.get_klines(symbol=coin,
interval=Client.KLINE_INTERVAL_5MINUTE,
limit=500,
startTime=start,
endTime=end))
return output_data
def get_historical_klines(self, symbol, interval, start, end):
# init our list
output_data = []
# setup the max limit
limit = 500
timeframe = interval_to_milliseconds(interval)
start_ts = start
idx = 0
# it can be difficult to know when a symbol was listed on Binance so allow start time to be before list date
symbol_existed = False
while True:
# fetch the klines from start_ts up to max 500 entries or the end_ts if set
temp_data = self.client.get_klines(symbol=symbol,
interval=interval,
limit=limit,
startTime=start_ts,
endTime=end)
# handle the case where our start date is before the symbol pair listed on Binance
if not symbol_existed and len(temp_data):
symbol_existed = True
if symbol_existed:
# append this loops data to our output data
output_data += temp_data
# update our start timestamp using the last value in the array and add the interval timeframe
start_ts = temp_data[len(temp_data) - 1][0] + timeframe
else:
# it wasn't listed yet, increment our start date
start_ts += timeframe
idx += 1
# check if we received less than the required limit and exit the loop
if len(temp_data) < limit:
# exit the while loop
break
# sleep after every 3rd call to be kind to the API
if idx % 3 == 0:
time.sleep(1)
return output_data
def get_orderbook_ticker(self):
pass
def order_limit_buy(self, **params):
return self.client.order_limit_buy(**params)
def order_limit_sell(self, **params):
return self.client.order_limit_sell(**params)
def order_market_sell(self, **params):
return self.client.order_market_sell(**params)
def order_market_buy(self, **params):
return self.client.order_market_buy(**params)
def get_open_orders(self, **params):
return self.client.get_open_orders(**params)
def create_test_order(self, **params):
self.client.create_test_order()
def get_order(self, **params):
self.client.get_order(self, **params)
def get_all_orders(self, **params):
self.client.get_all_orders(self, **params)
def cancel_order(self, **params):
self.client.cancel_order(self, **params)
def get_account(self, **params):
return (self.client.get_account(recvWindow=self.get_time()))
def get_asset_balance(self, asset, **params):
bal = self.client.get_asset_balance(asset=asset,
recvWindow=self.get_time())
return ast.literal_eval(json.dumps(bal))['free']
def start_trade():
pass
def get_kline_lag_time(self, coin, lookback_in_ms):
# lookback = 2*60*1000 #5mins
# rt.pred_coin_list=[coin]
end_ts = self.get_time()
# calendar.timegm(time.gmtime()) -lookback
start_ts = end_ts - lookback_in_ms
# print("start=",start_ts)
# print("end=",end_ts)
f = self.get_historical_klines(symbol=coin,
interval=Client.KLINE_INTERVAL_30MINUTE,
end=end_ts,
start=start_ts)
f = ast.literal_eval(json.dumps(f))
return f
def getState(self, coin_list):
features = np.empty((LOOK_BACK, 0), float)
coin_f_index = [2, 3, 4, 5, 7]
for coin in coin_list:
coin_f = np.array(self.get_kline_lag_time(coin, LOOK_BACK_IN_MS),
dtype=np.float).reshape(-1, 12)
coin_f = coin_f[coin_f.shape[0] - LOOK_BACK:, coin_f_index]
if (coin_f.shape[0] < 10):
print("something is wrong with binance api,return shape=",
coin_f.shape)
return
#print("coin_f shape ",coin_f.shape)
#print("features shape ",features.shape)
# COIN_FEATURE = np.concatenate((COIN_FEATURE, tmp), axis=0)
features = np.hstack((features, coin_f))
# features = self.create_input(features,LOOK_BACK)
# DF_FEATURES
#reshape for tensorflow backend
features = features.reshape(1, DF_FEATURES, 1, LOOK_BACK)
print("create_predictive_input, features shape ", features.shape)
# print("kline shape after modify",features.shape)
# features = self.create_input(features ,LOOK_BACK)
return features