class Polo:
def __init__(self):
self.public = Poloniex()
self.private = Poloniex(API_Key, API_Secret)
self.watch()
def watch(self):
res = self.private.returnBalances()
self.btc = float(res['BTC'])
self.usd = float(res['USDT'])
self.xrp = float(res['XRP'])
self.xem = float(res['XEM'])
self.ltc = float(res['LTC'])
self.eth = float(res['ETH'])
res = self.public.returnOrderBook(Currency_Pair)
self.ask = [float(res['asks'][0][0]), float(res['asks'][0][1])]
self.bid = [float(res['bids'][0][0]), float(res['bids'][0][1])]
def sell(self, am):
self.private.sell('USDT_BTC', self.bid[0], am)
self.watch()
def buy(self, am):
self.private.buy('USDT_BTC', self.ask[0], am)
self.watch()
class PoloniexWrap():
""" Syncronously Retrieves Poloniex Data """
def __init__(self, key, secret):
""" Initialize data model and authenticate"""
self.key = key
self.secret = secret
self.polo = Poloniex(self.key, self.secret, 120)
def getTick(self, pair):
"""get ticker"""
ticker = self.polo.returnTicker()[pair]
return ticker
def getOrderBooks(self, pair):
""" get orders"""
return self.polo.returnOrderBook(pair, '10')
def getLoanOrders(self):
"""get Loan orders"""
#orders = self.polo.returnLoanOrders('BTC')
order = self.polo.returnLoanOrders('BTC')
return order
def getActiveLoanOffers(self):
"""get my active loan offers"""
return self.polo.returnOpenLoanOffers()
def getActiveLoans(self):
"""get my active loans"""
return self.polo.returnActiveLoans()
class PoloniexDriver:
fee = 0.0025
name = "Poloniex"
def __init__(self, api_key, secret):
api_p=''
key_p=''
self.api=Poloniex(api_key, secret)
pass
def get_market_info(self):
market={}
try:
tickers=self.api.returnTicker()
for pairs, ticker in tickers.iteritems():
pair=pairs.split('_')
pair=tuple(pair)
market[pair]=(float(ticker['lowestAsk']), float(ticker['highestBid']))
except:
market={}
return market
def get_txFee(self):
txfee=list()
currencies=self.api.returnCurrencies()
for k, v in currencies.iteritems():
txfee.append(( k, v['name'], v['txFee'])) # create list of tuples(len = 2) 1 - trade, 2- trade name 3 - txFee
return txfee
def get_order(self, pairs): # return from lists sells and buy
pair = '{0}_{1}'.format(pairs[0], pairs[1])
try:
orders=self.api.returnOrderBook(pair,1) # return lists sells and buy
ask_rate=float(orders['asks'][0][0]) # ask-sell rate
bid_rate=float(orders['bids'] [0][0])#bid-buy rate
ask_quanity=float(orders['asks'][0][1])
bid_quanity=float(orders['bids'] [0][1])
order={'ask_rate': ask_rate, 'ask_quanity': ask_quanity, 'bid_rate': bid_rate, 'bid_quanity': bid_quanity}
except:
order={'ask_rate': '0', 'ask_quanity': '0', 'bid_rate': '0', 'bid_quanity': '0'}
return order
class TestPoloniex(object):
def setup(self):
self.poloniex = Poloniex('', '')
def test_ticker(self):
res = self.poloniex.returnTicker()
assert 'BTC_ETH' in res.keys()
assert 'lowestAsk' in res['BTC_ETH'].keys()
def test_volume(self):
res = self.poloniex.return24hVolume()
assert 'BTC_ETH' in res.keys()
assert 'BTC' in res['BTC_ETH'].keys()
def test_orderbook(self):
res = self.poloniex.returnOrderBook('BTC_ETH')
assert 'bids' in res.keys()
assert 'asks' in res.keys()
def test_tradehistory(self):
start = datetime.now() - timedelta(hours=1)
res = self.poloniex.returnTradeHistory('BTC_ETH', start)
assert len(res)
assert 'date' in res[0].keys()
assert 'type' in res[0].keys()
assert 'amount' in res[0].keys()
assert 'rate' in res[0].keys()
def test_chartdata(self):
start = datetime.now() - timedelta(hours=1)
res = self.poloniex.returnChartData('BTC_ETH', 300, start)
assert len(res)
assert 'date' in res[0].keys()
assert 'volume' in res[0].keys()
assert 'high' in res[0].keys()
assert 'low' in res[0].keys()
assert 'close' in res[0].keys()
class poloniex(Exchange):
def __init__(self):
self.client = Poloniex()
self.assets = {
'btc' : 2,
'eth' : 0,
'usd' : 10000000000,
'xrp' : 10000
}
self.maker_fee = 0.001 * 1
def getMarketDepth(self, sym):
return self.client.returnOrderBook(currencyPair = sym, depth = 10)
def getLastTradingPrice(self, sym):
return self.client.returnTicker()[sym]['last']
def getPortfolioValue(self):
return self.assets['btc'], self.assets['xrp']
backoff("The Order does not work, Maybe to small") # Error if can't calculate
exit(1)
while True: #5 get the orderbook of the coinpair (All Sell & Buy Orders)
try:
MinOrder = 0.0001 # Minimal order worth in BTC = Poloniex Trading Rule
if MinOrder > AltSellWorth: # Compare MinOrder with AltSellWorth (see #4 if)
print(" ---SELL Order To Small To Place---")
break # stop if loop
elif MinOrder > AltBuyWorth: # Compare MinOrder with AltBuyWorth (see #4 else)
print(" ---BUY Order To Small To Place---")
break # stop elseif loop
else: # run the buy/sell part if order is not to small
if float(AltWorth) >= float(budget): # SELL!!! Compare SellOrder with Available Bids
#print("**SELL** AltWorth HIGHER budget")
OrderBidsPrice0 = polo.returnOrderBook()[pair]['bids'][0][0] # Collect highest buyorder (0) price
OrderBidsAmount0 = polo.returnOrderBook()[pair]['bids'][0][1] # Collect highest buyorder (0) amount
OrderBidsSum0 = float(OrderBidsAmount0) * float(OrderBidsPrice0) # Calculate highest buyorder BTC Value
if float(AltSellWorth) <= float(OrderBidsSum0): # Sell if highest bid (in BTC) is bigger than AltSellWorth (in BTC)
sell = polo.sell(pair, Bid, AltSell) # Make the SellOrder
print("---!SELL Complete!--- fitted in first Bid")
break
else: # Highest BuyOrder (0) is to small, Calculate for 1st & 2nd BuyOrder (0&1)
print("Order is Bigger than BidsSum0")
OrderBidsPrice1 = polo.returnOrderBook()[pair]['bids'][1][0] # Collect 2nd highest buyorder (1) price
OrderBidsAmount1 = polo.returnOrderBook()[pair]['bids'][1][1] # Collect 2nd highest buyorder (1) amount
OrderBidsSum1 = float(OrderBidsAmount1) * float(OrderBidsPrice1) # Calculate 2nd highest buyorder BTC Value
OrderBidsSum01 = float(OrderBidsSum0) + float(OrderBidsSum1) # Calculate 1st & 2nd highest buyorders BTC Value
if float(AltSellWorth) >= float(OrderBidsSum01): #Highest BuyOrders (0&1) to small. Calculate for Order 0,1&2
class PoloniexBroker(BrokerBaseClass):
"""
Inherits from alchemist_lib.broker.broker.BrokerBaseClass.
Website: https://poloniex.com/
Api documentation: https://poloniex.com/support/api/
Api wrapper: https://github.com/s4w3d0ff/python-poloniex
Attributes:
session (sqlalchemy.orm.session.Session): Database connection.
polo (poloniex.Poloniex): Communication object.
"""
def __init__(self, api_key = None, secret_key = None):
"""
Costructor method.
Args:
api_key (str): The api key provided by Poloniex.
secret_key (str): The secret key provided by Poloniex.
Note:
https://poloniex.com/apiKeys
https://cryptocatbot.com/api-key-activation-exchanges/
"""
BrokerBaseClass.__init__(self)
self.polo = Poloniex(key = api_key, secret = secret_key)
def get_best_rate(self, asset, amount, field):
"""
Poloniex doesn't allow to place market orders so we need to get the best bid/ask price for every order.
Args:
asset (alchemist_lib.database.asset.Asset): The asset we want to exchange for BTC.
amount (decimal.Decimal): The amount we want to exchange.
field (str): Must be "ask" or "bid".
Return:
price (decimal.Decimal): The best bid/ask, executing an order at this price is like execute a market order. If the book is too thin the return value is 0.
"""
amount = abs(amount)
pair = "BTC_{}".format(asset.ticker)
book = self.polo.returnOrderBook(currencyPair = pair, depth = 20)
values = book["{}s".format(field)]
orders_sum = Decimal(0)
for book_item in values:
orders_sum += Decimal(book_item[1])
if orders_sum > amount:
return Decimal(book_item[0])
return Decimal(0)
def place_order(self, asset, amount, order_type):
"""
Places an order for a specific asset on Poloniex.
Args:
asset (alchemist_lib.database.asset.Asset): The asset we want exchange for BTC.
amount (decimal.Decimal): The amount we want to exchange.
order_type (str): Type of order.
Return:
order_id (int): The order identifier, if some error occurs returns -1.
"""
pair = "BTC_{}".format(asset.ticker)
if amount > 0:
field = "ask"
operation = "buy"
else:
field = "bid"
operation = "sell"
if order_type == "MKT":
rate = self.get_best_rate(asset = asset, amount = abs(amount), field = field)
else:
logging.critical("Unknown order type. NotImplemented raised.")
raise NotImplemented("Unknown order type. NotImplemented raised.")
logging.debug("Order: Pair: {}. Amount: {}. Operation: {}".format(pair, amount, operation))
try:
if operation == "buy":
order_dict = self.polo.buy(currencyPair = pair, rate = rate, amount = amount)
else:
order_dict = self.polo.sell(currencyPair = pair, rate = rate, amount = abs(amount))
order_id = int(order_dict["orderNumber"])
order = ExecutedOrder(order_id = order_id,
order_datetime = dt.datetime.utcnow(),
ticker = asset.ticker,
instrument_id = asset.instrument_id,
amount = amount,
operation = operation,
order_type = order_type,
broker_name = "poloniex",
exchange_name = "poloniex"
)
logging.info("{} order placed for {}. Amount: {}. Order id: {}.".format(operation.upper(), asset.ticker, amount, order_id))
print("{} order placed for {}. Amount: {}. Order id: {}.".format(operation.upper(), asset.ticker, amount, order_id))
self.session.add(order)
self.session.commit()
except PoloniexError:
logging.debug("Order failed for {}.".format(asset.ticker))
order_id = -1
return order_id
from poloniex import Poloniex import pandas as pd # Account key APIKEY = "PUT APIKEY HERE" SECRET = "PUT SECRET HERE" # Create poloniex object and initialize currency pair polo = Poloniex(APIKEY, SECRET) currency_pair = 'USDT_BTC' depth = 20000 # Get the data pair_data = polo.returnOrderBook(currency_pair, depth) asks_array = pair_data['asks'] bids_array = pair_data['bids'] # Create dataframe from 'asks' data asks_df = pd.DataFrame(asks_array, columns=['askRate', 'askAmount']) asks_df['askRate'] = asks_df['askRate'].apply(pd.to_numeric) asks_df['Product'] = asks_df['askRate'] * asks_df['askAmount'] # Create dataframe from 'bids' data bids_df = pd.DataFrame(bids_array, columns=['bidRate', 'bidAmount']) bids_df['bidRate'] = bids_df['bidRate'].apply(pd.to_numeric) bids_df['Product'] = bids_df['bidRate'] * bids_df['bidAmount'] # Aggregation of 'Rate' column total_ask_product = asks_df['Product'].sum()
import sys
from poloniex import Poloniex
logging.basicConfig()
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
if __name__ == '__main__':
polo = Poloniex()
market = 'BTC_STR'
spend_amount = 0.00200000
ob = polo.returnOrderBook(currencyPair=market)
pprint(ob)
bids = ob['bids']
asks = ob['asks']
print('BIDS:')
pprint(bids)
print('ASKS:')
pprint(asks)
ask_amount_total = 0
ask_price_total = 0
for ask in asks:
class Polo(Exchange):
trade = False
polon = 0
def __init__(self):
self.polon = Poloniex()
self.polon.key = config['polo']['key']
self.polon.secret = config['polo']['secret']
def get_exchange_name(self):
return "Poloniex"
def short_crypto(self, _crypto, _quantity, _price):
symbol = "USDT_" + _crypto
if trade:
order = self.polon.sell(symbol, _price, _quantity)
logger.info("Poloniex short " + _crypto + ". Quantity: " +
Util.float_to_str(_quantity) + ", Price: " + str(_price))
def long_crypto(self, _crypto, _quantity, _price):
symbol = "USDT_" + _crypto
if trade:
order = self.polon.buy(symbol, _price, _quantity)
logger.info("Poloniex short " + _crypto + ". Quantity: " +
Util.float_to_str(_quantity) + ", Price: " + str(_price))
def get_balances(self):
balances = self.polon.returnBalances()
non_zero_balances = {}
for key, value in balances.items():
if float(value) > 0:
non_zero_balances[key] = float(value)
return non_zero_balances
def get_balance_usd(self):
balance = float(self.polon.returnTicker()['USDT_ETH']['last']) * float(
self.polon.returnBalances()['ETH'])
balance = balance + float(self.polon.returnTicker(
)['USDT_DASH']['last']) * float(self.polon.returnBalances()['DASH'])
balance = balance + float(self.polon.returnTicker()['USDT_ZEC']['last']
) * float(self.polon.returnBalances()['ZEC'])
balance = balance + float(self.polon.returnTicker()['USDT_BCH']['last']
) * float(self.polon.returnBalances()['BCH'])
balance = balance + float(self.polon.returnTicker()['USDT_BTC']['last']
) * float(self.polon.returnBalances()['BTC'])
balance = balance + float(self.polon.returnBalances()['USDT'])
return balance
def get_lowest_ask(self, _crypto):
asks = self.polon.returnOrderBook()['USDT_' + _crypto]['asks']
lowestAsk = 10000000
for ask in asks:
ask_price = float(ask[0])
if ask_price < lowestAsk:
lowestAsk = ask_price
return lowestAsk
def get_highest_bid(self, _crypto):
bids = self.polon.returnOrderBook()['USDT_' + _crypto]['bids']
highest_bid = 0
for bid in bids:
bid_price = float(bid[0])
if bid_price > highest_bid:
highest_bid = bid_price
return highest_bid
def get_make_fee(self):
return 0.0015
def get_take_fee(self):
return 0.0025
from conf import config
from conf import database_setup as db
import time
import datetime
from poloniex import Poloniex
api_key = config.API_KEY
api_secret = config.API_SECRET
polo = Poloniex(api_key, api_secret)
while True:
time1 = time.time()
orders = polo.returnOrderBook(currencyPair='all', depth='1')
for key in orders:
if key not in config.PAIRS:
continue
data = orders[key]
buy = float(data['asks'][0][0])
sell = float(data['bids'][0][0])
avg = (buy + sell) / 2
ts = datetime.datetime.utcnow().timestamp()
with db.session_scope() as session:
session.add(
db.Price(
ts=ts,
avg=avg,
buy=buy,
sell=sell,
pair=key,
class Trader(object):
def __init__(self,
api_key,
api_secret,
coin,
currency,
dust_total=10,
dust_amount=100.0,
min_spread=0.0001,
max_trading_amount=1):
# set currency pair
self.coin = coin
self.currency = currency
self.my_pair = '%s_%s' % (currency, coin)
# we'll need this while finding buy/sell prices
self.dust_total = self.make_satoshi(dust_total)
self.dust_amount = self.make_satoshi(dust_amount)
self.min_spread = self.make_satoshi(min_spread)
self.max_trading_amount = self.make_satoshi(max_trading_amount)
# initialize the poloniex api
self.api_key = api_key
self.api_secret = api_secret
self.polo = Poloniex(api_key, api_secret)
# initialize other variables
self.coin_balance = self.make_satoshi('0.0')
self.currency_balance = self.make_satoshi('0.0')
self.total_coin_balance = self.make_satoshi('0.0')
self.total_currency_balance = self.make_satoshi('0.0')
self.open_orders_raw = []
self.open_orders = []
self.open_orders_sell = []
self.open_orders_buy = []
self.order_book_raw = []
self.order_book = {}
self.order_book["buy"] = []
self.order_book["sell"] = []
self.sell_price = self.make_satoshi('0.0')
self.buy_price = self.make_satoshi('0.0')
self.price_spread = self.make_satoshi('0.0')
self.sell_amount = self.make_satoshi('0.0')
self.buy_amount = self.make_satoshi('0.0')
self.trade = False
# those are hardcoded. may be added to settings later.
self.min_currency_balance = self.make_satoshi('0.00100000')
# seconds to wait for exchange rate limits.
self.exchange_wait_time = 0.8
def make_satoshi(self, num):
return decimal.Decimal(num).quantize(decimal.Decimal('1.00000000'))
def load_open_orders(self):
# loads open orders. Resets the balances so load_balances method should be called after.
self.total_coin_balance = self.make_satoshi('0.0')
self.total_currency_balance = self.make_satoshi('0.0')
self.open_orders_raw = self.polo.returnOpenOrders(
currencyPair=self.my_pair)
self.open_orders = []
self.open_orders_sell = []
self.open_orders_buy = []
for item in self.open_orders_raw:
order = {}
order['type'] = item['type']
order["order_number"] = item['orderNumber']
order["price"] = self.make_satoshi(item['rate'])
order["amount"] = self.make_satoshi(item['amount'])
order["total"] = self.make_satoshi(order['price'] *
order['amount'])
order["starting_amount"] = self.make_satoshi(
item['startingAmount'])
self.open_orders.append(order)
if order['type'] == 'sell':
self.open_orders_sell.append(order)
self.total_coin_balance = self.total_coin_balance + order[
"amount"]
else:
self.open_orders_buy.append(order)
self.total_currency_balance = self.total_currency_balance + order[
"total"]
return self.open_orders
def load_balances(self):
# first load the open orders to get the balances in open orders.
self.load_open_orders()
# request from exchange
self.balances = self.polo.returnBalances()
# set the coin balance
self.coin_balance = self.make_satoshi(self.balances[self.coin])
self.total_coin_balance = self.total_coin_balance + self.coin_balance
# '0.00000001' makes things complicated. get rid of it.
if self.coin_balance <= self.make_satoshi('0.00000001'):
self.coin_balance = self.make_satoshi('0.0')
if self.total_coin_balance <= self.make_satoshi('0.00000001'):
self.total_coin_balance = self.make_satoshi('0.0')
# set the main currency balance
self.currency_balance = self.make_satoshi(self.balances[self.currency])
self.total_currency_balance = self.total_currency_balance + self.currency_balance
# '0.00000001' makes things complicated. get rid of it.
if self.currency_balance <= self.make_satoshi('0.00000001'):
self.currency_balance = self.make_satoshi('0.0')
if self.total_currency_balance <= self.make_satoshi('0.00000001'):
self.total_currency_balance = self.make_satoshi('0.0')
# added for debugging. make the BTC amount > 0 so we can test buying.
# self.total_currency_balance = self.make_satoshi('0.10000000')
def load_order_book(self):
self.order_book_raw = self.polo.returnOrderBook(
currencyPair=self.my_pair, depth='200')
self.order_book["buy"] = []
self.order_book["sell"] = []
self.process_order_book('buy', self.order_book_raw["bids"])
self.process_order_book('sell', self.order_book_raw["asks"])
return self.order_book
def process_order_book(self, order_type, order_book_raw):
self.order_book[order_type] = []
total = self.make_satoshi("0.0")
for item in order_book_raw:
order = {}
order['type'] = order_type
order["price"] = self.make_satoshi(item[0])
order["amount"] = self.make_satoshi(item[1])
order["cur"] = self.make_satoshi(order["price"] * order["amount"])
total = self.make_satoshi(total + order["cur"])
order["total"] = total
# mark the order if its my order. put order number from open_orders
order['order_number'] = None
for open_order in self.open_orders:
if (open_order['type']
== order['type']) and (open_order["price"]
== order["price"]):
order["order_number"] = open_order['order_number']
print "order:", order
self.order_book[order_type].append(order)
return self.order_book[order_type]
def find_sell_price(self):
total = self.make_satoshi("0.0")
for order in self.order_book['sell']:
if order['order_number'] is None:
total = self.make_satoshi(total + order["cur"])
if (order["amount"] >= dust_amount) or (total >= dust_total):
return self.make_satoshi(order["price"] -
self.make_satoshi("0.00000003"))
return False
def find_buy_price(self):
total = self.make_satoshi("0.0")
for order in self.order_book['buy']:
if order['order_number'] is None:
total = self.make_satoshi(total + order["cur"])
if (order["amount"] >= dust_amount) or (total >= dust_total):
return self.make_satoshi(order["price"] +
self.make_satoshi("0.00000003"))
return False
def decide_to_trade(self):
self.sell_price = self.find_sell_price()
self.buy_price = self.find_buy_price()
self.price_spread = self.sell_price - self.buy_price
print "Sell Price:", self.sell_price
print "Buy Price:", self.buy_price
print "Price Spread:", self.price_spread
if (not self.sell_price) or (not self.buy_price):
print "Something is wrong with sell and buy prices. Will not trade!"
self.trade = False
return False
if self.total_currency_balance > self.min_currency_balance:
print 'I have %s %s, will try to buy %s.' % (
self.total_currency_balance, self.currency, self.coin)
self.trade = 'buy'
return True
else:
if self.price_spread >= self.min_spread:
print 'Spread is good. Will trade'
# sell or buy?
if self.total_coin_balance > 0:
print 'I have %s %s, will try to sell %s for %s.' % (
self.total_coin_balance, self.coin, self.coin,
self.currency)
self.trade = 'sell'
return True
else:
print 'I have nothing to trade.'
self.trade = False
else:
print 'Price Spread is not good. Stop trading.'
self.trade = False
return False
def cancel_open_orders(self, buy_sell):
for order in self.open_orders:
if order['type'] == buy_sell:
print "canceling order:", order
try:
retval = self.polo.cancelOrder(order["order_number"])
except:
retval = False
print 'ERROR canceling order.'
print "cancel order retval:", retval
self.open_orders.remove(order)
if buy_sell == 'sell':
self.open_orders_sell.remove(order)
else:
self.open_orders_buy.remove(order)
def cancel_open_order(self, order):
print "canceling order:", order
try:
retval = self.polo.cancelOrder(order["order_number"])
except:
retval = False
print 'ERROR canceling order.'
time.sleep(0.2)
print "cancel order retval:", retval
self.open_orders.remove(order)
if order['type'] == 'sell':
self.open_orders_sell.remove(order)
else:
self.open_orders_buy.remove(order)
def add_sell_order(self):
# compute the amount
if self.total_coin_balance > self.max_trading_amount:
self.sell_amount = self.max_trading_amount
else:
self.sell_amount = self.total_coin_balance
print "self.sell_amount:", self.sell_amount
# send order to exchange
try:
retval = self.polo.sell(currencyPair=self.my_pair,
rate=self.sell_price,
amount=self.sell_amount)
except:
print 'ERROR adding SELL order.'
retval = False
print retval
return retval
def sell(self):
# cancel all buy orders first.
self.cancel_open_orders('buy')
# check open sell orders if the sell price is ok.
for order in self.open_orders_sell:
if order['price'] == self.sell_price:
print "order is ok:", order
else:
# cancel the order.
retval = self.cancel_open_order(order)
print 'self.open_orders_sell:', len(self.open_orders_sell)
if len(self.open_orders_sell) == 0:
print 'adding a new sell order'
retval = self.add_sell_order()
def add_buy_order(self):
# compute the amount
if self.total_currency_balance > self.make_satoshi('0.00001000'):
self.buy_amount = self.make_satoshi(
self.total_currency_balance /
self.buy_price) - self.make_satoshi('0.00000001')
print "Buying amount:", self.buy_amount
else:
print "Buying amount is low. not buying:"
return False
# send order to exchange
try:
retval = self.polo.buy(currencyPair=self.my_pair,
rate=self.buy_price,
amount=self.buy_amount)
except:
print 'ERROR adding BUY order.'
retval = False
print retval
return retval
def buy(self):
# cancel all buy orders first.
self.cancel_open_orders('sell')
# check open sell orders if the sell price is ok.
for order in self.open_orders_buy:
if order['price'] == self.buy_price:
print "order is ok:", order
else:
# cancel the order.
retval = self.cancel_open_order(order)
print 'self.open_orders_buy:', len(self.open_orders_buy)
if len(self.open_orders_buy) == 0:
print 'adding a new buy order'
retval = self.add_buy_order()
def run_scalping(self):
while True:
now = datetime.datetime.now()
print str(now)
self.load_balances()
self.load_order_book()
print '%s Balance: %s' % (self.currency,
self.total_currency_balance)
print '%s Balance: %s' % (self.coin, self.total_coin_balance)
# trade or not trade?
trade = self.decide_to_trade()
print "Trade?", trade
if self.trade == 'sell':
self.sell()
elif self.trade == 'buy':
self.buy()
else:
#Will not trade. Cancel all orders.
self.cancel_open_orders('buy')
self.cancel_open_orders('sell')
print "."
print "open orders:", self.open_orders
print "."
now = datetime.datetime.now()
print str(now)
print "Will wait a little bit for not to flood the exchange..."
time.sleep(self.exchange_wait_time)
def add_sell_all_order(self):
# compute the amount
self.sell_amount = self.total_coin_balance
print "self.sell_amount:", self.sell_amount
if self.sell_amount:
# send order to exchange
try:
retval = self.polo.sell(currencyPair=self.my_pair,
rate=self.sell_price,
amount=self.sell_amount)
except:
print 'ERROR adding SELL ALL order.'
retval = False
print retval
return retval
else:
return False
def sell_all(self):
# cancel all buy orders first.
self.cancel_open_orders('buy')
# check open sell orders if the sell price is ok.
for order in self.open_orders_sell:
if order['price'] == self.sell_price:
print "order is ok:", order
else:
# cancel the order.
retval = self.cancel_open_order(order)
print 'self.open_orders_sell:', len(self.open_orders_sell)
if len(self.open_orders_sell) == 0:
print 'adding a new sell all order'
retval = self.add_sell_all_order()
def run_sell_all(self):
self.trade = 'sell'
while self.trade == 'sell':
now = datetime.datetime.now()
print str(now)
self.load_balances()
self.load_order_book()
print '%s Balance: %s' % (self.currency,
self.total_currency_balance)
print '%s Balance: %s' % (self.coin, self.total_coin_balance)
self.sell_price = self.find_sell_price()
print "Sell Price:", self.sell_price
if self.total_coin_balance > 0.0:
print 'I have %s %s, will try to sell %s for %s.' % (
self.total_coin_balance, self.coin, self.coin,
self.currency)
self.trade = 'sell'
else:
print 'I have nothing to trade.'
self.trade = False
if self.trade == 'sell':
self.sell_all()
else:
#Will not trade. Cancel all orders.
self.cancel_open_orders('buy')
self.cancel_open_orders('sell')
print "."
print "open orders:", self.open_orders
print "."
now = datetime.datetime.now()
print str(now)
print "Will wait a little bit for not to flood the exchange..."
time.sleep(self.exchange_wait_time)
def add_buy_all_order(self):
# compute the amount
if self.total_currency_balance > self.make_satoshi('0.00001000'):
self.buy_amount = self.make_satoshi(
self.total_currency_balance /
self.buy_price) - self.make_satoshi('0.00000001')
print "Buying amount:", self.buy_amount
else:
print "Buying amount is low. not buying:"
return False
# send order to exchange
try:
retval = self.polo.buy(currencyPair=self.my_pair,
rate=self.buy_price,
amount=self.buy_amount)
except:
print 'ERROR adding BUY ALL order.'
retval = False
print retval
return retval
def buy_all(self):
# cancel all buy orders first.
self.cancel_open_orders('sell')
# check open sell orders if the sell price is ok.
for order in self.open_orders_buy:
if order['price'] == self.buy_price:
print "order is ok:", order
else:
# cancel the order.
retval = self.cancel_open_order(order)
print 'self.open_orders_buy:', len(self.open_orders_buy)
if len(self.open_orders_buy) == 0:
print 'adding a new buy all order'
retval = self.add_buy_all_order()
def run_buy_all(self):
self.trade = 'buy'
while self.trade == 'buy':
now = datetime.datetime.now()
print str(now)
self.load_balances()
self.load_order_book()
print '%s Balance: %s' % (self.currency,
self.total_currency_balance)
print '%s Balance: %s' % (self.coin, self.total_coin_balance)
self.buy_price = self.find_buy_price()
print "Buy Price:", self.buy_price
if self.total_currency_balance > self.min_currency_balance:
print 'I have %s %s, will try to buy %s.' % (
self.total_currency_balance, self.currency, self.coin)
self.trade = 'buy'
else:
print 'I have nothing to trade.'
self.trade = False
if self.trade == 'buy':
self.buy_all()
else:
#Will not trade. Cancel all orders.
self.cancel_open_orders('buy')
self.cancel_open_orders('sell')
print "."
print "open orders:", self.open_orders
print "."
now = datetime.datetime.now()
print str(now)
print "Will wait a little bit for not to flood the exchange..."
time.sleep(self.exchange_wait_time)
class PoloniexClientWrapper:
MAX_TRIES = 3
SLEEP_TRIES = 1
API_KEY = EXCHANGE_DATA["poloniex"]["api_key"]
API_SECRET = EXCHANGE_DATA["poloniex"]["api_secret"]
def __init__(self):
self._client = Client(self.API_KEY, self.API_SECRET)
self._cache = dict()
def get_orderbook(self, symbol="BTC_USDT", limit=4612):
operation = PoloniexOperation.GET_ORDERBOOK
params = {"symbol": self._invert_symbol(symbol), "limit": limit}
return self._request(operation, params)
def get_orderbook_ticker(self, symbol="BTC_USDT"):
operation = PoloniexOperation.GET_ORDERBOOK_TICKER
params = {"symbol": self._invert_symbol(symbol)}
return self._request(operation, params)
def get_orderbook_tickers(self):
operation = PoloniexOperation.GET_ORDERBOOK_TICKERS
return self._request(operation)
def get_recent_trades(self, symbol="BTC_USDT", limit=200):
operation = PoloniexOperation.GET_RECENT_TRADES
params = {"symbol": self._invert_symbol(symbol), "limit": limit}
return self._request(operation, params)
def get_coins(self):
operation = PoloniexOperation.GET_COINS
return self._request(operation)
def _invert_symbol(self, symbol):
coin_1, coin_2 = symbol.split("_")
symbol = coin_2 + "_" + coin_1
return symbol
def _request(self, operation, params=dict()):
current_time = time.time()
# Create cache key.
key = str(operation)
for p in params:
key += str(params[p])
if key in self._cache and \
abs(current_time - self._cache[key]["time"]) < 60:
return self._cache[key]["database"]
else:
i = 0
while i < self.MAX_TRIES:
try:
if operation == PoloniexOperation.GET_ORDERBOOK:
response = self._client.returnOrderBook(
currencyPair=params["symbol"],
depth=params["limit"])
elif operation == PoloniexOperation.GET_ORDERBOOK_TICKER:
response = self._client.returnOrderBook(
currencyPair=params["symbol"], depth=1)
elif operation == PoloniexOperation.GET_ORDERBOOK_TICKERS:
response = self._client.returnOrderBook(
currencyPair="all", depth=1)
elif operation == PoloniexOperation.GET_RECENT_TRADES:
response = self._client.returnTradeHistoryPublic(
currencyPair=params["symbol"])[:params["limit"]]
elif operation == PoloniexOperation.GET_COINS:
response = self._client._private('returnBalances')
break
except Exception as e:
print(e)
if i < self.MAX_TRIES:
time.sleep(self.SLEEP_TRIES)
self._client = Client(self.API_KEY, self.API_SECRET)
current_time = time.time()
i += 1
else:
return None
if key not in self._cache:
self._cache[key] = dict()
# Update cache.
self._cache[key]["time"] = current_time
self._cache[key]["database"] = response
return response
import gdax
from poloniex import Poloniex
import pandas as pd
#### Polo Data
polo = Poloniex()
orders = polo.returnOrderBook()['BTC_ETH']
poloAsks = pd.DataFrame(orders['asks'])
poloAsks.columns = ['price', 'volume']
poloAsks = poloAsks.astype(float)
poloBids = pd.DataFrame(orders['bids'])
poloBids.columns = ['price', 'volume']
poloBids = poloBids.astype(float)
#### GDAX Data
public_client = gdax.PublicClient()
wsClient = gdax.WebsocketClient(url="wss://ws-feed.gdax.com",
products="ETH-BTC")
gdaxEthBtcOrderBook = public_client.get_product_order_book('ETH-BTC', level=2)
bids = dict.get(gdaxEthBtcOrderBook, 'bids')
asks = dict.get(gdaxEthBtcOrderBook, 'asks')
wsClient.close()
gdaxBids = pd.DataFrame(bids)
gdaxBids.columns = ["price", "volume", "orders"]
gdaxBids = gdaxBids.astype(float)
class PoloBot():
def __init__(self, api=None):
self.api = api
if not self.api:
self.api = Poloniex()
self.tick_count = 0
print(self.api.returnOrderBook(currencyPair="BTC_ETH", depth="10"))
self._ws = websocket.WebSocketApp('wss://api2.poloniex.com/',
on_open=self.on_open,
on_message=self.on_message,
on_error=self.on_error,
on_close=self.on_close)
def on_message(self, ws, message):
message = json.loads(message)
if 'error' in message:
return logger.error(message['error'])
# if message[0] == 1002:
# return logger.info('Subscribed to ticker')
if message[1] == 0:
return logger.info('Unsubscribed to ticker')
data = message[2]
data = [float(dat) for dat in data]
tick = {'id': data[0],
'last': data[1],
'lowestAsk': data[2],
'highestBid': data[3],
'percentChange': data[4],
'baseVolume': data[5],
'quoteVolume': data[6],
'isFrozen': data[7],
'high24hr': data[8],
'low24hr': data[9]
}
print(tick)
return
def on_error(self, ws, error):
logger.error(error)
return
def on_close(self, ws):
if self._t._running:
try:
self.stop()
except Exception as e:
logger.exception(e)
try:
self.start()
except Exception as e:
logger.exception(e)
self.stop()
else:
logger.info("Websocket closed!")
def on_open(self, ws):
self._ws.send(json.dumps({'command': 'subscribe', 'channel': 1002}))
@property
def status(self):
"""
Returns True if the websocket is running, False if not
"""
try:
return self._t._running
except:
return False
def start(self):
""" Run the websocket in a thread """
self._t = Thread(target=self._ws.run_forever)
self._t.daemon = True
self._t._running = True
self._t.start()
logger.info('Websocket thread started')
def stop(self):
""" Stop/join the websocket thread """
self._t._running = False
self._ws.close()
self._t.join()
logger.info('Websocket thread stopped/joined')
