def load_data(start): # Connect to API: con = krakenex.API() con.load_key(kraken_key_filepath) api = KrakenAPI(con) # Load past trading data: count = 0 total_count = 1 df_list = [] unix_start = api.datetime_to_unixtime(pd.to_datetime(start)) while count < total_count: df, all_count = api.get_trades_history(start=unix_start, ofs=count) df = df[df['pair'] == CRYPTO + FIAT] df_list.append(df) total_count = all_count count += len(df) df = pd.concat(df_list).reset_index() df = df.drop_duplicates() # Convert to Central time: df['dtime'] = pd.to_datetime( pd.to_datetime(df['dtime']).dt.tz_localize('UTC').dt.tz_convert( 'US/Central').dt.strftime('%Y-%m-%d %H:%M:%S')) # Merge trades with the same order id: df_wrangled = df.reset_index().groupby('ordertxid', as_index=False).agg({ 'dtime': 'min', 'type': 'min', 'ordertype': 'min', 'price': 'min', 'cost': 'sum', 'fee': 'sum', 'vol': 'sum' }).sort_values('dtime').reset_index(drop=True) # Build buy/sell matching ids: df_wrangled['trade_matchID'] = 0 buy = False matchID = 1 for i, row in df_wrangled.iterrows(): # Skip the first trade if it's a sell if row['type'] == 'sell': if buy: df_wrangled['trade_matchID'][i] = matchID matchID += 1 buy = False else: continue elif row['type'] == 'buy': df_wrangled['trade_matchID'][i] = matchID buy = True # Put the buy and the sell on the same line: df_sell = df_wrangled[df_wrangled['type'] == 'sell'].set_index( 'trade_matchID') df_buy = df_wrangled[df_wrangled['type'] == 'buy'].set_index( 'trade_matchID') df_trade = df_buy.merge(df_sell, how='left', left_index=True, right_index=True, suffixes=['_buy', '_sell']) # Build new fields: df_trade['time_held'] = df_trade['dtime_sell'] - df_trade['dtime_buy'] df_trade['time_held'] = [str(x) for x in df_trade['time_held']] df_trade['fee_total'] = df_trade['fee_buy'] + df_trade['fee_sell'] df_trade['abs_return'] = df_trade['cost_sell'] - df_trade['cost_buy'] df_trade['feeAdjusted_abs_return'] = df_trade['cost_sell'] - df_trade[ 'fee_total'] - df_trade['cost_buy'] df_trade['pct_return'] = df_trade['abs_return'] / df_trade['cost_buy'] df_trade['feeAdjusted_pct_return'] = df_trade[ 'feeAdjusted_abs_return'] / df_trade['cost_buy'] df_trade['winning_trade'] = [ 1 if x > 0 else 0 for x in df_trade['feeAdjusted_pct_return'] ] return df_trade
def get_open_orders(trades=None, userref=None): kraken = krakenex.API(key=public_key, secret=private_key) #result = kraken.query_private('OpenOrders', {'trades': trades, 'userref':userref}) result = kraken.query_private('OpenOrders', {}) return result
# # # Balance Result: # {'error': [], 'result': {'ZUSD': '0.0000', 'XXBT': '0.0434289700'}} # ISSUE WITH STRING VALUES # # import os import schedule import time, datetime import krakenex from influxdb import InfluxDBClient k = krakenex.API() k.load_api_key(os.environ.get('KRAKEN_API_KEY'), os.environ.get('KRAKEN_API_SECRET')) infx_client = InfluxDBClient(host=os.environ.get('INFLUXDB_HOST'), port=os.environ.get('INFLUXDB_PORT')) infx_client.switch_database('db') def collect(): balance_result = k.query_private('Balance') balance_return = balance(balance_result) print(balance_return) def balance(balance_result): # data = [
def get_ticker_info(pair): kraken = krakenex.API(key=public_key, secret=private_key) result = kraken.query_public('Ticker', {'pair': pair}) return result
def get_recent_trades(pair, since=None): kraken = krakenex.API(key=public_key, secret=private_key) result = kraken.query_public('Trades', {'pair': pair, 'since': since}) return result
def query_ledgers(ids): kraken = krakenex.API(key=public_key, secret=private_key) result = kraken.query_private('QueryLedgers', {'id': ids}) return result
def get_server_time(): kraken = krakenex.API(key=public_key, secret=private_key) result = kraken.query_public('Time') return result
def initApi(key, secret): api = krakenex.API(key=key, secret=secret) k = pykrakenapi.KrakenAPI(api, retry=0, crl_sleep=0) return k
class Kraken(ExchangeBase): api = krakenex.API() k = KrakenAPI(api) def __init__(self): super().__init__() self.wallets["LTC"] = Wallet("LTC", 0) self.wallets["ETH"] = Wallet("ETH", 0) self.wallets["BCH"] = Wallet("BCH", 0) self.wallets["BTC"] = Wallet("BTC", 0) self.wallets["USD"] = Wallet("USD", 500) self.valueWallet = self.wallets["USD"] # Maker fee # self.fee = 0.0016 # Taker fee self.fee = 0.0026 def get_last_trade_price(self, symbol): my_symbol = symbol.replace("BTC", "XBT").replace("-", "") kraken_ticker = self.k.get_ticker_information(my_symbol) # c = last trade return float(kraken_ticker['c'][0][0]) def get_buy_price_for(self, key): # Maker order # return self.getHighestBidPriceFor(key) * (1 - self.fee)) * (1 + self.fee) # Taker order return self.get_market_buy_price_for(key, self.arbitrar.amount * (1 - self.fee)) * (1 + self.fee) def get_sell_price(self): key = self.valueWallet.currency # Maker order # return self.getLowestAskPriceFor(key) * (1 - self.fee)) * (1 - self.fee) # Taker order return self.get_market_sell_price_for(key, self.wallets[key].amount * (1 - self.fee)) * (1 - self.fee) def get_highest_bid_price_for(self, key): symbol = key + "-" + self.arbitrar.currency pair = symbols[symbol] book = self.k.get_order_book(pair)[1].astype('float').sort_values(by=['price'], ascending=False) return float(book.iloc[0]['price']) def get_lowest_ask_price_for(self, key): symbol = key + "-" + self.arbitrar.currency pair = symbols[symbol] book = self.k.get_order_book(pair)[0].astype('float').sort_values(by=['price']) return float(book.iloc[0]['price']) def get_market_buy_price_for(self, key, amount): symbol = key + "-" + self.arbitrar.currency pair = symbols[symbol] book = self.k.get_order_book(pair)[0].astype('float').sort_values(by=['price']) full_amount = amount price = i = 0 while amount > 0: volume = float(book.iloc[i]['volume']) this_price = float(book.iloc[i]['price']) this_amount = amount if amount < volume * this_price else volume * this_price price += this_price * this_amount / full_amount amount -= this_amount i += 1 return price def get_market_sell_price_for(self, key, amount): symbol = key + "-" + self.arbitrar.currency pair = symbols[symbol] book = self.k.get_order_book(pair)[1].astype('float').sort_values(by=['price'], ascending=False) full_amount = amount price = i = 0 while amount > 0: volume = float(book.iloc[i]['volume']) this_price = float(book.iloc[i]['price']) this_amount = amount if amount < volume else volume price += this_price * this_amount / full_amount amount -= this_amount i += 1 return price def get_name(self): return "kraken"
import socket #import gdax #pip install gdax from twilio.rest import Client #pip install twilio #from bitfinex.client import Client as bfxClient ''' This used to be a program that would trade the time delay between Kraken and GDAX/Bitfinex but that difference is now gone so it's just used as an interface for other trading programs to take methods from ''' #for twilio client = Client("AC1c40800c09f14885137023f22ac618b6", "264ebf359aedd9157f654f160ca22eb7") #for Kraken k = krakenex.API() #private methods k.load_key('kraken.key') kpublic = krakenex.API() # public methods # transaction IDs/info for closing extra trades: mainTXID = '' closeTXID = '' stoplossTXID = '' main = '' trade = '' closedirection = '' inPosition = False # Api Key Strings: _RATE_LIMIT_ERROR_ = 'EAPI:Rate limit exceeded' _K_CURR_ = 'XETHXXBT'
def __init__(self, key_path): self.kraken_api = krakenex.API() self.kraken_api.load_key(key_path)
def create_client_from_file(filename): kraken_client = krakenex.API() kraken_client.load_key(filename) return kraken_client
# ============================================================================= # Script working # (a) Hard stop to prevent loss of capital # Initially one that takes account balance and cashes everything # out when less than a certain value. # TODO: # 1) What errors need to be caught # set mininum account balance min_bal = 100000 invested = True pause_period = 60 # seconds # location of the api keys api_dir ="/home/austin/Dropbox/kraken_data/api" k = krakenex.API() # start api instance and load keys k.load_key(os.path.join(api_dir, 'kraken.key')) while(invested): # get the current balance curr_bal = k.query_private('Balance') # if the current balance is below our minimum if (curr_bal < min_bal): # get open positions # START: this code is copied verbatim from # https://github.com/veox/python3-krakenex/blob/master/examples/print-open-positions.py # prepare request
def fetch_data(): api = krakenex.API() k = KrakenAPI(api) ohlc, last = k.get_ohlc_data("BCHUSD") return ohlc, last
def get_trades_history(ofs, type=None, trades=None, start=None, end=None): kraken = krakenex.API(key=public_key, secret=private_key) result = kraken.query_private('TradesHistory', {'ofs': ofs}) return result
#linear regression and data plotting algorithm #third priority is integrating threading such that both processes run concurrently #fourth priority is making a GUI #fifth and final priority is implementing machine learning techniques import krakenex import time import datetime import threading from tkinter import * from queue import Queue key = krakenex.API() key.load_key('kraken.key') pair = 'XXBTZUSD' init_price = 0 init_quant = 0 iterator = 1 root = Tk() run_tot_price = 0 run_tot_quant = 0 pq_ratio = 0 prev_ratio = 0 count = 1 def updateGUI(text): GUISTR = Label(root, text=text) GUISTR.pack() def compute_variance(price, quantity, average_price, average_quant):
def query_trades_info(txid, trades=False): kraken = krakenex.API(key=public_key, secret=private_key) result = kraken.query_private('QueryTrades', {'txid': txid}) return result
def __init__(self): self.cache = ExpiringDict(max_len=100, max_age_seconds=5) self.logger = Logger().get_logger() self.k = krakenex.API()
def cancel_open_order(txid): kraken = krakenex.API(key=public_key, secret=private_key) result = kraken.query_private('CancelOrder', {'txid': txid}) return result
def __init__(self) : self.k = krakenex.API() self.k.load_key('kraken.key')
def get_asset_pairs(info=None, pair=None): kraken = krakenex.API(key=public_key, secret=private_key) result = kraken.query_public('Assets', {'info': info, 'pair': pair}) return result
def __init__(self, pair, api_key_file, minimum_fund, percent_alloc, sleepage): self.pair = pair self.api_key_file = api_key_file self.minimum_fund = minimum_fund self.k = krakenex.API() self.k.load_key(self.api_key_file) self.balance = self.k.query_private('Balance')['result'] self.open_orders = self.k.query_private('OpenOrders')['result']['open'] #self.trades = self.k.query_private('TradesHistory') self.assets = list(self.balance.keys()) self.tickers = { 'BTC/EUR': 'XXBT', 'ETH/EUR': 'XETH', 'DASH/EUR': 'XDASH', 'XRP/EUR': 'XXRP', 'DOT/EUR': 'DOT', 'BAT/EUR': 'BAT', 'ADA/EUR': 'ADA' } self.percent_alloc = percent_alloc self.sleepage = sleepage self.fund = float(self.balance['ZEUR']) self.buying_power = self.fund * self.percent_alloc try: self.crypto_value = float(self.balance[self.tickers[self.pair]]) except: pass self.candle_rankings = { "CDL3LINESTRIKE_Bull": 1, "CDL3LINESTRIKE_Bear": 2, "CDL3BLACKCROWS_Bull": 3, "CDL3BLACKCROWS_Bear": 3, "CDLEVENINGSTAR_Bull": 4, "CDLEVENINGSTAR_Bear": 4, "CDLTASUKIGAP_Bull": 5, "CDLTASUKIGAP_Bear": 5, "CDLINVERTEDHAMMER_Bull": 6, "CDLINVERTEDHAMMER_Bear": 6, "CDLMATCHINGLOW_Bull": 7, "CDLMATCHINGLOW_Bear": 7, "CDLABANDONEDBABY_Bull": 8, "CDLABANDONEDBABY_Bear": 8, "CDLBREAKAWAY_Bull": 10, "CDLBREAKAWAY_Bear": 10, "CDLMORNINGSTAR_Bull": 12, "CDLMORNINGSTAR_Bear": 12, "CDLPIERCING_Bull": 13, "CDLPIERCING_Bear": 13, "CDLSTICKSANDWICH_Bull": 14, "CDLSTICKSANDWICH_Bear": 14, "CDLTHRUSTING_Bull": 15, "CDLTHRUSTING_Bear": 15, "CDLINNECK_Bull": 17, "CDLINNECK_Bear": 17, "CDL3INSIDE_Bull": 20, "CDL3INSIDE_Bear": 56, "CDLHOMINGPIGEON_Bull": 21, "CDLHOMINGPIGEON_Bear": 21, "CDLDARKCLOUDCOVER_Bull": 22, "CDLDARKCLOUDCOVER_Bear": 22, "CDLIDENTICAL3CROWS_Bull": 24, "CDLIDENTICAL3CROWS_Bear": 24, "CDLMORNINGDOJISTAR_Bull": 25, "CDLMORNINGDOJISTAR_Bear": 25, "CDLXSIDEGAP3METHODS_Bull": 27, "CDLXSIDEGAP3METHODS_Bear": 26, "CDLTRISTAR_Bull": 28, "CDLTRISTAR_Bear": 76, "CDLGAPSIDESIDEWHITE_Bull": 46, "CDLGAPSIDESIDEWHITE_Bear": 29, "CDLEVENINGDOJISTAR_Bull": 30, "CDLEVENINGDOJISTAR_Bear": 30, "CDL3WHITESOLDIERS_Bull": 32, "CDL3WHITESOLDIERS_Bear": 32, "CDLONNECK_Bull": 33, "CDLONNECK_Bear": 33, "CDL3OUTSIDE_Bull": 34, "CDL3OUTSIDE_Bear": 39, "CDLRICKSHAWMAN_Bull": 35, "CDLRICKSHAWMAN_Bear": 35, "CDLSEPARATINGLINES_Bull": 36, "CDLSEPARATINGLINES_Bear": 40, "CDLLONGLEGGEDDOJI_Bull": 37, "CDLLONGLEGGEDDOJI_Bear": 37, "CDLHARAMI_Bull": 38, "CDLHARAMI_Bear": 72, "CDLLADDERBOTTOM_Bull": 41, "CDLLADDERBOTTOM_Bear": 41, "CDLCLOSINGMARUBOZU_Bull": 70, "CDLCLOSINGMARUBOZU_Bear": 43, "CDLTAKURI_Bull": 47, "CDLTAKURI_Bear": 47, "CDLDOJISTAR_Bull": 49, "CDLDOJISTAR_Bear": 51, "CDLHARAMICROSS_Bull": 50, "CDLHARAMICROSS_Bear": 80, "CDLADVANCEBLOCK_Bull": 54, "CDLADVANCEBLOCK_Bear": 54, "CDLSHOOTINGSTAR_Bull": 55, "CDLSHOOTINGSTAR_Bear": 55, "CDLMARUBOZU_Bull": 71, "CDLMARUBOZU_Bear": 57, "CDLUNIQUE3RIVER_Bull": 60, "CDLUNIQUE3RIVER_Bear": 60, "CDL2CROWS_Bull": 61, "CDL2CROWS_Bear": 61, "CDLBELTHOLD_Bull": 62, "CDLBELTHOLD_Bear": 63, "CDLHAMMER_Bull": 65, "CDLHAMMER_Bear": 65, "CDLHIGHWAVE_Bull": 67, "CDLHIGHWAVE_Bear": 67, "CDLSPINNINGTOP_Bull": 69, "CDLSPINNINGTOP_Bear": 73, "CDLUPSIDEGAP2CROWS_Bull": 74, "CDLUPSIDEGAP2CROWS_Bear": 74, "CDLGRAVESTONEDOJI_Bull": 77, "CDLGRAVESTONEDOJI_Bear": 77, "CDLHIKKAKEMOD_Bull": 82, "CDLHIKKAKEMOD_Bear": 81, "CDLHIKKAKE_Bull": 85, "CDLHIKKAKE_Bear": 83, "CDLENGULFING_Bull": 84, "CDLENGULFING_Bear": 91, "CDLMATHOLD_Bull": 86, "CDLMATHOLD_Bear": 86, "CDLHANGINGMAN_Bull": 87, "CDLHANGINGMAN_Bear": 87, "CDLRISEFALL3METHODS_Bull": 94, "CDLRISEFALL3METHODS_Bear": 89, "CDLKICKING_Bull": 96, "CDLKICKING_Bear": 102, "CDLDRAGONFLYDOJI_Bull": 98, "CDLDRAGONFLYDOJI_Bear": 98, "CDLCONCEALBABYSWALL_Bull": 101, "CDLCONCEALBABYSWALL_Bear": 101, "CDL3STARSINSOUTH_Bull": 103, "CDL3STARSINSOUTH_Bear": 103, "CDLDOJI_Bull": 104, "CDLDOJI_Bear": 104 }
def get_order_book(pair, count=None): kraken = krakenex.API(key=public_key, secret=private_key) result = kraken.query_public('Depth', {'pair': pair, 'count': count}) return result
def __init__(self, test_session=True, account_type="starter", key="", secret=""): """ in fact all functions work in the same way, if the Kapi object is not live, each function will make a call to connection :param live_connection: :param test_session: :param key: the key used for kraken authentication :param secret: the secret used for kraken authentication """ if account_type not in ["starter", "intermediate", "pro"]: raise Exception( f"Invalid parameter for account_type: {account_type}") if not isinstance(test_session, bool): raise Exception( f"Invalid parameter for test_section: {test_session}") self._api = krakenex.API(key, secret) self._test_session = test_session self._account_type = account_type self._max_api_counter = { "starter": 15, "intermediate": 20, "pro": 20, }[self._account_type] self._api_call_counter = 0 self._max_num_orders = { "starter": 60, "intermediate": 80, "pro": 225, }[self._account_type] self._order_counter = 0 self._max_rate_count = { "starter": 60, "intermediate": 125, "pro": 180, }[self._account_type] self._order_rate_counter = 0 self._api_counter_decay = { "starter": 0.33, "intermediate": 0.5, "pro": 1., }[self._account_type] self._ratecount_decay = { "starter": 1., "intermediate": 2.34, "pro": 3.75, }[self._account_type] self._last_pair_used = None self._last_query_time = None
def get_recent_spread_data(pair, since=None): kraken = krakenex.API(key=public_key, secret=private_key) result = kraken.query_public('Spread', {'pair': pair, 'since': since}) # Note: returns arrays of [time, bid, ask] return result
def __init__(self, keyfile="kraken.key"): self.k = krakenex.API() self.k.load_key(keyfile)
from Utils import notify, loadConfig logging.basicConfig(filename="log.log", format='%(asctime)s %(levelname)s: %(message)s', datefmt='%m/%d/%Y %I:%M:%S', level=logging.DEBUG) config = loadConfig("config.ini") if config["debugOnConsole"]: stderrLogger = logging.StreamHandler() stderrLogger.setFormatter( logging.Formatter('%(asctime)s %(levelname)s: %(message)s')) logging.getLogger().addHandler(stderrLogger) exchange = krakenex.API() exchange.load_key(config["apiFileName"]) api = KrakenApi(exchange) dailyTimeframe = 1440 fourHourTimeframe = 240 logging.info(config["botName"] + " started up!") if config["notifications"]: notify(config["botName"], config["botId"], config["chatId"], "Started up!") lastCandles = api.getCandlesSinceTime(config["pair"], time() - 86400 * (config["days"] + 1), dailyTimeframe)[:-1] lastDailyCandle = api.getLastCandle(config["pair"], dailyTimeframe) lastFourHourCandle = api.getLastCandle(config["pair"], fourHourTimeframe)
def get_query_orders(txid, trades=None, userref=None): kraken = krakenex.API(key=public_key, secret=private_key) result = kraken.query_private('QueryOrders', {'txid': txid}) return result
c_price = config['PRICE'] c_type = config['TYPE'] c_api = config['API'] # Seconds to delay each iteration delay = int(c_time['delay']) # Sell every X minutes delay_sell = (60 / delay) * int(c_time['attempt_minutes']) # API variables api_key = c_api['key'] api_sec = c_api['sec'] # Kraken API variables k = krakenex.API(key=api_key, secret=api_sec) # Trade variables buy_at = Decimal(0.67) sell_at = Decimal(0.75) max_buy = Decimal(c_price['max_buy']) coin = c_type['coin'] currency = c_type['currency'] # Dictionaries to send pair = '{coin}{currency}'.format(coin=coin, currency=currency) buy_dict = { 'pair': pair, 'ordertype': 'market', 'type': 'buy', 'volume': Decimal(c_volume['buy'])
help='Sets the periodicity of order book queries in seconds.' ) parser.add_argument( '-w', '--write_period', type=float, default=3600, required=False, help='Sets the write periodicity to S3 in seconds.' ) args = parser.parse_args() if args.sentry: sentry_sdk.init(args.sentry) # handles error alerting via email kraken = krakenex.API() # starts kraken session trade_ledger = [] time_id = args.time_id # used as initial time stamp for kraken to get data from collection_cycle_start_time = time.time() # tracking for upload periodicity to S3 if time_id == -1: # set time id to current time time_id = get_kraken_server_time() * 10 ** 9 while True: # query trades query_time = time.time() new_trades, time_id = get_recent_trade_data(args.pair, time_id) trade_ledger += new_trades logging.info("Current number of collected trades in memory: %s", len(trade_ledger))