Het grote Cryptocurrency-Fok!-bot topic

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194

from time import sleep
import krakenex
import socket
import numpy

"""
NOTE:
Trades are based on last trade regardless how it is performed, including type of order, currency pair, costs, etc.
Volume for each buy and sell orders can be set in variable 'vol'
Trades can be limited by setting the while loop to number of trades

Current settings:
Ohlc data per minute
Regression triggers <x and >x
Price triggers buy <x% and sell >x% from last order cost

"""

k = krakenex.API()
k.load_key('kraken3.key')
c = krakenex.Connection()

"""
INFO LAST TRADE
"""

def last_trade():
    global last_cost
    global last_type
    global last_trade_id
    global last_currency

    time_dict = {}

    tradeslist = k.query_private('TradesHistory').get('result', {}).get('trades')
    trade_ids = list(tradeslist.keys())

    for i in trade_ids:
        time_dict[i] = tradeslist[i].get('time')

    last_trade = max(time_dict.values())
    last_trade_id = list(time_dict.keys())[list(time_dict.values()).index(last_trade)]
    tradeslist = k.query_private('TradesHistory').get('result', {}).get('trades')
    last_currency = tradeslist.get(last_trade_id).get('pair')
    last_cost = float(tradeslist.get(last_trade_id).get('price'))
    last_type = tradeslist.get(last_trade_id).get('type')

last_trade()
print("")
print("Last trade: ", last_trade_id, last_type, last_currency, last_cost)

"""
METHOD TO BUY OR SELL BASED ON BALANCE WALLET
"""

def wallet_biteur():
    global eur
    global bit

    wallet = (k.query_private('Balance'))

    for key, value in wallet.items():
        if key == 'result':
            wlt=(key, value)
            overview=(wlt[1])
            bit = overview['XXBT']
            eur = overview['ZEUR']

def wallet_repeur():
    global eur
    global rep

    wallet = (k.query_private('Balance'))

    for key, value in wallet.items():
        if key == 'result':
            wlt=(key, value)
            overview=(wlt[1])
            rep = overview['XREP']
            eur = overview['ZEUR']

"""
INFO CURRENT PRICES
"""

Ticker = last_currency
allowed_trades = 5          # change number while loop to 'allowed trades'
#vol = 0.015                # fixed or call method to buy or sell volume based on wallet balance
timer = 20                  # delay in loop (seconds)
interval = 10               # interval for regression coeff (minutes)

def ohlc_meth():
    global r_corr

    x = []
    y = []

    ohlc = k.query_public('OHLC', {'pair': Ticker, 'interval': '1'}).get('result', {}).get(Ticker)

    for i in ohlc:
        a = float(i[0])
        b = float(i[1])
        x.append(a)
        y.append(b)

    x = x[-interval:]
    y = y[-interval:]

    r_corr = numpy.corrcoef(x, y)[0, 1]

"""

!!!!! WARNING !!!!!
!!!!! CHECK ROUNDINGS FOR VOLUME AND BUY/SELL PRICES!!!!

"""

trade_no = 0

while trade_no < 5:
    try:
        koers = k.query_public('Ticker', {'pair': Ticker}).get('result', {}).get(Ticker, {})
        ask_prijs = float(koers.get('a')[0])
        bid_prijs = float(koers.get('b')[0])
        all_closed = k.query_private('OpenOrders', {}).get('result', {}).get('open') == {}
        if all_closed == False:  # False means not all orders closed
            print("Order still open or data not retrievable")
            sleep(timer)
        else:
            try:
                last_trade()
                ohlc_meth()
                if last_type == 'sell':
                    compare = ask_prijs / last_cost
                    if r_corr > 0.2:
                        if compare < 0.96:
                            price_buy = round(float(last_cost*0.96),3)
                            wallet_repeur()
                            buy_vol = round(((float(eur) / float(ask_prijs))*0.99),3)
                            k.query_private('AddOrder', {'pair': Ticker,
                                                         'type': 'buy',
                                                         'ordertype': 'limit',
                                                         'price': price_buy,
                                                         'volume': buy_vol,
                                                         'leverage': 'none',
                                                         'starttm': '0',
                                                         'expiretm': '0'})
                            print("Buy for", price_buy)
                            trade_no += 1
                            sleep(timer)
                        else:
                            compare = ask_prijs / last_cost
                            print("Wait for buy","  Last:", last_type, "  Ask:", "{0:.5f}".format(ask_prijs), "  Ratio:", "{0:.3f}".format(compare), "  Reg:", r_corr)
                            sleep(timer)
                    else:
                        print("Wait for buy","  Last:", last_type, "  Ask:", "{0:.5f}".format(ask_prijs), "  Regression coeff: ", r_corr)
                        sleep(timer)
                else:
                    compare = bid_prijs / last_cost
                    if r_corr < -0.2:
                        if compare > 1.05:
                            price_sell = round(float(last_cost*1.05),3)
                            wallet_repeur()
                            sell_vol = round((float(rep)*0.99),3)
                            k.query_private('AddOrder', {'pair': Ticker,
                                                         'type': 'sell',
                                                         'ordertype': 'limit',
                                                         'price': price_sell,
                                                         'volume': sell_vol,
                                                         'leverage': 'none',
                                                         'starttm': '0',
                                                         'expiretm': '0'})
                            trade_no += 1
                            print("Sell for", price_sell)
                            sleep(timer)
                        else:
                            compare = bid_prijs / last_cost
                            print("Wait for sell","  Last:", last_cost, "  Bid:", "{0:.5f}".format(bid_prijs), "  Ratio:", "{0:.3f}".format(compare), "  Reg:", r_corr)
                            sleep(timer)
                    else:
                        print("Wait for sell","  Last:", last_cost, "  Bid:", "{0:.5f}".format(bid_prijs), "  Regression coeff: ", r_corr)
                        sleep(timer)
            except ValueError:
                continue
            except AttributeError:
                continue
    except ValueError:
        continue
    except TypeError:
        continue
    except socket.timeout as err:
        continue
    except TimeoutError:
        continue