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')