Example #1
0
    def __init__(self, etherAddr, krakenKey, host='localhost', port='8545'):
        self.__isConnected = False
        self.currentWindow = eosutils.getCurrentWindow()

        # Connect to Ethereum
        try:
            self.eosContract = eoscontract.EOSContract(etherAddr, host, port)
            self.eosContract.connect()
            if self.eosContract.isConnected():
                log.info('Connection to Ethereum successful.')
                self.__isConnected = True
            else:
                log.error("Error connecting to Ethereum node.")
                return
        except:
            self.__isConnected = False
            log.error("Error connecting to Ethereum.")
            traceback.print_exc()
            return

        # Connect to EOS
        try:
            self.kraken = krakenex.API()
            self.kraken.load_key(krakenKey)
            self.krakenConn = krakenex.Connection()
            log.info('Connection to Kraken successful.')
        except:
            self.__isConnected = False
            log.error("Error connecting to Kraken.")
            return
def get_multi_closes(api = k, interval = 1, assets = assets_):
    global c
    results = []
    for asset_ in assets:
        timeline_raw = None
        while timeline_raw == None:
            try:
                print("\n" + asset_ + ": Asking for closes...")                
                timeline_raw = api.query_public('OHLC', req = {'pair':asset_, 'interval':interval})['result'][asset_]
            except:
                api = krakenex.API() #paloaltomünster
                c = krakenex.Connection()
                print("Reconnecting to kraken...")
                time.sleep(10)
        times = []
        closes = []
        
        for entry in timeline_raw:
            times.append(entry[0])
            closes.append(eval(entry[4]))
        
        filename = asset_ + ".txt"
            
        if os.path.isfile(filename):
            old_file = numpy.loadtxt(filename)
            old_times = old_file[:,0]
            old_closes = old_file[:,1] 
            old_max_time = old_times.max()
        else:
            old_max_time = 0
        
        new_times = []
        new_closes = []
        n = 0
        if 'old_file' in locals():
            print('\n' + asset_ + ": Combining old and new data...")
            for time_ in old_times:
                new_times.append(time_)
            for close in old_closes:
                new_closes.append(close)
            for i, time_ in enumerate(times):        
                if time_ > old_max_time:
                    n += 1
                    new_times.append(time_)
                    new_closes.append(closes[i])
            del old_file
        else:
            for i, time_ in enumerate(times):
                n += 1
                new_times.append(time_)
                new_closes.append(closes[i])
        new_entries = n
        print(asset_ + ': Closes cached')
        print(asset_ + ': ' + str(new_entries) + ' new entries.')
        results.append([new_times, new_closes, old_max_time, new_entries])
    return results
def get_closes(api=k, interval=1, filename='results.txt'):
    global c
    timeline_raw = None
    while timeline_raw == None:
        try:
            print("Asking for closes...")
            timeline_raw = api.query_public('OHLC',
                                            req={
                                                'pair': asset_,
                                                'interval': interval
                                            })['result'][asset_]
        except:
            api = krakenex.API()  #paloaltomünster
            c = krakenex.Connection()
            time.sleep(10)
    times = []
    closes = []

    for entry in timeline_raw:
        times.append(entry[0])
        closes.append(eval(entry[4]))

    if os.path.isfile(filename):
        old_file = numpy.loadtxt(filename)
        old_times = old_file[:, 0]
        old_closes = old_file[:, 1]
        old_max_time = old_times.max()
    else:
        old_max_time = 0

    new_times = []
    new_closes = []
    n = 0
    if 'old_file' in locals():
        print("Combining old and new data...")
        for time_ in old_times:
            new_times.append(time_)
        for close in old_closes:
            new_closes.append(close)
        for i, time_ in enumerate(times):
            if time_ > old_max_time:
                n += 1
                new_times.append(time_)
                new_closes.append(closes[i])
    else:
        for i, time_ in enumerate(times):
            n += 1
            new_times.append(time_)
            new_closes.append(closes[i])
    new_entries = n
    print('Closes cached')
    return new_times, new_closes, old_max_time, new_entries
Example #4
0
def run_kraken_book():

    global KrakenBook

    try:
        KrakenBook = k.query_public(KrakenURL)
        print("Finish running Bookqueries")

    except Exception:
        k = krakenex.API()
        k.load_key('kraken.key')
        k.set_connection(krakenex.Connection())
        KrakenBook = k.query_public(KrakenURL)
        print("Finish running Bookqueries on Exception")

    return KrakenBook
Example #5
0
def kraken_order_book(book_type: str,
                      currency_code: str = 'EUR',
                      coin_code: str = 'XBT'):
    """Kraken specific orderbook retrieval

    """
    import krakenex

    kraken_api = krakenex.API(key=KRAKEN_API_KEY,
                              secret=KRAKEN_PRIVATE_KEY,
                              conn=krakenex.Connection())

    pair = f'X{coin_code}Z{currency_code}'
    orders = kraken_api.query_public('Depth', {'pair': pair})

    df = pd.DataFrame(orders['result'][pair][book_type],
                      columns=['price', 'volume', 'timestamp'])

    return df
# Initial Variables
ArbitrageOpp = 0
ArbitrageOppArray = []
Iterations = 0

GDticker = "eth-usd"

#Kraken Variables
#kraken.key is the file of API Key and Private Key
KrakenFile = open('krakenXRPAdd.txt', 'r')
KRippleAdd = KrakenFile.readline()

#Kraken Authentication Info
k = krakenex.API()
k.load_key('kraken.key')
k.set_connection(krakenex.Connection())

ticker = "XXRPZUSD"  #Kraken Ticker
KrakenURL = "Depth?pair=XXRPZUSD"
KOpenID = []

# Bitstamp Variables
# Read Keys
BitFile = open('bitstampXRPkey.txt', 'r')
BSticker = "xrpusd"  #Bitstamp Ticker
BitClientID = '421841'
BitAPIKey = BitFile.readline()  #Ripple yaoshi
BitAPISecret = BitFile.readline()  #Ripple mimi
BitRippleAdd = BitFile.readline()  #Ripple Qianbao
BitRippleDest = BitFile.readline()  #Ripple Destination tag
import krakenex
import numpy
import os
import time
import threading
import matplotlib.pylab as pylab
import ftp_helper as ftp
import tkinter as tk
from tkinter import filedialog
import requests

print('Connecting to kraken...')
while not 'k' in locals():
    try:        
        k = krakenex.API() #paloaltomünster
        c = krakenex.Connection()
    except:
        pass
print('Connected to kraken.')

assetpairs = None

while(assetpairs == None):
    try:
        assetpairs = k.query_public('AssetPairs')['result']
    except:
        pass
assets_ = ['XETHZEUR', 'XREPZEUR', 'XXRPXXBT', 'XXLMZEUR', 'XLTCZEUR', 'XXBTZEUR', 'XETCZEUR', 'XXMRZEUR', 'XETHXXBT', 'GNOEUR', 'XETCXETH', 'XZECZEUR', 'XICNXXBT', 'XXLMXXBT', 'XXMRXXBT', 'DASHXBT'] 

def get_multi_closes(api = k, interval = 1, assets = assets_):
    global c
Example #8
0
 def __connect(self):
     self.__disconnect()
     self.log.info("Connecting to Kraken...")
     self.conn = krakenex.Connection()
     self.interface = krakenex.API(self.api_key, self.private_key,
                                   self.conn)
Example #9
0
def init():
    global krakken_connection
    logger.info('Initializing krakken exchange')
    c = krakenex.Connection()
    krakken_connection = krakenex.api.API(api_key, api_sign, c)