def checkArbitrage(token):
""" usdt -> eth -> token -> btc -> usdt
returns the one to one value of your investment after running through the trades outlined above
if the value is greater than one then there is profit to be made through arbitrage
"""
return 1/float(binance.prices()['ETHUSDT'])*FEE*1/float(binance.prices()[token+'ETH'])*FEE*float(binance.prices()[token+'BTC'])*FEE*float(binance.prices()['BTCUSDT'])
def sellPump(boughtPrice):
# big function
data = []
data.append(float(binance.prices()[symbol]))
for num in range(constants.MAXTIME):
if num == 0:
continue
data.append(float(binance.prices()[symbol]))
if calculateProfit(data[num], boughtPrice) >= constants.IDEALPROFIT:
binance.order(symbol,
binance.SELL,
(btcBalance * constants.PERCENT) / boughtPrice,
data[num] * 0.98,
binance.LIMIT,
binance.GTC,
test=True)
break
# other stuff
time.sleep(1)
success = 'success' if len(data) < constants.MAXTIME else 'fail'
print(success)
currentPrice = binance.prices()[symbol]
# check after a minute
return
def gbp_to_base(gbp, symbol):
"""
50GBP => OMG
50GBP => USD
USD => BTC
BTC => OMG
"""
usd = gbp * CURRENCY.get_rate("GBP", "USD")
btc = usd * float(binance.prices()["BTCUSDT"])
omg = btc * float(binance.prices()[symbol + "BTC"])
return format(omg, ".20f")
def main():
"""
Main method
"""
if sys.argv[1] == "--help":
print("Usage: {} <pair> <side>".format(sys.argv[0]))
sys.exit(0)
if len(sys.argv) < 3:
print("Usage: {} <pair> <side>".format(sys.argv[0]))
sys.exit(1)
pair = sys.argv[1]
side = sys.argv[2]
base_amount = 3000
account = config.accounts.binance[0]
binance_auth(account)
base = get_base(pair)
if side == 'OPEN':
result = binance.margin_borrow(base, base_amount)
print("Borrow result: {}".format(result))
quote_amount = 100/float(binance.prices()[pair])
precise_amount = get_step_precision(pair, quote_amount)
result = binance.margin_order(symbol=pair, side='BUY', quantity=precise_amount,
orderType=binance.MARKET)
print("Buy result: {}".format(result))
elif side == 'CLOSE':
result = binance.margin_order(symbol=pair, side='SELL', quantity=precise_amount,
orderType=binance.MARKET)
print("Sell result: {}".format(result))
result = binance.margin_repay(base, base_amount)
print("Repay result: {}".format(result))
else:
print('Unknown side: {}'.format(side))
def testforNumberErrors():
list = binance.balances()
for sym in list:
if (sym == "USDT" or sym == "BTC"): continue
sym = sym + "BTC"
pof = float(binance.prices()[sym])
if (btcBalance < pof):
are = float(
main.calcAmountNeeded(pof, btcBalance, constants.PERCENT))
are = des(are, TRUNCATE, 3, DECIMAL_PLACES)
else:
are = int(main.calcAmountNeeded(pof, btcBalance,
constants.PERCENT))
try:
pof = des(pof, TRUNCATE, 8, DECIMAL_PLACES)
binance.order(sym,
binance.BUY,
are,
pof,
binance.LIMIT,
binance.GTC,
test=True)
except Exception as e:
print(e)
print(sym)
finally:
time.sleep(1)
print(sym)
return
def get_balances():
balances = binance.balances()
prices = binance.prices()
epoch = time.time()
data_balances = {"balances": balances, "date": epoch}
data_prices = {"prices": prices, "date": epoch}
balancesCollection.insert_one(data_balances)
pricesCollection.insert_one(data_prices)
print("inserted data")
def update_prices(coins):
prices = binance.prices()
for c in coins:
price = prices.get(c.name)
c.add_price(price)
# Coins have their own average function
c.sma()
# Changes average out of scientific notation
printaverage="{0:0.8f}".format(c.average)
print("Coin: {}, SMA: {}, Current Price: {}".format(c.name, printaverage, price))
def profit_calculator(market_type):
try:
for error in b.myTrades(market_type):
if error == "msg":
if "ETH" not in market_type:
market_type.replace("BTC", "ETH")
else:
market_type.replace("ETH", "BTC")
trade_data = b.myTrades(market_type)
#trade_data return example
#[{u'orderId': 46584195, u'isBuyer': True, u'price': u'0.00000927', u'isMaker': True, u'qty': u'900.00000000', u'commission': u'0.90000000', u'time': 1525044165320, u'commissionAsset': u'TRX', u'id': 25242895, u'isBestMatch': True}]
index = 0
total_bought_revenue = float(0)
total_bought_qty = float(0)
bought_price = float(0)
while len(trade_data) > index:
if trade_data[index]["isBuyer"] == True and int(
trade_data[index]['time']) >= trade_after_this_date:
bought_price = float(trade_data[index]["price"])
if trade_data[index]["isMaker"] == True and int(
trade_data[index]['time']) >= trade_after_this_date:
bought_price = -float(trade_data[index]["price"])
bought_qty = float(trade_data[index]["qty"])
total_bought_qty += bought_qty
bought_revenue = bought_price * bought_qty
total_bought_revenue += bought_revenue
index += 1
avg_bought_price = (total_bought_revenue / total_bought_qty) * float(
1.02) #0.02 is for comission
if avg_bought_price >= float(0.000001):
avg_bought_price = float(0)
#getting price for specific coin
current_price = float(b.prices()[market_type])
#calculating profit is percentage
profit = ((current_price / avg_bought_price) - 1) * 100
# print "%s profit is "%market_type + str(profit) +str(" %")
if market_type not in summary:
summary.append(market_type)
if profit not in profit_list: #problem : this makes error if prices changes very quickly!
profit_list.append(profit)
return market_type, profit
except ZeroDivisionError as Zero_Division_Error:
return str("Try_different_market")
def main():
""" Main function """
if len(sys.argv) > 1 and sys.argv[1] == '--help':
print("Get current trade status")
print("Usage {} [pair] [interval]".format(sys.argv[0]))
sys.exit(0)
test = sys.argv[2].lower() == "test"
prices = binance.prices()
binance_auth()
dbase = Mysql(test=test, interval=sys.argv[1])
trades = dbase.get_trades()
profits = []
percs = []
print("\033[1m") # BOLD
print("pair buy_price current_price amount in_profit percentage profit")
print("\033[0m") # END
details = []
for trade in trades:
pair = trade[0]
current_price = float(prices[pair])
trade_details = dbase.get_trade_value(pair)
buy_price = float(trade_details[0][0])
amount = float(trade_details[0][1])
profit = (current_price / 0.00014 * amount) - (buy_price / 0.00014 *
amount)
perc = 100 * (current_price - buy_price) / buy_price
profits.append(profit)
percs.append(perc)
perc = float(format(perc, ".4f"))
profit = float(format(profit, ".4f"))
details.append(
(pair, format(float(buy_price), ".20f"),
format(float(current_price),
".20f"), amount, current_price > buy_price, perc, profit))
details = sorted(details, key=itemgetter(-2))
for item in details:
print("{0} {1} {2} {3} {4} {5} {6}".format(*item))
print(
"\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n\n\n\n"
)
count = len(profits)
count = 1 if count == 0 else count
print("Total_profit: {0} Avg_Profit: {1} Avg_Percs: {2} count: {3}".format(
sum(profits),
sum(profits) / count,
sum(percs) / count, count))
def initialize_coins():
coins=[]
# gives a dictionary which coin name as key and price as value
prices = binance.prices()
coinNames = list(prices.keys())
for c in coinNames:
# Create coin and add starting price
tmpcoin = coin(c)
tmpcoin.add_price(prices.get(c))
coins.append(tmpcoin)
return coins
def write_price():
"""writing prices to csv files"""
data = binance.prices() # calling prices
print(int(time.time() * 1000))
print(data)
for each_market in data:
# outputs "binance time" in miliseconds
write_price.time_index = int(time.time() * 1000)
current_price = float(data['%s' % each_market])
with open('./csv_data/%s.csv' % each_market, 'a') as f:
wr = csv.writer(f)
wr.writerow([write_price.time_index, current_price])
def prod_loop(interval, test_trade):
"""
Loop through collection cycle (PROD)
"""
main_indicators = config.main.indicators.split()
pairs = config.main.pairs.split()
LOGGER.debug("Performaing prod loop")
LOGGER.info("Pairs in config: %s", pairs)
LOGGER.info("Total unique pairs: %s", len(pairs))
max_trades = int(config.main.max_trades)
LOGGER.info("Starting new cycle")
LOGGER.debug("max trades: %s", max_trades)
prices = binance.prices()
prices_trunk = {}
for key, val in prices.items():
if key in pairs:
prices_trunk[key] = val
dataframes = get_dataframes(pairs, interval=interval)
redis = Redis(interval=interval, test=False)
engine = Engine(prices=prices_trunk,
dataframes=dataframes,
interval=interval,
redis=redis)
engine.get_data(localconfig=main_indicators, first_run=False)
buys = []
sells = []
for pair in pairs:
result, current_time, current_price, _ = redis.get_action(
pair=pair, interval=interval)
if result == "BUY":
LOGGER.debug("Items to buy")
buys.append((pair, current_time, current_price))
if result == "SELL":
LOGGER.debug("Items to sell")
sells.append((pair, current_time, current_price))
trade = Trade(interval=interval, test_trade=test_trade, test_data=False)
trade.sell(sells)
trade.buy(buys)
del engine
del redis
def main():
""" main function """
if len(sys.argv) > 1 and sys.argv[1] == '--help':
print("Sell a particular trade immediately")
print("Usage {} [pair] [interval] [test_trade] [test_data]".format(sys.argv[0]))
sys.exit(0)
binance_auth()
pair = sys.argv[1]
interval = sys.argv[2]
test_trade = bool(len(sys.argv) > 3 and sys.argv[3] == "test")
test_data = bool(len(sys.argv) > 3 and sys.argv[4] == "test")
current_time = time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime())
current_price = binance.prices()[pair]
print(current_time, current_price)
sells = []
trade = Trade(interval=interval, test_data=test_data, test_trade=test_trade)
sells.append((pair, current_time, current_price))
trade.sell(sells)
def prod_initial(interval, test=False):
"""
Initial prod run - back-fetching data for tech analysis.
"""
prices = binance.prices()
prices_trunk = {}
pairs = config.main.pairs.split()
for key, val in prices.items():
if key in pairs:
prices_trunk[key] = val
redis = Redis(interval=interval, test=test)
main_indicators = config.main.indicators.split()
dataframes = get_dataframes(pairs, interval=interval)
engine = Engine(prices=prices_trunk,
dataframes=dataframes,
interval=interval,
test=test,
redis=redis)
engine.get_data(localconfig=main_indicators, first_run=True)
del redis
def prod_int_check(interval, test):
"""Check price between candles for slippage below stoploss"""
prices = binance.prices()
dbase = Mysql(test=False, interval=interval)
current_trades = dbase.get_trades()
redis = Redis(interval=interval, test=False, db=0)
current_time = time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime())
sells = []
for trade in current_trades:
pair = trade[0]
buy_price = dbase.get_trade_value(pair)[0][0]
result, current_time, current_price = redis.get_intermittant(
pair, buy_price=buy_price, current_price=prices[pair])
buy_price = dbase.get_trade_value(pair)[0][0]
LOGGER.debug("%s int check result: %s Buy:%s Current:%s Time:%s", pair,
result, buy_price, current_price, current_time)
if result == "SELL":
LOGGER.debug("Items to sell")
sells.append((pair, current_time, current_price))
trade = Trade(interval=interval, test_trade=test, test_data=False)
trade.sell(sells)
del redis
del dbase
#this is a bridge between binance api and lpmbot. please write binance API details in here
#https://github.com/toshima/binance this is the link to the binance api i`m using
import binance
import sys
binance.set("API", "SECRET")
# api first and then secret
if sys.argv[ 1 ] == ("prices"):
print(binance.prices())
elif sys.argv[ 1 ] == ("balances"):
print(binance.balances())
else:
print ("Please write a valid argument")
def binance_summary():
# instead of having the API in the script..not a perfect solution
sign_key, sign_SECRET = get_credentials('binance_api')
api_info = {
'sign_key': sign_key,
'sign_SECRET': sign_SECRET,
'sign_id': 'anyone',
'coin_symbol': 'ZEC',
}
binance.set(api_info['sign_key'], api_info['sign_SECRET'])
relation = {'ZEC': 'ZECBTC', 'BTC': 'BTCUSDT'}
prices = binance.prices()
balances = binance.balances()
btc_price = float(prices['BTCUSDT'])
# print ("The current Bitcoin price is $ {0:.2f}").format(btc_price)
print
# print float(prices['ZECBTC'])
# cycle thru all coins balances
for key in balances.keys():
# if balance is greater than 0, display balance info
if float(balances[key]['free']) > 0:
# determine 'free' balance
balance_coin = float(balances[key]['free'])
# handle BTC different because other coins are based on BTC
if key == 'BTC':
# determine the coins current price
coin_price = float(prices[relation[key]])
# calculate the coin balance in USD
balance_usd = balance_coin * float(prices[relation[key]])
# display information to screen
template = ("The {0} price is currently $ {1:.2f}")
print template.format(key, coin_price)
else:
# calculate the price of the coin in USD not BTC
coin_price = float(prices[relation[key]]) * btc_price
# calculate the coin balance in USD
balance_usd = (float(prices[relation[key]]) * balance_coin *
btc_price)
# display information to screen
template = ("The {0} price is currently $ {1:.2f}")
print template.format(key, coin_price)
print("\n\tYour {0} balance is {1}").format(key, balance_coin)
print("\tYour {0} balance is worth $ {1:.2f}".format(
key, balance_usd))
print
def executeTrades(token):
"""
carries out the trades identified and specified in checkArbitrage(token)
Flooring and rounding is used in the quantity calculations so as to make sure that the amount
matches the step size and minimum quantities required by binance for the given asset
"""
binance.marketBuy("ETHUSDT", binance.BUY, round(math.floor(100000*int(float(binance.balances()["USDT"]['free'])))*1/float(binance.prices()["ETHUSDT"]) / 100000, 5), test=False)
binance.marketBuy(token+"ETH", binance.BUY, math.floor((10**getDigits(token)*int(float(binance.balances()["ETH"]['free'])*1/float(binance.prices()[token+"ETH"]))))/(10**getDigits(token)), test=False)
binance.marketBuy(token+"BTC", binance.SELL, math.floor((10**getDigits(token))*float(binance.balances()[token]["free"]))/(10**getDigits(token)), test=False)
binance.marketBuy("BTCUSDT", binance.SELL, math.floor(float(binance.balances()["BTC"]['free'])*1000000) / 1000000, test=False) # precision will always be 10^6 for BTC
def get_binance_values():
"""Get totals for each crypto from binance and convert to USD/GBP"""
mydict = lambda: defaultdict(mydict)
result = mydict()
binance_auth()
all_balances = binance.balances()
prices = binance.prices()
bitcoin_totals = 0
gbp_total = 0
usd_total = 0
currency = CurrencyRates()
for key in all_balances:
current_value = float(all_balances[key]["free"]) + float(
all_balances[key]["locked"])
if float(current_value) > 0: # available currency
result["binance"][key]["count"] = current_value
if key == "BTC":
bcoin = float(current_value)
bitcoin_totals += float(bcoin)
elif key == "USDT":
bcoin = float(current_value) / float(prices["BTCUSDT"])
bitcoin_totals += bcoin
else: # other currencies that need converting to BTC
try:
bcoin = float(current_value) * float(
prices[key + "BTC"]) # value in BTC
bitcoin_totals += bcoin
except KeyError:
LOGGER.critical("Error: Unable to quantify currency: %s ",
key)
continue
add_value(key, bcoin)
usd2gbp = lambda: currency.get_rate("USD", "GBP")
usd = bcoin * float(prices["BTCUSDT"])
gbp = usd2gbp() * usd
usd_total += usd
gbp_total += gbp
result["binance"][key]["BTC"] = bcoin
result["binance"][key]["USD"] = usd
result["binance"][key]["GBP"] = gbp
usd_total = bitcoin_totals * float(prices["BTCUSDT"])
result["binance"]["TOTALS"]["BTC"] = bitcoin_totals
result["binance"]["TOTALS"]["USD"] = usd_total
result["binance"]["TOTALS"]["count"] = ""
for _ in range(3):
# Try to get exchange rate 3 times before giving up
try:
gbp_total = currency.get_rate("USD", "GBP") * usd_total
except RatesNotAvailableError:
continue
break
result["binance"]["TOTALS"]["GBP"] = gbp_total
add_value("USD", usd_total)
add_value("GBP", gbp_total)
return default_to_regular(result)
def get_current_price(pair):
"""Get current price from binance"""
prices = binance.prices()
return prices[pair]
secret = 'add secrect'
binance.set(api_key, secret) # setting up
boughtCryptos = {}
# reterives my btc balance
btcBalance = float(binance.balances()["BTC"]['free'])
print("Your bitcoin balance is %s" % btcBalance) # my btc balance
symbol = input("what currency") + "BTC" # symbol of first
symbol = symbol.upper()
print(symbol)
# dec.decimal_to_precision()
priceOfWanted = float(binance.prices()[symbol]) # how much coin->btc is worth
print(priceOfWanted)
# binance.or
# binance.order(symbol,binance.BUY,)
#exchange.enableRateLimit = True
def calculateProfit(coinPrice, boughtPrice):
return coinPrice / boughtPrice
def calcAmountNeeded(coinAmount, Volume, percent):
# volume = current have 0-> inf
# percent = how much of btc 0->1
# coinAmount = how much is coin in terms of btc
