492 lines
15 KiB
Python
Executable File
492 lines
15 KiB
Python
Executable File
#!/usr/bin/env python
|
|
|
|
import asyncio
|
|
import inspect
|
|
import shutil
|
|
import time
|
|
from enum import Enum
|
|
from time import sleep
|
|
from typing import Dict, List
|
|
|
|
import dotenv
|
|
import termplotlib
|
|
from asciimatics.screen import Screen
|
|
from bfxapi import Client, Order
|
|
from bfxapi.models.position import Position
|
|
from playsound import playsound
|
|
from termcolor import colored
|
|
|
|
|
|
class Ticker:
|
|
def __init__(self, sec) -> None:
|
|
self.seconds: int = sec
|
|
self.start_time = time.time()
|
|
self.current_tick: int = 1
|
|
|
|
|
|
class EventKind(Enum):
|
|
NEW_MINIMUM = 1,
|
|
NEW_MAXIMUM = 2,
|
|
REACHED_LOSS = 3,
|
|
REACHED_BREAK_EVEN = 4,
|
|
REACHED_MIN_PROFIT = 5,
|
|
REACHED_GOOD_PROFIT = 6,
|
|
REACHED_MAX_LOSS = 7,
|
|
CLOSE_POSITION = 8,
|
|
TRAILING_STOP_SET = 9,
|
|
TRAILING_STOP_MOVED = 10,
|
|
ORDER_SUBMITTED = 11,
|
|
|
|
|
|
class Event:
|
|
def __init__(self, kind: EventKind, tick: int) -> None:
|
|
self.kind: EventKind = kind
|
|
self.tick: int = tick
|
|
|
|
def __repr__(self) -> str:
|
|
return f"{self.kind.name} @ Tick {self.tick}"
|
|
|
|
|
|
class State(Enum):
|
|
CRITICAL = -1,
|
|
LOSS = 0,
|
|
BREAK_EVEN = 1,
|
|
MINIMUM_PROFIT = 2,
|
|
PROFIT = 3
|
|
|
|
def color(self) -> str:
|
|
if self == self.LOSS or self == self.CRITICAL:
|
|
return "red"
|
|
elif self == self.BREAK_EVEN:
|
|
return "yellow"
|
|
else:
|
|
return "green"
|
|
|
|
|
|
class Printer:
|
|
def __init__(self, screen: Screen):
|
|
self.screen: Screen = screen
|
|
self.current_line: int = 0
|
|
(self.current_width, self.current_height) = shutil.get_terminal_size()
|
|
|
|
def get_current_line(self) -> int:
|
|
return self.current_line
|
|
|
|
def next(self) -> int:
|
|
line = self.current_line
|
|
self.current_line += 1
|
|
return line
|
|
|
|
def print_next_line(self, text):
|
|
for line in text.split("\n"):
|
|
self.screen.print_at(line, 0, self.next(), 1)
|
|
self.screen.refresh()
|
|
|
|
def reset_current_line(self):
|
|
self.current_line = 0
|
|
|
|
def set_screen(self, screen: Screen):
|
|
self.screen = screen
|
|
|
|
def has_screen_resized(self):
|
|
return (self.current_width, self.current_height) != shutil.get_terminal_size()
|
|
|
|
def to_current_screen_size(self):
|
|
(self.current_width, self.current_height) = shutil.get_terminal_size()
|
|
|
|
|
|
class Status:
|
|
def __init__(self, tick_duration, symbol, printer):
|
|
self.ticker: Ticker = Ticker(tick_duration)
|
|
self.events: List[Event] = []
|
|
self.symbol = symbol
|
|
self.ticks: Dict[int, (float, Position)] = {}
|
|
self.current_state: State = State.LOSS
|
|
self.printer: Printer = printer
|
|
self.stop_percentage: float = None
|
|
|
|
async def update(self, position: Position):
|
|
self.ticks[self.get_current_tick()] = (await get_current_price(self.symbol), position)
|
|
|
|
def wait(self):
|
|
sleep(self.ticker.seconds)
|
|
self.ticker.current_tick += 1
|
|
|
|
def get_current_tick(self) -> int:
|
|
return self.ticker.current_tick
|
|
|
|
def last_events(self, n):
|
|
return self.events[-n:]
|
|
|
|
def last_position(self) -> Position:
|
|
return self.ticks[self.ticker.current_tick][1]
|
|
|
|
async def add_event(self, event: Event):
|
|
self.events.append(event)
|
|
await eh.call_event(event, self)
|
|
|
|
async def last_price(self) -> float:
|
|
return await get_current_price(self.symbol)
|
|
|
|
async def set_state(self, state: State):
|
|
if self.current_state != state:
|
|
event: Event = None
|
|
|
|
if state == State.CRITICAL:
|
|
event = Event(EventKind.REACHED_MAX_LOSS,
|
|
self.get_current_tick())
|
|
elif state == State.LOSS:
|
|
event = Event(EventKind.REACHED_LOSS,
|
|
self.get_current_tick())
|
|
elif state == State.BREAK_EVEN:
|
|
event = Event(EventKind.REACHED_BREAK_EVEN,
|
|
self.get_current_tick())
|
|
elif state == State.MINIMUM_PROFIT:
|
|
event = Event(EventKind.REACHED_MIN_PROFIT,
|
|
self.get_current_tick())
|
|
elif state == State.PROFIT:
|
|
event = Event(EventKind.REACHED_GOOD_PROFIT,
|
|
self.get_current_tick())
|
|
|
|
self.events.append(event)
|
|
await eh.call_event(event, self)
|
|
self.current_state = state
|
|
|
|
await eh.call_state(self.current_state, self)
|
|
|
|
def get_current_state(self) -> State:
|
|
return self.current_state
|
|
|
|
|
|
class EventHandler:
|
|
def __init__(self):
|
|
self.event_handlers = {}
|
|
self.state_handlers = {}
|
|
|
|
async def call_event(self, event: Event, status: Status):
|
|
value = event.kind.value
|
|
if value in self.event_handlers:
|
|
for h in self.event_handlers[value]:
|
|
if inspect.iscoroutinefunction(h):
|
|
await h(event, status)
|
|
else:
|
|
h(event, status)
|
|
|
|
async def call_state(self, state: State, status: Status):
|
|
if state in self.state_handlers:
|
|
for h in self.state_handlers[state]:
|
|
if inspect.iscoroutinefunction(h):
|
|
await h(status)
|
|
else:
|
|
h(status)
|
|
|
|
def on_event(self, kind: EventKind):
|
|
value = kind.value
|
|
|
|
def registerhandler(handler):
|
|
if value in self.event_handlers:
|
|
self.event_handlers[value].append(handler)
|
|
else:
|
|
self.event_handlers[value] = [handler]
|
|
return handler
|
|
|
|
return registerhandler
|
|
|
|
def on_state(self, state: State):
|
|
def registerhandler(handler):
|
|
if state in self.state_handlers:
|
|
self.state_handlers[state].append(handler)
|
|
else:
|
|
self.state_handlers[state] = [handler]
|
|
return handler
|
|
|
|
return registerhandler
|
|
|
|
|
|
dotenv.load()
|
|
API_KEY = dotenv.get('API_KEY', default='')
|
|
API_SECRET = dotenv.get('API_SECRET', default='')
|
|
|
|
bfx = Client(
|
|
API_KEY=API_KEY,
|
|
API_SECRET=API_SECRET
|
|
).rest
|
|
eh = EventHandler()
|
|
|
|
TAKER_FEE = 0.2
|
|
MAKER_FEE = 0.1
|
|
|
|
BREAK_EVEN_PERC = TAKER_FEE
|
|
MIN_PROFIT_PERC = 0.75
|
|
GOOD_PROFIT_PERC = MIN_PROFIT_PERC * 2.1
|
|
MAX_LOSS_PERC = -3.75
|
|
OFFER_PERC = 0.01
|
|
|
|
TRAIL_STOP_PERCENTAGES = {
|
|
State.MINIMUM_PROFIT: 0.25,
|
|
State.PROFIT: 0.125
|
|
}
|
|
|
|
|
|
@eh.on_event(EventKind.REACHED_GOOD_PROFIT)
|
|
def on_good_profit(event: Event, status: Status):
|
|
playsound("sounds/coin.mp3")
|
|
|
|
|
|
@eh.on_event(EventKind.REACHED_MIN_PROFIT)
|
|
def on_min_profit(event: Event, status: Status):
|
|
playsound("sounds/1up.mp3")
|
|
|
|
|
|
@eh.on_event(EventKind.REACHED_MAX_LOSS)
|
|
def on_critical(event: Event, status: Status):
|
|
playsound("sounds/gameover.mp3")
|
|
|
|
|
|
@eh.on_state(State.MINIMUM_PROFIT)
|
|
async def on_state_min_profit(status: Status):
|
|
await update_stop_percentage(State.MINIMUM_PROFIT, status)
|
|
|
|
current_pl_perc = net_pl_percentage(
|
|
status.last_position().profit_loss_percentage, TAKER_FEE)
|
|
|
|
if current_pl_perc < status.stop_percentage:
|
|
await status.add_event(Event(EventKind.CLOSE_POSITION,
|
|
status.get_current_tick()))
|
|
|
|
|
|
@eh.on_state(State.CRITICAL)
|
|
async def on_state_critical(status: Status):
|
|
await status.add_event(Event(EventKind.CLOSE_POSITION,
|
|
status.get_current_tick()))
|
|
|
|
|
|
@eh.on_state(State.PROFIT)
|
|
async def on_state_min_profit(status: Status):
|
|
await update_stop_percentage(State.PROFIT, status)
|
|
|
|
current_pl_perc = net_pl_percentage(
|
|
status.last_position().profit_loss_percentage, TAKER_FEE)
|
|
|
|
if current_pl_perc < status.stop_percentage:
|
|
await status.add_event(Event(EventKind.CLOSE_POSITION,
|
|
status.get_current_tick()))
|
|
|
|
|
|
async def update_stop_percentage(state: State, status: Status):
|
|
last_position = status.last_position()
|
|
last_pl_net_perc = net_pl_percentage(
|
|
last_position.profit_loss_percentage, TAKER_FEE)
|
|
|
|
# set stop percentage for first time
|
|
if not status.stop_percentage:
|
|
await status.add_event(Event(EventKind.TRAILING_STOP_SET,
|
|
status.get_current_tick()))
|
|
status.stop_percentage = last_pl_net_perc - \
|
|
TRAIL_STOP_PERCENTAGES[state]
|
|
return
|
|
|
|
# moving trailing stop
|
|
if last_pl_net_perc - TRAIL_STOP_PERCENTAGES[state] > status.stop_percentage:
|
|
await status.add_event(Event(EventKind.TRAILING_STOP_MOVED,
|
|
status.get_current_tick()))
|
|
status.stop_percentage = last_pl_net_perc - \
|
|
TRAIL_STOP_PERCENTAGES[state]
|
|
|
|
return
|
|
|
|
|
|
@eh.on_event(EventKind.CLOSE_POSITION)
|
|
async def on_close_position(event: Event, status: Status):
|
|
closing_price = await calculate_best_closing_price(status)
|
|
amount = status.last_position().amount * -1
|
|
|
|
open_orders = await bfx.get_active_orders(status.symbol)
|
|
|
|
if not open_orders:
|
|
await bfx.submit_order(status.symbol, closing_price, amount, Order.Type.LIMIT)
|
|
await status.add_event(Event(EventKind.ORDER_SUBMITTED, status.get_current_tick()))
|
|
playsound("sounds/goal.wav")
|
|
|
|
@eh.on_event(EventKind.ORDER_SUBMITTED)
|
|
def on_order_submitted(event: Event, status: Status):
|
|
status.printer.print_next_line("ORDER SUBMITTED!")
|
|
return
|
|
|
|
|
|
async def calculate_best_closing_price(status: Status):
|
|
p: Position = status.last_position()
|
|
|
|
is_long_pos = p.amount < 0
|
|
|
|
pub_tick = await bfx.get_public_ticker(status.symbol)
|
|
|
|
bid_price = pub_tick[0]
|
|
ask_price = pub_tick[2]
|
|
|
|
if is_long_pos:
|
|
closing_price = bid_price * (1 - OFFER_PERC / 100)
|
|
else:
|
|
closing_price = ask_price * (1 + OFFER_PERC / 100)
|
|
|
|
return closing_price
|
|
|
|
|
|
def net_pl_percentage(perc: float, reference_fee_perc: float):
|
|
return perc - reference_fee_perc
|
|
|
|
|
|
async def main(screen: Screen):
|
|
min_perc = 999.0
|
|
max_perc = -999.0
|
|
symbol = "tBTCUSD"
|
|
|
|
printer = Printer(screen)
|
|
status = Status(20, symbol, printer)
|
|
balance = await get_usd_balance()
|
|
|
|
while True:
|
|
positions = [p for p in await bfx.get_active_position() if p.symbol == status.symbol]
|
|
orders = await bfx.get_active_orders(symbol)
|
|
|
|
current_price = await status.last_price()
|
|
|
|
screen.clear()
|
|
printer.print_next_line(
|
|
"Balance: ${} | Current {} price: {} | Current tick ({} sec): {}".format(colored_float(balance, "white"),
|
|
symbol,
|
|
colored_float(
|
|
current_price, "white",
|
|
attrs=["bold"]),
|
|
status.ticker.seconds,
|
|
status.get_current_tick(),
|
|
))
|
|
|
|
if positions:
|
|
printer.print_next_line("")
|
|
printer.print_next_line("Open {}:".format(
|
|
colored("POSITIONS", attrs=["underline"])))
|
|
|
|
if status.stop_percentage:
|
|
printer.print_next_line("Trailing stop percentage: {}".format(colored_percentage(status.stop_percentage, "yellow")))
|
|
|
|
for p in [p for p in positions if p.symbol == status.symbol]:
|
|
await status.update(p)
|
|
|
|
plfees_percentage = net_pl_percentage(
|
|
p.profit_loss_percentage, TAKER_FEE)
|
|
|
|
if plfees_percentage > GOOD_PROFIT_PERC:
|
|
await status.set_state(State.PROFIT)
|
|
elif MIN_PROFIT_PERC <= plfees_percentage < GOOD_PROFIT_PERC:
|
|
await status.set_state(State.MINIMUM_PROFIT)
|
|
elif 0.0 <= plfees_percentage < MIN_PROFIT_PERC:
|
|
await status.set_state(State.BREAK_EVEN)
|
|
elif MAX_LOSS_PERC < plfees_percentage < 0.0:
|
|
await status.set_state(State.LOSS)
|
|
else:
|
|
await status.set_state(State.CRITICAL)
|
|
|
|
status_color = status.get_current_state().color()
|
|
|
|
#
|
|
# min / max calculations
|
|
#
|
|
if plfees_percentage > max_perc:
|
|
max_perc = plfees_percentage
|
|
await status.add_event(Event(EventKind.NEW_MAXIMUM,
|
|
status.get_current_tick()))
|
|
if plfees_percentage < min_perc:
|
|
min_perc = plfees_percentage
|
|
await status.add_event(Event(EventKind.NEW_MINIMUM,
|
|
status.get_current_tick()))
|
|
|
|
min_perc_colored = colored_percentage(
|
|
min_perc, "red") if min_perc < 0.0 else colored_percentage(min_perc, "green")
|
|
max_perc_colored = colored_percentage(
|
|
max_perc, "red") if max_perc < 0.0 else colored_percentage(max_perc, "green")
|
|
|
|
#
|
|
# current status calculations
|
|
#
|
|
current_colored_format = "{} ({})".format(colored_percentage(plfees_percentage, status_color),
|
|
colored_float(p.profit_loss, status_color))
|
|
|
|
#
|
|
# Status bar
|
|
#
|
|
printer.print_next_line("{:1.5f} {} @ {} | {} | min: {}, MAX: {}".format(
|
|
p.amount,
|
|
p.symbol,
|
|
colored_float(p.base_price, "white", attrs=["underline"]),
|
|
current_colored_format,
|
|
min_perc_colored,
|
|
max_perc_colored))
|
|
|
|
# Separator
|
|
printer.print_next_line("")
|
|
|
|
if orders:
|
|
printer.print_next_line("Open {}:".format(
|
|
colored("ORDERS", attrs=["underline"])))
|
|
|
|
print_last_events(status, 10, printer)
|
|
plot(status, printer)
|
|
|
|
printer.reset_current_line()
|
|
status.wait()
|
|
|
|
return
|
|
|
|
|
|
def colored_percentage(perc, color, **kwargs):
|
|
return "{}".format(colored("{:1.2f}%".format(perc), color=color, **kwargs))
|
|
|
|
|
|
def colored_float(num, color, **kwargs):
|
|
return "{}".format(colored("{:1.2f}".format(num), color=color, **kwargs))
|
|
|
|
|
|
def print_last_events(status: Status, n: int, printer: Printer):
|
|
printer.print_next_line(colored(f"Last {n} events:", attrs=["bold"]))
|
|
|
|
for e in status.last_events(n):
|
|
printer.print_next_line(f"- {e}")
|
|
|
|
|
|
def plot(status: Status, printer: Printer):
|
|
if status.ticks:
|
|
figure = termplotlib.figure()
|
|
|
|
x = range(1, status.get_current_tick() + 1)
|
|
y = [x[0] for x in status.ticks.values()]
|
|
|
|
figure.plot(x, y, width=printer.screen.width,
|
|
height=printer.screen.height - printer.get_current_line())
|
|
|
|
printer.print_next_line(figure.get_string())
|
|
|
|
|
|
async def get_current_price(symbol):
|
|
tickers = await bfx.get_public_ticker(symbol)
|
|
return tickers[6]
|
|
|
|
|
|
async def get_usd_balance():
|
|
balance = 0.0
|
|
|
|
wallets = await bfx.get_wallets()
|
|
|
|
for w in wallets:
|
|
if w.currency == "USD":
|
|
balance += w.balance
|
|
else:
|
|
current_price = await get_current_price(f"t{w.currency}USD")
|
|
balance += current_price * w.balance
|
|
|
|
return balance
|
|
|
|
|
|
if __name__ == "__main__":
|
|
asyncio.run(Screen.wrapper(main))
|