class bittrex_public:
def __init__(self):
self.bittrex_public = Bittrex(None, None) # 公開情報を扱うBittrexオブジェクト
# 取引可能通貨サマリ一覧をList型で返す
def get_coin_summery_list(self):
coin_summery_list = []
response = self.bittrex_public.get_markets()
for item in response['result']:
coin_summery = str(item['MarketCurrencyLong'])
coin_summery_list.append(coin_summery)
return coin_summery_list
# 通貨の最小取引単位取得
def get_min_trade_size(self, market):
response = self.bittrex_public.get_markets()
for item in response['result']:
if item['MarketCurrency'] == market:
return item['MinTradeSize']
return False
# 通貨の終値取得
def get_last_price(self, market):
response = self.bittrex_public.get_marketsummary(market)
return response['result'][0]['Last']
def get_bitr(coin):
my_bittrex = Bittrex(None, None, api_version=API_V1_1)
l = []
p = []
markets = my_bittrex.get_markets()
tick = my_bittrex.get_ticker('NEO-USDT')
i=0
eth = get_eth()
while i<289:
l.append(markets['result'][i]['MarketName'])
i=i+1
for i in l:
if i[:3]=='ETH':
p.append(i)
i=0
tr=False
while i<len(p):
if coin==p[i][4:]:
tick = my_bittrex.get_ticker(p[i])
tr=True
try:
highlow = get_histor(p[i])
except:
print('Cant')
break
i=i+1
if tr==True:
try:
tests = check_coin(coin)
link = 'https://coinmarketcap.com/currencies/{}/'.format(tests[2])
return('1 ' + coin +' = ' + str(round(tick['result']['Bid']*eth,2)) + " USD\nСамая высокая цена: {} USD,\nСамая низкая цена: {} USD".format(round(highlow[0]*eth,2),round(highlow[1]*eth,2))+'\nИзменение за 24 часа: {} USD'.format(str(tests[0]))+'\nИзменение за 7 дней: {} USD\nСсылка на токен: '.format(str(tests[1]))+link)
except:
return('1 ' + coin +' = ' + str(tick['result']['Bid']*eth) + ' USD')
else:
return('Информации не найдено')
def get_data(number):
db_name = 'BB_coins'
trader = get_arg(1) # 'LANDON', 'CHRISTIAN' OR 'VIVEK.
# with open('accountkey.json') as data_file:
# data = json.load(data_file)
# print(data)
collection_name = '{}_bittrex_account'.format(trader)
try:
mongoserver_uri = "mongodb://*****:*****@10.8.0.2:27017/admin"
# mongoserver_uri = "mongodb://*****:*****@127.0.0:1"
connection = MongoClient(host=mongoserver_uri)
db = connection['BB_coins']
db_collection = db[collection_name]
except KeyError:
host = 'localhost'
db_collection = MyMongoClient(db_name,
collection_name=collection_name,
host=host)
balance_curr_codes = []
market_names = []
# key, secret = "141172172c12458f8d0051d4c2618559", "2d944113b64844f2b3ad33030f99101a"
key = get_arg(2)
secret = get_arg(3)
api = Bittrex(api_key=key, api_secret=secret)
markets_data = api.get_markets()["result"]
for markets_datum in markets_data:
if markets_datum["BaseCurrency"] == 'BTC':
balance_curr_codes.append(markets_datum["MarketCurrency"])
market_names.append(markets_datum["MarketName"])
for market_name in market_names:
market_history_data = api.get_market_history(market_name,
count=1)["result"][0]
balance_curr_code = market_name.split('-')[1]
json_data = ({
'Number': number,
'balance_curr_code': balance_curr_code,
'last_price': market_history_data['Price'],
'TimeStamp': market_history_data['TimeStamp']
})
db_collection.insert_one(json_data)
print('------table name-----')
print(collection_name)
print('Inserted: \n{}'.format(json_data))
class Market:
def __init__(self):
self.bittrex = Bittrex()
self.update_currencies_raw()
def update_currencies_raw(self):
self.currencies_raw = self.get_crypto_currencies()
self.currencies_list = sorted(
[c["MarketName"] for c in self.currencies_raw])
def get_crypto_currencies(self):
try:
return self.bittrex.get_markets()["result"]
except Exception:
return self.currencies_raw
def get_active_markets():
"""
Used to obtain the set of markets that are currently active on Bittrex
:return: list of Market objects
"""
b = Bittrex(None, None)
response = b.get_markets()
if response['success']:
markets = response['result']
active_markets = []
for market in markets:
if market['IsActive']:
active_markets.append(Market(market['MarketName']))
return active_markets
else:
raise Exception(response['message'])
def get_inactive_markets():
"""
Used to obtain the set of markets that are not currently active on Bittrex
:return: list of Market objects
"""
b = Bittrex(None, None)
response = b.get_markets()
if response['success']:
markets = response['result']
inactive_markets = []
for market in markets:
if not market['IsActive']:
inactive_markets.append(Market(market['MarketName']))
print "{:s}\t{:s}".format(market['MarketName'],
market['Notice'])
return inactive_markets
else:
raise Exception(response['message'])
class TestBittrexPublicAPI(unittest.TestCase):
"""
Integration tests for Bittrex Public API
"""
def setUp(self):
self.bittrex = Bittrex()
def test_get_markets(self):
actual = self.bittrex.get_markets()
test_basic_response(self, actual, 'get_markets')
def test_get_currencies(self):
actual = self.bittrex.get_currencies()
test_basic_response(self, actual, 'get_currencies')
def test_get_ticker(self):
self.assertRaises(TypeError, self.bittrex.get_ticker)
actual = self.bittrex.get_ticker('BTC-LTC')
test_basic_response(self, actual, 'get_ticker')
false_actual = self.bittrex.get_ticker('BTC')
test_failed_response(self, false_actual, 'get_ticker')
def test_get_market_summaries(self):
actual = self.bittrex.get_market_summaries()
test_basic_response(self, actual, 'get_market_summaries')
def test_get_market_summary(self):
self.assertRaises(TypeError, self.bittrex.get_market_summary)
actual = self.bittrex.get_ticker('BTC-LTC')
test_basic_response(self, actual, 'get_market_summar')
false_actual = self.bittrex.get_ticker('BTC')
test_failed_response(self, false_actual, 'get_market_summar')
def test_get_order_book(self):
self.assertRaises(TypeError, self.bittrex.get_order_book)
self.assertRaises(TypeError, self.bittrex.get_order_book, 'BTC-LTC')
actual = self.bittrex.get_order_book('BTC-LTC', 'buy')
test_basic_response(self, actual, 'get_order_book')
def test_get_market_history(self):
self.assertRaises(TypeError, self.bittrex.get_market_history)
actual = self.bittrex.get_market_history('BTC-LTC')
test_basic_response(self, actual, 'get_market_history')
def get_data():
db_name = 'BB_coins'
trader = get_arg(1, 'VIVEK') # 'LANDON', 'CHRISTIAN' OR 'VIVEK.
collection = '{}_coinigy_account'.format(trader)
try:
db_user = '******'
db_password = os.environ['MONGO-WRITE-PASSWORD']
host = 'mongodb://{}:{}@127.0.0.1'.format(db_user, db_password)
except KeyError:
host = 'localhost'
db = MyMongoClient(db_name, collection_name=collection,
host=host)
json_data = []
market_history_total_data = []
balance_curr_codes = []
market_names = []
key, secret = "54680684a8cb481c9f99a5f0ccaa1841", "4009a8a233114ab8a16f03c856d03752"
api = Bittrex(api_key=key, api_secret=secret)
markets_data = api.get_markets()["result"]
for markets_datum in markets_data:
if markets_datum["BaseCurrency"] == 'BTC':
balance_curr_codes.append(markets_datum["MarketCurrency"])
market_names.append(markets_datum["MarketName"])
for market_name in market_names:
market_history_data = api.get_market_history(market_name, count=1)["result"][0]
balance_curr_code = market_name.split('-')[1]
json_data = ({
'balance_curr_code': balance_curr_code,
'last_price': market_history_data['Price'],
'TimeStamp': market_history_data['TimeStamp']})
db.insert_one(json_data)
import pandas as pd
from cis.lib import capping
from coinmarketcap import Market
from bittrex import Bittrex, API_V2_0, API_V1_1
# get coinmarketcap top 50
coinmarketcap = Market()
data = coinmarketcap.ticker(limit=50)
# get all bittrex markets
my_bittrex = Bittrex(None, None, api_version=API_V1_1) # or defaulting to v1.1 as Bittrex(None, None)
bittrex_markets = pd.DataFrame(my_bittrex.get_markets()['result'])
# get coins traded in BTC in bittrex
bittrex_coins = bittrex_markets.loc[bittrex_markets['BaseCurrency'] == 'BTC']['MarketCurrency']
bittrex_coins = bittrex_coins.append(pd.Series('BTC'))
# create blacklist
blacklist = pd.Series(['BCC', 'USDT'])
# create dataframe from coinmarketcap data
df = pd.DataFrame(data)
# remove blacklist coins and coins not in bittrex from dataframe
df = df.loc[df['symbol'].isin(bittrex_coins) & ~df['symbol'].isin(blacklist), :]
# get top 20
df = df.head(20)
# compute market weights
df['market_cap_usd'] = df['market_cap_usd'].astype(float)
"""
buy_rule_boolean,buy_rule_dict=self.check_buy_rule(market,threshold)
if buy_rule_boolean:
print("The there is a chance of scoring on market {market}. Proceeding to bite algorithm.".format(market=market['MarketName']))
self.bite_and_let_go(market,buy_rule_dict)
else:
print("The there is nothing going on on market {market}.)".format(market=market['MarketName']))
pass
# init bittrex client
br = Bittrex(API_key, API_secret)
# get market names
markets={market['MarketName']:{'MarketName':market['MarketName'],
'MarketCurrency':market['MarketCurrency'],
'MinTradeSize':market['MinTradeSize']
} for market in br.get_markets()['result'] if market['MarketName'].startswith('BTC')}
def get_fertile_markets():
# /GET FERTILE MARKETS
print("Getting 0.9 quantile markets with respect to its base volume. This takes few minutes, please wait...")
# assign base_volume to markets
for market,market_dict in markets.items():
market_name=market_dict['MarketName']
markets[market_name]['base_volume']=get_market_base_volume(market_dict['MarketName'])
sum_base_volume=sum([market_dict['base_volume'] for market,market_dict in markets.items()])
# assign proxy for liquidity as a fraction of base_volume to markets
for market,market_dict in markets.items():
market_name=market_dict['MarketName']
markets[market_name]['liquidity']=markets[market_name]['base_volume']/sum_base_volume
class TradeBot():
def __init__(self, key=None, secret=None, **kwargs):
self.exchange = Bittrex(key, secret)
self.orders = []
# Default config
config = {
'base_currency': 'ETH',
'min_order': 0.001,
'max_order': 0.05,
'sleep_time': 60,
'profit': 2,
'min_volume': 75,
'max_units': 100
}
# Update config from object constructor
config.update(kwargs)
# Set attributes based on config
for attr in config.keys():
setattr(self, attr, config[attr])
def get_markets(self):
logging.info(f'Getting markets for {self.base_currency}')
all_markets = self.exchange.get_markets()['result']
markets = set()
for mkt in all_markets:
if mkt['BaseCurrency'] == self.base_currency:
markets.add(mkt['MarketName'])
return markets
def get_coins_with_open_orders(self):
open_orders = self.exchange.get_open_orders()['result']
if len(open_orders) == 0:
return []
else:
return [x['Exchange'] for x in open_orders]
def get_market_data(self):
mkt_data = []
for mkt in self.markets:
logging.info(f'Getting market data for {mkt}')
data = self.exchange.get_marketsummary(mkt)['result'][0]
data['Change'] = calculate_change(data['Last'], data['Low'])
mkt_data.append(data)
return mkt_data
def has_balance_to_buy(self):
logging.info('checking if we have some balance to buy')
q = self.exchange.get_balance(self.base_currency)
# balance_adjustment to avoid INSUFFICIENT FUNDS MESSAGE
balance_adjustment = 0.0005
self.balance = q['result']['Available'] - balance_adjustment
logging.debug(f'{self.balance}{self.base_currency} available')
if self.balance >= self.min_order:
return True
else:
return False
def get_market_to_buy(self):
self.update()
mkt = [
m for m in self.market_data if m['BaseVolume'] >= self.min_volume
]
sorted_mkt = sorted(mkt, key=lambda x: x['BaseVolume'], reverse=True)
while sorted_mkt[0]['MarketName'] in self.coins_with_open_orders:
sorted_mkt.pop(0)
return sorted_mkt[0]
def buy(self, mkt):
coin = mkt['MarketName']
# get a price between ask and bid
price = (mkt['Ask'] + mkt['Bid']) / 2
if self.balance > self.max_order:
qnt = self.max_order / price
else:
qnt = self.balance / price
if qnt > self.max_units:
qnt = self.max_units
if (qnt * price) < self.min_order:
qnt = self.min_order / price
logging.info(f'BUY {qnt} {coin} - price {price}, total {price * qnt}')
order = self.exchange.buy_limit(coin, qnt, price)
if order['success']:
self.orders.append(order['result']['uuid'])
else:
logging.error(f'BUY FAIL - {order}')
return (order)
def sell(self):
for order in self.orders:
order_info = self.exchange.get_order(order)['result']
if order_info['Closed']:
coin = order_info['Exchange']
qnt = order_info['Quantity']
price = profit(order_info['PricePerUnit'], self.profit)
sell_order = self.exchange.sell_limit(coin, qnt, price)
self.orders.remove(order)
logging.info(f'SELL {order} {sell_order}')
def update(self):
logging.info('Updating data')
self.markets = self.get_markets()
self.market_data = self.get_market_data()
self.coins_with_open_orders = self.get_coins_with_open_orders()
def do_trade(self):
if self.has_balance_to_buy():
self.buy(self.get_market_to_buy())
if len(self.orders) > 0:
self.sell()
logging.info(f'Sleeping for {self.sleep_time} seconds')
sleep(self.sleep_time)
def run(self):
logging.info('Starting Bot')
while True:
self.do_trade()
"BTC",
"DASH",
"ETC",
"ETH",
"LTC",
"NEO",
"XMR",
"XRP",
"ZEC",
]
EXCHANGE_RATE = 0.9975
print key, secret
api = Bittrex(key, secret)
data = api.get_markets()
money = 100
def lineno():
"""Returns the current line number in our program."""
return inspect.currentframe().f_back.f_lineno
def get_new_round():
''' Need return buying path . Currently only use static path
meaning keep going this path regarding the current price
'''
marketsummaries = api.get_market_summaries().get("result")
#print marketsummaries[0].get("TimeStamp")
Load Libraries
import pandas as pd
from bittrex import Bittrex
my_bittrex = Bittrex("99f9f179b8e84a43a1204903a5c242eb", "0994a3ebc9aa4d0fa44d0c9d94d272bc")
my_bittrex.get_markets()
# Key = 99f9f179b8e84a43a1204903a5c242eb
# Secret = 0994a3ebc9aa4d0fa44d0c9d94d272bc
# Function to extract required data from the bittrex API - Symbol, time frame, frequency
# Additional data cleaning ?
# Backtester
# Trend following
# Momentum
class CryptoCommander:
def __init__(self, poloapicreds=['', ''], bittrexapicreds=['', '']):
print(
"Initializing Crypto Commander, Intelligent and Responsive Crypto-Currency Platform..."
)
print(
"Disclaimer!! You have launched this via command line, great caution is advised and the developers are NOT responsible for proper usage or lost coins!"
)
print(
"Notice - :: :: Bitcoin & Crypto-Currencies are largely untested and come with no assurances! Trade with care. :: ::"
)
if poloapicreds == ['', '']:
print(
"No poloniex credentials found, skipping initialization. This may cause instability!"
)
else:
try:
self.poloniexBot = poloniex(poloapicreds[0], poloapicreds[1])
self.btcBalance, self.btsBalance, self.clamBalance, self.dashBalance, self.dogeBalance, self.ethBalance, self.fctBalance, self.ltcBalance, self.maidBalance, self.strBalance, self.xmrBalance, self.xrpBalance, = Decimal(
0.0), Decimal(0.0), Decimal(0.0), Decimal(0.0), Decimal(
0.0), Decimal(0.0), Decimal(0.0), Decimal(
0.0), Decimal(0.0), Decimal(0.0), Decimal(
0.0), Decimal(0.0)
except AttributeError:
print(
"An error occurred trying to initialize Poloniex functionality."
)
if bittrexapicreds == ['', '']:
print(
"No bittrex credentials detected, skipping initialization. This may cause instability!"
)
else:
try:
self.bittrexBot = Bittrex(bittrexapicreds[0],
bittrexapicreds[1])
except AttributeError:
print(
"An error occurred trying to initialized Bittrex functionality."
)
def convert_coinpair_poloniex(self, coinpair):
return coinpair.replace('-', '_')
def get_tickers_raw(self, market):
# A clone of the bittrex get_markets() & poloniex returnTicker commands, in a unified stream.
if market == 'poloniex':
return self.poloniexBot.returnTicker()
elif market == 'bittrex':
return self.bittrexBot.get_markets()
def get_coinpair_ticker_raw(self, market, coinpair):
# Returns raw market information on coin pair on market
if market == 'poloniex':
coinpair = self.convert_coinpair_poloniex(coinpair)
rawtickerdata = self.get_tickers_raw(market)
for coinpairdata in rawtickerdata:
if coinpairdata == coinpair:
return rawtickerdata[coinpairdata]
if market == 'bittrex':
return self.bittrexBot.get_ticker(coinpair.capitalize())
def getTickerData(self,
market,
bitcoinMarketsOnly=True,
activeOnly=True,
printFriendly=False,
decimalTypes=True):
#if market == 'poloniex:
if market == 'bittrex':
cryptoCommandTickers = {'BTC': [], 'Other': []}
btcMarketsList = cryptoCommandTickers['BTC']
otherMarketsList = cryptoCommandTickers['Other']
stagingList = []
if printFriendly == True:
decimalTypes = False
for ticker in self.bittrexBot.get_markets()['result']:
if ticker != None:
stagingList.append([
str(ticker['MarketName']),
str(ticker['BaseCurrency']),
bool(str(ticker['IsActive']))
])
for ticker in self.bittrexBot.get_market_summaries()['result']:
if ticker != None:
for list in stagingList:
if list[0] == str(ticker['MarketName']):
list.extend([
ticker['High'], ticker['Low'], ticker['Ask'],
ticker['Bid'], ticker['Last'],
ticker['PrevDay'], ticker['Volume'],
ticker['BaseVolume'],
(ticker['High'] + ticker['Low'] / 2.0)
])
for list in stagingList:
if list[1] == 'BTC':
btcMarketsList.append(list)
else:
otherMarketsList.append(list)
if printFriendly == True:
for dictobject in cryptoCommandTickers:
for list in cryptoCommandTickers[dictobject]:
for n, listobject in enumerate(list):
if type(listobject) == float:
list[n] = format(listobject, '.8f')
elif decimalTypes == True:
for dictobject in cryptoCommandTickers:
for list in cryptoCommandTickers[dictobject]:
for n, listobject in enumerate(list):
if type(listobject) == float:
list[n] = Decimal(format(listobject, '.8f'))
return cryptoCommandTickers
def getActiveMarketCurrencies(self, market, appendString=''):
currentMarketList = []
if market == 'poloniex':
rawCoinPairData = self.poloniexBot.api_query('returnTicker')
for coinPairData in rawCoinPairData:
if str(rawCoinPairData[coinPairData]['isFrozen']) == '0':
currentMarketList.append(
str(coinPairData).split('_', 1)[1])
if market == 'bittrex':
for coinData in self.bittrexBot.get_currencies()['result']:
if coinData['IsActive'] == True:
currentMarketList.append(appendString +
str(coinData['Currency']))
return set(currentMarketList)
def getCurrentBalance(self, market, coin):
if market == 'poloniex':
return self.poloniexBot.returnBalances()[coin.upper()]
elif market == 'bittrex':
return self.bittrexBot.get_balance(coin)['result']['Balance']
def getTopOrder(self, market, coinPair, buyOrders):
if buyOrders == True:
if market == 'poloniex':
for i in self.poloniexBot.returnOrderBook(
coinPair.replace('-', '_'))['bids']:
return i
elif market == 'bittrex':
for i in self.bittrexBot.get_orderbook(coinPair,
'buy')['result']:
return i
else:
print('Not a valid market: ' + str(market))
else:
if market == 'poloniex':
for i in self.poloniexBot.returnOrderBook(
coinPair.replace('-', '_'))['asks']:
return i
elif market == 'bittrex':
for i in self.bittrexBot.get_orderbook(coinPair,
'sell')['results']:
return i
else:
print('Not a valid market: ' + str(market))
def getWalletAddress(self, market, coin):
if market == "poloniex" or market == "Poloniex":
return self.poloniexBot.api_query('returnDepositAddresses')[coin]
elif market == "bittrex" or market == "Bittrex":
return self.bittrexBot.get_balance(coin)['result']['CryptoAddress']
def compareMarkets(self, market1, market2):
currentActiveMarketsLists = [
self.getActiveMarketCurrencies(market1),
self.getActiveMarketCurrencies(market2)
]
comparisonList = []
for i in currentActiveMarketsLists[0]:
for y in currentActiveMarketsLists[1]:
if i == y: comparisonList.append(i)
else: continue
return comparisonList
def getCoinPairPriceDifferencePercent(self, buyPrice, sellPrice):
return (((float(buyPrice) - float(sellPrice)) / float(buyPrice)) *
100.00)
def arbitrageScan(self, market1, market2, minPercent=0.45):
try:
arbOpportunitiesList = []
for coinpair in self.doMarketComparison(market1, market2):
print("Scanning Coin Pair : " + str(coinpair))
differenceBetweenMarket1and2 = format(
self.getCoinPairPriceDifferencePercent(
float(self.getTopOrder(market1, coinpair, False, 1)),
float(self.getTopOrder(market2, coinpair, True, 1))))
differenceBetweenMarket2and1 = format(
self.getCoinPairPriceDifferencePercent(
float(self.getTopOrder(market2, coinpair, False, 1)),
float(self.getTopOrder(market1, coinpair, True, 1))))
if float(differenceBetweenMarket2and1) < (-.525 - minPercent):
if (float(self.getTopOrder(market1, coinpair, True)[0]) *
float(
self.getTopOrder(market1, coinpair, True)[1])
) >= float(self.getCurrentBalance(market1, "BTC")):
print("Arb Op: " + str(differenceBetweenMarket2and1) +
" for coin pair ")
print("Info: Bittrex: Buy:: ")
print(self.getTopOrder('bittrex', coinpair, True))
print("- Sell:: ")
print(self.getTopOrder('bittrex', coinpair, False))
arbOpportunity = (coinpair, "Market2to1",
differenceBetweenMarket2and1, 1)
arbOpportunitiesList.append(arbOpportunity)
else:
continue
elif float(differenceBetweenMarket1and2) < (-.525 -
minPercent):
if float(
self.getTopOrder('bittrex', coinpair, True, 3)[0]
) * float(self.getTopOrder(
'bittrex', coinpair, True)[1]) >= float(
self.getCurrentBalance(market2, "BTC")):
print("Arb Op: ")
print(str(differenceBetweenMarket1and2))
print("Info: Bittrex: Buy:: ")
print(self.getTopOrder('poloniex', coinpair, True))
print("- Sell:: ")
print(self.getTopOrder('poloniex', coinpair, False))
print("Info: Poloniex: Buy:: ")
print(self.getTopOrder('bittrex', coinpair, True))
print("- Sell:: ")
print(self.getTopOrder('bittrex', coinpair, False))
arbOpportunity = (coinpair, "Market1to2",
differenceBetweenMarket1and2, 1)
arbOpportunitiesList.append(arbOpportunity)
else:
continue
else:
print(differenceBetweenMarket1and2 + " or " +
differenceBetweenMarket2and1 + " is more than -.7")
continue
return arbOpportunitiesList
except AttributeError:
print("Attribute Error")
def selectBestOpportunity(self, market1, market2, minPercent=0.45):
opportunitiesList = []
while opportunitiesList == []:
opportunitiesList = self.arbitrageScan(market1, market2,
minPercent)
if len(opportunitiesList) != 0:
bestOpportunity = opportunitiesList[0]
for opportunity in opportunitiesList:
if bestOpportunity[2] < opportunity[2]:
bestOpportunity = opportunity
else:
print("No Opportunities Found")
bestOpportunity = ("", "", 0.0, 0)
return bestOpportunity
def activateArbitrage(self, market1, market2, minPercent=0.45):
bestArbitrageOpportunity = self.selectBestOpportunity(
market1, market2, minPercent)
coinName = str(bestArbitrageOpportunity[0]).replace("BTC-", "")
if bestArbitrageOpportunity[1] == 'Market1to2':
fullTopBuyOrder = self.getTopOrder(market1,
bestArbitrageOpportunity[0],
False)
btcBuyOrderAvailable = (float(fullTopBuyOrder[0]) *
float(fullTopBuyOrder[1]))
btcBalanceOnMarket = float(
self.getCurrentBalance('poloniex', "BTC"))
if float(btcBuyOrderAvailable) > float(btcBalanceOnMarket):
btcBuyOrderAvailable = float(btcBalanceOnMarket)
coinAvailable = float(btcBuyOrderAvailable) / float(
fullTopBuyOrder[0])
if market1 == "poloniex" or market1 == "Poloniex":
try:
if float(
self.getTopOrder(
market1, bestArbitrageOpportunity[0], False,
0)[0]) * float(
self.getTopOrder(
market1, bestArbitrageOpportunity[0],
False, 0)[1]) < float(
self.getBalance('poloniex',
'BTC')):
self.poloniexBot.buy(
bestArbitrageOpportunity[0].replace("-", "_"),
fullTopBuyOrder[0], coinAvailable)
print(
"Successfully Bought on Poloniex, Attempting to Send to Bittrex Now..."
)
time.sleep(3)
self.poloniexBot.withdraw(
coinName,
(self.getCurrentBalance('poloniex', coinName)),
self.getWalletAddress('bittrex', coinName))
tempCounter = 0
print(self.getCurrentBalance('bittrex', coinName))
while float(self.getCurrentBalance(
'bittrex', coinName)) < 0.0005:
time.sleep(5)
tempCounter = tempCounter + 1
if tempCounter > 15:
print("Still Awaiting Deposit...")
tempCounter = 0
print(
"Deposit Confirmed & Active! Preparing to Dump in 5 Seconds"
)
time.sleep(5)
while float(self.getCurrentBalance(market2, coinName)
) > 0.00050055 or self.getCurrentBalance(
market2, coinName) == None:
time.sleep(3)
self.bittrexBot.sell_limit(
bestArbitrageOpportunity[0],
self.getCurrentBalance('bittrex', coinName),
self.getTopOrder(market2,
bestArbitrageOpportunity[0],
True, 1))
print(
"Finished Selling All the Coins that Could be Sold. Cycle Complete."
)
else:
print(
"The order didnt stay high enough, starting over")
self.activateArbitrage(market1, market2, minPercent)
except MemoryError:
print("Error")
if bestArbitrageOpportunity[1] == 'Market2to1':
fullTopBuyOrder = self.getTopOrder(market2,
bestArbitrageOpportunity[0],
False, 0)
btcBuyOrderAvailable = (float(fullTopBuyOrder[0]) *
float(fullTopBuyOrder[1]))
btcBalanceOnMarket = float(self.getCurrentBalance(market2, "BTC"))
if btcBuyOrderAvailable > btcBalanceOnMarket:
btcBuyOrderAvailable = btcBalanceOnMarket
coinAvailable = float(btcBuyOrderAvailable) / float(
fullTopBuyOrder[0])
if market2 == "bittrex" or market2 == "Bittrex":
try:
if float(
self.getTopOrder(
market1, bestArbitrageOpportunity[0], False,
0)[0]) * float(
self.getTopOrder(
market1, bestArbitrageOpportunity[0],
False, 0)[1]) < float(
self.getCurrentBalance(
'bittrex', 'BTC')):
print("Buying " + str(bestArbitrageOpportunity[0]) +
" " + str(coinAvailable))
buy = self.bittrexBot.buy_limit(
bestArbitrageOpportunity[0], coinAvailable,
fullTopBuyOrder[0])
print(buy)
time.sleep(5)
if buy['success'] == True:
print(
"Successfully Bought on Bittrex, Attempting to Send to Poloniex Now..."
)
time.sleep(5)
self.bittrexBot.withdraw(
coinName,
self.getCurrentBalance(market2, coinName),
self.getWalletAddress(market1, coinName))
tempCounter = 0
print(self.getCurrentBalance(market1, coinName))
while float(
self.getCurrentBalance(market1, coinName)
) < 0.00050055 or self.getCurrentBalance(
market1, coinName) == None:
time.sleep(5)
tempCounter = tempCounter + 1
if tempCounter > 15:
print("Still Awaiting Deposit...")
tempCounter = 0
print(
"Deposit Confirmed and Active! Preparing to Dump in 5 Seconds"
)
time.sleep(5)
while float(
self.getCurrentBalance(
market1, coinName)) > 0.00010055:
time.sleep(5)
self.poloniexBot.sell(
str(bestArbitrageOpportunity[0]).replace(
"-", "_"),
float(
self.getTopOrder(
market1,
bestArbitrageOpportunity[0].
replace("-", "_"), True, 1)),
self.getCurrentBalance(market1, coinName))
print(
"Attempting to Sell Maximum Amount of Coins that Could be Sold."
)
print("Finished Selling all coins. Cycle Complete")
else:
print("Failed to Buy")
return "Failed to Buy"
else:
print(
"The order didn't stay high enough, starting over")
self.activateArbitrage(market1, market2, minPercent)
except AttributeError:
print("Attribute Error, sorry")
def getLendingBalances(self):
#Only works with Poloniex
try:
return cryptoCommander.poloniexBot.api_query(
'returnAvailableAccountBalances')['lending']
except KeyError:
return []
def getCurrentLoanOffers(self, coin):
#Only works with Poloniex
ret = urllib2.request.urlopen('http://poloniex.com/public?command=' +
'returnLoanOrders' + '¤cy=' +
str(coin))
return json.loads(ret.read())
def getPrimeLendingRate(self, coin, minWeight=Decimal('25.0')):
#Only works with Poloniex
accumulatedWeight, bestRate = Decimal('0.0'), Decimal('0.0')
print(accumulatedWeight)
for offer in self.getCurrentLoanOffers(coin)['offers']:
if accumulatedWeight < minWeight:
print('Accumulated weight is less than 25: ' +
str(accumulatedWeight))
accumulatedWeight = accumulatedWeight + Decimal(
str(offer['amount']))
else:
print('Best rate is: ' + str(offer['rate']))
bestRate = Decimal(str(offer['rate'])) - Decimal('0.000001')
break
if bestRate < Decimal('0.000001'): bestRate = Decimal('0.000001')
return bestRate
def getActiveLoans(self):
#Only works with Poloniex
return self.poloniexBot.api_query('returnActiveLoans')
def getOpenLoanOffers(self):
#Only works with Poloniex
try:
return self.poloniexBot.api_query('returnOpenLoanOffers')
except KeyError:
return []
def cancelLoanOffer(self, currency, orderNumber):
#Only works with Poloniex
return self.poloniexBot.api_query('cancelLoanOffer', {
"currency": currency,
"orderNumber": orderNumber
})
def cancelAllLoanOffers(self):
openLoansDict = self.getOpenLoanOffers()
for openLoanCoin in openLoansDict:
for dataObject in openLoansDict[openLoanCoin]:
self.cancelLoanOffer(openLoanCoin, dataObject[id])
def createLoanOffer(self, currency, amount, duration, autoRenew,
lendingRate):
return self.poloniexBot.api_query(
'createLoanOffer', {
"currency": currency,
"amount": amount,
"duration": duration,
"autoRenew": autoRenew,
"lendingRate": lendingRate,
})
def checkLendingStagnation(self):
openLoansDict = self.getOpenLoanOffers()
for openLoanCoin in openLoansDict:
for data in openLoansDict[openLoanCoin]:
if (datetime.datetime.utcnow() - datetime.datetime.strptime(
str(data['date']), '%Y-%m-%d %X') >
datetime.timedelta(minutes=2)):
print('Cancelling Loan Orders that are stagnant.')
self.cancelLoanOffer(openLoanCoin, data['id'])
def placeAllLoans(self):
balances = self.getLendingBalances()
for coin in balances:
try:
print(balances[coin])
if type(balances[coin]
) != Decimal and balances[coin] > Decimal('0.0'):
balances[coin] = Decimal(str(balances[coin]))
if type(balances[coin]
) == Decimal and balances[coin] >= Decimal('0.01'):
#print "Print currency available is: " + str(balances[coin]) + str(coin) + ", Lending Now."
while Decimal(str(balances[coin])) >= Decimal('0.01'):
if Decimal(str(balances[coin])) <= Decimal(
'0.02') and Decimal(str(
balances[coin])) >= Decimal('0.01'):
print('lending between 0.01 and 0.02')
print(
self.createLoanOffer(
coin, float(balances[coin]), 2, 0,
self.getPrimeLendingRate(coin)))
else:
primeRate = self.getPrimeLendingRate(coin)
print("Prime Rate is: " + str(primeRate))
if primeRate <= Decimal('0.000025') or Decimal(
balances[coin]) > Decimal('0.1'):
if Decimal(balances[coin]) >= Decimal('10.0'):
if Decimal(
balances[coin]
) < Decimal('20.0') and Decimal(
balances[coin]) > Decimal('10.0'):
print('lending between 10 and 20')
print(
self.createLoanOffer(
coin, float(balances[coin]), 2,
0, primeRate))
else:
print('lending 10')
print(
self.createLoanOffer(
coin, 10.0, 2, 0, primeRate))
else:
if Decimal(
balances[coin]) > Decimal('0.1'):
if Decimal(balances[coin]) < Decimal(
'0.2') and Decimal(
balances[coin]) > Decimal(
'0.1'):
print(
'lending between 0.1 and 0.2')
print(
self.createLoanOffer(
coin,
float(balances[coin]), 2,
0, primeRate))
else:
print('lending 0.1')
print(
self.createLoanOffer(
coin, 0.1, 2, 0,
primeRate))
else:
print('lending 0.01')
print(
self.createLoanOffer(
coin, 0.01, 2, 0, primeRate))
else:
print('lending 0.01')
print(
self.createLoanOffer(
coin, 0.01, 2, 0, primeRate))
time.sleep(.2)
balances = self.getLendingBalances()
else:
print('No coins available to lend, sorry!')
except KeyError:
print('All loans for ' + str(coin) + ' actively being lent.')
def startLendingAutomation(self):
while True:
try:
while self.getLendingBalances(
) != None and self.getOpenLoanOffers() != None:
while any(self.getLendingBalances()) > Decimal(
'0.001') or any(self.getOpenLoanOffers()):
self.placeAllLoans()
time.sleep(150)
self.checkLendingStagnation()
print('All Done.')
except TypeError:
print("NOT done")
class Trader(object):
"""
Used for handling all trade functionality
"""
def __init__(self, secrets):
self.trade_params = secrets["tradeParameters"]
self.pause_params = secrets["pauseParameters"]
self.Bittrex = Bittrex(secrets)
self.Messenger = Messenger(secrets)
self.Database = Database()
def initialise(self):
"""
Fetch the initial coin pairs to track and to print the header line
"""
try:
if len(self.Database.app_data["coinPairs"]) < 1:
self.Database.store_coin_pairs(self.get_markets("BTC"))
self.Messenger.print_header(
len(self.Database.app_data["coinPairs"]))
except ConnectionError as exception:
self.Messenger.print_exception_error("connection")
logger.exception(exception)
exit()
def analyse_pauses(self):
"""
Check all the paused buy and sell pairs and reactivate the necessary ones
"""
if self.Database.check_resume(self.pause_params["buy"]["pauseTime"],
"buy"):
self.Database.store_coin_pairs(self.get_markets("BTC"))
self.Messenger.print_resume_pause(
len(self.Database.app_data["coinPairs"]), "buy")
if self.Database.check_resume(self.pause_params["sell"]["pauseTime"],
"sell"):
self.Messenger.print_resume_pause(
self.Database.app_data["pausedTrackedCoinPairs"], "sell")
self.Database.resume_sells()
def analyse_buys(self):
"""
Analyse all the un-paused coin pairs for buy signals and apply buys
"""
trade_len = len(self.Database.trades["trackedCoinPairs"])
pause_trade_len = len(self.Database.app_data["pausedTrackedCoinPairs"])
if (trade_len < 1 or pause_trade_len == trade_len
) and trade_len < self.trade_params["buy"]["maxOpenTrades"]:
for coin_pair in self.Database.app_data["coinPairs"]:
self.buy_strategy(coin_pair)
def analyse_sells(self):
"""
Analyse all the un-paused tracked coin pairs for sell signals and apply sells
"""
for coin_pair in self.Database.trades["trackedCoinPairs"]:
if coin_pair not in self.Database.app_data[
"pausedTrackedCoinPairs"]:
self.sell_strategy(coin_pair)
def buy_strategy(self, coin_pair):
"""
Applies the buy checks on the coin pair and handles the results appropriately
:param coin_pair: Coin pair market to check (ex: BTC-ETH, BTC-FCT)
:type coin_pair: str
"""
if (len(self.Database.trades["trackedCoinPairs"]) >=
self.trade_params["buy"]["maxOpenTrades"]
or coin_pair in self.Database.trades["trackedCoinPairs"]):
return
rsi = self.calculate_RSI(coin_pair=coin_pair,
period=14,
unit=self.trade_params["tickerInterval"])
day_volume = self.get_current_24hr_volume(coin_pair)
current_buy_price = self.get_current_price(coin_pair, "ask")
if self.check_buy_parameters(rsi, day_volume, current_buy_price):
buy_stats = {"rsi": rsi, "24HrVolume": day_volume}
self.buy(coin_pair, self.trade_params["buy"]["btcAmount"],
current_buy_price, buy_stats)
elif rsi is not None and rsi <= self.pause_params["buy"][
"rsiThreshold"]:
self.Messenger.print_no_buy(coin_pair, rsi, day_volume,
current_buy_price)
elif rsi is not None:
self.Messenger.print_pause(coin_pair, rsi,
self.pause_params["buy"]["pauseTime"],
"buy")
self.Database.pause_buy(coin_pair)
def sell_strategy(self, coin_pair):
"""
Applies the sell checks on the coin pair and handles the results appropriately
:param coin_pair: Coin pair market to check (ex: BTC-ETH, BTC-FCT)
:type coin_pair: str
"""
if (coin_pair in self.Database.app_data["pausedTrackedCoinPairs"]
or coin_pair not in self.Database.trades["trackedCoinPairs"]):
return
rsi = self.calculate_RSI(coin_pair=coin_pair,
period=14,
unit=self.trade_params["tickerInterval"])
current_sell_price = self.get_current_price(coin_pair, "bid")
profit_margin = self.Database.get_profit_margin(
coin_pair, current_sell_price)
if self.check_sell_parameters(rsi, profit_margin):
sell_stats = {"rsi": rsi, "profitMargin": profit_margin}
self.sell(coin_pair, current_sell_price, sell_stats)
elif rsi is not None and profit_margin >= self.pause_params["sell"][
"profitMarginThreshold"]:
self.Messenger.print_no_sell(coin_pair, rsi, profit_margin,
current_sell_price)
elif rsi is not None:
self.Messenger.print_pause(coin_pair, profit_margin,
self.pause_params["sell"]["pauseTime"],
"sell")
self.Database.pause_sell(coin_pair)
def check_buy_parameters(self, rsi, day_volume, current_buy_price):
"""
Used to check if the buy conditions have been met
:param rsi: The coin pair's current RSI
:type rsi: float
:param day_volume: The coin pair's current 24 hour volume
:type day_volume: float
:param current_buy_price: The coin pair's current price
:type current_buy_price: float
:return: Boolean indicating if the buy conditions have been met
:rtype : bool
"""
return (
rsi is not None and rsi <= self.trade_params["buy"]["rsiThreshold"]
and day_volume >= self.trade_params["buy"]["24HourVolumeThreshold"]
and
current_buy_price > self.trade_params["buy"]["minimumUnitPrice"])
def check_sell_parameters(self, rsi, profit_margin):
"""
Used to check if the sell conditions have been met
:param rsi: The coin pair's current RSI
:type rsi: float
:param profit_margin: The coin pair's current profit margin
:type profit_margin: float
:return: Boolean indicating if the sell conditions have been met
:rtype : bool
"""
return ((rsi is not None
and rsi >= self.trade_params["sell"]["rsiThreshold"]
and profit_margin >
self.trade_params["sell"]["minProfitMarginThreshold"])
or profit_margin >
self.trade_params["sell"]["profitMarginThreshold"])
def buy(self, coin_pair, btc_quantity, price, stats, trade_time_limit=2):
"""
Used to place a buy order to Bittrex. Wait until the order is completed.
If the order is not filled within trade_time_limit minutes cancel it.
:param coin_pair: String literal for the market (ex: BTC-LTC)
:type coin_pair: str
:param btc_quantity: The amount of BTC to buy with
:type btc_quantity: float
:param price: The price at which to buy
:type price: float
:param stats: The buy stats object
:type stats: dict
:param trade_time_limit: The time in minutes to wait fot the order before cancelling it
:type trade_time_limit: float
"""
buy_data = self.Bittrex.buy_limit(coin_pair, btc_quantity / price,
price)
if not buy_data["success"]:
return logger.error(
"Failed to buy on {} market.".format(coin_pair))
self.Database.store_initial_buy(coin_pair, buy_data["result"]["uuid"])
buy_order_data = self.get_order(buy_data["result"]["uuid"],
trade_time_limit * 60)
self.Database.store_buy(buy_order_data["result"], stats)
self.Messenger.send_buy_email(buy_order_data["result"], stats)
self.Messenger.print_buy(coin_pair, price, stats["rsi"],
stats["24HrVolume"])
self.Messenger.play_sw_imperial_march()
def sell(self, coin_pair, price, stats, trade_time_limit=2):
"""
Used to place a sell order to Bittrex. Wait until the order is completed.
If the order is not filled within trade_time_limit minutes cancel it.
:param coin_pair: String literal for the market (ex: BTC-LTC)
:type coin_pair: str
:param price: The price at which to buy
:type price: float
:param stats: The buy stats object
:type stats: dict
:param trade_time_limit: The time in minutes to wait fot the order before cancelling it
:type trade_time_limit: float
"""
trade = self.Database.get_open_trade(coin_pair)
sell_data = self.Bittrex.sell_limit(coin_pair, trade["quantity"],
price)
if not sell_data["success"]:
return logger.error(
"Failed to sell on {} market. Bittrex error message: {}".
format(coin_pair, sell_data["message"]))
sell_order_data = self.get_order(sell_data["result"]["uuid"],
trade_time_limit * 60)
# TODO: Handle partial/incomplete sales.
self.Database.store_sell(sell_order_data["result"], stats)
self.Messenger.send_sell_email(sell_order_data["result"], stats)
self.Messenger.print_sell(coin_pair, price, stats["rsi"],
stats["profitMargin"])
self.Messenger.play_sw_theme()
def get_markets(self, main_market_filter=None):
"""
Gets all the Bittrex markets and filters them based on the main market filter
:param main_market_filter: Main market to filter on (ex: BTC, ETH, USDT)
:type main_market_filter: str
:return: All Bittrex markets (with filter applied, if any)
:rtype : list
"""
markets = self.Bittrex.get_markets()
if not markets["success"]:
logger.error("Failed to fetch Bittrex markets")
exit()
markets = markets["result"]
if main_market_filter is not None:
market_check = main_market_filter + "-"
markets = py_.filter_(
markets, lambda market: market_check in market["MarketName"])
markets = py_.map_(markets, lambda market: market["MarketName"])
return markets
def get_current_price(self, coin_pair, price_type):
"""
Gets current market price for a coin pair
:param coin_pair: Coin pair market to check (ex: BTC-ETH, BTC-FCT)
:type coin_pair: str
:param price_type: The type of price to get (one of: 'ask', 'bid')
:type price_type: str
:return: Coin pair's current market price
:rtype : float
"""
coin_summary = self.Bittrex.get_market_summary(coin_pair)
if not coin_summary["success"]:
logger.error(
"Failed to fetch Bittrex market summary for the {} market".
format(coin_pair))
return None
if price_type == "ask":
return coin_summary["result"][0]["Ask"]
if price_type == "bid":
return coin_summary["result"][0]["Bid"]
return coin_summary["result"][0]["Last"]
def get_current_24hr_volume(self, coin_pair):
"""
Gets current 24 hour market volume for a coin pair
:param coin_pair: Coin pair market to check (ex: BTC-ETH, BTC-FCT)
:type coin_pair: str
:return: Coin pair's current 24 hour market volume
:rtype : float
"""
coin_summary = self.Bittrex.get_market_summary(coin_pair)
if not coin_summary["success"]:
logger.error(
"Failed to fetch Bittrex market summary for the {} market".
format(coin_pair))
return None
return coin_summary["result"][0]["BaseVolume"]
def get_closing_prices(self, coin_pair, period, unit):
"""
Returns closing prices within a specified time frame for a coin pair
:param coin_pair: String literal for the market (ex: BTC-LTC)
:type coin_pair: str
:param period: Number of periods to query
:type period: int
:param unit: Ticker interval (one of: 'oneMin', 'fiveMin', 'thirtyMin', 'hour', 'week', 'day', and 'month')
:type unit: str
:return: Array of closing prices
:rtype : list
"""
historical_data = self.Bittrex.get_historical_data(
coin_pair, period, unit)
closing_prices = []
for i in historical_data:
closing_prices.append(i["C"])
return closing_prices
def get_order(self, order_uuid, trade_time_limit):
"""
Used to get an order from Bittrex by it's UUID.
First wait until the order is completed before retrieving it.
If the order is not completed within trade_time_limit seconds, cancel it.
:param order_uuid: The order's UUID
:type order_uuid: str
:param trade_time_limit: The time in seconds to wait fot the order before cancelling it
:type trade_time_limit: float
:return: Order object
:rtype : dict
"""
start_time = time.time()
order_data = self.Bittrex.get_order(order_uuid)
while time.time() - start_time <= trade_time_limit and order_data[
"result"]["IsOpen"]:
time.sleep(10)
order_data = self.Bittrex.get_order(order_uuid)
if order_data["result"]["IsOpen"]:
error_str = self.Messenger.print_order_error(
order_uuid, trade_time_limit, order_data["result"]["Exchange"])
logger.error(error_str)
if order_data["result"]["Type"] == "LIMIT_BUY":
self.Bittrex.cancel(order_uuid)
return order_data
return order_data
def calculate_RSI(self, coin_pair, period, unit):
"""
Calculates the Relative Strength Index for a coin_pair
If the returned value is above 75, it's overbought (SELL IT!)
If the returned value is below 25, it's oversold (BUY IT!)
:param coin_pair: String literal for the market (ex: BTC-LTC)
:type coin_pair: str
:param period: Number of periods to query
:type period: int
:param unit: Ticker interval (one of: 'oneMin', 'fiveMin', 'thirtyMin', 'hour', 'week', 'day', and 'month')
:type unit: str
:return: RSI
:rtype : float
"""
closing_prices = self.get_closing_prices(coin_pair, period * 3, unit)
count = 0
change = []
# Calculating price changes
for i in closing_prices:
if count != 0:
change.append(i - closing_prices[count - 1])
count += 1
if count == 15:
break
# Calculating gains and losses
advances = []
declines = []
for i in change:
if i > 0:
advances.append(i)
if i < 0:
declines.append(abs(i))
average_gain = (sum(advances) / 14)
average_loss = (sum(declines) / 14)
new_avg_gain = average_gain
new_avg_loss = average_loss
for _ in closing_prices:
if 14 < count < len(closing_prices):
close = closing_prices[count]
new_change = close - closing_prices[count - 1]
add_loss = 0
add_gain = 0
if new_change > 0:
add_gain = new_change
if new_change < 0:
add_loss = abs(new_change)
new_avg_gain = (new_avg_gain * 13 + add_gain) / 14
new_avg_loss = (new_avg_loss * 13 + add_loss) / 14
count += 1
if new_avg_loss == 0:
return None
rs = new_avg_gain / new_avg_loss
new_rs = 100 - 100 / (1 + rs)
return new_rs
#bidPrice = float('%.8f' % bittrex.get_ticker('BTC-'+coinName)['result']['Bid']) * rate
bidPrice = '%.8f' % (float(bidPrice) * rate)
print(bidPrice)
buyResult = bittrex.sell_limit('BTC-' + coinName, coinAvail, bidPrice)['result']
myOrderHistory = bittrex.get_order_history(coinName, 1)
openOrders = bittrex.get_open_orders(coinName)
return buyResult, myOrderHistory, openOrders
#coinName = sys.argv[1].upper()
#print(coinName)
#askPrice, buyResult, myOrderHistory, openOrders = buyCoin(coinName,1.2)
#print(str(buyResult))
#sellResult, myOrderHistory, openOrders = sellCoin(coinName,askPrice, 2.5)
#print(str(sellResult))
result = bittrex.get_markets()
for coin in result['result']:
MarketName = coin['MarketName']
if 'BTC-' in MarketName:
try:
#ticker = bittrex.get_ticker(MarketName)
#currency = float('%.8f' % ticker['result']['Ask'])
#print(ticker)
#print(MarketName + ' : ' + str(currency))
ThreadGetTiker(MarketName).start()
except:
print('error : ' + MarketName)
#print(MarketName + ' : ' + str(currency))
#print(result)
#print(str(myOrderHistory))
#print(str(openOrders))
return [
self.minutes, self.price, self.trans_amount, self.coin_amount,
self.change_sm, self.change_md, self.change_lg, self.t0_price
]
#settings
CHANGE_SM = 5 * 60 #seconds
CHANGE_MD = 15 * 60 #seconds
CHANGE_LG = 30 * 60 #seconds
HISTORY = 60 * 60 #size of history store in seconds
OFFSET = 30 * 60 #time for future prediction
#vars + init
my_bitterx = Bittrex(None, None)
markets = []
bit_markets = my_bitterx.get_markets()["result"]
for market in bit_markets:
markets.append(market["BaseCurrency"] + "-" + market["MarketCurrency"])
print(markets)
history_store = [] #storage for history
#markets = json.load(open("markets.json",'r'))
for market in markets:
history_store.append({"flag": False, "market": market, "history": []})
lock = allocate_lock()
#extract markethistory
def hist_fetch(a):
global my_bitterx, history_store, markets
print("Thread 1 started")
while True:
class Trader(object):
"""
Used for handling all trade functionality
"""
def __init__(self, secrets):
self.trade_params = secrets["tradeParameters"]
self.pause_params = secrets["pauseParameters"]
self.Bittrex = Bittrex(secrets)
self.Messenger = Messenger(secrets)
self.Database = Database()
def initialise(self):
"""
Fetch the initial coin pairs to track and to print the header line
"""
try:
if len(self.Database.app_data["coinPairs"]) < 1:
self.Database.store_coin_pairs(self.get_markets("BTC"))
self.Messenger.print_header(len(self.Database.app_data["coinPairs"]))
except ConnectionError as exception:
self.Messenger.print_exception_error("connection")
logger.exception(exception)
exit()
def analyse_pauses(self):
"""
Check all the paused buy and sell pairs and reactivate the necessary ones
"""
if self.Database.check_resume(self.pause_params["buy"]["pauseTime"], "buy"):
self.Database.store_coin_pairs(self.get_markets("BTC"))
self.Messenger.print_resume_pause(len(self.Database.app_data["coinPairs"]), "buy")
if self.Database.check_resume(self.pause_params["sell"]["pauseTime"], "sell"):
self.Messenger.print_resume_pause(self.Database.app_data["pausedTrackedCoinPairs"], "sell")
self.Database.resume_sells()
def analyse_buys(self):
"""
Analyse all the un-paused coin pairs for buy signals and apply buys
"""
trade_len = len(self.Database.trades["trackedCoinPairs"])
pause_trade_len = len(self.Database.app_data["pausedTrackedCoinPairs"])
if (trade_len < 1 or pause_trade_len == trade_len) and trade_len < self.trade_params["buy"]["maxOpenTrades"]:
for coin_pair in self.Database.app_data["coinPairs"]:
self.buy_strategy(coin_pair)
def analyse_sells(self):
"""
Analyse all the un-paused tracked coin pairs for sell signals and apply sells
"""
for coin_pair in self.Database.trades["trackedCoinPairs"]:
if coin_pair not in self.Database.app_data["pausedTrackedCoinPairs"]:
self.sell_strategy(coin_pair)
def buy_strategy(self, coin_pair):
"""
Applies the buy checks on the coin pair and handles the results appropriately
:param coin_pair: Coin pair market to check (ex: BTC-ETH, BTC-FCT)
:type coin_pair: str
"""
if (len(self.Database.trades["trackedCoinPairs"]) >= self.trade_params["buy"]["maxOpenTrades"] or
coin_pair in self.Database.trades["trackedCoinPairs"]):
return
rsi = self.calculate_RSI(coin_pair=coin_pair, period=14, unit=self.trade_params["tickerInterval"])
day_volume = self.get_current_24hr_volume(coin_pair)
current_buy_price = self.get_current_price(coin_pair, "ask")
if self.check_buy_parameters(rsi, day_volume, current_buy_price):
buy_stats = {
"rsi": rsi,
"24HrVolume": day_volume
}
self.buy(coin_pair, self.trade_params["buy"]["btcAmount"], current_buy_price, buy_stats)
elif rsi is not None and rsi <= self.pause_params["buy"]["rsiThreshold"]:
self.Messenger.print_no_buy(coin_pair, rsi, day_volume, current_buy_price)
elif rsi is not None:
self.Messenger.print_pause(coin_pair, rsi, self.pause_params["buy"]["pauseTime"], "buy")
self.Database.pause_buy(coin_pair)
def sell_strategy(self, coin_pair):
"""
Applies the sell checks on the coin pair and handles the results appropriately
:param coin_pair: Coin pair market to check (ex: BTC-ETH, BTC-FCT)
:type coin_pair: str
"""
if (coin_pair in self.Database.app_data["pausedTrackedCoinPairs"] or
coin_pair not in self.Database.trades["trackedCoinPairs"]):
return
rsi = self.calculate_RSI(coin_pair=coin_pair, period=14, unit=self.trade_params["tickerInterval"])
current_sell_price = self.get_current_price(coin_pair, "bid")
profit_margin = self.Database.get_profit_margin(coin_pair, current_sell_price)
if self.check_sell_parameters(rsi, profit_margin):
sell_stats = {
"rsi": rsi,
"profitMargin": profit_margin
}
self.sell(coin_pair, current_sell_price, sell_stats)
elif rsi is not None and profit_margin >= self.pause_params["sell"]["profitMarginThreshold"]:
self.Messenger.print_no_sell(coin_pair, rsi, profit_margin, current_sell_price)
elif rsi is not None:
self.Messenger.print_pause(coin_pair, profit_margin, self.pause_params["sell"]["pauseTime"], "sell")
self.Database.pause_sell(coin_pair)
def check_buy_parameters(self, rsi, day_volume, current_buy_price):
"""
Used to check if the buy conditions have been met
:param rsi: The coin pair's current RSI
:type rsi: float
:param day_volume: The coin pair's current 24 hour volume
:type day_volume: float
:param current_buy_price: The coin pair's current price
:type current_buy_price: float
:return: Boolean indicating if the buy conditions have been met
:rtype : bool
"""
return (rsi is not None and rsi <= self.trade_params["buy"]["rsiThreshold"] and
day_volume >= self.trade_params["buy"]["24HourVolumeThreshold"] and
current_buy_price > self.trade_params["buy"]["minimumUnitPrice"])
def check_sell_parameters(self, rsi, profit_margin):
"""
Used to check if the sell conditions have been met
:param rsi: The coin pair's current RSI
:type rsi: float
:param profit_margin: The coin pair's current profit margin
:type profit_margin: float
:return: Boolean indicating if the sell conditions have been met
:rtype : bool
"""
return ((rsi is not None and rsi >= self.trade_params["sell"]["rsiThreshold"] and
profit_margin > self.trade_params["sell"]["minProfitMarginThreshold"]) or
profit_margin > self.trade_params["sell"]["profitMarginThreshold"])
def buy(self, coin_pair, btc_quantity, price, stats, trade_time_limit=2):
"""
Used to place a buy order to Bittrex. Wait until the order is completed.
If the order is not filled within trade_time_limit minutes cancel it.
:param coin_pair: String literal for the market (ex: BTC-LTC)
:type coin_pair: str
:param btc_quantity: The amount of BTC to buy with
:type btc_quantity: float
:param price: The price at which to buy
:type price: float
:param stats: The buy stats object
:type stats: dict
:param trade_time_limit: The time in minutes to wait fot the order before cancelling it
:type trade_time_limit: float
"""
buy_data = self.Bittrex.buy_limit(coin_pair, btc_quantity / price, price)
if not buy_data["success"]:
return logger.error("Failed to buy on {} market.".format(coin_pair))
self.Database.store_initial_buy(coin_pair, buy_data["result"]["uuid"])
buy_order_data = self.get_order(buy_data["result"]["uuid"], trade_time_limit * 60)
self.Database.store_buy(buy_order_data["result"], stats)
self.Messenger.print_buy(coin_pair, price, stats["rsi"], stats["24HrVolume"])
self.Messenger.send_buy_slack(coin_pair, stats["rsi"], stats["24HrVolume"])
self.Messenger.send_buy_gmail(buy_order_data["result"], stats)
self.Messenger.play_sw_imperial_march()
def sell(self, coin_pair, price, stats, trade_time_limit=2):
"""
Used to place a sell order to Bittrex. Wait until the order is completed.
If the order is not filled within trade_time_limit minutes cancel it.
:param coin_pair: String literal for the market (ex: BTC-LTC)
:type coin_pair: str
:param price: The price at which to buy
:type price: float
:param stats: The buy stats object
:type stats: dict
:param trade_time_limit: The time in minutes to wait fot the order before cancelling it
:type trade_time_limit: float
"""
trade = self.Database.get_open_trade(coin_pair)
sell_data = self.Bittrex.sell_limit(coin_pair, trade["quantity"], price)
if not sell_data["success"]:
return logger.error(
"Failed to sell on {} market. Bittrex error message: {}".format(coin_pair, sell_data["message"])
)
sell_order_data = self.get_order(sell_data["result"]["uuid"], trade_time_limit * 60)
# TODO: Handle partial/incomplete sales.
self.Database.store_sell(sell_order_data["result"], stats)
self.Messenger.print_sell(coin_pair, price, stats["rsi"], stats["profitMargin"])
self.Messenger.send_sell_slack(coin_pair, stats["rsi"], stats["profitMargin"])
self.Messenger.send_sell_gmail(sell_order_data["result"], stats)
self.Messenger.play_sw_theme()
def get_markets(self, main_market_filter=None):
"""
Gets all the Bittrex markets and filters them based on the main market filter
:param main_market_filter: Main market to filter on (ex: BTC, ETH, USDT)
:type main_market_filter: str
:return: All Bittrex markets (with filter applied, if any)
:rtype : list
"""
markets = self.Bittrex.get_markets()
if not markets["success"]:
logger.error("Failed to fetch Bittrex markets")
exit()
markets = markets["result"]
if main_market_filter is not None:
market_check = main_market_filter + "-"
markets = py_.filter_(markets, lambda market: market_check in market["MarketName"])
markets = py_.map_(markets, lambda market: market["MarketName"])
return markets
def get_current_price(self, coin_pair, price_type):
"""
Gets current market price for a coin pair
:param coin_pair: Coin pair market to check (ex: BTC-ETH, BTC-FCT)
:type coin_pair: str
:param price_type: The type of price to get (one of: 'ask', 'bid')
:type price_type: str
:return: Coin pair's current market price
:rtype : float
"""
coin_summary = self.Bittrex.get_market_summary(coin_pair)
if not coin_summary["success"]:
logger.error("Failed to fetch Bittrex market summary for the {} market".format(coin_pair))
return None
if price_type == "ask":
return coin_summary["result"][0]["Ask"]
if price_type == "bid":
return coin_summary["result"][0]["Bid"]
return coin_summary["result"][0]["Last"]
def get_current_24hr_volume(self, coin_pair):
"""
Gets current 24 hour market volume for a coin pair
:param coin_pair: Coin pair market to check (ex: BTC-ETH, BTC-FCT)
:type coin_pair: str
:return: Coin pair's current 24 hour market volume
:rtype : float
"""
coin_summary = self.Bittrex.get_market_summary(coin_pair)
if not coin_summary["success"]:
logger.error("Failed to fetch Bittrex market summary for the {} market".format(coin_pair))
return None
return coin_summary["result"][0]["BaseVolume"]
def get_closing_prices(self, coin_pair, period, unit):
"""
Returns closing prices within a specified time frame for a coin pair
:param coin_pair: String literal for the market (ex: BTC-LTC)
:type coin_pair: str
:param period: Number of periods to query
:type period: int
:param unit: Ticker interval (one of: 'oneMin', 'fiveMin', 'thirtyMin', 'hour', 'week', 'day', and 'month')
:type unit: str
:return: Array of closing prices
:rtype : list
"""
historical_data = self.Bittrex.get_historical_data(coin_pair, period, unit)
closing_prices = []
for i in historical_data:
closing_prices.append(i["C"])
return closing_prices
def get_order(self, order_uuid, trade_time_limit):
"""
Used to get an order from Bittrex by it's UUID.
First wait until the order is completed before retrieving it.
If the order is not completed within trade_time_limit seconds, cancel it.
:param order_uuid: The order's UUID
:type order_uuid: str
:param trade_time_limit: The time in seconds to wait fot the order before cancelling it
:type trade_time_limit: float
:return: Order object
:rtype : dict
"""
start_time = time.time()
order_data = self.Bittrex.get_order(order_uuid)
while time.time() - start_time <= trade_time_limit and order_data["result"]["IsOpen"]:
time.sleep(10)
order_data = self.Bittrex.get_order(order_uuid)
if order_data["result"]["IsOpen"]:
error_str = self.Messenger.print_order_error(order_uuid, trade_time_limit, order_data["result"]["Exchange"])
logger.error(error_str)
if order_data["result"]["Type"] == "LIMIT_BUY":
self.Bittrex.cancel(order_uuid)
return order_data
return order_data
def calculate_RSI(self, coin_pair, period, unit):
"""
Calculates the Relative Strength Index for a coin_pair
If the returned value is above 75, it's overbought (SELL IT!)
If the returned value is below 25, it's oversold (BUY IT!)
:param coin_pair: String literal for the market (ex: BTC-LTC)
:type coin_pair: str
:param period: Number of periods to query
:type period: int
:param unit: Ticker interval (one of: 'oneMin', 'fiveMin', 'thirtyMin', 'hour', 'week', 'day', and 'month')
:type unit: str
:return: RSI
:rtype : float
"""
closing_prices = self.get_closing_prices(coin_pair, period * 3, unit)
count = 0
change = []
# Calculating price changes
for i in closing_prices:
if count != 0:
change.append(i - closing_prices[count - 1])
count += 1
if count == 15:
break
# Calculating gains and losses
advances = []
declines = []
for i in change:
if i > 0:
advances.append(i)
if i < 0:
declines.append(abs(i))
average_gain = (sum(advances) / 14)
average_loss = (sum(declines) / 14)
new_avg_gain = average_gain
new_avg_loss = average_loss
for _ in closing_prices:
if 14 < count < len(closing_prices):
close = closing_prices[count]
new_change = close - closing_prices[count - 1]
add_loss = 0
add_gain = 0
if new_change > 0:
add_gain = new_change
if new_change < 0:
add_loss = abs(new_change)
new_avg_gain = (new_avg_gain * 13 + add_gain) / 14
new_avg_loss = (new_avg_loss * 13 + add_loss) / 14
count += 1
if new_avg_loss == 0:
return None
rs = new_avg_gain / new_avg_loss
new_rs = 100 - 100 / (1 + rs)
return new_rs
import time
from bittrex import Bittrex
import pandas as pd
apikey = 'fd25ef6daf6c4d5cb8507878781df312'
secret = '5f00769f175141be861bf199f089f9fd'
my_bittrex = Bittrex(apikey, secret)
my_bittrex.get_currencies()
my_bittrex.get_marketsummary('BTC-LTC')
coinList = [{
'CoinName': x['MarketCurrency'],
'CoinName_Full': x['MarketCurrencyLong'],
'MarketName': x['MarketName'],
'BaseCurrency': x['BaseCurrency']
} for x in my_bittrex.get_markets()['result']]
coinList = pd.DataFrame(coinList)
coinList
BTC - LTC,
col = [
'MarketName', 'High', 'Low', 'Volume', 'Last', 'BaseVolume', 'TimeStamp',
'Bid', 'Ask', 'OpenBuyOrders', 'OpenSellOrders', 'PrevDay', 'Created'
]
market_price = pd.DataFrame(columns=col)
i = 0
while 1:
market_price = pd.DataFrame(columns=col)
time = time.asctime()
class TestBittrexV11PublicAPI(unittest.TestCase):
"""
Integration tests for the Bittrex public API.
These will fail in the absence of an internet connection or if bittrex API goes down
"""
def setUp(self):
self.bittrex = Bittrex(None, None, api_version=API_V1_1)
def test_handles_none_key_or_secret(self):
self.bittrex = Bittrex(None, None)
# could call any public method here
actual = self.bittrex.get_markets()
self.assertTrue(actual['success'],
"failed with None key and None secret")
self.bittrex = Bittrex("123", None)
actual = self.bittrex.get_markets()
self.assertTrue(actual['success'], "failed with None secret")
self.bittrex = Bittrex(None, "123")
actual = self.bittrex.get_markets()
self.assertTrue(actual['success'], "failed with None key")
def test_get_markets(self):
actual = self.bittrex.get_markets()
test_basic_response(self, actual, "get_markets")
self.assertTrue(isinstance(actual['result'], list),
"result is not a list")
self.assertTrue(len(actual['result']) > 0, "result list is 0-length")
def test_get_currencies(self):
actual = self.bittrex.get_currencies()
test_basic_response(self, actual, "get_currencies")
def test_get_ticker(self):
actual = self.bittrex.get_ticker(market='BTC-LTC')
test_basic_response(self, actual, "get_ticker")
def test_get_market_summaries(self):
actual = self.bittrex.get_market_summaries()
test_basic_response(self, actual, "get_market_summaries")
def test_get_orderbook(self):
actual = self.bittrex.get_orderbook('BTC-LTC',
depth_type=BUY_ORDERBOOK)
test_basic_response(self, actual, "get_orderbook")
def test_get_market_history(self):
actual = self.bittrex.get_market_history('BTC-LTC')
test_basic_response(self, actual, "get_market_history")
def test_list_markets_by_currency(self):
actual = self.bittrex.list_markets_by_currency('LTC')
self.assertListEqual(['BTC-LTC', 'ETH-LTC', 'USDT-LTC'], actual)
def test_get_wallet_health(self):
self.assertRaisesRegexp(Exception, 'method call not available',
self.bittrex.get_wallet_health)
def test_get_balance_distribution(self):
self.assertRaisesRegexp(Exception, 'method call not available',
self.bittrex.get_balance_distribution)
def test_get_candles(self):
self.assertRaisesRegexp(Exception,
'method call not available',
self.bittrex.get_candles,
market='BTC-LTC',
tick_interval=TICKINTERVAL_ONEMIN)
def test_get_latest_candle(self):
self.assertRaisesRegexp(Exception,
'method call not available',
self.bittrex.get_latest_candle,
market='BTC-LTC',
tick_interval=TICKINTERVAL_ONEMIN)
# for terminal output -- sorry Windows users!
class colors:
HEADER = '\033[95m'
BLUE = '\033[94m'
GREEN = '\033[92m'
YELLOW = '\033[93m'
RED = '\033[91m'
ENDC = '\033[0m'
BOLD = '\033[1m'
UNDERLINE = '\033[4m'
# fetch markets
print("fetching markets...")
markets = api.get_markets()
print(" - done")
# read config
print("reading config...")
c = open("marketmusic.conf", "r").readlines()
currency = []
for i in range(0, len(c)):
t = c[i].replace("\n", "")
currency.append(t)
print(" - currency added: " + t)
print(" - done")
# get current market values
i = 1
s = ""
