def __fee(self, exchange): nonce = str(int(time.time() * 1e6)) d = dict() if exchange == "trt": url = "https://api.therocktrading.com/v1/funds/BTCEUR" signature = hmac.new(self.secret_trt.encode(), msg=(str(nonce) + url).encode(), digestmod=hashlib.sha512).hexdigest() _headers = { "Content-Type": "application/json", "X-TRT-KEY": self.apikey_trt, "X-TRT-SIGN": signature, "X-TRT-NONCE": nonce } resp = requests.get(url, headers=_headers) d["feetrttaker"] = json.loads(resp.text)["buy_fee"] d["feetrtmaker"] = json.loads(resp.text)["sell_fee"] return d elif exchange == "krk": api = krakenex.API(self.apikey_krk, self.secret_krk) k = KrakenAPI(api) resp = pd.DataFrame(k.get_trade_volume("BTCEUR")[2]) d["feekrk"] = resp["XXBTZEUR"][0] return d elif exchange == "bnb": resp = self.client.get_trade_fee(symbol="BNBTRX") print(resp) d["feebnbtaker"] = resp["tradeFee"][0]["taker"] d["feebnbmaker"] = resp["tradeFee"][0]["maker"] return d
def __order(self, exchange, order): nonce = str(int(time.time() * 1e6)) d = dict() if order == None: return d if exchange == "TRT": url = "https://api.therocktrading.com/v1/funds/" + self.pair + "/orders/" + order signature = hmac.new(self.secret_TRT.encode(), msg=(str(nonce) + url).encode(), digestmod=hashlib.sha512).hexdigest() _headers = { "Content-Type": "application/json", "X-TRT-KEY": self.apikey_TRT, "X-TRT-SIGN": signature, "X-TRT-NONCE": nonce } resp = requests.get(url, headers=_headers) print("TRT", resp) d["status_TRT"] = json.loads(resp.text)["status"] return d elif exchange == "krk": print( "FUNCTION NOT ENABLED ON KRAKEN EXCHANGE, USE OTHER EXCHANGES FOR THIS FEATURE TO WORK" ) exit(2) api = krakenex.API(self.apikey_krk, self.secret_krk) k = KrakenAPI(api) resp = pd.DataFrame(k.get_trade_volume(self.pair)[2]) d["feekrk"] = resp["XXBTZEUR"][0] return d elif exchange == "BNB": resp = self.client.get_order(symbol=self.pair, orderId=order) print("binance", resp) d["status_BNB"] = resp["status"] return d
def kraken(): api = krakenex.API() k = KrakenAPI(api) x = k.get_ticker_information('XBTUSD') for i in x: a = x.iloc[0][0][0] return a
def _get_backcast_data(self): api = krakenex.API() k = KrakenAPI(api) api.load_key('kraken_keys.py') df, last = k.get_ohlc_data(self.pair, interval=self.data_agg, ascending=True) df.index = df.index.tz_localize(tz='UTC').tz_convert('US/Central') return df
def __init__(self): super().__init__() args = json.load(open('krakenKey.json')) api = krakenex.API(**args) self.kraken = KrakenAPI(api) accounts = self.kraken.get_account_balance() print(accounts) return
def __init__(self, interval=1, waitInterval=1, **params): self.KAPI = KrakenAPI(krakenex.API()) self.ohlc, self.since = self.KAPI.get_ohlc_data( "BTCUSD", interval=interval, since=None, ascending=True, ) self.interval = interval self.waitInterval = waitInterval super().__init__(**params)
def __init__(self, folder, pair, timezone): # initiate api self.api = krakenex.API() self.k = KrakenAPI(self.api, tier=0, retry=.1) # set pair self.pair = pair self.tz = pytz.timezone(timezone) # set and create folder self.folder = folder os.makedirs(self.folder + pair, exist_ok=True)
def trade(self, exchange, fund_id, side, amount, price): nonce = str(int(time.time() * 1e6)) print(amount) amount = round(amount, 8) if exchange == "trt": url = "https://api.therocktrading.com/v1/funds/" + fund_id + "/orders" payload_trt = { "fund_id": "BTCEUR", "side": side, "amount": amount, "price": 0 } signature = hmac.new(self.secret_trt.encode(), msg=(str(nonce) + url).encode(), digestmod=hashlib.sha512).hexdigest() _headers = { 'User-Agent': 'PyRock v1', "Content-Type": "application/json", "X-TRT-KEY": self.apikey_trt, "X-TRT-SIGN": signature, "X-TRT-NONCE": nonce } resp = requests.post(url, data=json.dumps(payload_trt), headers=_headers) try: return json.loads(resp.text) except KeyError: return "ERROR" elif exchange == "krk": api = krakenex.API(self.apikey_krk, self.secret_krk) k = KrakenAPI(api) resp = k.add_standard_order(fund_id, side, "limit", str(amount), str(price)) resp = str(resp).replace("\'", "\"") return resp elif exchange == "bnb": if side == "buy": order = self.client.order_limit_buy(symbol=fund_id, quantity=round(amount, 8), price=price) elif side == "sell": order = self.client.order_limit_sell(symbol=fund_id, quantity=round(amount, 8), price=price) return dict(order)
def get_data(monnaie='XXBTZEUR', interval=60, since=None): """Renvoie une DataFrame de max 720 valeurs selon : - la paire de monnaie (monnaie) choisie sous forme de string. Par defaut elle vaut 'XXBTZEUR' et renvoie donc la valeur du Bitcoin en Euros. Si la paire pose problème, tenter de rajouter un X devant la cryptomonaie et un Z devant la monnaie "classique", comme pour la valeur par défaut. (se référer aux monnaies disponibles sur la plateforme Kraken) - l'intervalle (interval) en minutes, qui représente l'intervalle temporel entre deux entrées de la DataFrame. Par défaut elle vaut 60. - la date de début (since). Par défaut la fonction renvoie les 720 dernières valeurs selon l'intervalle choisi. """ api = krakenex.API() k = KrakenAPI(api) ohlc = k.get_ohlc_data(monnaie, interval, since) return ohlc[0]
def calculate_capital(): # Connect to API: con = krakenex.API() con.load_key(kraken_key_filepath) api = KrakenAPI(con) volume = api.get_account_balance() crypto_on_hand = volume.loc[CRYPTO][0] open_position = check_openPosition(crypto_on_hand) if open_position: current_price = float( api.get_ticker_information(CRYPTO + FIAT)['c'][0][0]) return round(current_price * crypto_on_hand, 2) else: return round(float(volume.loc[FIAT][0]), 2)
def __init__(self, pair='XXBTZUSD', timezone='America/New_York', folder='data'): # initiate api api = krakenex.API() self.k = KrakenAPI(api, tier=0, retry=.1) # set pair self.pair = pair self.tz = pytz.timezone(timezone) # set and create folder self.folder = folder os.makedirs(os.path.join(self.folder, pair), exist_ok=True)
def get_api(): """Get krakenx API object""" log.debug("Getting kraken API object") kx_api = krakenex.API(get_secret("KRAKEN_KEY"), get_secret("KRAKEN_SECRET")) return KrakenAPI(kx_api)
def __balance(self, exchange): nonce = str(int(time.time() * 1e6)) d = dict() if exchange == "trt": url = "https://api.therocktrading.com/v1/balances" signature = hmac.new(self.secret_trt.encode(), msg=(str(nonce) + url).encode(), digestmod=hashlib.sha512).hexdigest() _headers = { "Content-Type": "application/json", "X-TRT-KEY": self.apikey_trt, "X-TRT-SIGN": signature, "X-TRT-NONCE": nonce } resp = requests.get(url, headers=_headers) d["trtbtc"] = json.loads(resp.text)["balances"][0]["balance"] d["trteur"] = json.loads(resp.text)["balances"][8]["balance"] return d elif exchange == "krk": api = krakenex.API(self.apikey_krk, self.secret_krk) k = KrakenAPI(api) resp = k.get_account_balance() d["krkbtc"] = resp["vol"]["XXBT"] d["krkbch"] = resp["vol"]["BCH"] return d elif exchange == "bnb": is_fine = True while is_fine: try: is_fine = False except ConnectionError: print( f"{Fore.RED}[ERR] CHECK INTERNET CONNECTION{Style.RESET_ALL}" ) try: d["bnbtrx"] = float( self.client.get_asset_balance(asset="TRX")["free"]) d["bnbbnb"] = float( self.client.get_asset_balance(asset="BNB")["free"]) except Exception: d["bnbtrx"] = float( self.client.get_asset_balance(asset="TRX")["free"]) d["bnbbnb"] = float( self.client.get_asset_balance(asset="BNB")["free"]) return d
class KrakenData(Data): def __init__(self, interval=1, waitInterval=1, **params): self.KAPI = KrakenAPI(krakenex.API()) self.ohlc, self.since = self.KAPI.get_ohlc_data( "BTCUSD", interval=interval, since=None, ascending=True, ) self.interval = interval self.waitInterval = waitInterval super().__init__(**params) async def dataGenerator(self): wait = 60 maxRows = 2880 blockSize = 1440 retry = 0 timer = None while retry < 10: if timer is not None: await timer try: ohlcnew, self.since = self.KAPI.get_ohlc_data( "BTCUSD", interval=self.interval, since=self.since, ascending=True, ) except Exception: await asyncio.sleep(wait) retry += 1 continue # Remove the last enty as it is unconfirmed retry = 0 self.ohlc.drop(self.ohlc.tail(1).index, inplace=True) self.ohlc = self.ohlc.append(ohlcnew) if len(self.ohlc) >= maxRows: self.ohlc.drop(self.ohlc.head(blockSize).index, inplace=True) timer = asyncio.create_task(asyncio.sleep(self.waitInterval * wait)) yield self.ohlc raise ConnectionError("Retry Exceeded 10")
def create_client_from_config(config): retry = config["API"].get("retry", 0) crl_sleep = config["API"].get("crl_sleep", 5) tier = config["API"].get("tier", "Intermediate") api_key = config["API"].get("key", None) secret = config["API"].get("secret", None) client = krakenex.API(key=api_key, secret=secret) client = KrakenAPI(client, retry=float(retry), crl_sleep=float(crl_sleep), tier=tier) return client
class CryptoTracker(object): def __init__(self, config): api = krakenex.API() self.k = KrakenAPI(api) self.config = config def get_exchange_rate(self, crypto, fiat): pair = "X{}Z{}".format(crypto, fiat) ticker = self.k.get_ticker_information(pair) return ticker def get_currencies(self): return { 'XRP': XrpHandler(self.config), 'ETH': EthHandler(self.config), 'XBT': XbtHandler(self.config), 'LTC': LtcHandler(self.config), } def get_local_currency(self): return self.config.local_currency def get_fiat_currency(self): return self.config.fiat_currency def get_exchange_rates(self, base=None): url = 'https://api.fixer.io/latest' if base is not None: url += '?base={}'.format(base) req = requests.get(url) rates = json.loads(req.text) return rates['rates'] def update_currencies(self): accounts = self.config.accounts balances = defaultdict(float) rates = defaultdict(float) crypto_currencies = self.get_currencies() for curr in accounts.keys(): ohlc = self.get_exchange_rate( curr, crypto_currencies[curr].fiat_currency()) if ohlc is not None and len(ohlc) > 0: rates[curr] = float(ohlc.iloc[0]['c'][0]) balances[curr] += crypto_currencies[curr].update(accounts[curr]) positions = { curr: balances[curr] * rates[curr] for curr in balances if curr in rates and curr in balances } return balances, positions
def __init__(self, instance, data={}, parent=None): JSConfigClient.__init__(self, instance=instance, data=data, parent=parent, template=TEMPLATE) import krakenex from pykrakenapi import KrakenAPI kraken_api = krakenex.API() kraken_api.key = self.config.data["api_key_"] kraken_api.secret = self.config.data["private_key_"] self.api = KrakenAPI(kraken_api)
def __init__(self, exchanges): '''exchanges = comma separated list of exchanges you want to monitor''' self.exchanges = [e.lower() for e in exchanges] # Depending on which exchanges got included, connect to APIs if 'kraken' in self.exchanges: self.kraken_api = krakenex.API() self.kraken = KrakenAPI(self.kraken_api) if 'gdax' in self.exchanges: self.gdax = gdax_api.PublicClient() if 'bittrex' in self.exchanges: self.bittrex = Bittrex(None, None) if 'coinmarketcap' in self.exchanges: self.coinmarketcap = Market()
def connect_account(self, kraken_key_filepath): '''Connects to a private Kraken account. kraken_key_filepath : str kraken_key_filepath must be a Python file in the format: <API_KEY> <API_SECRET_KEY> On the first two lines. pair : ticker pair that you are trading interval : aggregation of the historical data ''' # Connect to API: con = krakenex.API() con.load_key(kraken_key_filepath) api = KrakenAPI(con) return api, con
def __init__(self,market=None): #Make sure the intialised values are set for the Connections if market==None: raise NameError("No market pair defined. Add pair=xxx to the Controller initialization") #Make the connections once for better practice #without storing keys #Try make a connection to the Kracken API try: api = krakenex.API() #Use the kraken wapper for better functionality self.client = KrakenAPI(api) except: print("Couldn't make a connection to the Kraken API") print("exit") sys.exit(1) # self.market = market
class GetTradeData(object): def __init__(self, pair='XXBTZUSD', timezone='America/New_York', folder='data'): # initiate api api = krakenex.API() self.k = KrakenAPI(api, tier=0, retry=.1) # set pair self.pair = pair self.tz = pytz.timezone(timezone) # set and create folder self.folder = folder os.makedirs(os.path.join(self.folder, pair), exist_ok=True) def download_trade_data(self, since): folder = os.path.join(self.folder, self.pair) # update or new download if since is 0: fs = os.listdir(folder) if len(fs) > 0: fs.sort() last = int(fs[-1].split('.')[0]) else: last = 0 else: last = since # get data while True: try: time.sleep(0.75) fname = os.path.join(folder, '{}.pickle'.format(str(last).zfill(19))) trades, last = self.k.get_recent_trades(pair=self.pair, since=last) # set timezone index = trades.index.tz_localize(pytz.utc).tz_convert(self.tz) trades.index = index # store print('Data Downloader: storing', fname) trades.to_pickle(fname) except AttributeError: # can't tz_localize on empty (last) trades print('Data Downloader: download/update finished!') break def agg_ohlc(self, since, interval=[0]): folder = os.path.join(self.folder, self.pair) if interval == [0]: from config import INTERVALS interval = INTERVALS # fetch files and convert to dataframe fs = os.listdir(folder) fs.sort(reverse=True) if since > 0: fs = [f for f in fs if int(f.split('.')[0]) >= since * 1e9] trades = [] for f in fs: print(f) if f[0] == '.': continue trades.append(pd.read_pickle(os.path.join(folder, f))) trades = pd.concat(trades, axis=0) trades.loc[:, 'cost'] = trades.price * trades.volume # store on disc # fname = self.folder + self.pair + '_trades.pickle' # print('\nData Downloader: storing', fname) # trades.to_pickle(fname) for i in interval: # resample gtrades = trades.resample('{}min'.format(i)) if i == 1: fname = os.path.join(self.folder, 'OHLC', self.pair + '.pickle') else: fname = os.path.join(self.folder, 'OHLC', self.pair + '_{}.pickle'.format(i)) # ohlc, volume ohlc = gtrades.price.ohlc() ohlc.loc[:, 'volume'] = gtrades.volume.sum() ohlc.volume.fillna(0, inplace=True) closes = ohlc.close.fillna(method='pad') ohlc = ohlc.apply(lambda x: x.fillna(closes)) # vwap ohlc.loc[:, 'vwap'] = gtrades.cost.sum() / ohlc.volume ohlc.vwap.fillna(ohlc.close, inplace=True) # count ohlc.loc[:, 'count'] = gtrades.size() # store on disc print('\nData Downloader: storing', fname) ohlc.to_pickle(fname)
import krakenex from pykrakenapi import KrakenAPI api = krakenex.API() k = KrakenAPI(api) ohlc, last = k.get_ohlc_data(pair="BCHUSD", interval=30) print('Fetching from Kraken API:\n', ohlc.head(1), '\n') import numpy as np import talib close = np.array(ohlc.close.to_list()) high = np.array(ohlc.high.to_list()) low = np.array(ohlc.low.to_list()) print("Candlestick information:") print("Candle Close\n", close[-10:], "\n") print("Candle High\n", high[-10:], "\n") print("Candle Low\n", low[-10:], "\n") simple_moving_average = talib.SMA(close) print("simple_moving_average:\n", simple_moving_average[-10:], "\n") macd, macdsignal, macdhist = talib.MACD(close, fastperiod=12, slowperiod=26, signalperiod=9) print("MACD:\n", macd[-10:], "\n") parbolic_sar = talib.SAR(high, low, acceleration=1, maximum=1) print("parbolic_sar:\n", parbolic_sar[-10:], "\n")
import pandas as pd import matplotlib.pyplot as plt import boto import schedule import time from logger import logging import requests session = requests.Session() session.verify = False import krakenex from pykrakenapi import KrakenAPI api = krakenex.API() k = KrakenAPI(api) api.load_key('kraken_keys.py') df = k.get_trades_history(start=1558587601)[0] df.index = df.index.tz_localize(tz='UTC').tz_convert('US/Central') cols = ['ordertxid','cost', 'fee', 'margin', 'price', 'vol', 'type', 'ordertype'] df2 = df[cols].reset_index().groupby('ordertxid', as_index=False).agg({'dtime':'first', 'cost':'sum', 'fee':'sum', 'margin':'sum', 'price':'sum','vol':'sum', 'type':'first', 'ordertype':'first' }) df3 = df2.set_index('dtime').sort_values('dtime') df3['is_closing'] = ['open' if x=='limit' else 'close' for x in df3['ordertype']] def is_long(row): order_type = row[0] is_closing = row[1] if ((order_type=='buy') & (is_closing=='open')) | ((order_type=='sell') & (is_closing=='close')): return 'long' else: return 'short'
class GetTradeData(object): def __init__(self, folder, pair, timezone): # initiate api self.api = krakenex.API() self.k = KrakenAPI(self.api, tier=0, retry=.1) # set pair self.pair = pair self.tz = pytz.timezone(timezone) # set and create folder self.folder = folder os.makedirs(self.folder + pair, exist_ok=True) def download_trade_data(self, since): folder = self.folder + self.pair + '/' # update or new download? if since is 0: fs = os.listdir(folder) if len(fs) > 0: fs.sort() last = int(fs[-1].split('.')[0]) else: last = 0 else: last = since # get data while True: try: fname = folder + '{}.pickle'.format(str(last).zfill(19)) trades, last = self.k.get_recent_trades(pair=self.pair, since=last) # set timezone index = trades.index.tz_localize(pytz.utc).tz_convert(self.tz) trades.index = index # store print('storing', fname) trades.to_pickle(fname) except CallRateLimitError: print('\n this should not happen. please report an issue on ' 'github! thanks. \n') raise except ValueError: print('download/update finished!') break def agg_ohlc(self, interval): folder = self.folder + self.pair + '/' # fetch files and convert to dataframe fs = os.listdir(folder) fs.sort(reverse=True) trades = [] for f in fs: trades.append(pd.read_pickle(folder + f)) trades = pd.concat(trades, axis=0) trades.loc[:, 'cost'] = trades.price * trades.volume # resample gtrades = trades.resample('{}min'.format(interval)) # ohlc, volume ohlc = gtrades.price.ohlc() ohlc.loc[:, 'vol'] = gtrades.volume.sum() ohlc.vol.fillna(0, inplace=True) closes = ohlc.close.fillna(method='pad') ohlc = ohlc.apply(lambda x: x.fillna(closes)) # vwap ohlc.loc[:, 'vwap'] = gtrades.cost.sum() / ohlc.vol ohlc.vwap.fillna(ohlc.close, inplace=True) # count ohlc.loc[:, 'count'] = gtrades.size() # store on disc fname = self.folder + self.pair + '_{}.pickle'.format(interval) print('storing', fname) ohlc.to_pickle(fname)
def __init__(self, config): api = krakenex.API() self.k = KrakenAPI(api) self.config = config
Created on Mon Dec 18 13:03:45 2017 @author: austin """ import krakenex from pykrakenapi import KrakenAPI #import os api = krakenex.API() key = "ignored/new_key.key" api.load_key(key) api.query_private(method="Balance") k = KrakenAPI(api) k.get_account_balance() k.get_trades_history() ohlc, last = k.get_ohlc_data("BCHUSD") print(ohlc) print(last) # open trade descr = k.add_standard_order(pair="XBTEUR", type="buy", ordertype="market", volume=0.002) descr k.get_open_orders(trades=True)
class Kraken(ExchangeBase, ABC): def __init__(self): super().__init__() args = json.load(open('krakenKey.json')) api = krakenex.API(**args) self.kraken = KrakenAPI(api) accounts = self.kraken.get_account_balance() print(accounts) return # for account in accounts: # currency = account['currency'] # balance = float(account['available']) # self.wallets[currency] = Wallet(currency, balance) # print(currency, balance) # if balance > self.valueWallet.amount: # self.valueWallet = self.wallets[currency] # self.fee = 0.0025 def get_last_trade_price(self, symbol): ticker = self.kraken.get_product_ticker(symbol) return float(ticker['price']) def buy(self, key): buy_symbol = (key + "-" + self.arbitrar.currency).replace( "BTC", "XBT").replace("-", "") amount = str(self.arbitrar.amount // 0.01 / 100) order = self.kraken.buy(product_id=buy_symbol, type='market', funds=amount) if 'message' in order.keys(): raise InsufficientFundsError(order['message']) settled = order['settled'] while not settled: order = self.kraken.get_order(order['id']) settled = order['settled'] time.sleep(0.12) self.wallets[key].amount = float(order['filled_size']) self.arbitrar.amount = 0 self.valueWallet = self.wallets[key] # NOTE: This includes the fee! rate = float(order['executed_value']) / float(order['filled_size']) return buy_symbol, rate def sell(self): sell_symbol = (self.valueWallet.currency + "-" + self.arbitrar.currency).replace("BTC", "XBT").replace("-", "") amount = str(self.valueWallet.amount) order = self.kraken.sell(product_id=sell_symbol, type='market', size=amount) if 'message' in order.keys(): raise InsufficientFundsError(order['message']) settled = order['settled'] while not settled: order = self.kraken.get_order(order['id']) settled = order['settled'] time.sleep(0.12) self.arbitrar.amount = float(order['executed_value']) self.valueWallet.amount = 0 self.valueWallet = self.arbitrar # NOTE: This includes the fee! rate = float(order['executed_value']) / float(order['filled_size']) return sell_symbol, rate def get_name(self): return "kraken"
def get_price_from_kraken(kraken_token): krakenApi = KrakenAPI(krakenex.API()); krakenprice = krakenApi.get_ticker_information(kraken_token).loc[kraken_token]['a'][0] return float(krakenprice)
import sys, json, numpy as np import krakenex from pykrakenapi import KrakenAPI import decimal import time import nltk import numpy as np import random import string from sklearn.linear_model import LinearRegression #connection to the kraken api api = krakenex.API() k = KrakenAPI(api) #user message treatement greeting_input = ( "hello", "hi", "greetings", "what's up", "hey", ) greeting_responses = ["hi !", "hey !", "hi there !", "hello !"] farewell_input = ("bye", "goodbye") simple_question_input = ("open", "close", "high", "low", "vwap", "volume") possible_pairs = ("bcheur", "bchusd", "bchxbt", "xxbtzeur", "xbtzusd", "xethxxbt", "xethzusd", "xethzeur") predictions_input = ("short", "long", "short-term", "long-term") sample_input = ("yesterday", "week", "weeks")
def __init__(self, key=[''], secret=[''], sftppassword='', settings=None): """ Constructor of the Kraken Core Class This sets up the connection to Kraken and sets the global variables. Parameters ---------- key : list of str, optional -The keys to a kraken account secret : list of str, optional -The secrets to a kraken account sftppassword : str, optional -The password to the sftpserver settings : dict, optional - A dictionary of the settings to be used Returns ------- Class - A kraken core class """ #Check if market specified in settings file and #Figure out what market we are interested in if not "Ex_Market1" in settings.keys(): print( "Need a Kraken Exchange market specified in the settings file") print("Specify Ex_Market1 keyword in settings file") raise if not "Ex_Market2" in settings.keys(): print( "Need a Kraken Excahnge market 2 specified in the settings file" ) print("Specify Ex_Market2 keyword in settings file") raise else: market = settings["Ex_Market1"] + settings["Ex_Market2"] # #Do Trivial checks if market == "": raise NameError( "No market pair defined. Add pair=xxx to the Controller initialization" ) if key == ['']: print( "No Kraken Key defined. No key=xxx given to the Controller initialization" ) if secret == ['']: print( "No Kraken secret defined. No secret=xxx given to the Controller initialization" ) #Make the connections once for better practice #without storing keys #Try make all connection to the Kracken API try: print("Using Keys from input") print("*****MAKE SURE KEYS/SECRETS IN RIGHT ORDER") #Loop over all keys/secrets self.clients = [] for keyj, secretj in zip(key, secret): #Make the connection api_j = krakenex.API(key=keyj, secret=secretj) #Use the kraken wapper for better functionality self.clients.append(KrakenAPI(api_j)) #Make a way to cycle through the keys self.client_cycler = cycle(self.clients) except: traceback.print_exc() print("Couldn't make a connection to the Kraken API") print("exit") raise #Setup FileBot if there is any self.Setup_FileBot(settings, sftppassword) #Save for later self.market = market self.min_price = settings["min_increment"] #This is not bp self.bp = 0.0001 #This is bp self.acct_mrkt1 = self.Kraken_Lookup_Acct_Market( settings["Ex_Market1"]) self.acct_mrkt2 = self.Kraken_Lookup_Acct_Market( settings["Ex_Market2"]) #Find the number of significant digits so we can round #the price later digits = format(self.min_price, ".16f") #Seperate based on dot digits = digits.partition(".")[2] self.min_price_digit = len(digits) - len(digits.lstrip("0")) + 1 #Setup stuff if "dust" in settings.keys(): self.dust = settings["dust"] if "volume" in settings.keys(): self.tot_vol = settings["volume"] if "odepth" in settings.keys(): self.odepth = settings["odepth"]