Cargo.toml

@@ -1,26 +0,0 @@
-[package]
-name = "rustico"
-version = "0.1.0"
-authors = ["Giulio De Pasquale <depasquale@giugl.io>"]
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-bitfinex = { path= "/home/giulio/dev/bitfinex-rs" }
-tokio = { version = "1", features=["full"]}
-futures-util = { version = "0.3", default-features = false, features = ["async-await", "sink", "std"] }
-async-trait = "0.1"
-regex = "1"
-dyn-clone = "1"
-log = "0.4"
-fern = {version = "0.6", features = ["colored"]}
-chrono = "0.4"
-byteorder = "1"
-float-cmp = "0.8"
-merge = "0.1"
-futures-retry = "0.6"
-tungstenite = "0.12"
-tokio-tungstenite = "0.13"
-dotenv = "0.15"
-ears = "0.8.0"

bfxbot.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+  <component name="PackageRequirementsSettings">
+    <option name="removeUnused" value="true" />
+  </component>
+</module>

bfxbot/__init__.py

@@ -0,0 +1 @@
+from .bfxbot import BfxBot

bfxbot/bfxbot.py

@@ -0,0 +1,151 @@
+import asyncio
+import time
+from typing import Dict, List, Optional, Tuple
+
+from bfxapi import Order
+
+from bfxbot.bfxwrapper import BfxWrapper
+from bfxbot.currency import TradingPair, Symbol
+from bfxbot.models import SymbolStatus, Ticker, EventHandler, Strategy, Event, EventKind, OFFER_PERC, PositionWrapper
+
+
+class BfxBot:
+    def __init__(self, api_key: str, api_secret: str, symbols: List[TradingPair], quote: Symbol,
+                 tick_duration: int = 1):
+        if api_key is None:
+            print("API_KEY is not set!")
+            raise ValueError
+
+        if api_secret is None:
+            print("API_SECRET is not set!")
+            raise ValueError
+
+        self.__bfx: BfxWrapper = BfxWrapper(api_key, api_secret)
+        self.__ticker: Ticker = Ticker(tick_duration)
+        self.__status: Dict[TradingPair, SymbolStatus] = {}
+        self.__quote: Symbol = quote
+        self.__account_info = None
+        self.__ledger = None
+
+        if isinstance(symbols, TradingPair):
+            symbols = [symbols]
+
+        self.symbols: List[TradingPair] = symbols
+
+        # init symbol statuses
+        for s in self.symbols:
+            self.__status[s] = SymbolStatus(s)
+
+    def __position_wrapper_from_id(self, position_id) -> Tuple[Optional[PositionWrapper], Optional[SymbolStatus]]:
+        for s in self.__status.values():
+            pw = s.active_position_wrapper_from_id(position_id)
+
+            if pw:
+                return pw, s
+        return None, None
+
+    async def __update_status__(self):
+        active_positions = await self.__bfx.get_active_position()
+
+        for symbol in self.__status:
+            # updating tick
+            self.__status[symbol].__init_tick__(self.__ticker.current_tick)
+
+            # updating last price
+            last_price = await self.__bfx.get_current_prices(symbol)
+            last_price = last_price[0]
+
+            self.__status[symbol].set_tick_price(self.__ticker.current_tick, last_price)
+
+            # updating positions
+            symbol_positions = [x for x in active_positions if x.symbol == str(symbol)]
+            for p in symbol_positions:
+                await self.__status[TradingPair.from_str(p.symbol)].add_position(p)
+
+            # updating orders
+            active_orders = await self.__bfx.get_active_orders(symbol)
+
+            for o in active_orders:
+                self.__status[symbol].add_order(o)
+
+            # emitting new tick event
+            # TODO: handle _on_new_tick() from Strategy
+            await self.__status[symbol].add_event(Event(EventKind.NEW_TICK, self.__ticker.current_tick))
+
+    async def best_position_closing_price(self, position_id: int) -> Optional[float]:
+        pw, _ = self.__position_wrapper_from_id(position_id)
+
+        if not pw:
+            return None
+
+        is_long_pos = pw.position.amount < 0
+
+        pub_tick = await self.__bfx.get_public_ticker(pw.position.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 close_order(self, symbol: TradingPair, order_id: int):
+        print(f"I would have closed order {order_id} for {symbol}")
+
+    async def close_position(self, position_id: int):
+        pw, ss = self.__position_wrapper_from_id(position_id)
+
+        if not pw:
+            print("Could not find open position!")
+            return
+
+        closing_price = await self.best_position_closing_price(pw.position.id)
+
+        amount = pw.position.amount * -1
+
+        open_orders = await self.__bfx.get_active_orders(pw.position.symbol)
+
+        if not open_orders:
+            await self.__bfx.submit_order(pw.position.symbol, closing_price, amount, Order.Type.LIMIT)
+            await ss.add_event(Event(EventKind.ORDER_SUBMITTED, ss.current_tick))
+
+    async def get_balances(self):
+        return await self.__bfx.get_current_balances(self.__quote)
+
+    async def get_profit_loss(self, start: int, end: int):
+        return await self.__bfx.profit_loss(start, end, self.__ledger, self.__quote)
+
+    def set_strategy(self, symbol, strategy: Strategy):
+        if symbol in self.__status:
+            self.__status[symbol].strategy = strategy
+        else:
+            self.__status[symbol] = SymbolStatus(symbol, strategy)
+
+    async def start(self):
+        self.__account_info = self.__bfx.get_account_information()
+        self.__ledger = await self.__bfx.ledger_history(0, time.time() * 1000)
+
+        await self.__update_status__()
+
+    def symbol_event_handler(self, symbol) -> Optional[EventHandler]:
+        if symbol not in self.__status:
+            return None
+
+        return self.__status[symbol].eh
+
+    def symbol_status(self, symbol: TradingPair) -> Optional[SymbolStatus]:
+        if symbol not in self.__status:
+            return None
+
+        return self.__status[symbol]
+
+    async def update(self):
+        await asyncio.sleep(self.__ticker.seconds)
+        self.__ticker.inc()
+        await self.__update_status__()
+
+    async def __update_ledger(self):
+        self.__ledger = await self.__bfx.ledger_history(0, time.time() * 1000)

bfxbot/bfxwrapper.py

@@ -0,0 +1,212 @@
+from bfxapi.rest.bfx_rest import BfxRest
+from retrying_async import retry
+
+from bfxbot.currency import TradingPair, Balance, WalletKind, OrderType, Direction, Currency, BalanceGroup, Symbol
+from bfxbot.utils import average
+
+
+class BfxWrapper(BfxRest):
+    # default timeframe (in milliseconds) when retrieving old prices
+    DEFAULT_TIME_DELTA = 5 * 60 * 1000
+
+    def __init__(self, api_key: str, api_secret: str):
+        super().__init__(API_KEY=api_key, API_SECRET=api_secret)
+
+    #######################################
+    # OVERRIDDEN METHODS TO IMPLEMENT RETRY
+    #######################################
+
+    @retry()
+    async def get_public_ticker(self, symbol):
+        if isinstance(symbol, TradingPair):
+            symbol = str(symbol)
+
+        return await super().get_public_ticker(symbol)
+
+    @retry()
+    async def get_active_position(self):
+        return await super().get_active_position()
+
+    @retry()
+    async def get_active_orders(self, symbol):
+        if isinstance(symbol, TradingPair):
+            symbol = str(symbol)
+
+        return await super().get_active_orders(symbol)
+
+    @retry()
+    async def get_trades(self, symbol, start, end):
+        if isinstance(symbol, TradingPair):
+            symbol = str(symbol)
+
+        return await super().get_trades(symbol, start, end)
+
+    @retry()
+    async def post(self, endpoint: str, data=None, params=""):
+        if data is None:
+            data = {}
+        return await super().post(endpoint, data, params)
+
+    ################################
+    # NEW METHODS
+    ################################
+
+    async def account_movements_between(self, start: int, end: int, ledger, quote: Symbol) -> BalanceGroup:
+        movements = BalanceGroup(quote)
+
+        # TODO: Parallelize this
+        for entry in filter(lambda x: start <= x[3] <= end, ledger):
+            description: str = entry[8]
+            currency = entry[1]
+            amount = entry[5]
+            time = entry[3]
+
+            if not description.lower().startswith("deposit"):
+                continue
+
+            trading_pair = f"t{currency}{quote}"
+            start_time = time - self.DEFAULT_TIME_DELTA
+            end_time = time + self.DEFAULT_TIME_DELTA
+
+            if currency != str(quote):
+                trades = await self.get_public_trades(symbol=trading_pair, start=start_time, end=end_time)
+                currency_price = average(list(map(lambda x: x[3], trades)))
+
+                c = Currency(currency, amount, currency_price)
+            else:
+                c = Currency(currency, amount)
+
+            b = Balance(c, quote)
+
+            movements.add_balance(b)
+
+        return movements
+
+    async def balance_at(self, time: int, ledger, quote: Symbol):
+        bg = BalanceGroup(quote)
+
+        # TODO: Parallelize this
+        for entry in filter(lambda x: x[3] <= time, ledger):
+            currency = entry[1]
+            amount = entry[6]
+
+            if currency in bg.currency_names():
+                continue
+
+            trading_pair = f"t{currency}{quote}"
+            start_time = time - self.DEFAULT_TIME_DELTA
+            end_time = time + self.DEFAULT_TIME_DELTA
+
+
+            if currency != str(quote):
+                trades = await self.get_public_trades(symbol=trading_pair, start=start_time, end=end_time)
+                currency_price = average(list(map(lambda x: x[3], trades)))
+
+                c = Currency(currency, amount, currency_price)
+            else:
+                c = Currency(currency, amount)
+
+            b = Balance(c, quote)
+
+            bg.add_balance(b)
+
+        return bg
+
+    # Calculate the average execution price for Trading or rate for Margin funding.
+    async def calculate_execution_price(self, pair: str, amount: float):
+        api_path = "/calc/trade/avg"
+
+        res = await self.post(api_path, {
+            'symbol': pair,
+            'amount': amount
+        })
+
+        return res[0]
+
+    async def get_account_information(self):
+        api_path = "auth/r/info/user"
+
+        return await self.post(api_path)
+
+    async def get_current_balances(self, quote: Symbol) -> BalanceGroup:
+        bg: BalanceGroup = BalanceGroup(quote)
+
+        wallets = await self.get_wallets()
+
+        for w in wallets:
+            kind = WalletKind.from_str(w.type)
+
+            if not kind:
+                continue
+
+            execution_price = await self.calculate_execution_price(f"t{w.currency}{quote}", w.balance)
+            c = Currency(w.currency, w.balance, execution_price)
+            b = Balance(c, quote, kind)
+
+            bg.add_balance(b)
+
+        return bg
+
+    async def get_current_prices(self, symbol: TradingPair) -> (float, float, float):
+        if isinstance(symbol, TradingPair):
+            symbol = str(symbol)
+
+        tickers = await self.get_public_ticker(symbol)
+
+        bid_price = tickers[0]
+        ask_price = tickers[2]
+        ticker_price = tickers[6]
+
+        return bid_price, ask_price, ticker_price
+
+    async def ledger_history(self, start, end):
+        def chunks(lst):
+            for i in range(len(lst) - 1):
+                yield lst[i:i + 2]
+
+        def get_timeframes(start, end, increments=10):
+            start = int(start)
+            end = int(end)
+
+            delta = int((end - start) / increments)
+
+            return [x for x in range(start, end, delta)]
+
+        api_path = "auth/r/ledgers/hist"
+
+        history = []
+
+        # TODO: Parallelize this
+        for c in chunks(get_timeframes(start, end)):
+            history.extend(await self.post(api_path, {'start': c[0], 'end': c[1], 'limit': 2500}))
+
+        history.sort(key=lambda ledger_entry: ledger_entry[3], reverse=True)
+
+        return history
+
+    async def maximum_order_amount(self, symbol: TradingPair, direction: Direction,
+                                   order_type: OrderType = OrderType.EXCHANGE,
+                                   rate: int = 1):
+        api_path = "auth/calc/order/avail"
+
+        return await self.post(api_path,
+                               {'symbol': str(symbol), 'type': order_type.value, "dir": direction.value, "rate": rate})
+
+    async def profit_loss(self, start: int, end: int, ledger, quote: Symbol):
+        if start > end:
+            raise ValueError
+
+        start_bg = await self.balance_at(start, ledger, quote)
+        end_bg = await self.balance_at(end, ledger, quote)
+        movements_bg = await self.account_movements_between(start, end, ledger, quote)
+
+        start_quote = start_bg.quote_equivalent()
+        end_quote = end_bg.quote_equivalent()
+        movements_quote = movements_bg.quote_equivalent()
+
+        profit_loss = end_quote - (start_quote + movements_quote)
+
+        profit_loss_percentage = profit_loss / (start_quote + movements_quote) * 100
+
+
+        return profit_loss, profit_loss_percentage

bfxbot/currency.py

@@ -0,0 +1,161 @@
+import re
+from enum import Enum
+from typing import Optional, List
+
+
+class Symbol(Enum):
+    XMR = "XMR"
+    BTC = "BTC"
+    ETH = "ETH"
+    USD = "USD"
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __str__(self):
+        return self.value
+
+    def __eq__(self, other):
+        return self.value == other.value
+
+
+class TradingPair(Enum):
+    XMR = "XMR"
+    BTC = "BTC"
+    ETH = "ETH"
+
+    def __repr__(self):
+        return f"t{self.value}USD"
+
+    def __str__(self):
+        return self.__repr__()
+
+    def __eq__(self, other):
+        return self.value == other.value
+
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    @staticmethod
+    def from_str(string: str):
+        match = re.compile("t([a-zA-Z]+)USD").match(string)
+
+        if not match:
+            raise ValueError
+
+        currency = match.group(1).lower()
+
+        if currency in ("xmr"):
+            return TradingPair.XMR
+        elif currency in ("btc"):
+            return TradingPair.BTC
+        elif currency in ("eth"):
+            return TradingPair.ETH
+        else:
+            return NotImplementedError
+
+
+class Currency:
+    def __init__(self, name: str, amount: float, price: float = None):
+        self.__name: str = name
+        self.__amount: float = amount
+        self.__price: Optional[float] = price
+
+    def __str__(self):
+        if self.__price:
+            return f"{self.__name} {self.__amount} @ {self.__price}"
+        else:
+            return f"{self.__name} {self.__amount}"
+
+    def __repr__(self):
+        return self.__str__()
+
+    def amount(self) -> float:
+        return self.__amount
+
+    def name(self) -> str:
+        return self.__name
+
+    def price(self) -> Optional[float]:
+        return self.__price
+
+
+class WalletKind(Enum):
+    EXCHANGE = "exchange",
+    MARGIN = "margin"
+
+    @staticmethod
+    def from_str(string: str):
+        string = string.lower()
+
+        if "margin" in string:
+            return WalletKind.MARGIN
+        if "exchange" in string:
+            return WalletKind.EXCHANGE
+
+        return None
+
+
+class Balance:
+    def __init__(self, currency: Currency, quote: Symbol, wallet: Optional[WalletKind] = None):
+        self.__currency: Currency = currency
+        self.__quote: Symbol = quote
+        self.__quote_equivalent: float = 0.0
+        self.__wallet: Optional[WalletKind] = wallet
+
+        if currency.name() == str(quote):
+            self.__quote_equivalent = currency.amount()
+        else:
+            self.__quote_equivalent = currency.amount() * currency.price()
+
+    def currency(self) -> Currency:
+        return self.__currency
+
+    def quote(self) -> Symbol:
+        return self.__quote
+
+    def quote_equivalent(self) -> float:
+        return self.__quote_equivalent
+
+    def wallet(self) -> Optional[WalletKind]:
+        return self.__wallet
+
+
+class BalanceGroup:
+    def __init__(self, quote: Symbol, balances: Optional[List[Balance]] = None):
+        if balances is None:
+            balances = []
+
+        self.__quote: Symbol = quote
+        self.__balances: Optional[List[Balance]] = balances
+        self.__quote_equivalent: float = 0.0
+
+    def __iter__(self):
+        return self.__balances.__iter__()
+
+    def add_balance(self, balance: Balance):
+        self.__balances.append(balance)
+
+        self.__quote_equivalent += balance.quote_equivalent()
+
+    def balances(self) -> Optional[List[Balance]]:
+        return self.__balances
+
+    def currency_names(self) -> List[str]:
+        return list(map(lambda x: x.currency().name(), self.balances()))
+
+    def quote(self) -> Symbol:
+        return self.__quote
+
+    def quote_equivalent(self) -> float:
+        return self.__quote_equivalent
+
+
+class Direction(Enum):
+    UP = 1,
+    DOWN = -1
+
+
+class OrderType(Enum):
+    EXCHANGE = "EXCHANGE",
+    MARGIN = "MARGIN"

bfxbot/models.py

@@ -0,0 +1,295 @@
+import inspect
+import time
+from enum import Enum
+from typing import List, Dict, Tuple, Optional
+
+from bfxapi import Order, Position
+
+from bfxbot.currency import TradingPair
+
+OFFER_PERC = 0.008
+TAKER_FEE = 0.2
+MAKER_FEE = 0.1
+
+
+def __add_to_dict_list__(dictionary: Dict[int, List], k, v) -> Dict[int, List]:
+    if k not in dictionary:
+        dictionary[k] = [v]
+    else:
+        dictionary[k].append(v)
+
+    return dictionary
+
+
+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,
+    NEW_TICK = 12
+
+
+class EventMetadata:
+    def __init__(self, position_id: int = None, order_id: int = None):
+        self.position_id: int = position_id
+        self.order_id: int = order_id
+
+
+class PositionState(Enum):
+    CRITICAL = -1,
+    LOSS = 0,
+    BREAK_EVEN = 1,
+    MINIMUM_PROFIT = 2,
+    PROFIT = 3,
+    UNDEFINED = 4
+
+    def color(self) -> str:
+        if self == self.LOSS or self == self.CRITICAL:
+            return "red"
+        elif self == self.BREAK_EVEN:
+            return "yellow"
+        else:
+            return "green"
+
+    def __str__(self):
+        return f"{self.name}"
+
+    def __repr__(self):
+        return self.__str__()
+
+
+class Ticker:
+    def __init__(self, sec) -> None:
+        self.seconds: int = sec
+        self.start_time = time.time()
+        self.current_tick: int = 1
+
+    def inc(self):
+        self.current_tick += 1
+
+
+class Event:
+    def __init__(self, kind: EventKind, tick: int, metadata: EventMetadata = None) -> None:
+        self.kind: EventKind = kind
+        self.tick: int = tick
+        self.metadata: EventMetadata = metadata
+
+    def __repr__(self) -> str:
+        return f"{self.kind.name} @ Tick {self.tick}"
+
+    def has_metadata(self) -> bool:
+        return self.metadata is not None
+
+
+class PositionWrapper:
+    def __init__(self, position: Position, state: PositionState = PositionState.UNDEFINED,
+                 net_profit_loss: float = None,
+                 net_profit_loss_percentage: float = None):
+        self.position: Position = position
+        self.__net_profit_loss: float = net_profit_loss
+        self.__net_profit_loss_percentage: float = net_profit_loss_percentage
+        self.__state: PositionState = state
+
+    def net_profit_loss(self) -> float:
+        return self.__net_profit_loss
+
+    def net_profit_loss_percentage(self) -> float:
+        return self.__net_profit_loss_percentage
+
+    def set_state(self, state: PositionState):
+        self.__state = state
+
+    def state(self) -> PositionState:
+        return self.__state
+
+
+class SymbolStatus:
+    def __init__(self, symbol: TradingPair, strategy=None):
+        self.symbol = symbol
+        self.eh = EventHandler()
+        self.prices: Dict[int, float] = {}
+        self.events: List[Event] = []
+        self.orders: Dict[int, List[Order]] = {}
+        self.positions: Dict[int, List[PositionWrapper]] = {}
+        self.current_tick: int = 1
+        self.strategy: Strategy = strategy
+
+    def __init_tick__(self, tick: int):
+        self.current_tick = tick
+        self.prices[self.current_tick] = None
+        self.orders[self.current_tick] = []
+        self.positions[self.current_tick] = []
+
+    async def add_event(self, event: Event):
+        self.events.append(event)
+        await self.eh.call_event(self, event)
+
+    def add_order(self, order: Order):
+        if self.strategy:
+            self.strategy.order_on_new_tick(order, self)
+        self.orders = __add_to_dict_list__(self.orders, self.current_tick, order)
+
+    # Applies strategy and adds position to list
+    async def add_position(self, position: Position):
+        events = []
+
+        # if a strategy is defined then the strategy takes care of creating a PW for us
+        if not self.strategy:
+            pw = PositionWrapper(position)
+        else:
+            pw, events = await self.__apply_strategy_to_position__(position)
+        self.positions = __add_to_dict_list__(self.positions, self.current_tick, pw)
+
+        # triggering state callbacks
+        await self.__trigger_position_state_callbacks__(pw)
+
+        # triggering events callbacks
+        for e in events:
+            if not isinstance(e, Event):
+                raise ValueError
+            await self.add_event(e)
+
+    def all_prices(self) -> List[float]:
+        return list(map(lambda x: self.prices[x], range(1, self.current_tick + 1)))
+
+    def all_ticks(self) -> List[int]:
+        return [x for x in range(1, self.current_tick + 1)]
+
+    def current_positions(self) -> List[PositionWrapper]:
+        return self.positions[self.current_tick]
+
+    def current_price(self):
+        return self.prices[self.current_tick]
+
+    def previous_pw(self, pid: int) -> Optional[PositionWrapper]:
+        if self.current_tick == 1:
+            return None
+
+        if not self.positions[self.current_tick - 1]:
+            return None
+
+        return next(filter(lambda x: x.position.id == pid, self.positions[self.current_tick - 1]))
+
+    def active_position_wrapper_from_id(self, position_id: int) -> Optional[PositionWrapper]:
+        if self.current_tick in self.positions:
+            for pw in self.positions[self.current_tick]:
+                if pw.position.id == position_id:
+                    return pw
+        return None
+
+    def set_tick_price(self, tick, price):
+        self.prices[tick] = price
+
+    async def __apply_strategy_to_position__(self, position: Position) -> Tuple[PositionWrapper, List[Event]]:
+        pw, events = self.strategy.position_on_new_tick(position, self)
+
+        if not isinstance(pw, PositionWrapper):
+            raise ValueError
+
+        if not isinstance(events, list):
+            raise ValueError
+
+        return pw, events
+
+    async def __trigger_position_state_callbacks__(self, pw: PositionWrapper):
+        await self.eh.call_position_state(self, pw)
+
+
+class Strategy:
+    """
+    Defines new position state and events after tick.
+    """
+
+    def position_on_new_tick(self, position: Position, ss: SymbolStatus) -> Tuple[PositionWrapper, List[Event]]:
+        pass
+
+    """
+    Defines new order state and events after tick.
+    """
+
+    def order_on_new_tick(self, order: Order, ss: SymbolStatus):
+        pass
+
+
+class EventHandler:
+    def __init__(self):
+        self.event_handlers = {}
+        self.state_handlers = {}
+        self.any_events = []
+        self.any_state = []
+
+    async def call_event(self, status: SymbolStatus, event: Event):
+        value = event.kind.value
+
+        # print("CALLING EVENT: {}".format(event))
+        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)
+
+        for h in self.any_events:
+            if inspect.iscoroutinefunction(h):
+                await h(event, status)
+            else:
+                h(event, status)
+
+    async def call_position_state(self, status: SymbolStatus, pw: PositionWrapper):
+        state = pw.state()
+
+        if state in self.state_handlers:
+            for h in self.state_handlers[state]:
+                if inspect.iscoroutinefunction(h):
+                    await h(pw, status)
+                else:
+                    h(pw, status)
+
+        for h in self.any_state:
+            if inspect.iscoroutinefunction(h):
+                await h(pw, status)
+            else:
+                h(pw, 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_position_state(self, state: PositionState):
+        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
+
+    def on_any_event(self):
+        def registerhandle(handler):
+            self.any_events.append(handler)
+            return handler
+
+        return registerhandle
+
+    def on_any_position_state(self):
+        def registerhandle(handler):
+            self.any_state.append(handler)
+            return handler
+
+        return registerhandle

bfxbot/utils.py

@@ -0,0 +1,59 @@
+import re
+
+from bfxbot.bfxwrapper import Balance
+from bfxbot.models import PositionWrapper
+
+
+class CurrencyPair:
+    def __init__(self, base: str, quote: str):
+        self.base: str = base
+        self.quote: str = quote
+
+    @staticmethod
+    def from_str(string: str):
+        symbol_regex = re.compile("t(?P<base>[a-zA-Z]{3})(?P<quote>[a-zA-Z]{3})")
+
+        match = symbol_regex.match(string)
+
+        if not match:
+            return None
+
+        return CurrencyPair(match.group("base"), match.group("quote"))
+
+
+def average(a):
+    return sum(a) / len(a)
+
+
+def balance_to_json(balance: Balance):
+    return {
+        'currency': balance.currency().name(),
+        'amount': balance.currency().amount(),
+        'kind': balance.wallet().value,
+        'quote': balance.quote().value,
+        'quote_equivalent': balance.quote_equivalent()
+    }
+
+
+def net_pl_percentage(perc: float, reference_fee_perc: float):
+    return perc - reference_fee_perc
+
+
+def pw_to_posprop(pw: PositionWrapper):
+    pair = CurrencyPair.from_str(pw.position.symbol)
+
+    if not pair:
+        raise ValueError
+
+    return {
+        "id": pw.position.id,
+        "amount": pw.position.amount,
+        "base_price": pw.position.base_price,
+        "state": str(pw.state()),
+        "pair": {
+            "base": pair.base,
+            "quote": pair.quote
+        },
+        "profit_loss": pw.net_profit_loss(),
+        "profit_loss_percentage": pw.net_profit_loss_percentage()
+    }

main.py

@@ -0,0 +1,140 @@
+# #!/usr/bin/env python
+
+import asyncio
+import os
+import threading
+from time import sleep
+from typing import List
+
+import dotenv
+from flask import Flask, render_template
+from flask_socketio import SocketIO
+
+from bfxbot import BfxBot
+from bfxbot.bfxwrapper import Balance
+from bfxbot.currency import TradingPair, Symbol
+from bfxbot.models import PositionWrapper, SymbolStatus, Event, EventKind
+from bfxbot.utils import pw_to_posprop, balance_to_json
+from strategy import TrailingStopStrategy
+
+
+async def bot_loop():
+    await bot.start()
+
+    while True:
+        await bot.update()
+
+
+loop = asyncio.new_event_loop()
+
+dotenv.load_dotenv()
+
+API_KEY = os.getenv("API_KEY")
+API_SECRET = os.getenv("API_SECRET")
+
+app = Flask(__name__)
+socketio = SocketIO(app, async_mode="threading")
+bot = BfxBot(api_key=API_KEY, api_secret=API_SECRET,
+             symbols=[TradingPair.BTC], quote=Symbol.USD, tick_duration=20)
+strategy = TrailingStopStrategy()
+bot.set_strategy(TradingPair.BTC, strategy)
+btc_eh = bot.symbol_event_handler(TradingPair.BTC)
+
+# initializing and starting bot on other thread
+threading.Thread(target=lambda: asyncio.run(bot_loop())).start()
+
+
+###################################
+# Flask callbacks
+###################################
+
+@app.route('/')
+def entry():
+    return render_template('index.html')
+
+
+###################################
+# Socker.IO callbacks
+###################################
+
+@socketio.on("close_position")
+def on_close_position(message: dict):
+    position_id = message['position_id']
+
+    loop.run_until_complete(bot.close_position(position_id))
+
+
+@socketio.on('connect')
+def on_connect():
+    # sleeping on exception to avoid race condition
+    ticks, prices, positions, balances = [], [], [], []
+
+    while not ticks or not prices:
+        try:
+            ticks = bot.symbol_status(TradingPair.BTC).all_ticks()
+            prices = bot.symbol_status(TradingPair.BTC).all_prices()
+            positions = bot.symbol_status(TradingPair.BTC).current_positions()
+            balances = loop.run_until_complete(bot.get_balances())
+        except KeyError:
+            sleep(1)
+
+    socketio.emit("first_connect",
+                  {
+                      "ticks": ticks,
+                      "prices": prices,
+                      "positions": list(map(pw_to_posprop, positions)),
+                      "balances": list(map(balance_to_json, balances))
+                  })
+
+
+@socketio.on('get_profit_loss')
+def on_get_profit_loss(message):
+    start = message['start']
+    end = message['end']
+
+    profit_loss = loop.run_until_complete(bot.get_profit_loss(start, end))
+
+    socketio.emit("put_profit_loss", {
+        "pl": profit_loss[0],
+        "pl_perc": profit_loss[1]
+    })
+
+###################################
+# Bot callbacks
+###################################
+
+@btc_eh.on_event(EventKind.CLOSE_POSITION)
+async def on_close_position(event: Event, _):
+    print("CLOSING!")
+    await bot.close_position(event.metadata.position_id)
+
+
+@btc_eh.on_any_position_state()
+async def on_any_state(pw: PositionWrapper, ss: SymbolStatus):
+    await strategy.update_stop_percentage(pw, ss)
+
+
+@btc_eh.on_event(EventKind.NEW_TICK)
+async def on_new_tick(event: Event, status: SymbolStatus):
+    tick = event.tick
+    price = status.prices[event.tick]
+
+    balances: List[Balance] = await bot.get_balances()
+    positions: List[PositionWrapper] = status.positions[event.tick] if event.tick in status.positions else []
+
+    socketio.emit("new_tick", {"tick": tick,
+                               "price": price,
+                               "positions": list(map(pw_to_posprop, positions)),
+                               "balances": list(map(balance_to_json, balances))})
+
+
+@btc_eh.on_any_event()
+def on_any_event(event: Event, _):
+    socketio.emit("new_event", {
+        "tick": event.tick,
+        "kind": event.kind.name
+    })
+
+
+if __name__ == '__main__':
+    socketio.run(app)

requirements.txt

@@ -0,0 +1,36 @@
+aiohttp==3.7.3
+astroid==2.4.2
+async-timeout==3.0.1
+asyncio==3.4.3
+attrs==20.3.0
+bidict==0.21.2
+bitfinex-api-py==1.1.8
+chardet==3.0.4
+click==7.1.2
+eventemitter==0.2.0
+Flask==1.1.2
+Flask-SocketIO==5.0.1
+idna==2.10
+isort==5.6.4
+itsdangerous==1.1.0
+Jinja2==2.11.2
+lazy-object-proxy==1.4.3
+MarkupSafe==1.1.1
+mccabe==0.6.1
+mpmath==1.1.0
+multidict==5.1.0
+pyee==8.1.0
+pylint==2.6.0
+python-dotenv==0.15.0
+python-engineio==4.0.0
+python-socketio==5.0.3
+retrying-async==1.2.0
+six==1.15.0
+sympy==1.7.1
+toml==0.10.2
+typing-extensions==3.7.4.3
+websockets==8.1
+Werkzeug==1.0.1
+wrapt==1.12.1
+yarl==1.6.3
+

src/bot.rs

@@ -1,68 +0,0 @@
-use core::time::Duration;
-
-use log::{error, info};
-use tokio::time::sleep;
-
-use crate::BoxError;
-use crate::connectors::ExchangeDetails;
-use crate::currency::{Symbol, SymbolPair};
-use crate::frontend::FrontendManagerHandle;
-use crate::managers::ExchangeManager;
-use crate::ticker::Ticker;
-
-pub struct Rustico {
-    ticker: Ticker,
-    exchange_managers: Vec<ExchangeManager>,
-    frontend_connector: FrontendManagerHandle,
-}
-
-impl Rustico {
-    // TODO: change constructor to take SymbolPairs and not Symbol
-    pub fn new(
-        exchanges: Vec<ExchangeDetails>,
-        trading_pairs: Vec<SymbolPair>,
-        tick_duration: Duration,
-    ) -> Self {
-        let exchange_managers = exchanges
-            .iter()
-            .map(|x| ExchangeManager::new(x, &trading_pairs))
-            .collect();
-
-        Rustico {
-            ticker: Ticker::new(tick_duration),
-            exchange_managers,
-            frontend_connector: FrontendManagerHandle::new(),
-        }
-    }
-
-    pub async fn start_loop(&mut self) -> Result<(), BoxError> {
-        self.update_exchanges().await?;
-
-        loop {
-            info!("Current tick: {}", self.ticker.current_tick());
-
-            if let Err(e) = self.update().await {
-                error!("Error in main bot loop: {}", e);
-            }
-        }
-    }
-
-    async fn update_exchanges(&mut self) -> Result<(), BoxError> {
-        for e in &mut self.exchange_managers {
-            if let Err(err) = e.update_managers(self.ticker.current_tick()).await {
-                error!("Error while updating managers: {}", err);
-            }
-        }
-
-        Ok(())
-    }
-
-    async fn update(&mut self) -> Result<(), BoxError> {
-        sleep(self.ticker.duration()).await;
-        self.ticker.inc();
-
-        self.update_exchanges().await?;
-
-        Ok(())
-    }
-}

src/connectors.rs

@@ -1,764 +0,0 @@
-use std::convert::{TryFrom, TryInto};
-use std::fmt::{Debug, Formatter};
-use std::str::FromStr;
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use bitfinex::api::RestClient;
-use bitfinex::book::BookPrecision;
-use bitfinex::orders::{CancelOrderForm, OrderMeta};
-use bitfinex::responses::{OrderResponse, TradeResponse};
-use bitfinex::ticker::TradingPairTicker;
-use bitfinex::websockets::WebSocketClient;
-use futures_retry::RetryPolicy;
-use log::trace;
-use tokio::macros::support::Future;
-use tokio::time::Duration;
-
-use crate::BoxError;
-use crate::currency::{Symbol, SymbolPair};
-use crate::models::{
-    ActiveOrder, OrderBook, OrderBookEntry, OrderDetails, OrderFee, OrderForm, OrderKind, Position,
-    PositionState, PriceTicker, Trade, TradingFees, TradingPlatform, WalletKind,
-};
-
-#[derive(PartialEq, Eq, Clone, Copy, Debug)]
-pub enum Exchange {
-    Bitfinex,
-}
-
-#[derive(Eq, PartialEq, Hash, Clone, Debug)]
-pub enum ExchangeDetails {
-    Bitfinex { api_key: String, api_secret: String },
-}
-
-/// You do **not** have to wrap the `Client` in an [`Rc`] or [`Arc`] to **reuse** it,
-/// because it already uses an [`Arc`] internally.
-#[derive(Clone, Debug)]
-pub struct Client {
-    exchange: Exchange,
-    inner: Arc<Box<dyn RestConnector>>,
-}
-
-impl Client {
-    pub fn new(exchange: &ExchangeDetails) -> Self {
-        match exchange {
-            ExchangeDetails::Bitfinex {
-                api_key,
-                api_secret,
-            } => Self {
-                exchange: Exchange::Bitfinex,
-                inner: Arc::new(Box::new(BitfinexConnector::new(api_key, api_secret))),
-            },
-        }
-    }
-
-    pub async fn active_positions(
-        &self,
-        pair: &SymbolPair,
-    ) -> Result<Option<Vec<Position>>, BoxError> {
-        // retrieving open positions and order book to calculate effective profit/loss
-        let (positions, order_book, fees) = tokio::join!(
-            self.inner.active_positions(pair),
-            self.inner.order_book(pair),
-            self.inner.trading_fees()
-        );
-
-        let (mut positions, order_book, fees) = (positions?, order_book?, fees?);
-        let (best_ask, best_bid) = (order_book.lowest_ask(), order_book.highest_bid());
-
-        if positions.is_none() {
-            return Ok(None);
-        }
-
-        let derivative_taker = fees
-            .iter()
-            .filter_map(|x| match x {
-                TradingFees::Taker {
-                    platform,
-                    percentage,
-                } if platform == &TradingPlatform::Derivative => Some(percentage),
-                _ => None,
-            })
-            .next()
-            .ok_or("Could not retrieve derivative taker fee!")?;
-        let margin_taker = fees
-            .iter()
-            .filter_map(|x| match x {
-                TradingFees::Taker {
-                    platform,
-                    percentage,
-                } if platform == &TradingPlatform::Margin => Some(percentage),
-                _ => None,
-            })
-            .next()
-            .ok_or("Could not retrieve margin taker fee!")?;
-
-        // updating positions with effective profit/loss
-        positions.iter_mut().flatten().for_each(|x| {
-            let fee = match x.platform() {
-                TradingPlatform::Funding | TradingPlatform::Exchange => {
-                    unimplemented!()
-                }
-                TradingPlatform::Margin => margin_taker,
-                TradingPlatform::Derivative => derivative_taker,
-            };
-
-            if x.is_short() {
-                x.update_profit_loss(best_ask, *fee);
-            } else {
-                x.update_profit_loss(best_bid, *fee);
-            }
-        });
-
-        Ok(positions)
-    }
-
-    pub async fn current_prices(&self, pair: &SymbolPair) -> Result<TradingPairTicker, BoxError> {
-        self.inner.current_prices(pair).await
-    }
-
-    pub async fn active_orders(&self, pair: &SymbolPair) -> Result<Vec<ActiveOrder>, BoxError> {
-        Ok(self
-            .inner
-            .active_orders(pair)
-            .await?
-            .into_iter()
-            .filter(|x| x.pair() == pair)
-            .collect())
-    }
-
-    pub async fn submit_order(&self, order: &OrderForm) -> Result<ActiveOrder, BoxError> {
-        self.inner.submit_order(order).await
-    }
-
-    pub async fn order_book(&self, pair: &SymbolPair) -> Result<OrderBook, BoxError> {
-        self.inner.order_book(pair).await
-    }
-
-    pub async fn cancel_order(&self, order: &ActiveOrder) -> Result<ActiveOrder, BoxError> {
-        self.inner.cancel_order(order).await
-    }
-
-    pub async fn transfer_between_wallets(
-        &self,
-        from: &WalletKind,
-        to: &WalletKind,
-        symbol: Symbol,
-        amount: f64,
-    ) -> Result<(), BoxError> {
-        self.inner
-            .transfer_between_wallets(from, to, symbol, amount)
-            .await
-    }
-
-    pub async fn trades_from_order(
-        &self,
-        order: &OrderDetails,
-    ) -> Result<Option<Vec<Trade>>, BoxError> {
-        self.inner.trades_from_order(order).await
-    }
-
-    pub async fn orders_history(
-        &self,
-        pair: &SymbolPair,
-    ) -> Result<Option<Vec<OrderDetails>>, BoxError> {
-        self.inner.orders_history(pair).await
-    }
-
-    pub async fn trading_fees(&self) -> Result<Vec<TradingFees>, BoxError> { self.inner.trading_fees().await }
-}
-
-/// This trait represents a REST API service.
-#[async_trait]
-pub trait RestConnector: Send + Sync {
-    fn name(&self) -> String;
-    async fn active_positions(&self, pair: &SymbolPair) -> Result<Option<Vec<Position>>, BoxError>;
-    async fn current_prices(&self, pair: &SymbolPair) -> Result<TradingPairTicker, BoxError>;
-    async fn order_book(&self, pair: &SymbolPair) -> Result<OrderBook, BoxError>;
-    async fn active_orders(&self, pair: &SymbolPair) -> Result<Vec<ActiveOrder>, BoxError>;
-    async fn submit_order(&self, order: &OrderForm) -> Result<ActiveOrder, BoxError>;
-    async fn cancel_order(&self, order: &ActiveOrder) -> Result<ActiveOrder, BoxError>;
-    async fn transfer_between_wallets(
-        &self,
-        from: &WalletKind,
-        to: &WalletKind,
-        symbol: Symbol,
-        amount: f64,
-    ) -> Result<(), BoxError>;
-    async fn trades_from_order(&self, order: &OrderDetails)
-                               -> Result<Option<Vec<Trade>>, BoxError>;
-    async fn orders_history(
-        &self,
-        pair: &SymbolPair,
-    ) -> Result<Option<Vec<OrderDetails>>, BoxError>;
-    async fn trading_fees(&self) -> Result<Vec<TradingFees>, BoxError>;
-}
-
-impl Debug for dyn RestConnector {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        write!(f, "{}", self.name())
-    }
-}
-
-/// This trait represents a WebSocket API service.
-#[async_trait]
-pub trait WebSocketConnector: Send + Sync {
-    fn name(&self) -> String;
-    async fn connect(&self) -> Result<(), BoxError>;
-}
-
-/**************
-* BITFINEX
-**************/
-
-pub struct BitfinexConnector {
-    rest: bitfinex::api::RestClient,
-    ws: bitfinex::websockets::WebSocketClient,
-}
-
-impl BitfinexConnector {
-    const AFFILIATE_CODE: &'static str = "XPebOgHxA";
-
-    fn handle_small_nonce_error(e: BoxError) -> RetryPolicy<BoxError> {
-        if e.to_string().contains("nonce: small") {
-            return RetryPolicy::WaitRetry(Duration::from_millis(1));
-        }
-        RetryPolicy::ForwardError(e)
-    }
-
-    pub fn new(api_key: &str, api_secret: &str) -> Self {
-        BitfinexConnector {
-            rest: RestClient::new(Some(api_key.into()), Some(api_secret.into())),
-            ws: WebSocketClient::new(),
-        }
-    }
-
-    fn format_trading_pair(pair: &SymbolPair) -> String {
-        if pair.to_string().to_lowercase().contains("test")
-            || pair.to_string().to_lowercase().contains("f0")
-        {
-            format!("{}:{}", pair.base(), pair.quote())
-        } else {
-            format!("{}{}", pair.base(), pair.quote())
-        }
-    }
-
-    // retry to submit the request until it succeeds.
-    // the function may fail due to concurrent signed requests
-    // parsed in different times by the server
-    async fn retry_nonce<F, Fut, O>(mut func: F) -> Result<O, BoxError>
-        where
-            F: FnMut() -> Fut,
-            Fut: Future<Output=Result<O, BoxError>>,
-    {
-        let response = {
-            loop {
-                match func().await {
-                    Ok(response) => break response,
-                    Err(e) => {
-                        if !e.to_string().contains("nonce: small") {
-                            return Err(e);
-                        }
-                        tokio::time::sleep(Duration::from_nanos(1)).await;
-                    }
-                }
-            }
-        };
-
-        Ok(response)
-    }
-}
-
-#[async_trait]
-impl RestConnector for BitfinexConnector {
-    fn name(&self) -> String {
-        "Bitfinex REST".into()
-    }
-
-    async fn active_positions(&self, pair: &SymbolPair) -> Result<Option<Vec<Position>>, BoxError> {
-        let active_positions =
-            BitfinexConnector::retry_nonce(|| self.rest.positions.active_positions()).await?;
-
-        let positions: Vec<_> = active_positions
-            .into_iter()
-            .filter_map(|x| x.try_into().ok())
-            .filter(|x: &Position| x.pair() == pair)
-            .collect();
-
-        trace!("\tRetrieved positions for {}", pair);
-        Ok((!positions.is_empty()).then_some(positions))
-    }
-
-    async fn current_prices(&self, pair: &SymbolPair) -> Result<TradingPairTicker, BoxError> {
-        let symbol_name = BitfinexConnector::format_trading_pair(pair);
-
-        let ticker: TradingPairTicker = self.rest.ticker.trading_pair(symbol_name).await?;
-
-        Ok(ticker)
-    }
-
-    async fn order_book(&self, pair: &SymbolPair) -> Result<OrderBook, BoxError> {
-        let symbol_name = BitfinexConnector::format_trading_pair(pair);
-
-        let response = BitfinexConnector::retry_nonce(|| {
-            self.rest.book.trading_pair(&symbol_name, BookPrecision::P0)
-        })
-            .await?;
-
-        let entries = response
-            .into_iter()
-            .map(|x| OrderBookEntry::Trading {
-                price: x.price,
-                count: x.count as u64,
-                amount: x.amount,
-            })
-            .collect();
-
-        Ok(OrderBook::new(pair.clone()).with_entries(entries))
-    }
-
-    async fn active_orders(&self, _: &SymbolPair) -> Result<Vec<ActiveOrder>, BoxError> {
-        let response = BitfinexConnector::retry_nonce(|| self.rest.orders.active_orders()).await?;
-
-        Ok(response.iter().map(Into::into).collect())
-    }
-
-    async fn submit_order(&self, order: &OrderForm) -> Result<ActiveOrder, BoxError> {
-        let symbol_name = format!("t{}", BitfinexConnector::format_trading_pair(order.pair()));
-        let amount = order.amount();
-
-        let order_form = {
-            match order.kind() {
-                OrderKind::Limit { price } => {
-                    bitfinex::orders::OrderForm::new(symbol_name, price, amount, order.into())
-                }
-                OrderKind::Market => {
-                    bitfinex::orders::OrderForm::new(symbol_name, 0.0, amount, order.into())
-                }
-                OrderKind::Stop { price } => {
-                    bitfinex::orders::OrderForm::new(symbol_name, price, amount, order.into())
-                }
-                OrderKind::StopLimit { stop_price: price, limit_price } => {
-                    bitfinex::orders::OrderForm::new(symbol_name, price, amount, order.into())
-                        .with_price_aux_limit(Some(limit_price))?
-                }
-                OrderKind::TrailingStop { distance } => {
-                    bitfinex::orders::OrderForm::new(symbol_name, 0.0, amount, order.into())
-                        .with_price_trailing(Some(distance))?
-                }
-                OrderKind::FillOrKill { price } => {
-                    bitfinex::orders::OrderForm::new(symbol_name, price, amount, order.into())
-                }
-                OrderKind::ImmediateOrCancel { price } => {
-                    bitfinex::orders::OrderForm::new(symbol_name, price, amount, order.into())
-                }
-            }
-                .with_meta(Some(OrderMeta::new(
-                    BitfinexConnector::AFFILIATE_CODE.to_string(),
-                )))
-                // TODO: CHANGEME!
-                .with_leverage(Some(15))
-        };
-
-        let response =
-            BitfinexConnector::retry_nonce(|| self.rest.orders.submit_order(&order_form)).await?;
-
-        // parsing response into ActiveOrder and adding leverage from order form
-        let order_response: ActiveOrder = (&response).try_into()?;
-
-        // TODO: CHANGEME!!!!
-        Ok(order_response.with_leverage(Some(15.0)))
-    }
-
-    async fn cancel_order(&self, order: &ActiveOrder) -> Result<ActiveOrder, BoxError> {
-        let cancel_form = order.into();
-
-        let response =
-            BitfinexConnector::retry_nonce(|| self.rest.orders.cancel_order(&cancel_form)).await?;
-
-        Ok((&response).try_into()?)
-    }
-
-    async fn transfer_between_wallets(
-        &self,
-        from: &WalletKind,
-        to: &WalletKind,
-        symbol: Symbol,
-        amount: f64,
-    ) -> Result<(), BoxError> {
-        BitfinexConnector::retry_nonce(|| {
-            self.rest.account.transfer_between_wallets(
-                from.into(),
-                to.into(),
-                symbol.to_string(),
-                amount,
-            )
-        })
-            .await?;
-
-        Ok(())
-    }
-
-    async fn trades_from_order(
-        &self,
-        order: &OrderDetails,
-    ) -> Result<Option<Vec<Trade>>, BoxError> {
-        let response = BitfinexConnector::retry_nonce(|| {
-            self.rest
-                .trades
-                .generated_by_order(order.pair().trading_repr(), order.id())
-        })
-            .await?;
-
-        if response.is_empty() {
-            Ok(None)
-        } else {
-            Ok(Some(response.iter().map(Into::into).collect()))
-        }
-    }
-
-    async fn orders_history(
-        &self,
-        pair: &SymbolPair,
-    ) -> Result<Option<Vec<OrderDetails>>, BoxError> {
-        let response =
-            BitfinexConnector::retry_nonce(|| self.rest.orders.history(Some(pair.trading_repr())))
-                .await?;
-        let mapped_vec: Vec<_> = response.iter().map(Into::into).collect();
-
-        Ok((!mapped_vec.is_empty()).then_some(mapped_vec))
-    }
-
-    async fn trading_fees(&self) -> Result<Vec<TradingFees>, BoxError> {
-        let mut fees = vec![];
-        let accountfees =
-            BitfinexConnector::retry_nonce(|| self.rest.account.account_summary()).await?;
-
-        // Derivatives
-        let derivative_taker = TradingFees::Taker {
-            platform: TradingPlatform::Derivative,
-            percentage: accountfees.derivative_taker() * 100.0,
-        };
-        let derivative_maker = TradingFees::Maker {
-            platform: TradingPlatform::Derivative,
-            percentage: accountfees.derivative_rebate() * 100.0,
-        };
-        fees.push(derivative_taker);
-        fees.push(derivative_maker);
-
-        // Exchange
-        let exchange_taker = TradingFees::Taker {
-            platform: TradingPlatform::Exchange,
-            percentage: accountfees.taker_to_fiat() * 100.0,
-        };
-        let exchange_maker = TradingFees::Maker {
-            platform: TradingPlatform::Exchange,
-            percentage: accountfees.maker_fee() * 100.0,
-        };
-        fees.push(exchange_taker);
-        fees.push(exchange_maker);
-
-        // Margin
-        let margin_taker = TradingFees::Taker {
-            platform: TradingPlatform::Margin,
-            percentage: accountfees.taker_to_fiat() * 100.0,
-        };
-        let margin_maker = TradingFees::Maker {
-            platform: TradingPlatform::Margin,
-            percentage: accountfees.maker_fee() * 100.0,
-        };
-        fees.push(margin_taker);
-        fees.push(margin_maker);
-
-        Ok(fees)
-    }
-}
-
-#[async_trait]
-impl WebSocketConnector for BitfinexConnector {
-    fn name(&self) -> String {
-        "Bitfinex WS".into()
-    }
-
-    async fn connect(&self) -> Result<(), BoxError> {
-        Ok(())
-    }
-}
-
-impl From<&ActiveOrder> for CancelOrderForm {
-    fn from(o: &ActiveOrder) -> Self {
-        Self::from_id(o.id())
-    }
-}
-
-impl TryFrom<&bitfinex::responses::OrderResponse> for ActiveOrder {
-    type Error = BoxError;
-
-    fn try_from(response: &OrderResponse) -> Result<Self, Self::Error> {
-        let pair = SymbolPair::from_str(response.symbol())?;
-
-        Ok(ActiveOrder::new(
-            Exchange::Bitfinex,
-            response.id(),
-            pair.clone(),
-            OrderForm::new(pair, response.into(), response.into(), response.amount()),
-            response.mts_create(),
-            response.mts_update(),
-        )
-            .with_group_id(response.gid())
-            .with_client_id(Some(response.cid())))
-    }
-}
-
-impl TryInto<Position> for bitfinex::positions::Position {
-    type Error = BoxError;
-
-    fn try_into(self) -> Result<Position, Self::Error> {
-        let state = {
-            if self.status().to_lowercase().contains("active") {
-                PositionState::Open
-            } else {
-                PositionState::Closed
-            }
-        };
-
-        let platform = {
-            if self.symbol().to_ascii_lowercase().contains("f0") {
-                TradingPlatform::Derivative
-            } else {
-                TradingPlatform::Margin
-            }
-        };
-
-        Ok(Position::new(
-            SymbolPair::from_str(self.symbol())?,
-            state,
-            self.amount(),
-            self.base_price(),
-            self.pl(),
-            self.pl_perc(),
-            self.price_liq(),
-            self.position_id(),
-            platform,
-            self.leverage(),
-        )
-            .with_creation_date(self.mts_create())
-            .with_creation_update(self.mts_update()))
-    }
-}
-
-impl From<&OrderForm> for bitfinex::orders::OrderKind {
-    fn from(o: &OrderForm) -> Self {
-        match o.platform() {
-            TradingPlatform::Exchange => match o.kind() {
-                OrderKind::Limit { .. } => bitfinex::orders::OrderKind::ExchangeLimit,
-                OrderKind::Market { .. } => bitfinex::orders::OrderKind::ExchangeMarket,
-                OrderKind::Stop { .. } => bitfinex::orders::OrderKind::ExchangeStop,
-                OrderKind::StopLimit { .. } => bitfinex::orders::OrderKind::ExchangeStopLimit,
-                OrderKind::TrailingStop { .. } => bitfinex::orders::OrderKind::ExchangeTrailingStop,
-                OrderKind::FillOrKill { .. } => bitfinex::orders::OrderKind::ExchangeFok,
-                OrderKind::ImmediateOrCancel { .. } => bitfinex::orders::OrderKind::ExchangeIoc,
-            },
-            TradingPlatform::Margin | TradingPlatform::Derivative => match o.kind() {
-                OrderKind::Limit { .. } => bitfinex::orders::OrderKind::Limit,
-                OrderKind::Market { .. } => bitfinex::orders::OrderKind::Market,
-                OrderKind::Stop { .. } => bitfinex::orders::OrderKind::Stop,
-                OrderKind::StopLimit { .. } => bitfinex::orders::OrderKind::StopLimit,
-                OrderKind::TrailingStop { .. } => bitfinex::orders::OrderKind::TrailingStop,
-                OrderKind::FillOrKill { .. } => bitfinex::orders::OrderKind::Fok,
-                OrderKind::ImmediateOrCancel { .. } => bitfinex::orders::OrderKind::Ioc,
-            },
-            _ => unimplemented!(),
-        }
-    }
-}
-
-impl From<&bitfinex::responses::OrderResponse> for TradingPlatform {
-    fn from(response: &OrderResponse) -> Self {
-        match response.order_type() {
-            bitfinex::orders::OrderKind::Limit
-            | bitfinex::orders::OrderKind::Market
-            | bitfinex::orders::OrderKind::StopLimit
-            | bitfinex::orders::OrderKind::Stop
-            | bitfinex::orders::OrderKind::TrailingStop
-            | bitfinex::orders::OrderKind::Fok
-            | bitfinex::orders::OrderKind::Ioc => Self::Margin,
-            _ => Self::Exchange,
-        }
-    }
-}
-
-impl From<&bitfinex::orders::ActiveOrder> for TradingPlatform {
-    fn from(response: &bitfinex::orders::ActiveOrder) -> Self {
-        match response.order_type() {
-            bitfinex::orders::OrderKind::Limit
-            | bitfinex::orders::OrderKind::Market
-            | bitfinex::orders::OrderKind::StopLimit
-            | bitfinex::orders::OrderKind::Stop
-            | bitfinex::orders::OrderKind::TrailingStop
-            | bitfinex::orders::OrderKind::Fok
-            | bitfinex::orders::OrderKind::Ioc => Self::Margin,
-            _ => Self::Exchange,
-        }
-    }
-}
-
-impl From<&bitfinex::responses::OrderResponse> for OrderKind {
-    fn from(response: &OrderResponse) -> Self {
-        match response.order_type() {
-            bitfinex::orders::OrderKind::Limit | bitfinex::orders::OrderKind::ExchangeLimit => {
-                Self::Limit {
-                    price: response.price(),
-                }
-            }
-            bitfinex::orders::OrderKind::Market | bitfinex::orders::OrderKind::ExchangeMarket => {
-                Self::Market
-            }
-            bitfinex::orders::OrderKind::Stop | bitfinex::orders::OrderKind::ExchangeStop => {
-                Self::Stop {
-                    price: response.price(),
-                }
-            }
-            bitfinex::orders::OrderKind::StopLimit
-            | bitfinex::orders::OrderKind::ExchangeStopLimit => Self::StopLimit {
-                stop_price: response.price(),
-                limit_price: response.price_aux_limit().expect("Limit price not found!"),
-            },
-            bitfinex::orders::OrderKind::TrailingStop
-            | bitfinex::orders::OrderKind::ExchangeTrailingStop => Self::TrailingStop {
-                distance: response.price_trailing().expect("Distance not found!"),
-            },
-            bitfinex::orders::OrderKind::Fok | bitfinex::orders::OrderKind::ExchangeFok => {
-                Self::FillOrKill {
-                    price: response.price(),
-                }
-            }
-            bitfinex::orders::OrderKind::Ioc | bitfinex::orders::OrderKind::ExchangeIoc => {
-                Self::ImmediateOrCancel {
-                    price: response.price(),
-                }
-            }
-        }
-    }
-}
-
-impl From<&bitfinex::orders::ActiveOrder> for OrderKind {
-    fn from(response: &bitfinex::orders::ActiveOrder) -> Self {
-        match response.order_type() {
-            bitfinex::orders::OrderKind::Limit | bitfinex::orders::OrderKind::ExchangeLimit => {
-                Self::Limit {
-                    price: response.price(),
-                }
-            }
-            bitfinex::orders::OrderKind::Market | bitfinex::orders::OrderKind::ExchangeMarket => {
-                Self::Market {}
-            }
-            bitfinex::orders::OrderKind::Stop | bitfinex::orders::OrderKind::ExchangeStop => {
-                Self::Stop {
-                    price: response.price(),
-                }
-            }
-            bitfinex::orders::OrderKind::StopLimit
-            | bitfinex::orders::OrderKind::ExchangeStopLimit => Self::StopLimit {
-                stop_price: response.price(),
-                limit_price: response.price_aux_limit().expect("Limit price not found!"),
-            },
-            bitfinex::orders::OrderKind::TrailingStop
-            | bitfinex::orders::OrderKind::ExchangeTrailingStop => Self::TrailingStop {
-                distance: response.price_trailing().expect("Distance not found!"),
-            },
-            bitfinex::orders::OrderKind::Fok | bitfinex::orders::OrderKind::ExchangeFok => {
-                Self::FillOrKill {
-                    price: response.price(),
-                }
-            }
-            bitfinex::orders::OrderKind::Ioc | bitfinex::orders::OrderKind::ExchangeIoc => {
-                Self::ImmediateOrCancel {
-                    price: response.price(),
-                }
-            }
-        }
-    }
-}
-
-impl From<&bitfinex::orders::ActiveOrder> for ActiveOrder {
-    fn from(order: &bitfinex::orders::ActiveOrder) -> Self {
-        let pair = SymbolPair::from_str(&order.symbol()).expect("Invalid symbol!");
-
-        ActiveOrder::new(
-            Exchange::Bitfinex,
-            order.id(),
-            pair.clone(),
-            OrderForm::new(pair, order.into(), order.into(), order.amount()),
-            order.creation_timestamp(),
-            order.update_timestamp(),
-        )
-            .with_client_id(Some(order.client_id()))
-            .with_group_id(order.group_id())
-    }
-}
-
-impl From<TradingPairTicker> for PriceTicker {
-    fn from(t: TradingPairTicker) -> Self {
-        Self {
-            bid: t.bid,
-            bid_size: t.bid_size,
-            ask: t.ask,
-            ask_size: t.ask_size,
-            daily_change: t.daily_change,
-            daily_change_perc: t.daily_change_perc,
-            last_price: t.last_price,
-            volume: t.volume,
-            high: t.high,
-            low: t.low,
-        }
-    }
-}
-
-impl From<&WalletKind> for &bitfinex::account::WalletKind {
-    fn from(k: &WalletKind) -> Self {
-        match k {
-            WalletKind::Exchange => &bitfinex::account::WalletKind::Exchange,
-            WalletKind::Margin => &bitfinex::account::WalletKind::Margin,
-            WalletKind::Funding => &bitfinex::account::WalletKind::Funding,
-        }
-    }
-}
-
-impl From<&bitfinex::orders::ActiveOrder> for OrderDetails {
-    fn from(order: &bitfinex::orders::ActiveOrder) -> Self {
-        Self::new(
-            Exchange::Bitfinex,
-            order.id(),
-            SymbolPair::from_str(order.symbol()).unwrap(),
-            order.into(),
-            order.into(),
-            order.update_timestamp(),
-        )
-    }
-}
-
-// TODO: fields are hardcoded, to fix
-impl From<&bitfinex::responses::TradeResponse> for Trade {
-    fn from(response: &TradeResponse) -> Self {
-        let pair = SymbolPair::from_str(&response.symbol()).unwrap();
-        let fee = {
-            if response.is_maker() {
-                OrderFee::Maker(response.fee())
-            } else {
-                OrderFee::Taker(response.fee())
-            }
-        };
-
-        Self {
-            trade_id: response.trade_id(),
-            pair,
-            execution_timestamp: response.execution_timestamp(),
-            price: response.execution_price(),
-            amount: response.execution_amount(),
-            fee,
-            fee_currency: Symbol::new(response.symbol().to_owned()),
-        }
-    }
-}

src/currency.rs

@@ -1,198 +0,0 @@
-use core::fmt;
-use std::borrow::Cow;
-use std::fmt::{Display, Formatter};
-use std::str::FromStr;
-
-use regex::Regex;
-
-use crate::BoxError;
-
-#[derive(Clone, PartialEq, Hash, Debug, Eq)]
-pub struct Symbol {
-    name: Cow<'static, str>,
-}
-
-impl<S> From<S> for Symbol
-    where
-        S: Into<String>,
-{
-    fn from(item: S) -> Self {
-        Symbol::new(item.into())
-    }
-}
-
-impl Symbol {
-    pub const XMR: Symbol = Symbol::new_static("XMR");
-    pub const BTC: Symbol = Symbol::new_static("BTC");
-    pub const ETH: Symbol = Symbol::new_static("ETH");
-    pub const LTC: Symbol = Symbol::new_static("LTC");
-    pub const DOT: Symbol = Symbol::new_static("DOT");
-
-    pub const DERIV_BTC: Symbol = Symbol::new_static("BTCF0");
-    pub const DERIV_ETH: Symbol = Symbol::new_static("ETHF0");
-    pub const DERIV_USDT: Symbol = Symbol::new_static("USTF0");
-    pub const DERIV_ADA: Symbol = Symbol::new_static("ADAF0");
-    pub const DERIV_POLKADOT: Symbol = Symbol::new_static("DOTF0");
-
-    // Paper trading
-    pub const TESTBTC: Symbol = Symbol::new_static("TESTBTC");
-    pub const TESTUSD: Symbol = Symbol::new_static("TESTUSD");
-
-    pub const DERIV_TESTBTC: Symbol = Symbol::new_static("TESTBTCF0");
-    pub const DERIV_TESTUSDT: Symbol = Symbol::new_static("TESTUSDTF0");
-
-    // Fiat coins
-    pub const USD: Symbol = Symbol::new_static("USD");
-    pub const GBP: Symbol = Symbol::new_static("GBP");
-    pub const EUR: Symbol = Symbol::new_static("EUR");
-
-    pub fn new(name: String) -> Self {
-        Symbol {
-            name: Cow::from(name),
-        }
-    }
-
-    pub const fn new_static(name: &'static str) -> Self {
-        Symbol {
-            name: Cow::Borrowed(name),
-        }
-    }
-
-    pub fn name(&self) -> &str {
-        &self.name
-    }
-}
-
-impl Display for Symbol {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.name)
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct SymbolPair {
-    quote: Symbol,
-    base: Symbol,
-}
-
-impl SymbolPair {
-    pub fn new(base: Symbol, quote: Symbol) -> Self {
-        SymbolPair { base, quote }
-    }
-    pub fn trading_repr(&self) -> String {
-        format!("t{}{}", self.base, self.quote)
-    }
-    pub fn funding_repr(&self) -> String {
-        format!("f{}{}", self.base, self.quote)
-    }
-    pub fn quote(&self) -> &Symbol {
-        &self.quote
-    }
-    pub fn base(&self) -> &Symbol {
-        &self.base
-    }
-}
-
-impl Into<String> for SymbolPair {
-    fn into(self) -> String {
-        format!("{}/{}", self.base, self.quote)
-    }
-}
-
-impl FromStr for SymbolPair {
-    type Err = BoxError;
-
-    fn from_str(value: &str) -> Result<Self, Self::Err> {
-        const REGEX: &str = r"^[t|f](?P<base>\w{3,7}):?(?P<quote>\w{3,7})";
-
-        let captures = Regex::new(REGEX)?.captures(&value).ok_or("Invalid input")?;
-        let quote = captures.name("quote").ok_or("Quote not found")?.as_str();
-        let base = captures.name("base").ok_or("Base not found")?.as_str();
-
-        Ok(SymbolPair {
-            quote: quote.into(),
-            base: base.into(),
-        })
-    }
-}
-
-impl Display for SymbolPair {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "{}/{}", self.base, self.quote)
-    }
-}
-
-#[derive(Clone)]
-enum WalletKind {
-    Margin,
-    Exchange,
-    Funding,
-}
-
-#[derive(Clone)]
-struct Balance {
-    pair: SymbolPair,
-    base_price: f64,
-    base_amount: f64,
-    quote_equivalent: f64,
-    wallet: WalletKind,
-}
-
-impl Balance {
-    pub fn new(pair: SymbolPair, base_price: f64, base_amount: f64, wallet: WalletKind) -> Self {
-        Balance {
-            pair,
-            base_price,
-            base_amount,
-            quote_equivalent: base_amount * base_price,
-            wallet,
-        }
-    }
-
-    pub fn pair(&self) -> &SymbolPair {
-        &self.pair
-    }
-    pub fn base_price(&self) -> f64 {
-        self.base_price
-    }
-    pub fn base_amount(&self) -> f64 {
-        self.base_amount
-    }
-    pub fn quote_equivalent(&self) -> f64 {
-        self.quote_equivalent
-    }
-    pub fn wallet(&self) -> &WalletKind {
-        &self.wallet
-    }
-}
-
-struct BalanceGroup {
-    quote_equivalent: f64,
-    balances: Vec<Balance>,
-}
-
-impl BalanceGroup {
-    pub fn new() -> Self {
-        BalanceGroup {
-            balances: Vec::new(),
-            quote_equivalent: 0f64,
-        }
-    }
-
-    pub fn add_balance(&mut self, balance: &Balance) {
-        self.balances.push(balance.clone());
-
-        self.quote_equivalent += balance.quote_equivalent()
-    }
-
-    pub fn currency_names(&self) -> Vec<String> {
-        self.balances
-            .iter()
-            .map(|x| x.pair().base().name().into())
-            .collect()
-    }
-
-    pub fn balances(&self) -> &Vec<Balance> {
-        &self.balances
-    }
-}

src/events.rs

@@ -1,75 +0,0 @@
-use tokio::sync::oneshot;
-
-use crate::managers::OptionUpdate;
-use crate::models::OrderForm;
-
-#[derive(Debug)]
-pub struct ActorMessage {
-    pub(crate) message: ActionMessage,
-    pub(crate) respond_to: oneshot::Sender<OptionUpdate>,
-}
-
-#[derive(Debug)]
-pub enum ActionMessage {
-    Update { tick: u64 },
-    ClosePosition { position_id: u64 },
-    SubmitOrder { order: OrderForm },
-    ClosePositionOrders { position_id: u64 },
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-pub struct EventMetadata {
-    position_id: Option<u64>,
-    order_id: Option<u64>,
-}
-
-impl EventMetadata {
-    pub fn new(position_id: Option<u64>, order_id: Option<u64>) -> Self {
-        EventMetadata {
-            position_id,
-            order_id,
-        }
-    }
-}
-
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
-pub enum EventKind {
-    NewMinimum,
-    NewMaximum,
-    ReachedLoss,
-    ReachedBreakEven,
-    ReachedMinProfit,
-    ReachedGoodProfit,
-    ReachedMaxLoss,
-    TrailingStopSet,
-    TrailingStopMoved,
-    OrderSubmitted,
-    NewTick,
-    PositionClosed { position_id: u64 },
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-pub struct Event {
-    kind: EventKind,
-    tick: u64,
-    metadata: Option<EventMetadata>,
-}
-
-impl Event {
-    pub fn new(kind: EventKind, tick: u64) -> Self {
-        Event {
-            kind,
-            tick,
-            metadata: None,
-        }
-    }
-
-    pub fn with_metadata(mut self, metadata: Option<EventMetadata>) -> Self {
-        self.metadata = metadata;
-        self
-    }
-
-    fn has_metadata(&self) -> bool {
-        self.metadata.is_some()
-    }
-}

src/frontend.rs

@@ -1,89 +0,0 @@
-use std::net::SocketAddr;
-
-use futures_util::stream::TryStreamExt;
-use futures_util::StreamExt;
-use log::info;
-use tokio::net::{TcpListener, TcpStream};
-use tokio::sync::mpsc::{channel, Receiver, Sender};
-use tokio_tungstenite::accept_async;
-
-use crate::BoxError;
-use crate::events::ActorMessage;
-
-#[derive(Debug)]
-pub struct FrontendManager {
-    receiver: Receiver<ActorMessage>,
-}
-
-impl FrontendManager {
-    pub fn new(receiver: Receiver<ActorMessage>) -> Self {
-        Self { receiver }
-    }
-
-    async fn handle_ws_connection(stream: TcpStream, addr: SocketAddr) -> Result<(), BoxError> {
-        let websocket = accept_async(stream).await?;
-        info!("Received WebSocket connection <{:?}>", addr);
-
-        let (_, ws_in) = websocket.split();
-
-        let on_received = ws_in.try_for_each(move |msg| {
-            info!(
-                "Received a message from {:?}: {}",
-                addr,
-                msg.to_text().unwrap()
-            );
-
-            futures_util::future::ok(())
-        });
-
-        tokio::spawn(on_received);
-
-        Ok(())
-    }
-
-    pub async fn websocket() -> Result<(), BoxError> {
-        let server = TcpListener::bind("127.0.0.1:3012").await?;
-
-        while let Ok((stream, addr)) = server.accept().await {
-            tokio::spawn(FrontendManager::handle_ws_connection(stream, addr));
-        }
-
-        Ok(())
-    }
-
-    pub async fn handle_message(&mut self, message: ActorMessage) -> Result<(), BoxError> {
-        match message.message {
-            _ => {}
-        }
-
-        Ok(message
-            .respond_to
-            .send((None, None))
-            .map_err(|_| BoxError::from("Could not send message."))?)
-    }
-}
-
-pub struct FrontendManagerHandle {
-    sender: Sender<ActorMessage>,
-}
-
-impl FrontendManagerHandle {
-    // async fn run_frontend_manager(mut manager: FrontendManager) {
-    //     info!("Frontend handler ready");
-    //
-    //     while let Some(msg) = manager.receiver.recv().await {
-    //         manager.handle_message(msg).await.unwrap();
-    //     }
-    // }
-
-    pub fn new() -> Self {
-        let (sender, receiver) = channel(1);
-
-        let _frontend = FrontendManager::new(receiver);
-
-        tokio::spawn(FrontendManager::websocket());
-        // tokio::spawn(FrontendManagerHandle::run_frontend_manager(frontend));
-
-        Self { sender }
-    }
-}

src/main.rs

@@ -1,100 +0,0 @@
-#![feature(drain_filter)]
-#![feature(bool_to_option)]
-
-use std::env;
-
-use fern::colors::{Color, ColoredLevelConfig};
-use log::error;
-use log::LevelFilter::Info;
-use tokio::time::Duration;
-
-use crate::bot::Rustico;
-use crate::connectors::ExchangeDetails;
-use crate::currency::{Symbol, SymbolPair};
-
-mod bot;
-mod connectors;
-mod currency;
-mod events;
-mod frontend;
-mod managers;
-mod models;
-mod strategy;
-mod ticker;
-mod tests;
-mod sounds;
-
-pub type BoxError = Box<dyn std::error::Error + Send + Sync>;
-
-#[tokio::main]
-async fn main() -> Result<(), BoxError> {
-    if let Err(e) = setup_logger() {
-        error!("Could not setup logger: {}", e);
-        return Err(e.into());
-    }
-
-    if let Err(e) = dotenv::dotenv() {
-        error!("Could not open .env file: {}", e);
-        return Err(e.into());
-    }
-
-    let api_key = env::vars()
-        .find(|(k, _v)| k == "API_KEY")
-        .map(|(_k, v)| v)
-        .ok_or("API_KEY not set!")?;
-    let api_secret = env::vars()
-        .find(|(k, _v)| k == "API_SECRET")
-        .map(|(_k, v)| v)
-        .ok_or("API_SECRET not set!")?;
-
-    let bitfinex = ExchangeDetails::Bitfinex {
-        api_key,
-        api_secret,
-    };
-
-    let pairs = vec![
-        SymbolPair::new(Symbol::BTC, Symbol::USD),
-        SymbolPair::new(Symbol::XMR, Symbol::USD),
-        SymbolPair::new(Symbol::ETH, Symbol::USD),
-        SymbolPair::new(Symbol::DERIV_ADA, Symbol::DERIV_USDT),
-        SymbolPair::new(Symbol::DERIV_POLKADOT, Symbol::DERIV_USDT),
-        SymbolPair::new(Symbol::DERIV_BTC, Symbol::DERIV_USDT),
-        SymbolPair::new(Symbol::DERIV_ETH, Symbol::DERIV_USDT),
-        SymbolPair::new(Symbol::DERIV_TESTBTC, Symbol::DERIV_TESTUSDT),
-    ];
-
-    let mut bot = Rustico::new(
-        vec![bitfinex],
-        pairs,
-        Duration::new(10, 0),
-    );
-
-    Ok(bot.start_loop().await?)
-}
-
-fn setup_logger() -> Result<(), fern::InitError> {
-    let colors = ColoredLevelConfig::new()
-        .info(Color::Green)
-        .error(Color::Red)
-        .trace(Color::Blue)
-        .debug(Color::Cyan)
-        .warn(Color::Yellow);
-
-    fern::Dispatch::new()
-        .format(move |out, message, record| {
-            out.finish(format_args!(
-                "{} | [{}][{}] | {}",
-                chrono::Local::now().format("[%d/%m/%Y][%H:%M:%S]"),
-                record.target().strip_prefix("rustico::").unwrap_or("rustico"),
-                colors.color(record.level()),
-                message
-            ))
-        })
-        .level(Info)
-        .filter(|metadata| metadata.target().contains("rustico"))
-        .chain(std::io::stdout())
-        .chain(fern::log_file("rustico.log")?)
-        .apply()?;
-
-    Ok(())
-}

src/managers.rs

@@ -1,769 +0,0 @@
-use std::collections::{HashMap, HashSet};
-use std::ops::Neg;
-
-use futures_util::stream::FuturesUnordered;
-use futures_util::StreamExt;
-use log::{debug, error, info, trace};
-use merge::Merge;
-use tokio::sync::mpsc::{Receiver, Sender};
-use tokio::sync::mpsc::channel;
-use tokio::sync::oneshot;
-use tokio::time::Duration;
-
-use crate::BoxError;
-use crate::connectors::{Client, ExchangeDetails};
-use crate::currency::SymbolPair;
-use crate::events::{ActionMessage, ActorMessage, Event};
-use crate::models::{ActiveOrder, OrderBook, OrderForm, OrderKind, OrderMetadata, Position, PriceTicker};
-use crate::sounds::{MARKET_ORDER_PLACED_PATH, play_sound};
-use crate::strategy::{MarketEnforce, PositionStrategy, TrailingStop};
-
-pub type OptionUpdate = (Option<Vec<Event>>, Option<Vec<ActionMessage>>);
-
-/******************
-* PRICES
-******************/
-
-#[derive(Debug)]
-pub struct PriceManager {
-    receiver: Receiver<ActorMessage>,
-    pair: SymbolPair,
-    prices: Vec<PriceEntry>,
-    client: Client,
-}
-
-impl PriceManager {
-    pub fn new(receiver: Receiver<ActorMessage>, pair: SymbolPair, client: Client) -> Self {
-        PriceManager {
-            receiver,
-            pair,
-            prices: Vec::new(),
-            client,
-        }
-    }
-
-    pub async fn handle_message(&mut self, message: ActorMessage) -> Result<(), BoxError> {
-        if let ActionMessage::Update { tick } = message.message {
-            let a = self.update(tick).await?;
-            self.add_entry(a);
-        }
-
-        Ok(message
-            .respond_to
-            .send((None, None))
-            .map_err(|_| BoxError::from("Could not send message."))?)
-    }
-
-    pub fn add_entry(&mut self, entry: PriceEntry) {
-        self.prices.push(entry);
-    }
-
-    pub async fn update(&mut self, tick: u64) -> Result<PriceEntry, BoxError> {
-        let current_prices = self.client.current_prices(&self.pair).await?.into();
-
-        Ok(PriceEntry::new(
-            tick,
-            current_prices,
-            self.pair.clone(),
-            None,
-        ))
-    }
-
-    pub fn pair(&self) -> &SymbolPair {
-        &self.pair
-    }
-}
-
-pub struct PriceManagerHandle {
-    sender: Sender<ActorMessage>,
-}
-
-impl PriceManagerHandle {
-    async fn run_price_manager(mut manager: PriceManager) {
-        while let Some(msg) = manager.receiver.recv().await {
-            manager.handle_message(msg).await.unwrap();
-        }
-    }
-
-    pub fn new(pair: SymbolPair, client: Client) -> Self {
-        let (sender, receiver) = channel(1);
-
-        let price_manager = PriceManager::new(receiver, pair, client);
-        tokio::spawn(PriceManagerHandle::run_price_manager(price_manager));
-
-        Self { sender }
-    }
-
-    pub async fn update(&mut self, tick: u64) -> Result<OptionUpdate, BoxError> {
-        let (send, recv) = oneshot::channel();
-
-        self.sender
-            .send(ActorMessage {
-                message: ActionMessage::Update { tick },
-                respond_to: send,
-            })
-            .await?;
-
-        Ok(recv.await?)
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct PriceEntry {
-    tick: u64,
-    pair: SymbolPair,
-    price: PriceTicker,
-    events: Option<Vec<Event>>,
-}
-
-impl PriceEntry {
-    pub fn new(
-        tick: u64,
-        price: PriceTicker,
-        pair: SymbolPair,
-        events: Option<Vec<Event>>,
-    ) -> Self {
-        PriceEntry {
-            tick,
-            pair,
-            price,
-            events,
-        }
-    }
-
-    pub fn tick(&self) -> u64 {
-        self.tick
-    }
-    pub fn pair(&self) -> &SymbolPair {
-        &self.pair
-    }
-    pub fn price(&self) -> PriceTicker {
-        self.price
-    }
-    pub fn events(&self) -> &Option<Vec<Event>> {
-        &self.events
-    }
-}
-
-/******************
-* POSITIONS
-******************/
-
-pub struct PositionManagerHandle {
-    sender: Sender<ActorMessage>,
-}
-
-impl PositionManagerHandle {
-    async fn run_position_manager(mut manager: PositionManager) {
-        while let Some(msg) = manager.receiver.recv().await {
-            manager.handle_message(msg).await.unwrap();
-        }
-    }
-
-    pub fn new(pair: SymbolPair, client: Client, strategy: Box<dyn PositionStrategy>) -> Self {
-        let (sender, receiver) = channel(1);
-
-        let manager = PositionManager::new(receiver, pair, client, strategy);
-
-        tokio::spawn(PositionManagerHandle::run_position_manager(manager));
-
-        Self { sender }
-    }
-
-    pub async fn update(&mut self, tick: u64) -> Result<OptionUpdate, BoxError> {
-        let (send, recv) = oneshot::channel();
-
-        self.sender
-            .send(ActorMessage {
-                message: ActionMessage::Update { tick },
-                respond_to: send,
-            })
-            .await?;
-
-        let response = recv.await?;
-        Ok(response)
-    }
-}
-
-#[derive(Debug)]
-pub struct PositionManager {
-    receiver: Receiver<ActorMessage>,
-    current_tick: u64,
-    pair: SymbolPair,
-    positions_history: HashMap<u64, Position>,
-    active_position: Option<Position>,
-    client: Client,
-    strategy: Box<dyn PositionStrategy>,
-}
-
-impl PositionManager {
-    pub fn new(
-        receiver: Receiver<ActorMessage>,
-        pair: SymbolPair,
-        client: Client,
-        strategy: Box<dyn PositionStrategy>,
-    ) -> Self {
-        PositionManager {
-            receiver,
-            current_tick: 0,
-            pair,
-            positions_history: HashMap::new(),
-            active_position: None,
-            client,
-            strategy,
-        }
-    }
-
-    pub fn current_tick(&self) -> u64 {
-        self.current_tick
-    }
-
-    pub async fn handle_message(&mut self, msg: ActorMessage) -> Result<(), BoxError> {
-        let (events, messages) = match msg.message {
-            ActionMessage::Update { tick } => self.update(tick).await?,
-            _ => (None, None),
-        };
-
-        Ok(msg
-            .respond_to
-            .send((events, messages))
-            .map_err(|_| BoxError::from("Could not send message."))?)
-    }
-
-    pub async fn update(&mut self, tick: u64) -> Result<OptionUpdate, BoxError> {
-        trace!("\t[PositionManager] Updating {}", self.pair);
-
-        self.current_tick = tick;
-        let (fees, opt_active_positions) = tokio::join!(self.client.trading_fees(),self.client.active_positions(&self.pair));
-        let (fees, opt_active_positions) = (fees?, opt_active_positions?);
-
-        // we assume there is only ONE active position per pair
-        match opt_active_positions {
-            // no open positions, no events and no messages returned
-            None => return Ok((None, None)),
-
-            Some(positions) => {
-                // checking if there are positions open for our pair
-                match positions.into_iter().find(|x| x.pair() == &self.pair) {
-                    // no open positions for our pair, setting active position to none
-                    None => {
-                        self.active_position = None;
-                        return Ok((None, None));
-                    }
-
-                    // applying strategy to open position and saving into struct
-                    Some(position) => {
-                        let mut events = None;
-                        let mut messages = None;
-
-                        let (pos_on_tick, events_on_tick, messages_on_tick) = self
-                            .strategy
-                            .on_tick(position, self.current_tick(), &self.positions_history, &fees);
-
-                        let (pos_post_tick, events_post_tick, messages_post_tick) = self
-                            .strategy
-                            .post_tick(pos_on_tick, self.current_tick(), &self.positions_history, &fees);
-
-                        events.merge(events_on_tick);
-                        events.merge(events_post_tick);
-
-                        messages.merge(messages_on_tick);
-                        messages.merge(messages_post_tick);
-
-                        self.positions_history
-                            .insert(self.current_tick(), pos_post_tick.clone());
-                        self.active_position = Some(pos_post_tick);
-
-                        return Ok((events, messages));
-                    }
-                }
-            }
-        };
-    }
-}
-
-/******************
-* ORDERS
-******************/
-
-pub struct OrderManagerHandle {
-    sender: Sender<ActorMessage>,
-}
-
-impl OrderManagerHandle {
-    const SLEEP_DURATION: u64 = 5;
-
-    async fn run_order_manager(mut manager: OrderManager) {
-        let mut sleep =
-            tokio::time::interval(Duration::from_secs(OrderManagerHandle::SLEEP_DURATION));
-
-        loop {
-            tokio::select! {
-                opt_msg = manager.receiver.recv() => {
-                    if let Some(msg) = opt_msg {
-                        manager.handle_message(msg).await.unwrap()
-                    }
-                },
-                _ = sleep.tick() => {
-                    manager.update().await.unwrap();
-                }
-            }
-        }
-    }
-
-    pub fn new(pair: SymbolPair, client: Client) -> Self {
-        let (sender, receiver) = channel(1);
-
-        let manager = OrderManager::new(receiver, pair, client);
-
-        tokio::spawn(OrderManagerHandle::run_order_manager(manager));
-
-        Self { sender }
-    }
-
-    pub async fn close_position(&mut self, position_id: u64) -> Result<OptionUpdate, BoxError> {
-        let (send, recv) = oneshot::channel();
-
-        self.sender
-            .send(ActorMessage {
-                message: ActionMessage::ClosePosition { position_id },
-                respond_to: send,
-            })
-            .await?;
-
-        Ok(recv.await?)
-    }
-
-    pub async fn close_position_orders(
-        &mut self,
-        position_id: u64,
-    ) -> Result<OptionUpdate, BoxError> {
-        let (send, recv) = oneshot::channel();
-
-        self.sender
-            .send(ActorMessage {
-                message: ActionMessage::ClosePositionOrders { position_id },
-                respond_to: send,
-            })
-            .await?;
-
-        Ok(recv.await?)
-    }
-
-    pub async fn submit_order(&mut self, order_form: OrderForm) -> Result<OptionUpdate, BoxError> {
-        let (send, recv) = oneshot::channel();
-
-        self.sender
-            .send(ActorMessage {
-                message: ActionMessage::SubmitOrder { order: order_form },
-                respond_to: send,
-            })
-            .await?;
-
-        Ok(recv.await?)
-    }
-}
-
-pub struct OrderManager {
-    receiver: Receiver<ActorMessage>,
-    orders_map: HashMap<u64, HashSet<ActiveOrder>>,
-    pair: SymbolPair,
-    client: Client,
-}
-
-impl OrderManager {
-    pub fn new(
-        receiver: Receiver<ActorMessage>,
-        pair: SymbolPair,
-        client: Client,
-    ) -> Self {
-        OrderManager {
-            receiver,
-            pair,
-            client,
-            orders_map: Default::default(),
-        }
-    }
-
-    /*
-     * PRIVATE METHODS
-     */
-
-    fn add_to_orders_map(&mut self, position_id: u64, order: ActiveOrder) -> bool {
-        self.orders_map
-            .entry(position_id)
-            .or_default()
-            .insert(order)
-    }
-
-    fn orders_from_position_id(&self, position_id: u64) -> Option<&HashSet<ActiveOrder>> {
-        self.orders_map.get(&position_id)
-    }
-
-    fn all_tracked_orders(&self) -> Option<Vec<ActiveOrder>> {
-        let orders: Vec<_> = self.orders_map.values().flat_map(|x| x.clone()).collect();
-
-        (!orders.is_empty()).then_some(orders)
-    }
-
-    async fn update_orders_map_from_remote(&mut self) -> Result<(), BoxError> {
-        let (res_remote_orders, res_remote_positions) = tokio::join!(self.client.active_orders(&self.pair),
-         self.client.active_positions(&self.pair));
-        let (remote_orders, remote_positions) = (res_remote_orders?, res_remote_positions?);
-
-        match remote_positions {
-            // no positions open, clear internal mapping
-            None => { self.orders_map.clear(); }
-            Some(positions) => {
-                // retain only positions that are open remotely as well
-                self.orders_map.retain(|local_id, _| positions.iter().any(|r| r.id() == *local_id));
-
-                for position in positions {
-                    // mapping tracked orders to their ids
-                    let tracked_orders: Vec<_> = self.orders_from_position_id(position.id())
-                        .iter()
-                        .flat_map(|x| x
-                            .iter()
-                            .map(|x| x.id()))
-                        .collect();
-
-                    // adding remote order that are not in the internal mapping
-                    for remote_order in remote_orders.iter().filter(|x| !tracked_orders.contains(&x.id())) {
-                        // the only check to bind an active order to an open position,
-                        // is to check for their amount which should be identical
-                        if (remote_order.order_form().amount().abs() - position.amount().abs()).abs() < 0.0001 {
-                            trace!("Adding order {} to internal mapping from remote.", remote_order.id());
-                            self.add_to_orders_map(position.id(), remote_order.clone());
-                        }
-                    }
-
-                    // removing local orders that are not in remote
-                    for local_orders in self.orders_map.values_mut() {
-                        local_orders.retain(|l| remote_orders.iter().any(|r| r.id() == l.id()));
-                    }
-
-                    // clean-up empty positions in local mapping
-                    let empty_positions_id: Vec<_> = self.orders_map
-                        .iter()
-                        .filter(|(_, orders)| orders.is_empty())
-                        .map(|(&position, _)| position)
-                        .collect();
-
-                    for position_id in empty_positions_id {
-                        self.orders_map.remove(&position_id);
-                    }
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    /*
-     * PUBLIC METHODS
-     */
-
-    pub async fn handle_message(&mut self, msg: ActorMessage) -> Result<(), BoxError> {
-        let (events, messages) = match msg.message {
-            ActionMessage::Update { .. } => self.update().await?,
-            ActionMessage::ClosePosition { position_id } => {
-                self.close_position(position_id).await?
-            }
-            ActionMessage::ClosePositionOrders { position_id } => {
-                self.close_position_orders(position_id).await?
-            }
-            ActionMessage::SubmitOrder { order } => self.submit_order(&order).await?,
-        };
-
-        Ok(msg
-            .respond_to
-            .send((events, messages))
-            .map_err(|_| BoxError::from("Could not send message."))?)
-    }
-
-    pub async fn close_position_orders(&self, position_id: u64) -> Result<OptionUpdate, BoxError> {
-        info!("Closing outstanding orders for position #{}", position_id);
-
-        if let Some(position_orders) = self.orders_map.get(&position_id) {
-            for order in position_orders {
-                match self.client.cancel_order(order).await {
-                    Ok(_) => info!("Order #{} closed successfully.", order.id()),
-                    Err(e) => error!("Could not close order #{}: {}", order.id(), e),
-                }
-            }
-        }
-
-        // TODO: return valid messages and events!
-        Ok((None, None))
-    }
-
-    pub async fn submit_order(&mut self, order_form: &OrderForm) -> Result<OptionUpdate, BoxError> {
-        info!("Submitting order: {}", order_form.kind());
-
-        // adding strategy to order, if present in the metadata
-        let active_order = {
-            if let Some(metadata) = order_form.metadata() {
-                // TODO: this seems extremely dirty. Double check!
-                self.client.submit_order(order_form).await?.with_strategy(metadata.cloned_strategy())
-            } else {
-                self.client.submit_order(order_form).await?
-            }
-        };
-
-        if let Some(metadata) = order_form.metadata() {
-            if let Some(position_id) = metadata.position_id() {
-                debug!("Adding order to tracked orders.");
-
-                if !self.add_to_orders_map(position_id, active_order) {
-                    error!("Failed while adding order to internal mapping.");
-                };
-            }
-        };
-
-        // play sound if Market order is placed
-        if let OrderKind::Market = order_form.kind() {
-            play_sound(MARKET_ORDER_PLACED_PATH);
-        }
-
-        // TODO: return valid messages and events!111!!!1!
-        Ok((None, None))
-    }
-
-    pub async fn close_position(&mut self, position_id: u64) -> Result<OptionUpdate, BoxError> {
-        info!("Closing position #{}", position_id);
-
-        debug!("Retrieving open orders, positions and current prices...");
-        let (res_open_orders, res_order_book, res_open_positions) = tokio::join!(
-            self.client.active_orders(&self.pair),
-            self.client.order_book(&self.pair),
-            self.client.active_positions(&self.pair)
-        );
-
-        let (open_orders, order_book, open_positions) =
-            (res_open_orders?, res_order_book?, res_open_positions?);
-
-        // if there are open positions
-        if let Some(open_positions) = open_positions {
-            // if we find an open position with the ID we are looking for
-            if let Some(position) = open_positions.into_iter().find(|x| x.id() == position_id) {
-                let opt_position_order = open_orders
-                    .iter()
-                    // avoid using direct equality, using error margin instead
-                    .find(|x| {
-                        (x.order_form().amount().neg() - position.amount()).abs() < 0.0000001
-                    });
-
-                // checking if the position has an open order.
-                // If so, don't do anything since the order is taken care of
-                // in the update phase.
-                // If no order is open, send an undercut limit order at the best current price.
-                if opt_position_order.is_none() {
-                    // No open order, undercutting best price with limit order
-                    let closing_price = self.best_closing_price(&position, &order_book);
-
-                    let order_form = OrderForm::new(
-                        self.pair.clone(),
-                        OrderKind::Limit {
-                            price: closing_price,
-                        },
-                        position.platform(),
-                        position.amount().neg(),
-                    )
-                        .with_leverage(Some(position.leverage()))
-                        .with_metadata(Some(OrderMetadata::new()
-                            .with_strategy(Some(Box::new(MarketEnforce::default())))
-                            .with_position_id(Some(position.id())))
-                        );
-
-                    // submitting order
-                    if let Err(e) = self.submit_order(&order_form).await {
-                        error!(
-                            "Could not submit {} to close position #{}: {}",
-                            order_form.kind(),
-                            position.id(),
-                            e
-                        );
-                        return Err(e);
-                    }
-                }
-            }
-        }
-
-        Ok((None, None))
-    }
-
-    pub async fn update(&mut self) -> Result<OptionUpdate, BoxError> {
-        debug!("\t[OrderManager] Updating {}", self.pair);
-
-        // updating internal orders' mapping from remote
-        self.update_orders_map_from_remote().await?;
-
-        // calling strategies for the orders and collecting resulting messages
-        let _orders_messages: HashMap<&ActiveOrder, Vec<ActionMessage>> = HashMap::new();
-
-        if let Some(tracked_orders) = self.all_tracked_orders() {
-            // since there are open orders, retrieve order book
-            let order_book = self.client.order_book(&self.pair).await?;
-
-            for active_order in tracked_orders.iter().filter(|x| x.strategy().is_some()) {
-                let strategy = active_order.strategy().as_ref().unwrap();
-
-                trace!(
-                    "Found open order with \"{}\" strategy.",
-                    strategy.name()
-                );
-
-                // executing the order's strategy and collecting its messages, if any
-                let (_, strat_messages) = strategy.on_open_order(&active_order, &order_book)?;
-
-                if let Some(messages) = strat_messages {
-                    for m in messages {
-                        match m {
-                            ActionMessage::SubmitOrder { order: order_form } => {
-                                info!("Closing open order...");
-                                info!("\tCancelling open order #{}", &active_order.id());
-                                self.client.cancel_order(&active_order).await?;
-
-                                info!("\tSubmitting {}...", order_form.kind());
-                                self.submit_order(&order_form).await?;
-                                info!("Done!");
-                            }
-                            _ => {
-                                debug!(
-                                    "Received unsupported message from order strategy. Unimplemented."
-                                )
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        Ok((None, None))
-    }
-
-
-    pub fn best_closing_price(&self, position: &Position, order_book: &OrderBook) -> f64 {
-        let ask = order_book.lowest_ask();
-        let bid = order_book.highest_bid();
-        let avg = (bid + ask) / 2.0;
-        let delta = (ask - bid) / 10.0;
-
-        let closing_price = {
-            if position.is_short() {
-                bid - delta
-            } else {
-                ask + delta
-            }
-        };
-
-        if avg > 9999.0 {
-            if position.is_short() {
-                closing_price.ceil()
-            } else {
-                closing_price.floor()
-            }
-        } else {
-            closing_price
-        }
-    }
-}
-
-pub struct PairManager {
-    pair: SymbolPair,
-    price_manager: PriceManagerHandle,
-    order_manager: OrderManagerHandle,
-    position_manager: PositionManagerHandle,
-}
-
-impl PairManager {
-    pub fn new(pair: SymbolPair, client: Client) -> Self {
-        Self {
-            pair: pair.clone(),
-            price_manager: PriceManagerHandle::new(pair.clone(), client.clone()),
-            order_manager: OrderManagerHandle::new(
-                pair.clone(),
-                client.clone(),
-            ),
-            position_manager: PositionManagerHandle::new(
-                pair,
-                client,
-                Box::new(TrailingStop::default()),
-            ),
-        }
-    }
-
-    pub async fn update_managers(&mut self, tick: u64) -> Result<(), BoxError> {
-        let mut events = None;
-        let mut messages = None;
-
-        let (price_results, pos_results) = tokio::join!(
-            self.price_manager.update(tick),
-            self.position_manager.update(tick),
-        );
-
-        let (opt_price_events, opt_price_messages) = price_results?;
-        let (opt_pos_events, opt_pos_messages) = pos_results?;
-
-        events.merge(opt_price_events);
-        events.merge(opt_pos_events);
-
-        messages.merge(opt_price_messages);
-        messages.merge(opt_pos_messages);
-
-        // TODO: to move into Handler?
-        if let Some(messages) = messages {
-            for m in messages {
-                match m {
-                    ActionMessage::Update { .. } => {}
-                    ActionMessage::ClosePosition { position_id } => {
-                        self.order_manager.close_position(position_id).await?;
-                    }
-                    ActionMessage::SubmitOrder { order } => {
-                        self.order_manager.submit_order(order).await?;
-                    }
-                    ActionMessage::ClosePositionOrders { position_id } => {
-                        self.order_manager
-                            .close_position_orders(position_id)
-                            .await?;
-                    }
-                }
-            }
-        }
-
-        Ok(())
-    }
-}
-
-pub struct ExchangeManager {
-    kind: ExchangeDetails,
-    pair_managers: Vec<PairManager>,
-}
-
-impl ExchangeManager {
-    pub fn new(kind: &ExchangeDetails, pairs: &[SymbolPair]) -> Self {
-        let client = Client::new(kind);
-        let pair_managers = pairs
-            .iter()
-            .map(|x| PairManager::new(x.clone(), client.clone()))
-            .collect();
-
-        Self {
-            kind: kind.clone(),
-            pair_managers,
-        }
-    }
-
-    pub async fn update_managers(&mut self, tick: u64) -> Result<(), BoxError> {
-        let mut futures: FuturesUnordered<_> = self
-            .pair_managers
-            .iter_mut()
-            .map(|x| x.update_managers(tick))
-            .collect();
-
-        // execute the futures
-        while futures.next().await.is_some() {}
-
-        Ok(())
-    }
-}

src/models.rs

@@ -1,674 +0,0 @@
-use std::fmt;
-use std::fmt::{Display, Formatter};
-use std::hash::{Hash, Hasher};
-
-use dyn_clone::clone_box;
-
-use crate::connectors::Exchange;
-use crate::currency::{Symbol, SymbolPair};
-use crate::strategy::OrderStrategy;
-
-/***************
-* Prices
-***************/
-
-#[derive(Copy, Clone, Debug)]
-pub struct PriceTicker {
-    pub bid: f64,
-    pub bid_size: f64,
-    pub ask: f64,
-    pub ask_size: f64,
-    pub daily_change: f64,
-    pub daily_change_perc: f64,
-    pub last_price: f64,
-    pub volume: f64,
-    pub high: f64,
-    pub low: f64,
-}
-
-/***************
-* Orders
-***************/
-
-#[derive(Debug)]
-pub enum OrderBookEntry {
-    Trading {
-        price: f64,
-        count: u64,
-        amount: f64,
-    },
-    Funding {
-        rate: f64,
-        period: u64,
-        count: u64,
-        amount: f64,
-    },
-}
-
-#[derive(Debug)]
-pub struct OrderBook {
-    pair: SymbolPair,
-    entries: Vec<OrderBookEntry>,
-}
-
-impl OrderBook {
-    pub fn new(pair: SymbolPair) -> Self {
-        OrderBook {
-            pair,
-            entries: Vec::new(),
-        }
-    }
-
-    pub fn with_entries(mut self, entries: Vec<OrderBookEntry>) -> Self {
-        self.entries = entries;
-        self
-    }
-
-    // TODO: distinguish between trading and funding
-    pub fn bids(&self) -> Vec<&OrderBookEntry> {
-        self.entries
-            .iter()
-            .filter(|x| match x {
-                OrderBookEntry::Trading { amount, .. } => amount > &0.0,
-                OrderBookEntry::Funding { amount, .. } => amount < &0.0,
-            })
-            .collect()
-    }
-
-    // TODO: distinguish between trading and funding
-    pub fn asks(&self) -> Vec<&OrderBookEntry> {
-        self.entries
-            .iter()
-            .filter(|x| match x {
-                OrderBookEntry::Trading { amount, .. } => amount < &0.0,
-                OrderBookEntry::Funding { amount, .. } => amount > &0.0,
-            })
-            .collect()
-    }
-
-    pub fn highest_bid(&self) -> f64 {
-        self.bids()
-            .iter()
-            .map(|x| match x {
-                OrderBookEntry::Trading { price, .. } => price,
-                OrderBookEntry::Funding { rate, .. } => rate,
-            })
-            .fold(f64::NEG_INFINITY, |a, &b| a.max(b))
-    }
-
-    pub fn lowest_ask(&self) -> f64 {
-        self.asks()
-            .iter()
-            .map(|x| match x {
-                OrderBookEntry::Trading { price, .. } => price,
-                OrderBookEntry::Funding { rate, .. } => rate,
-            })
-            .fold(f64::INFINITY, |a, &b| a.min(b))
-    }
-}
-
-#[derive(Debug)]
-pub enum OrderFee {
-    Maker(f64),
-    Taker(f64),
-}
-
-#[derive(Debug)]
-pub struct OrderDetails {
-    exchange: Exchange,
-    pair: SymbolPair,
-    platform: TradingPlatform,
-    kind: OrderKind,
-    execution_timestamp: u64,
-    id: u64,
-}
-
-impl OrderDetails {
-    pub fn new(
-        exchange: Exchange,
-        id: u64,
-        pair: SymbolPair,
-        platform: TradingPlatform,
-        kind: OrderKind,
-        execution_timestamp: u64,
-    ) -> Self {
-        OrderDetails {
-            exchange,
-            pair,
-            platform,
-            kind,
-            execution_timestamp,
-            id,
-        }
-    }
-
-    pub fn id(&self) -> u64 {
-        self.id
-    }
-
-    pub fn pair(&self) -> &SymbolPair {
-        &self.pair
-    }
-}
-
-#[derive(Debug)]
-pub struct ActiveOrder {
-    exchange: Exchange,
-    id: u64,
-    group_id: Option<u64>,
-    client_id: Option<u64>,
-    pair: SymbolPair,
-    order_form: OrderForm,
-    creation_timestamp: u64,
-    update_timestamp: u64,
-    strategy: Option<Box<dyn OrderStrategy>>,
-}
-
-impl ActiveOrder {
-    pub fn new(
-        exchange: Exchange,
-        id: u64,
-        pair: SymbolPair,
-        order_form: OrderForm,
-        creation_timestamp: u64,
-        update_timestamp: u64,
-    ) -> Self {
-        Self {
-            exchange,
-            id,
-            group_id: None,
-            client_id: None,
-            pair,
-            order_form,
-            creation_timestamp,
-            update_timestamp,
-            strategy: None,
-        }
-    }
-
-    pub fn with_group_id(mut self, group_id: Option<u64>) -> Self {
-        self.group_id = group_id;
-        self
-    }
-
-    pub fn with_client_id(mut self, client_id: Option<u64>) -> Self {
-        self.client_id = client_id;
-        self
-    }
-
-    pub fn with_strategy(mut self, strategy: Option<Box<dyn OrderStrategy>>) -> Self {
-        self.strategy = strategy;
-        self
-    }
-
-    pub fn with_leverage(mut self, leverage: Option<f64>) -> Self {
-        self.order_form = self.order_form.with_leverage(leverage);
-        self
-    }
-
-    pub fn exchange(&self) -> Exchange {
-        self.exchange
-    }
-    pub fn id(&self) -> u64 {
-        self.id
-    }
-    pub fn group_id(&self) -> Option<u64> {
-        self.group_id
-    }
-    pub fn client_id(&self) -> Option<u64> {
-        self.client_id
-    }
-    pub fn pair(&self) -> &SymbolPair {
-        &self.pair
-    }
-    pub fn order_form(&self) -> &OrderForm {
-        &self.order_form
-    }
-    pub fn creation_timestamp(&self) -> u64 {
-        self.creation_timestamp
-    }
-    pub fn update_timestamp(&self) -> u64 {
-        self.update_timestamp
-    }
-    pub fn strategy(&self) -> &Option<Box<dyn OrderStrategy>> {
-        &self.strategy
-    }
-}
-
-impl Hash for ActiveOrder {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        state.write(&self.id.to_le_bytes());
-    }
-}
-
-impl PartialEq for ActiveOrder {
-    fn eq(&self, other: &Self) -> bool {
-        self.id == other.id && self.client_id == other.client_id && self.group_id == other.group_id
-    }
-}
-
-impl Eq for ActiveOrder {}
-
-impl Clone for ActiveOrder {
-    fn clone(&self) -> Self {
-        Self {
-            exchange: self.exchange,
-            id: self.id,
-            group_id: self.group_id,
-            client_id: self.client_id,
-            pair: self.pair.clone(),
-            order_form: self.order_form.clone(),
-            creation_timestamp: self.creation_timestamp,
-            update_timestamp: self.update_timestamp,
-            strategy: self.strategy.as_ref().map(|x| clone_box(&**x)),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
-pub enum TradingPlatform {
-    Exchange,
-    Derivative,
-    Funding,
-    Margin,
-}
-
-impl TradingPlatform {
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            TradingPlatform::Exchange => "Exchange",
-            TradingPlatform::Derivative => "Derivative",
-            TradingPlatform::Funding => "Funding",
-            TradingPlatform::Margin => "Margin",
-        }
-    }
-}
-
-impl Display for TradingPlatform {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.as_str())
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub enum OrderKind {
-    Limit { price: f64 },
-    Market,
-    Stop { price: f64 },
-    StopLimit { stop_price: f64, limit_price: f64 },
-    TrailingStop { distance: f64 },
-    FillOrKill { price: f64 },
-    ImmediateOrCancel { price: f64 },
-}
-
-impl OrderKind {
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            OrderKind::Limit { .. } => "Limit",
-            OrderKind::Market { .. } => "Market",
-            OrderKind::Stop { .. } => "Stop",
-            OrderKind::StopLimit { .. } => "Stop Limit",
-            OrderKind::TrailingStop { .. } => "Trailing Stop",
-            OrderKind::FillOrKill { .. } => "Fill or Kill",
-            OrderKind::ImmediateOrCancel { .. } => "Immediate or Cancel",
-        }
-    }
-}
-
-impl Display for OrderKind {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            OrderKind::Limit { price } => {
-                write!(f, "[{} | Price: {:0.5}]", self.as_str(), price, )
-            }
-            OrderKind::Market => {
-                write!(f, "[{}]", self.as_str())
-            }
-            OrderKind::Stop { price } => {
-                write!(f, "[{} | Price: {:0.5}]", self.as_str(), price, )
-            }
-            OrderKind::StopLimit { stop_price, limit_price } => {
-                write!(
-                    f,
-                    "[{} | Stop: {:0.5}, Limit: {:0.5}]",
-                    self.as_str(),
-                    stop_price,
-                    limit_price
-                )
-            }
-            OrderKind::TrailingStop { distance } => {
-                write!(f, "[{} | Distance: {:0.5}]", self.as_str(), distance, )
-            }
-            OrderKind::FillOrKill { price } => {
-                write!(f, "[{} | Price: {:0.5}]", self.as_str(), price, )
-            }
-            OrderKind::ImmediateOrCancel { price } => {
-                write!(f, "[{} | Price: {:0.5}]", self.as_str(), price, )
-            }
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct OrderForm {
-    pair: SymbolPair,
-    kind: OrderKind,
-    platform: TradingPlatform,
-    amount: f64,
-    leverage: Option<f64>,
-    metadata: Option<OrderMetadata>,
-}
-
-impl OrderForm {
-    pub fn new(
-        pair: SymbolPair,
-        order_kind: OrderKind,
-        platform: TradingPlatform,
-        amount: f64,
-    ) -> Self {
-        Self {
-            pair,
-            kind: order_kind,
-            platform,
-            amount,
-            leverage: None,
-            metadata: None,
-        }
-    }
-
-    pub fn with_leverage(mut self, leverage: Option<f64>) -> Self {
-        self.leverage = leverage;
-        self
-    }
-
-    pub fn with_metadata(mut self, metadata: Option<OrderMetadata>) -> Self {
-        self.metadata = metadata;
-        self
-    }
-
-    pub fn pair(&self) -> &SymbolPair {
-        &self.pair
-    }
-    pub fn kind(&self) -> OrderKind {
-        self.kind
-    }
-    pub fn platform(&self) -> &TradingPlatform {
-        &self.platform
-    }
-    pub fn amount(&self) -> f64 {
-        self.amount
-    }
-    pub fn price(&self) -> Option<f64> {
-        match self.kind {
-            OrderKind::Limit { price, .. } => Some(price),
-            OrderKind::Market { .. } => None,
-            OrderKind::Stop { price, .. } => Some(price),
-            OrderKind::StopLimit { stop_price: price, .. } => Some(price),
-            OrderKind::TrailingStop { .. } => None,
-            OrderKind::FillOrKill { price, .. } => Some(price),
-            OrderKind::ImmediateOrCancel { price, .. } => Some(price),
-        }
-    }
-    pub fn leverage(&self) -> Option<f64> {
-        self.leverage
-    }
-    pub fn metadata(&self) -> &Option<OrderMetadata> {
-        &self.metadata
-    }
-    pub fn is_long(&self) -> bool {
-        self.amount.is_sign_positive()
-    }
-    pub fn is_short(&self) -> bool {
-        self.amount.is_sign_negative()
-    }
-}
-
-#[derive(Debug)]
-pub struct OrderMetadata {
-    position_id: Option<u64>,
-    strategy: Option<Box<dyn OrderStrategy>>,
-}
-
-impl Clone for OrderMetadata {
-    fn clone(&self) -> Self {
-        Self {
-            position_id: self.position_id,
-            strategy: self.strategy.as_ref().map(|x| clone_box(&**x)),
-        }
-    }
-}
-
-impl OrderMetadata {
-    pub fn new() -> Self {
-        Self {
-            position_id: None,
-            strategy: None,
-        }
-    }
-
-    pub fn with_position_id(mut self, position_id: Option<u64>) -> Self {
-        self.position_id = position_id;
-        self
-    }
-
-    pub fn with_strategy(mut self, strategy: Option<Box<dyn OrderStrategy>>) -> Self {
-        self.strategy = strategy;
-        self
-    }
-
-    pub fn position_id(&self) -> Option<u64> {
-        self.position_id
-    }
-    pub fn cloned_strategy(&self) -> Option<Box<dyn OrderStrategy>> {
-        match &self.strategy {
-            None => { None }
-            Some(strategy) => {
-                Some(clone_box(&**strategy))
-            }
-        }
-    }
-}
-
-impl Default for OrderMetadata {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-/***************
-* Positions
-***************/
-
-#[derive(Clone, Debug)]
-pub struct Position {
-    pair: SymbolPair,
-    state: PositionState,
-    profit_state: Option<PositionProfitState>,
-    amount: f64,
-    base_price: f64,
-    pl: f64,
-    pl_perc: f64,
-    price_liq: f64,
-    position_id: u64,
-    creation_date: Option<u64>,
-    creation_update: Option<u64>,
-    platform: TradingPlatform,
-    leverage: f64,
-}
-
-impl Position {
-    pub fn new(
-        pair: SymbolPair,
-        state: PositionState,
-        amount: f64,
-        base_price: f64,
-        pl: f64,
-        pl_perc: f64,
-        price_liq: f64,
-        position_id: u64,
-        platform: TradingPlatform,
-        leverage: f64,
-    ) -> Self {
-        Position {
-            pair,
-            state,
-            amount,
-            base_price,
-            pl,
-            pl_perc,
-            price_liq,
-            position_id,
-            creation_date: None,
-            creation_update: None,
-            profit_state: None,
-            platform,
-            leverage,
-        }
-    }
-
-    pub fn with_creation_date(mut self, creation_date: Option<u64>) -> Self {
-        self.creation_date = creation_date;
-        self
-    }
-
-    pub fn with_creation_update(mut self, creation_update: Option<u64>) -> Self {
-        self.creation_update = creation_update;
-        self
-    }
-
-    pub fn with_profit_state(mut self, profit_state: Option<PositionProfitState>) -> Self {
-        self.profit_state = profit_state;
-        self
-    }
-
-    pub fn update_profit_loss(&mut self, best_offer: f64, fee_perc: f64) {
-        let (base_price, delta) = {
-            if self.is_short() {
-                let base_price = self.base_price * (1.0 - fee_perc / 100.0);
-                let delta = base_price - best_offer;
-
-                (base_price, delta)
-            } else {
-                let base_price = self.base_price * (1.0 + fee_perc / 100.0);
-                let delta = best_offer - base_price;
-
-                (base_price, delta)
-            }
-        };
-
-        let profit_loss = delta * self.amount.abs();
-        let profit_loss_percentage = delta / base_price * 100.0;
-
-        self.pl = profit_loss;
-        self.pl_perc = profit_loss_percentage;
-    }
-
-    pub fn with_profit_loss(mut self, profit_loss: f64) -> Self {
-        self.pl = profit_loss;
-        self
-    }
-
-    pub fn pair(&self) -> &SymbolPair {
-        &self.pair
-    }
-    pub fn state(&self) -> PositionState {
-        self.state
-    }
-    pub fn amount(&self) -> f64 {
-        self.amount
-    }
-    pub fn base_price(&self) -> f64 {
-        self.base_price
-    }
-    pub fn pl(&self) -> f64 {
-        self.pl
-    }
-    pub fn pl_perc(&self) -> f64 {
-        self.pl_perc
-    }
-    pub fn price_liq(&self) -> f64 {
-        self.price_liq
-    }
-    pub fn id(&self) -> u64 {
-        self.position_id
-    }
-    pub fn profit_state(&self) -> Option<PositionProfitState> {
-        self.profit_state
-    }
-    pub fn creation_date(&self) -> Option<u64> {
-        self.creation_date
-    }
-    pub fn creation_update(&self) -> Option<u64> {
-        self.creation_update
-    }
-    pub fn is_short(&self) -> bool {
-        self.amount.is_sign_negative()
-    }
-    pub fn is_long(&self) -> bool {
-        self.amount.is_sign_positive()
-    }
-    pub fn platform(&self) -> TradingPlatform {
-        self.platform
-    }
-    pub fn leverage(&self) -> f64 {
-        self.leverage
-    }
-}
-
-impl Hash for Position {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        state.write(&self.id().to_le_bytes())
-    }
-}
-
-impl PartialEq for Position {
-    fn eq(&self, other: &Self) -> bool {
-        self.id() == other.id()
-    }
-}
-
-impl Eq for Position {}
-
-#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-pub enum PositionProfitState {
-    Critical,
-    Loss,
-    BreakEven,
-    MinimumProfit,
-    Profit,
-}
-
-#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-pub enum PositionState {
-    Closed,
-    Open,
-}
-
-pub enum WalletKind {
-    Exchange,
-    Margin,
-    Funding,
-}
-
-#[derive(Debug)]
-pub struct Trade {
-    pub trade_id: u64,
-    pub pair: SymbolPair,
-    pub execution_timestamp: u64,
-    pub price: f64,
-    pub amount: f64,
-    pub fee: OrderFee,
-    pub fee_currency: Symbol,
-}
-
-#[derive(Debug)]
-pub enum TradingFees {
-    Maker {
-        platform: TradingPlatform,
-        percentage: f64,
-    },
-    Taker {
-        platform: TradingPlatform,
-        percentage: f64,
-    },
-}

src/sounds.rs

@@ -1,19 +0,0 @@
-use ears::{AudioController, Sound};
-use log::error;
-
-pub const MARKET_ORDER_PLACED_PATH: &str = "sounds/smas-smb3_goal.wav";
-pub const LOSS_TO_BREAK_EVEN_PATH: &str = "sounds/smw2_boing.wav";
-pub const MIN_PROFIT_SOUND_PATH: &str = "sounds/smw_1-up.wav";
-pub const GOOD_PROFIT_SOUND_PATH: &str = "sounds/smw_power-up.wav";
-
-pub fn play_sound(sound_path: &'static str) {
-    std::thread::spawn(move || {
-        match Sound::new(sound_path) {
-            Ok(mut sound) => {
-                sound.play();
-                while sound.is_playing() {}
-            }
-            Err(e) => { error!("Could not play {}: {}", sound_path, e); }
-        }
-    });
-}

src/strategy.rs

@@ -1,449 +0,0 @@
-use std::collections::HashMap;
-use std::fmt::{Debug, Formatter};
-use std::ops::Neg;
-
-use dyn_clone::DynClone;
-use log::info;
-
-use crate::BoxError;
-use crate::events::{ActionMessage, Event, EventKind, EventMetadata};
-use crate::managers::OptionUpdate;
-use crate::models::{ActiveOrder, OrderBook, OrderForm, OrderKind, OrderMetadata, Position, PositionProfitState, TradingFees};
-use crate::models::PositionProfitState::{BreakEven, Critical, Loss, MinimumProfit, Profit};
-use crate::sounds::{GOOD_PROFIT_SOUND_PATH, LOSS_TO_BREAK_EVEN_PATH, MIN_PROFIT_SOUND_PATH, play_sound};
-
-/***************
-* DEFINITIONS
-***************/
-
-pub trait PositionStrategy: DynClone + Send + Sync {
-    fn name(&self) -> String;
-    fn on_tick(
-        &mut self,
-        position: Position,
-        current_tick: u64,
-        positions_history: &HashMap<u64, Position>,
-        fees: &[TradingFees],
-    ) -> (Position, Option<Vec<Event>>, Option<Vec<ActionMessage>>);
-    fn post_tick(
-        &mut self,
-        position: Position,
-        current_tick: u64,
-        positions_history: &HashMap<u64, Position>,
-        fees: &[TradingFees],
-    ) -> (Position, Option<Vec<Event>>, Option<Vec<ActionMessage>>);
-}
-
-impl Debug for dyn PositionStrategy {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        write!(f, "{}", self.name())
-    }
-}
-
-pub trait OrderStrategy: DynClone + Send + Sync {
-    /// The name of the strategy, used for debugging purposes
-    fn name(&self) -> String;
-    /// This method is called when the OrderManager checks the open orders on a new tick.
-    /// It should manage if some orders have to be closed or keep open.
-    fn on_open_order(
-        &self,
-        order: &ActiveOrder,
-        order_book: &OrderBook,
-    ) -> Result<OptionUpdate, BoxError>;
-    // /// This method is called when the OrderManager is requested to close
-    // /// a position that has an open order associated to it.
-    // fn on_position_order(
-    //     &self,
-    //     order: &ActiveOrder,
-    //     open_position: &Position,
-    //     order_book: &OrderBook,
-    // ) -> Result<OptionUpdate, BoxError>;
-}
-
-impl Debug for dyn OrderStrategy {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        write!(f, "{}", self.name())
-    }
-}
-
-/***************
-* IMPLEMENTATIONS
-***************/
-
-#[derive(Clone, Debug)]
-pub struct TrailingStop {
-    // Position ID: stop percentage mapping
-    stop_percentages: HashMap<u64, f64>,
-    // Position ID: bool mapping. Represents when the strategy has asked the
-    // order manager to set a stop loss order
-    stop_loss_flags: HashMap<u64, bool>,
-    // Position ID: bool mapping. Represents when the strategy has asked the
-    // order manager to set a limit order to close the position as the stop percentage
-    // has been surpassed
-    trail_set_flags: HashMap<u64, bool>,
-    capital_max_loss: f64,
-    capital_min_profit: f64,
-    capital_good_profit: f64,
-    min_profit_trailing_delta: f64,
-    good_profit_trailing_delta: f64,
-    leverage: f64,
-    min_profit_percentage: f64,
-    good_profit_percentage: f64,
-    max_loss_percentage: f64,
-}
-
-
-impl TrailingStop {
-    fn play_sound_on_state(prev_position: &Position, current_position: &Position) {
-        if prev_position.profit_state().is_none() {
-            return;
-        }
-
-        if current_position.profit_state().is_none() {
-            return;
-        }
-
-        let prev_state = prev_position.profit_state().unwrap();
-        let current_state = current_position.profit_state().unwrap();
-
-        // negative to positive
-        if let Loss | Critical = prev_state {
-            match current_state {
-                PositionProfitState::BreakEven => { play_sound(LOSS_TO_BREAK_EVEN_PATH); }
-                PositionProfitState::MinimumProfit => { play_sound(MIN_PROFIT_SOUND_PATH); }
-                PositionProfitState::Profit => { play_sound(GOOD_PROFIT_SOUND_PATH); }
-                _ => {}
-            }
-        }
-
-        if let BreakEven = prev_state {
-            match current_state {
-                PositionProfitState::MinimumProfit => { play_sound(MIN_PROFIT_SOUND_PATH); }
-                PositionProfitState::Profit => { play_sound(GOOD_PROFIT_SOUND_PATH); }
-                _ => {}
-            }
-        }
-    }
-
-    fn print_status(&self, position: &Position) {
-        match self.stop_percentages.get(&position.id()) {
-            None => {
-                info!(
-                    "\tState: {:?} | PL: {:0.2}{} ({:0.2}%)",
-                    position.profit_state().unwrap(),
-                    position.pl(),
-                    position.pair().quote(),
-                    position.pl_perc()
-                );
-            }
-            Some(stop_percentage) => {
-                info!(
-                    "\tState: {:?} | PL: {:0.2}{} ({:0.2}%) | Stop: {:0.2}",
-                    position.profit_state().unwrap(),
-                    position.pl(),
-                    position.pair().quote(),
-                    position.pl_perc(),
-                    stop_percentage
-                );
-            }
-        }
-    }
-
-    fn update_stop_percentage(&mut self, position: &Position) {
-        if let Some(profit_state) = position.profit_state() {
-            let profit_state_delta = match profit_state {
-                PositionProfitState::MinimumProfit => self.min_profit_trailing_delta,
-                PositionProfitState::Profit => self.good_profit_trailing_delta,
-                _ => return
-            };
-
-            let current_trailing_delta = position.pl_perc() - profit_state_delta;
-
-            match self.stop_percentages.get(&position.id()) {
-                None => {
-                    self.stop_percentages
-                        .insert(position.id(), current_trailing_delta);
-                }
-                Some(existing_threshold) => {
-                    if existing_threshold < &current_trailing_delta {
-                        self.stop_percentages
-                            .insert(position.id(), current_trailing_delta);
-                    }
-                }
-            }
-        }
-    }
-}
-
-impl Default for TrailingStop {
-    fn default() -> Self {
-        let leverage = 15.0;
-
-        // in percentage
-        let capital_min_profit = 8.5;
-        let capital_max_loss = capital_min_profit * 1.9;
-        let capital_good_profit = capital_min_profit * 2.0;
-
-        let weighted_min_profit = capital_min_profit / leverage;
-        let weighted_good_profit = capital_good_profit / leverage;
-        let weighted_max_loss = capital_max_loss / leverage;
-
-        let min_profit_trailing_delta = weighted_min_profit * 0.17;
-        let good_profit_trailing_delta = weighted_good_profit * 0.08;
-
-        let min_profit_percentage = weighted_min_profit + min_profit_trailing_delta;
-        let good_profit_percentage = weighted_good_profit + good_profit_trailing_delta;
-        let max_loss_percentage = -weighted_max_loss;
-
-        TrailingStop {
-            stop_percentages: Default::default(),
-            stop_loss_flags: Default::default(),
-            trail_set_flags: Default::default(),
-            capital_max_loss,
-            capital_min_profit,
-            capital_good_profit,
-            min_profit_trailing_delta,
-            good_profit_trailing_delta,
-            leverage,
-            min_profit_percentage,
-            good_profit_percentage,
-            max_loss_percentage,
-        }
-    }
-}
-
-impl PositionStrategy for TrailingStop {
-    fn name(&self) -> String {
-        "Trailing Stop".into()
-    }
-
-    /// Sets the profit state of an open position
-    fn on_tick(
-        &mut self,
-        position: Position,
-        current_tick: u64,
-        positions_history: &HashMap<u64, Position>,
-        _: &[TradingFees],
-    ) -> (Position, Option<Vec<Event>>, Option<Vec<ActionMessage>>) {
-        let pl_perc = position.pl_perc();
-
-        // setting the state of the position based on its profit/loss percentage
-        let state = {
-            if pl_perc > self.good_profit_percentage {
-                Profit
-            } else if (self.min_profit_percentage..self.good_profit_percentage).contains(&pl_perc) {
-                MinimumProfit
-            } else if (0.0..self.min_profit_percentage).contains(&pl_perc) {
-                BreakEven
-            } else if (self.max_loss_percentage..0.0).contains(&pl_perc) {
-                Loss
-            } else {
-                Critical
-            }
-        };
-
-        let opt_prev_position = positions_history.get(&(current_tick - 1));
-        let event_metadata = EventMetadata::new(Some(position.id()), None);
-        let new_position = position.with_profit_state(Some(state));
-
-        // checking if there was a state change between the current position
-        // and its last state
-        match opt_prev_position {
-            Some(prev) => {
-                if prev.profit_state() == Some(state) {
-                    return (new_position, None, None);
-                }
-
-                TrailingStop::play_sound_on_state(&prev, &new_position);
-            }
-            None => return (new_position, None, None),
-        };
-
-        let event = match state {
-            PositionProfitState::Critical => {
-                Event::new(
-                    EventKind::ReachedMaxLoss,
-                    current_tick,
-                )
-            }
-            PositionProfitState::Loss => {
-                Event::new(
-                    EventKind::ReachedLoss,
-                    current_tick,
-                )
-            }
-            PositionProfitState::BreakEven => {
-                Event::new(
-                    EventKind::ReachedBreakEven,
-                    current_tick,
-                )
-            }
-            PositionProfitState::MinimumProfit => {
-                Event::new(
-                    EventKind::ReachedMinProfit,
-                    current_tick,
-                )
-            }
-            PositionProfitState::Profit => {
-                Event::new(
-                    EventKind::ReachedGoodProfit,
-                    current_tick,
-                )
-            }
-        }.with_metadata(Some(event_metadata));
-
-        (new_position, Some(vec![event]), None)
-    }
-
-    fn post_tick(
-        &mut self,
-        position: Position,
-        _: u64,
-        _: &HashMap<u64, Position>,
-        fees: &[TradingFees],
-    ) -> (Position, Option<Vec<Event>>, Option<Vec<ActionMessage>>) {
-        let taker_fee = fees
-            .iter()
-            .filter_map(|x| match x {
-                TradingFees::Taker {
-                    platform,
-                    percentage,
-                } if platform == &position.platform() => Some(percentage),
-                _ => None,
-            })
-            .next().map_or_else(|| 0.0, |&x| x);
-
-        // we need to consider possible slippage when executing the stop order
-        let slippage_percentage = self.max_loss_percentage * 0.085;
-
-        // calculating the stop price based on short/long position
-        let stop_loss_price = {
-            if position.is_short() {
-                position.base_price() * (1.0 - (self.max_loss_percentage - taker_fee - slippage_percentage) / 100.0)
-            } else {
-                position.base_price() * (1.0 + (self.max_loss_percentage - taker_fee - slippage_percentage) / 100.0)
-            }
-        };
-
-        let close_position_orders_msg = ActionMessage::ClosePositionOrders {
-            position_id: position.id(),
-        };
-        let close_position_msg = ActionMessage::ClosePosition {
-            position_id: position.id(),
-        };
-        let set_stop_loss_msg = ActionMessage::SubmitOrder {
-            order: OrderForm::new(position.pair().clone(),
-                                  OrderKind::Stop { price: stop_loss_price },
-                                  position.platform(),
-                                  position.amount().neg())
-                .with_leverage(Some(self.leverage))
-                .with_metadata(Some(OrderMetadata::new().with_position_id(Some(position.id()))))
-        };
-        let stop_loss_set = *self.stop_loss_flags.entry(position.id()).or_insert(false);
-
-        // if in loss, ask the order manager to set the stop limit order,
-        // if not already set
-        if let Some(PositionProfitState::Critical) | Some(PositionProfitState::Loss) = position.profit_state() {
-            self.print_status(&position);
-
-            if !stop_loss_set {
-                info!("In loss. Opening trailing stop order.");
-
-                self.stop_loss_flags.insert(position.id(), true);
-                return (position, None, Some(vec![set_stop_loss_msg]));
-            }
-            return (position, None, None);
-        }
-
-        // if we get here we are with a profit/loss ration > 0.0
-
-        let mut messages = vec![];
-
-        // if a stop loss order was previously set,
-        // ask the order manager to remove the order first
-        if stop_loss_set {
-            info!("Removing stop loss order.");
-            messages.push(close_position_orders_msg);
-            self.stop_loss_flags.insert(position.id(), false);
-        }
-
-        self.update_stop_percentage(&position);
-        self.print_status(&position);
-
-        // let's check if we surpassed an existing stop percentage
-        if let Some(existing_stop_percentage) = self.stop_percentages.get(&position.id()) {
-            if &position.pl_perc() <= existing_stop_percentage {
-                info!("Stop percentage surpassed. Closing position.");
-                messages.push(close_position_msg);
-                return (position, None, Some(messages));
-            }
-        }
-
-        (position, None, Some(messages))
-    }
-}
-
-/*
- * ORDER STRATEGIES
- */
-
-#[derive(Clone, Debug)]
-pub struct MarketEnforce {
-    // threshold (%) for which we trigger a market order
-    // to close an open position
-    threshold: f64,
-}
-
-impl Default for MarketEnforce {
-    fn default() -> Self {
-        Self {
-            threshold: 1.2 / 15.0,
-        }
-    }
-}
-
-impl OrderStrategy for MarketEnforce {
-    fn name(&self) -> String {
-        "Market Enforce".into()
-    }
-
-    fn on_open_order(
-        &self,
-        order: &ActiveOrder,
-        order_book: &OrderBook,
-    ) -> Result<OptionUpdate, BoxError> {
-        let mut messages = vec![];
-
-        // long
-        let offer_comparison = {
-            if order.order_form().is_long() {
-                order_book.highest_bid()
-            } else {
-                order_book.lowest_ask()
-            }
-        };
-
-        // if the best offer is higher than our threshold,
-        // ask the manager to close the position with a market order
-        let order_price = order
-            .order_form()
-            .price()
-            .ok_or("The active order does not have a price!")?;
-        let delta = (1.0 - (offer_comparison / order_price)).abs() * 100.0;
-
-        if delta > self.threshold {
-            messages.push(ActionMessage::SubmitOrder {
-                order: OrderForm::new(
-                    order.pair().clone(),
-                    OrderKind::Market,
-                    *order.order_form().platform(),
-                    order.order_form().amount(),
-                )
-                    .with_leverage(order.order_form().leverage())
-                    .with_metadata(order.order_form().metadata().clone()),
-            })
-        }
-
-        Ok((None, (!messages.is_empty()).then_some(messages)))
-    }
-}

src/tests.rs

@@ -1,89 +0,0 @@
-#[cfg(test)]
-mod common {
-    use crate::currency::{Symbol, SymbolPair};
-    use crate::models::{Position, PositionState, TradingPlatform};
-    use crate::models::PositionProfitState::Loss;
-
-// TODO: generate other helper generator functions like the one below
-
-    // Generates two short positions with different profit/loss ratios. Both are position in "Loss".
-    pub fn get_short_loss_positions(pair: SymbolPair) -> (Position, Position) {
-        let almost_critical = Position::new(pair.clone(),
-                                            PositionState::Open,
-                                            -0.1,
-                                            100.0,
-                                            -2.0,
-                                            -2.0,
-                                            150.0,
-                                            0,
-                                            TradingPlatform::Margin,
-                                            0.0)
-            .with_profit_state(Some(Loss));
-        let loss = Position::new(pair.clone(),
-                                 PositionState::Open,
-                                 -0.1,
-                                 100.0,
-                                 -1.0,
-                                 -1.0,
-                                 150.0,
-                                 0,
-                                 TradingPlatform::Margin,
-                                 0.0)
-            .with_profit_state(Some(Loss));
-
-        (almost_critical, loss)
-    }
-
-    pub fn get_btcusd_pair() -> SymbolPair {
-        SymbolPair::new(Symbol::BTC, Symbol::USD)
-    }
-}
-
-#[cfg(test)]
-mod positions {
-    use crate::models::{Position, PositionState, TradingPlatform};
-    use crate::models::PositionProfitState::Loss;
-    use crate::tests::common::{get_btcusd_pair, get_short_loss_positions};
-
-    #[test]
-    fn short_positions() {
-        let pair = get_btcusd_pair();
-
-        let one = Position::new(pair.clone(),
-                                PositionState::Open,
-                                -0.1,
-                                100.0,
-                                -2.0,
-                                -2.0,
-                                150.0,
-                                0,
-                                TradingPlatform::Margin,
-                                0.0);
-
-        assert_eq!(one.pair(), &pair);
-        assert_eq!(one.is_long(), false);
-        assert_eq!(one.is_short(), true);
-        assert_eq!(one.profit_state(), None);
-        assert_eq!(one.platform(), TradingPlatform::Margin);
-        assert_eq!(one.amount(), -0.1);
-        assert_eq!(one.base_price(), 100.0);
-        assert_eq!(one.pl(), -2.0);
-        assert_eq!(one.pl_perc(), -2.0);
-        assert_eq!(one.id(), 0);
-        assert_eq!(one.leverage(), 0.0);
-        assert_eq!(one.price_liq(), 150.0);
-        assert_eq!(one.state(), PositionState::Open);
-        assert!(one.price_liq() > one.base_price());
-
-        let (two, three) = get_short_loss_positions(pair);
-
-        assert_eq!(two.is_short(), true);
-        assert_eq!(two.is_long(), false);
-        assert_eq!(three.is_short(), true);
-        assert_eq!(three.is_long(), false);
-        assert_eq!(two.profit_state(), Some(Loss));
-        assert_eq!(three.profit_state(), Some(Loss));
-
-        // TODO: add more test positions with and without profit states
-    }
-}

src/ticker.rs

@@ -1,25 +0,0 @@
-use tokio::time::Duration;
-
-pub struct Ticker {
-    duration: Duration,
-    current_tick: u64,
-}
-
-impl Ticker {
-    pub fn new(duration: Duration) -> Self {
-        Ticker {
-            duration,
-            current_tick: 1,
-        }
-    }
-
-    pub fn inc(&mut self) {
-        self.current_tick += 1
-    }
-    pub fn duration(&self) -> Duration {
-        self.duration
-    }
-    pub fn current_tick(&self) -> u64 {
-        self.current_tick
-    }
-}

static/.gitignore

@@ -0,0 +1,3 @@
+*
+!.gitignore
+

strategy.py

@@ -0,0 +1,123 @@
+from typing import List, Dict
+
+import sympy.abc
+from bfxapi import Position
+from sympy import Point, solve
+
+from bfxbot.models import Strategy, PositionState, SymbolStatus, Event, EventKind, EventMetadata, PositionWrapper, \
+    TAKER_FEE
+from bfxbot.utils import net_pl_percentage
+
+
+class SquaredTrailingStop:
+    def __init__(self, p_min: Point, p_max: Point):
+        a = sympy.abc.a
+        b = sympy.abc.b
+        c = sympy.abc.c
+
+        self.p_min = p_min
+        self.p_max = p_max
+
+        e1 = 2 * a * (p_max.x + b)
+        e2 = a * (p_min.x + b) ** 2 + c - p_min.y
+        e3 = a * (p_max.x + b) ** 2 + c - p_max.y
+
+        s = solve([e1, e2, e3])[0]
+
+        self.a, self.b, self.c = s[a], s[b], s[c]
+
+    def y(self, x):
+        def inter_y(x):
+            return self.a * (x + self.b) ** 2 + self.c
+
+        if x < self.p_min.x:
+            return self.p_min.y
+        elif x > self.p_max.x:
+            return self.p_max.y
+        else:
+            return inter_y(x)
+
+    def profit(self, x):
+        if x < self.p_min.x:
+            return 0
+        return x - self.y(x)
+
+
+class TrailingStopStrategy(Strategy):
+    BREAK_EVEN_PERC = TAKER_FEE
+    MIN_PROFIT_PERC = BREAK_EVEN_PERC + 0.3
+    GOOD_PROFIT_PERC = MIN_PROFIT_PERC * 2.5
+    MAX_LOSS_PERC = -4.0
+
+    TRAILING_STOP = SquaredTrailingStop(Point(MIN_PROFIT_PERC, MIN_PROFIT_PERC / 3 * 2), Point(GOOD_PROFIT_PERC, 0.1))
+
+    def __init__(self):
+        # position_id : stop percentage
+        self.stop_percentage: Dict[int, float] = {}
+
+    def position_on_new_tick(self, current_position: Position, ss: SymbolStatus) -> (PositionState, List[Event]):
+        events = []
+
+        pl_perc = net_pl_percentage(current_position.profit_loss_percentage, TAKER_FEE)
+        prev = ss.previous_pw(current_position.id)
+        event_metadata = EventMetadata(position_id=current_position.id)
+
+        if pl_perc > self.GOOD_PROFIT_PERC:
+            state = PositionState.PROFIT
+        elif self.MIN_PROFIT_PERC <= pl_perc < self.GOOD_PROFIT_PERC:
+            state = PositionState.MINIMUM_PROFIT
+        elif 0.0 <= pl_perc < self.MIN_PROFIT_PERC:
+            state = PositionState.BREAK_EVEN
+        elif self.MAX_LOSS_PERC < pl_perc < 0.0:
+            state = PositionState.LOSS
+        else:
+            events.append(Event(EventKind.CLOSE_POSITION, ss.current_tick, event_metadata))
+            state = PositionState.CRITICAL
+
+        pw = PositionWrapper(current_position, state=state, net_profit_loss=current_position.profit_loss,
+                             net_profit_loss_percentage=pl_perc)
+
+        if not prev or prev.state() == state:
+            return pw, events
+
+        if state == PositionState.PROFIT:
+            events.append(Event(EventKind.REACHED_GOOD_PROFIT, ss.current_tick, event_metadata))
+        elif state == PositionState.MINIMUM_PROFIT:
+            events.append(Event(EventKind.REACHED_MIN_PROFIT, ss.current_tick, event_metadata))
+        elif state == PositionState.BREAK_EVEN:
+            events.append(Event(EventKind.REACHED_BREAK_EVEN, ss.current_tick, event_metadata))
+        elif state == PositionState.LOSS:
+            events.append(Event(EventKind.REACHED_LOSS, ss.current_tick, event_metadata))
+        else:
+            events.append(Event(EventKind.REACHED_MAX_LOSS, ss.current_tick, event_metadata))
+            events.append(Event(EventKind.CLOSE_POSITION, ss.current_tick, event_metadata))
+
+        return pw, events
+
+    async def update_stop_percentage(self, pw: PositionWrapper, ss: SymbolStatus):
+        current_pl_perc = pw.net_profit_loss_percentage()
+        pid = pw.position.id
+        event_metadata = EventMetadata(position_id=pw.position.id)
+
+        # if trailing stop not set for this position and state is not profit (we should not set it)
+        if pid not in self.stop_percentage and pw.state() not in [PositionState.MINIMUM_PROFIT,
+                                                                  PositionState.PROFIT]:
+            return
+
+        # set stop percentage for first time only if in profit
+        if pid not in self.stop_percentage:
+            await ss.add_event(Event(EventKind.TRAILING_STOP_SET, ss.current_tick, event_metadata))
+
+            self.stop_percentage[pid] = current_pl_perc - self.TRAILING_STOP.y(current_pl_perc)
+            return
+
+        # moving trailing stop
+        if current_pl_perc - self.TRAILING_STOP.y(current_pl_perc) > self.stop_percentage[pid]:
+            await ss.add_event(Event(EventKind.TRAILING_STOP_MOVED, ss.current_tick, event_metadata))
+            self.stop_percentage[pid] = current_pl_perc - self.TRAILING_STOP.y(current_pl_perc)
+
+        # close position if current P/L below stop percentage
+        if current_pl_perc < self.stop_percentage[pid]:
+            await ss.add_event(Event(EventKind.CLOSE_POSITION, ss.current_tick, event_metadata))
+
+        return

templates/index.html

@@ -0,0 +1,16 @@
+<!doctype html>
+<html>
+
+<head>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='index.css') }}">
+</head>
+
+<title>Rustico</title>
+
+<body>
+<div id="root"></div>
+<script src="{{ url_for('static', filename='index.js') }}"></script>
+</body>
+
+</html>

websrc/.gitignore

@@ -0,0 +1 @@
+*.js

websrc/components/App.tsx

@@ -0,0 +1,131 @@
+import React, {Component} from "react";
+import {EventProp} from "./Events";
+import {
+    Balance,
+    CurrencyPair,
+    EventName,
+    FirstConnectMessage,
+    NewEventMessage,
+    NewTickMessage,
+    PositionProp
+} from "../types";
+import {socket} from "../index";
+import {symbolToPair} from "../utils";
+import {Helmet} from "react-helmet";
+import {Navbar, Sidebar} from "./Navbars";
+import {Statusbar} from "./Statusbar";
+import {PositionsTable} from "./Tables";
+import RPlot from "./RPlot";
+
+type AppState = {
+    current_price: number,
+    current_tick: number,
+    last_update: Date,
+    positions: Array<PositionProp>,
+    events: Array<EventProp>,
+    active_pair: CurrencyPair,
+    available_pairs: Array<CurrencyPair>,
+    balances: Array<Balance>
+}
+
+class App extends Component<{}, AppState> {
+    event_id = 0;
+
+    state = {
+        current_price: 0,
+        current_tick: 0,
+        last_update: new Date(),
+        positions: [],
+        events: [],
+        balances: [],
+        active_pair: symbolToPair("tBTCUSD"),
+        available_pairs: []
+    }
+
+    constructor(props) {
+        super(props)
+    }
+
+    componentDidMount() {
+        socket.on(EventName.FirstConnect, (data: FirstConnectMessage) => {
+            this.setState({
+                current_price: data.prices[data.prices.length - 1],
+                current_tick: data.ticks[data.ticks.length - 1],
+                last_update: new Date(),
+                positions: data.positions,
+                balances: data.balances
+            })
+        })
+
+        socket.on(EventName.NewTick, (data: NewTickMessage) => {
+            this.setState({
+                current_price: data.price,
+                current_tick: data.tick,
+                last_update: new Date(),
+                positions: data.positions,
+                balances: data.balances
+            })
+        })
+
+        socket.on(EventName.NewEvent, (data: NewEventMessage) => {
+            // ignore new tick
+            if (!data.kind.toLowerCase().includes("new_tick")) {
+                const new_event: EventProp = {
+                    id: this.event_id,
+                    name: data.kind,
+                    tick: data.tick
+                }
+
+                this.event_id += 1
+
+                this.setState((state) => ({
+                    events: [...state.events, new_event]
+                }))
+            }
+        })
+    }
+
+    render() {
+        return (
+            <>
+                <Helmet>
+                    <title> Rustico
+                        - {String(this.state.current_price.toLocaleString())} {String(this.state.active_pair.base) + "/" + String(this.state.active_pair.quote)} </title>
+                </Helmet>
+                <div className="bg-gray-800">
+                    <div className="h-screen max-w-screen flex mx-auto">
+                        <Navbar/>
+
+                        <main
+                            className="my-1 py-2 px-10 flex-1 bg-gray-200 dark:bg-black rounded-l-lg*
+                    transition duration-500 ease-in-out overflow-y-auto flex flex-col">
+                            <div className="flex justify-center text-2xl my-2">
+                                <Statusbar balances={this.state.balances} positions={this.state.positions}
+                                           price={this.state.current_price}
+                                           tick={this.state.current_tick}/>
+                            </div>
+
+                            <div className="flex flex-col flex-grow my-8 shadow-md hover:shadow-lg">
+                                <div
+                                    className="py-2 flex-grow bg-white min-width dark:bg-gray-600 rounded-lg overflow-hidden">
+                                    <RPlot/>
+                                </div>
+                            </div>
+
+                            {this.state.positions.length > 0 ?
+                                <PositionsTable positions={this.state.positions}/> : null}
+
+                            <footer className="flex rounded-lg justify-center bg-gray-600 mt-4 border-t text-gray-300">
+                                <span className="my-1 mx-1">Made with ❤️ by the Peperone in a scantinato</span>
+                            </footer>
+                        </main>
+
+                        <Sidebar/>
+                    </div>
+                </div>
+            </>
+        )
+    }
+}
+
+export default App;

websrc/components/Cards.tsx

@@ -0,0 +1,155 @@
+import React, {Component} from 'react';
+import {Balance, EventName, FirstConnectMessage, NewTickMessage} from "../types";
+import {socket} from "../index";
+
+export type CoinBalanceProps = {
+    name: string,
+    amount: number,
+    percentage?: number,
+    quote_equivalent: number,
+    quote_symbol: string,
+}
+
+class CoinBalance extends Component<CoinBalanceProps> {
+    constructor(props) {
+        super(props);
+
+    }
+
+    render() {
+        // do not print equivalent if this element is the quote itself
+        const quoteBlock = this.props.name != this.props.quote_symbol ? this.props.quote_symbol.concat(" ").concat(this.props.quote_equivalent.toLocaleString()) : null
+
+        // const accessory = SymbolAccessories.filter((accessory) => {
+        //     return accessory.name == this.props.name
+        // })
+        //
+        // const icon = accessory.length > 0 ? accessory.pop().icon : null
+
+        return (
+            <div className="flex-grow flex px-6 py-3 text-gray-800 items-center border-b -mx-4 align-middle">
+                <div className={"w-1/8"}>
+                    {/*{icon}*/}
+                </div>
+                <div className="w-2/5 xl:w-1/4 px-4 flex items-center">
+                    <span className="text-lg">{this.props.name}</span>
+                </div>
+                <div className="hidden md:flex lg:hidden xl:flex w-1/4 px-1 flex-col">
+                    <div className={"italic w-full text-center"}>
+                        {Math.trunc(this.props.percentage)}%
+                    </div>
+                    <div className="w-full bg-transparent mt-2">
+                        <div className={"bg-blue-400 rounded-lg text-xs leading-none py-1 text-center text-white"}
+                             style={{width: this.props.percentage.toString().concat("%")}}/>
+                    </div>
+                </div>
+                <div className="flex w-3/5 md:w/12">
+                    <div className="w-1/2 px-4">
+                        <div className="text-right">
+                            {this.props.amount.toFixed(5)} {this.props.name}
+                        </div>
+                    </div>
+                    <div className="w-1/2 px-4 my-auto">
+                        <div
+                            className={"px-2 inline-flex text-center text-xs leading-5 font-semibold rounded-full bg-gray-200 text-gray-800"}>
+                            {quoteBlock}
+                        </div>
+                    </div>
+                </div>
+            </div>
+        )
+    }
+
+}
+
+export type WalletCardProps = {
+    quote: string,
+}
+
+export class WalletCard extends Component
+    <{}, { balances: Array<Balance> }> {
+    constructor(props) {
+        super(props);
+    }
+
+    state =
+        {
+            balances: []
+        }
+
+    totalQuoteBalance() {
+        let total = 0
+
+        this.state.balances.forEach((balance: Balance) => {
+            if (balance.currency == balance.quote) {
+                total += balance.amount
+            } else {
+                total += balance.quote_equivalent
+            }
+        })
+
+        return total
+    }
+
+    renderCoinBalances() {
+        return (
+            this.state.balances.map((balance: Balance) => {
+                const percentage_amount = balance.quote == balance.currency ? balance.amount : balance.quote_equivalent;
+
+                return (
+                    <CoinBalance key={balance.currency.concat(balance.kind)} name={balance.currency}
+                                 amount={balance.amount} quote_equivalent={balance.quote_equivalent}
+                                 percentage={percentage_amount / this.totalQuoteBalance() * 100}
+                                 quote_symbol={balance.quote}/>
+                )
+            })
+        )
+    }
+
+    componentDidMount() {
+        socket.on(EventName.NewTick, (data: NewTickMessage) => {
+            this.setState({
+                balances: data.balances
+            })
+        })
+
+        socket.on(EventName.FirstConnect, (data: FirstConnectMessage) => {
+            this.setState({
+                balances: data.balances
+            })
+        })
+    }
+
+    render() {
+        return (
+            <div className="w-full mb-6 lg:mb-0 px-4 flex flex-col">
+                <div
+                    className="flex-grow flex bg-white flex-col border-t border-b sm:rounded-lg sm:border shadow overflow-hidden">
+                    <div className="border-b bg-gray-50">
+                        <div className="flex justify-between px-6 -mb-px">
+                            <h3 className="text-blue-700 py-4 font-normal text-lg">Your Wallets</h3>
+                            <div className="flex">
+                                <button type="button"
+                                        className="appearance-none py-4 text-blue-700 border-b border-blue-dark mr-3">
+                                    Margin
+                                </button>
+                                <button type="button"
+                                        className="appearance-none py-4 text-gray-600 border-b border-transparent hover:border-grey-dark">
+                                    Chart
+                                </button>
+                            </div>
+                        </div>
+                    </div>
+
+                    {this.renderCoinBalances()}
+
+                    <div className="px-6 py-4">
+                        <div className="text-center text-gray-400">
+                            Total Balance &asymp; USD {this.totalQuoteBalance().toLocaleString()}
+                        </div>
+                    </div>
+                </div>
+            </div>
+        )
+    }
+}

websrc/components/Currency.tsx

@@ -0,0 +1,45 @@
+import {Button, ButtonGroup, Dropdown} from "react-bootstrap";
+import React, {Component} from "react";
+import DropdownItem from "react-bootstrap/DropdownItem";
+import {CurrencyPair} from "../types";
+
+
+export type CurrencyPairProps = {
+    active_pair: CurrencyPair,
+    pairs: Array<CurrencyPair>
+}
+
+export class CurrencyDropdown extends Component<CurrencyPairProps> {
+    constructor(props) {
+        super(props);
+    }
+
+    dropdownItems() {
+        return this.props.pairs.map((pair) => {
+            return (
+                <DropdownItem key={String(pair.base) + String(pair.quote)}> {pair.base} / {pair.quote} </DropdownItem>)
+        })
+    }
+
+    render() {
+        return (
+            <Dropdown as={ButtonGroup} className={"mr-3"}>
+                <Button variant="outline-primary"><b>{this.props.active_pair.base} / {this.props.active_pair.quote}</b></Button>
+
+                {this.props.pairs.length > 0 &&
+
+                <>
+                    <Dropdown.Toggle split variant="primary" id="dropdown-split-basic"/>
+
+                    <Dropdown.Menu className={"mr-3"}>
+                        {this.dropdownItems()}
+                    </Dropdown.Menu>
+                </>
+                }
+
+            </Dropdown>
+        )
+    }
+
+}
+

websrc/components/Events.tsx

@@ -0,0 +1,42 @@
+import React, {Component} from "react";
+import {Container, ListGroup} from "react-bootstrap";
+
+
+export type EventProp = {
+    id: number,
+    name: string,
+    tick: number
+}
+
+export class Events extends Component<{ events: Array<EventProp> }> {
+    constructor(props) {
+        super(props);
+    }
+
+    state = {
+        events: this.props.events
+    }
+
+    mapEvents() {
+        return this.state.events.map((event: EventProp) => {
+            return (
+                <ListGroup.Item action key={event.id}>
+                    {event.name} @ Tick {event.tick}
+                </ListGroup.Item>
+            )
+        })
+    }
+
+    render() {
+        return (
+            <Container>
+                <div className={"border-bottom mb-2"}>
+                    <h2>Events</h2>
+                </div>
+                <ListGroup>
+                    {this.mapEvents()}
+                </ListGroup>
+            </Container>
+        )
+    }
+}

websrc/components/Icons.tsx

@@ -0,0 +1,50 @@
+import React, {Component} from "react";
+
+type IconProps = {
+    width: number,
+    height: number,
+}
+
+class Icon extends Component <IconProps> {
+    private readonly width: string;
+    private readonly height: string;
+
+    constructor(props) {
+        super(props);
+
+        this.width = "w-" + this.props.width.toString();
+        this.height = "h-" + this.props.width.toString();
+    }
+
+    dimensionsClassName() {
+        return (this.height + " " + this.width)
+    }
+}
+
+
+export class DollarIcon extends Icon {
+    render() {
+        return (
+            <svg className={this.dimensionsClassName()} xmlns="http://www.w3.org/2000/svg" fill="none"
+                 viewBox="0 0 24 24"
+                 stroke="currentColor">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2}
+                      d="M12 8c-1.657 0-3 .895-3 2s1.343 2 3 2 3 .895 3 2-1.343 2-3 2m0-8c1.11 0 2.08.402 2.599 1M12 8V7m0 1v8m0 0v1m0-1c-1.11 0-2.08-.402-2.599-1M21 12a9 9 0 11-18 0 9 9 0 0118 0z"/>
+            </svg>
+        )
+    }
+}
+
+export class ClockIcon extends Icon {
+    render() {
+        return (
+            <svg className={this.dimensionsClassName()} xmlns="http://www.w3.org/2000/svg" fill="none"
+                 viewBox="0 0 24 24"
+                 stroke="currentColor">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2}
+                      d="M12 8v4l3 3m6-3a9 9 0 11-18 0 9 9 0 0118 0z"/>
+            </svg>
+        )
+    }
+}
+

websrc/components/Navbars.tsx

@@ -0,0 +1,71 @@
+import React, {Component} from "react";
+import {WalletCard} from "./Cards";
+
+export class Navbar extends Component<any, any> {
+    constructor(props) {
+        super(props);
+    }
+
+    render() {
+        return (
+            <nav
+                className="ml-1 w-24 flex flex-col items-center bg-gray-700 dark:bg-gray-700 py-4 my-1 rounded-tl rounded-bl">
+
+                <ul className="flex-1 mt-2 text-gray-700 dark:text-gray-400 capitalize">
+                    {/* Links */}
+                    <li className="mt-3 p-2 text-gray-400 dark:text-blue-300 rounded-lg">
+                        <a href="#" className=" flex flex-col items-center">
+                            <svg className="fill-current h-5 w-5" viewBox="0 0 24 24">
+                                <path
+                                    d="M19 5v2h-4V5h4M9 5v6H5V5h4m10 8v6h-4v-6h4M9
+							17v2H5v-2h4M21 3h-8v6h8V3M11 3H3v10h8V3m10
+							8h-8v10h8V11m-10 4H3v6h8v-6z"/>
+                            </svg>
+                            <span className="text-xs mt-2 text-gray-300">Dashboard</span>
+                        </a>
+                    </li>
+                    <li className="mt-3 p-2 text-gray-400 dark:text-blue-300 rounded-lg">
+                        <a href="#" className=" flex flex-col items-center">
+                            <svg className="w-5 h-5" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24"
+                                 stroke="currentColor">
+                                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2}
+                                      d="M3 10h18M7 15h1m4 0h1m-7 4h12a3 3 0 003-3V8a3 3 0 00-3-3H6a3 3 0 00-3 3v8a3 3 0 003 3z"/>
+                            </svg>
+                            <span className="text-xs mt-2 text-gray-300">Reports</span>
+                        </a>
+                    </li>
+                </ul>
+                <ul className="text-gray-700 dark:text-gray-400 capitalize">
+                    <li className="mt-auto p-2 text-gray-400 dark:text-blue-300 rounded-lg">
+                        <a href="#" className=" flex flex-col items-center">
+                            <svg className="w-5 h-5" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24"
+                                 stroke="currentColor">
+                                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2}
+                                      d="M10.325 4.317c.426-1.756 2.924-1.756 3.35 0a1.724 1.724 0 002.573 1.066c1.543-.94 3.31.826 2.37 2.37a1.724 1.724 0 001.065 2.572c1.756.426 1.756 2.924 0 3.35a1.724 1.724 0 00-1.066 2.573c.94 1.543-.826 3.31-2.37 2.37a1.724 1.724 0 00-2.572 1.065c-.426 1.756-2.924 1.756-3.35 0a1.724 1.724 0 00-2.573-1.066c-1.543.94-3.31-.826-2.37-2.37a1.724 1.724 0 00-1.065-2.572c-1.756-.426-1.756-2.924 0-3.35a1.724 1.724 0 001.066-2.573c-.94-1.543.826-3.31 2.37-2.37.996.608 2.296.07 2.572-1.065z"/>
+                                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2}
+                                      d="M15 12a3 3 0 11-6 0 3 3 0 016 0z"/>
+                            </svg>
+                            <span className="text-xs mt-2 text-gray-300">Settings</span>
+                        </a>
+                    </li>
+                </ul>
+            </nav>
+        )
+    }
+}
+
+export class Sidebar extends Component {
+    constructor(props) {
+        super(props);
+    }
+
+    render() {
+        return (
+            <aside
+                className="w-1/4 my-1 mr-1 pr-2 py-4 flex flex-col bg-gray-200 dark:bg-black
+		dark:text-gray-400 rounded-r-lg overflow-y-auto">
+                <WalletCard/>
+            </aside>
+        )
+    }
+}

websrc/components/Overlays.tsx

@@ -0,0 +1,90 @@
+import React, {Component} from "react";
+import {socket} from "../index";
+import {EventName} from "../types";
+
+export type ModalProps = {
+    show: boolean,
+    positionId: number,
+    toggleConfirmation: any
+}
+
+export class ClosePositionModal extends Component<ModalProps, any> {
+    constructor(props) {
+        super(props);
+    }
+
+    render() {
+        if (!this.props.show) {
+            return null
+        }
+
+        return (
+            <div className="fixed z-10 inset-0 overflow-y-auto">
+                <div className="flex items-end justify-center min-h-screen pt-4 px-4 pb-20 text-center sm:block sm:p-0">
+                    <div className="fixed inset-0 transition-opacity" aria-hidden="true">
+                        <div className="absolute inset-0 bg-gray-500 opacity-75"/>
+                    </div>
+
+                    {/*This element is to trick the browser into centering the modal contents. -->*/}
+                    <span className="hidden sm:inline-block sm:align-middle sm:h-screen"
+                          aria-hidden="true">&#8203;</span>
+
+                      {/*Modal panel, show/hide based on modal state.*/}
+
+                      {/*Entering: "ease-out duration-300"*/}
+                      {/*  From: "opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95"*/}
+                      {/*  To: "opacity-100 translate-y-0 sm:scale-100"*/}
+                      {/*Leaving: "ease-in duration-200"*/}
+                      {/*  From: "opacity-100 translate-y-0 sm:scale-100"*/}
+                      {/*  To: "opacity-0 translate-y-4 sm:translate-y-0 sm:scale-95"*/}
+
+                    <div
+                        className="inline-block align-bottom bg-white rounded-lg text-left overflow-hidden shadow-xl transform transition-all sm:my-8 sm:align-middle sm:max-w-lg sm:w-full"
+                        role="dialog" aria-modal="true" aria-labelledby="modal-headline">
+                        <div className="bg-white px-4 pt-5 pb-4 sm:p-6 sm:pb-4">
+                            <div className="sm:flex sm:items-start">
+                                <div
+                                    className="mx-auto flex-shrink-0 flex items-center justify-center h-12 w-12 rounded-full bg-red-100 sm:mx-0 sm:h-10 sm:w-10">
+                                     {/*Heroicon name: exclamation -->*/}
+                                    <svg className="h-6 w-6 text-red-600" xmlns="http://www.w3.org/2000/svg" fill="none"
+                                         viewBox="0 0 24 24" stroke="currentColor" aria-hidden="true">
+                                        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth="2"
+                                              d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"/>
+                                    </svg>
+                                </div>
+                                <div className="mt-3 text-center sm:mt-0 sm:ml-4 sm:text-left">
+                                    <h3 className="text-lg leading-6 font-medium text-gray-900" id="modal-headline">
+                                        Close position
+                                    </h3>
+                                    <div className="mt-2">
+                                        <p className="text-sm text-gray-500">
+                                            Are you sure you want to close the position? This action cannot be undone.
+                                        </p>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                        <div className="bg-gray-50 px-4 py-3 sm:px-6 sm:flex sm:flex-row-reverse">
+                            <button type="button"
+                                    className="w-full inline-flex justify-center rounded-md border border-transparent shadow-sm px-4 py-2 bg-red-600 text-base font-medium text-white hover:bg-red-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-red-500 sm:ml-3 sm:w-auto sm:text-sm"
+                                    onClick={event => {
+                                        socket.emit(EventName.ClosePosition, {
+                                            position_id: this.props.positionId
+                                        })
+
+                                        this.props.toggleConfirmation()
+                                    }}>
+                                Close
+                            </button>
+                            <button type="button"
+                                    className="mt-3 w-full inline-flex justify-center rounded-md border border-gray-300 shadow-sm px-4 py-2 bg-white text-base font-medium text-gray-700 hover:bg-gray-50 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 sm:mt-0 sm:ml-3 sm:w-auto sm:text-sm"
+                                    onClick={() => this.props.toggleConfirmation()}>
+                                Cancel
+                            </button>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        )
+    }
+}

websrc/components/RPlot.tsx

@@ -0,0 +1,168 @@
+import React, {Component} from "react"
+import Plot from "react-plotly.js"
+
+import {socket} from '../';
+import {EventName, NewTickMessage} from "../types";
+
+
+type FirstConnectData = {
+    ticks: Array<number>,
+    prices: Array<number>
+}
+
+
+type PriceLine = {
+    x0: number,
+    y0: number,
+    x1: number,
+    y1: number
+}
+
+type PlotState = {
+    x: Array<number>,
+    y: Array<number>,
+    current_price_line: PriceLine,
+    positions_price_lines: Array<PriceLine>,
+}
+
+class RPlot extends Component<{}, PlotState> {
+    state = {
+        x: [],
+        y: [],
+        current_price_line: {x0: 0, x1: 0, y0: 0, y1: 0},
+        positions_price_lines: []
+    }
+
+    constructor(props) {
+        super(props)
+    }
+
+    componentDidMount() {
+        socket.on(EventName.FirstConnect, (data: FirstConnectData) => {
+            const last_tick = data.ticks[data.ticks.length - 1];
+            const last_price = data.prices[data.prices.length - 1];
+
+            this.setState({
+                x: data.ticks,
+                y: data.prices,
+                current_price_line: {
+                    x0: 0,
+                    y0: last_price,
+                    x1: last_tick,
+                    y1: last_price
+                },
+            })
+        })
+
+        socket.on(EventName.NewTick, (data: NewTickMessage) => {
+            const position_price_lines = data.positions.map((pstat): PriceLine => {
+                return {
+                    x0: 0,
+                    y0: pstat.base_price,
+                    x1: data.tick,
+                    y1: pstat.base_price
+                }
+            })
+
+            this.setState((state) => ({
+                x: state.x.concat(data.tick),
+                y: state.y.concat(data.price),
+                current_price_line: {
+                    x0: 0,
+                    y0: data.price,
+                    x1: data.tick,
+                    y1: data.price
+                },
+                positions_price_lines: position_price_lines
+            }))
+        })
+    }
+
+    render() {
+        let additional_shapes = []
+
+        if (this.state.positions_price_lines.length > 0) {
+            additional_shapes = this.state.positions_price_lines.map((priceline: PriceLine) => {
+                return {
+                    type: 'line',
+                    x0: priceline.x0,
+                    y0: priceline.y0,
+                    x1: priceline.x1,
+                    y1: priceline.y1,
+                    line: {
+                        color: 'rgb(1, 1, 1)',
+                        width: 1,
+                        dash: 'solid'
+                    }
+                }
+            })
+        }
+
+        return (
+            <Plot
+                data={[
+                    {
+                        x: this.state.x,
+                        y: this.state.y,
+                        type: 'scatter',
+                        mode: 'lines+markers',
+                    },
+                ]}
+                layout={{
+                    margin: {
+                        l: 110,
+                        r: 20,
+                        b: 100,
+                        t: 20,
+                        pad: 4
+                    },
+                    dragmode: "pan",
+                    shapes: [
+                        {
+                            type: 'line',
+                            x0: this.state.current_price_line.x0,
+                            y0: this.state.current_price_line.y0,
+                            x1: this.state.current_price_line.x1,
+                            y1: this.state.current_price_line.y1,
+                            line: {
+                                color: 'rgb(50, 171, 96)',
+                                width: 2,
+                                dash: 'dashdot'
+                            }
+                        },
+                    ].concat(additional_shapes),
+                    xaxis: {
+                        title: {
+                            text: 'Tick',
+                            font: {
+                                family: 'Courier New, monospace',
+                                size: 18,
+                                color: '#7f7f7f'
+                            }
+                        },
+                    },
+                    yaxis: {
+                        title: {
+                            text: 'Price',
+                            font: {
+                                family: 'Courier New, monospace',
+                                size: 18,
+                                color: '#7f7f7f'
+                            }
+                        },
+                        tickformat: 'r',
+                    }
+                }}
+                config={{
+                    scrollZoom: true,
+                    displayModeBar: false,
+                    responsive: true,
+                }}
+                style={{width: '100%', height: '100%'}}
+            />
+        )
+    }
+
+}
+
+export default RPlot;

websrc/components/RToast.tsx

@@ -0,0 +1,48 @@
+import React, {Component} from 'react';
+import {Toast} from 'react-bootstrap';
+import {socket} from "../";
+
+type ToastProps = {
+    title: string,
+    content?: string,
+    bg?: string
+}
+
+type ToastState = {
+    lastUpdated: Date,
+    show: boolean
+}
+
+
+export class RToast extends Component<ToastProps, ToastState> {
+    state = {
+        lastUpdated: new Date(),
+        show: false
+    }
+
+    constructor(props: ToastProps) {
+        super(props)
+    }
+
+    componentDidMount() {
+        socket.on("connect", () => {
+            this.setState({show: true})
+        })
+    }
+
+    tick() {
+        this.setState({lastUpdated: new Date()})
+    }
+
+    render() {
+        return (
+            <Toast show={this.state.show} delay={5000} autohide>
+                <Toast.Header>
+                    <strong className="mr-auto">{this.props.title}</strong>
+                    <small>{this.state.lastUpdated.toLocaleTimeString('en-GB')}</small>
+                </Toast.Header>
+                {this.props.content ? <Toast.Body> {this.props.content}</Toast.Body> : null}
+            </Toast>
+        )
+    }
+}

websrc/components/Statusbar.tsx

@@ -0,0 +1,293 @@
+import React, {Component} from "react";
+import {EventName, GetProfitLossMessage, NewTickMessage, PutProfitLossMessage} from "../types";
+import {socket} from "../index";
+import {DateTime} from "luxon";
+
+type QuoteStatusProps = {
+    percentage?: boolean,
+    quote_symbol?: string,
+    amount: number,
+    subtitle: string,
+    sign?: boolean
+}
+
+export class QuoteStatus extends Component<QuoteStatusProps> {
+    private whole: number;
+    private decimal: number;
+    private sign: string;
+    private signClass: string;
+
+    constructor(props) {
+        super(props);
+
+        this.deriveProps()
+    }
+
+    deriveProps() {
+        this.whole = Math.abs(Math.trunc(this.props.amount))
+        this.decimal = Math.trunc(this.props.amount % 1 * 100)
+        this.sign = this.props.amount > 0 ? "+" : "-"
+
+        this.signClass = this.props.amount > 0 ? "text-green-500" : "text-red-500"
+    }
+
+    renderSign() {
+        if (this.props.sign) {
+            return (
+                <span
+                    className={this.signClass}>{this.sign}</span>
+            )
+        }
+        return null
+    }
+
+    symbolOrPercentageRender() {
+        if (this.props.percentage) {
+            return (
+                <>
+                <span className="text-4xl text-bold align-top">
+                    {this.renderSign()}</span>
+                    <span className="text-5xl">{Math.abs(this.props.amount).toFixed(2)}</span>
+                    <span className="text-3xl align-top">%</span>
+                </>
+            )
+        } else {
+            return (
+                <>
+                    <span className="text-4xl text-bold align-top">{this.renderSign()}{this.props.quote_symbol}</span>
+                    <span className="text-5xl">{this.whole.toLocaleString()}</span>
+                    <span className="text-3xl align-top">.{Math.abs(this.decimal)}</span>
+                </>
+            )
+        }
+    }
+
+    render() {
+        return (
+            <>
+                <div className="text-gray-700 mb-2">
+                    {this.symbolOrPercentageRender()}
+                </div>
+                <div className="text-sm uppercase text-gray-300 tracking-wide">
+                    {this.props.subtitle}
+                </div>
+            </>
+        )
+    }
+}
+
+type DateButtonProps = {
+    label: string,
+    onClick: any,
+    selected_default?: boolean
+}
+
+type DateButtonState = {
+    selected: boolean,
+}
+
+class DateButton extends Component<DateButtonProps, DateButtonState> {
+    private classSelected: string = "appearance-none py-4 text-blue-600 border-b border-blue-600 mr-3";
+    private classNotSelected: string = "appearance-none py-4 text-gray-600 border-b border-transparent hover:border-gray-800 mr-3";
+    private currentClass: string;
+
+    state = {
+        selected: this.props.selected_default
+    }
+
+    constructor(props) {
+        super(props);
+
+        this.updateClass()
+    }
+
+    onClick() {
+        this.setState({selected: !this.state.selected}, this.updateClass)
+
+        this.props.onClick()
+    }
+
+    updateClass() {
+        this.currentClass = this.state.selected ? this.classSelected : this.classNotSelected
+    }
+
+    render() {
+        return (
+            <button key={this.props.label} type="button"
+                    className={this.currentClass} onClick={this.onClick.bind(this)}>
+                {this.props.label}
+            </button>
+        )
+    }
+}
+
+const PeriodUnit = {
+    SECOND: "second",
+    MINUTE: "minute",
+    HOUR: "hour",
+    DAY: "day",
+    WEEK: "week",
+    MONTH: "month",
+    YEAR: "year"
+}
+
+type StatusBarState = {
+    pl_period_unit: string,
+    pl_period_amount: number,
+    pl: number,
+    pl_perc: number
+}
+
+export class Statusbar extends Component<NewTickMessage, StatusBarState> {
+
+    constructor(props) {
+        super(props);
+
+        this.state = {
+            pl_period_unit: PeriodUnit.WEEK,
+            pl_period_amount: 1,
+            pl: 0.0,
+            pl_perc: 0.0
+        }
+
+        this.emitGetProfitLoss = this.emitGetProfitLoss.bind(this)
+    }
+
+    componentDidMount() {
+        socket.on(EventName.PutProfitLoss, (data: PutProfitLossMessage) => {
+            this.setState({
+                pl: data.pl,
+                pl_perc: data.pl_perc
+            })
+        })
+
+        socket.on(EventName.FirstConnect, this.emitGetProfitLoss)
+        socket.on(EventName.NewTick, this.emitGetProfitLoss)
+    }
+
+
+    durationObjectfromStr(str: string) {
+        switch (str) {
+            case PeriodUnit.MINUTE:
+                return {
+                    minutes: this.state.pl_period_amount
+                }
+            case PeriodUnit.HOUR:
+                return {
+                    hours: this.state.pl_period_amount
+                }
+            case PeriodUnit.DAY:
+                return {
+                    days: this.state.pl_period_amount
+                }
+            case PeriodUnit.WEEK:
+                return {
+                    weeks: this.state.pl_period_amount
+                }
+            case PeriodUnit.MONTH:
+                return {
+                    months: this.state.pl_period_amount
+                }
+            case PeriodUnit.YEAR:
+                return {
+                    years: this.state.pl_period_amount
+                }
+            default:
+                return {}
+        }
+    }
+
+    emitGetProfitLoss() {
+        const message: GetProfitLossMessage = {
+            start: DateTime.local().minus(this.durationObjectfromStr(this.state.pl_period_unit)).toMillis(),
+            end: DateTime.local().toMillis()
+        }
+
+        socket.emit(EventName.GetProfitLoss, message)
+    }
+
+    changeProfitLossPeriod(amount: number, unit: string) {
+        this.setState({
+            pl_period_amount: amount,
+            pl_period_unit: unit
+        }, this.emitGetProfitLoss)
+    }
+
+    render() {
+        return (
+            <div className="bg-white border-t border-b sm:border-l sm:border-r sm:rounded-lg shadow flex-grow mb-6">
+                <div className="bg-gray-50 rounded-tl-lg rounded-tr-lg border-b px-6">
+                    <div className="flex justify-between -mb-px">
+                        <div className="lg:hidden text-blue-600 py-4 text-lg">
+                            Price Charts
+                        </div>
+                        <div className="hidden lg:flex">
+                            <button type="button"
+                                    className="appearance-none py-4 text-blue-600 border-b border-blue-dark mr-6">
+                                Bitcoin
+                            </button>
+                        </div>
+                        <div className="flex text-sm">
+                            <DateButton key={PeriodUnit.MINUTE} label={"1m"}
+                                        onClick={() => this.changeProfitLossPeriod(1, PeriodUnit.MINUTE)}/>
+                            <DateButton key={PeriodUnit.DAY} label={"1D"}
+                                        onClick={() => this.changeProfitLossPeriod(1, PeriodUnit.DAY)}/>
+                            <DateButton key={PeriodUnit.WEEK} label={"1W"} selected_default={true}
+                                        onClick={() => this.changeProfitLossPeriod(1, PeriodUnit.WEEK)}/>
+                            <DateButton key={PeriodUnit.MONTH} label={"1M"}
+                                        onClick={() => this.changeProfitLossPeriod(1, PeriodUnit.MONTH)}/>
+                            <DateButton key={PeriodUnit.YEAR} label={"1Y"}
+                                        onClick={() => this.changeProfitLossPeriod(1, PeriodUnit.YEAR)}/>
+                            {/*<DateButton label={"ALL"} onClick={() => this.changeProfitLossPeriod(1, PeriodUnit.MINUTE)}/>*/}
+                        </div>
+                    </div>
+                </div>
+                <div className="flex items-center px-6 lg:hidden">
+                    <div className="flex-grow flex-no-shrink py-6">
+                        <div className="text-gray-700 mb-2">
+                            <span className="text-3xl align-top">CA$</span>
+                            <span className="text-5xl">21,404</span>
+                            <span className="text-3xl align-top">.74</span>
+                        </div>
+                        <div className="text-green-300 text-sm">
+                            &uarr; CA$12,955.35 (154.16%)
+                        </div>
+                    </div>
+                    <div className="flex-shrink w-32 inline-block relative">
+                        <select
+                            className="block appearance-none w-full bg-white border border-grey-light px-4 py-2 pr-8 rounded">
+                            <option>BTC</option>
+                        </select>
+                        <div className="pointer-events-none absolute pin-y pin-r flex items-center px-2 text-gray-300">
+                            <svg className="fill-current h-4 w-4" xmlns="http://www.w3.org/2000/svg"
+                                 viewBox="0 0 20 20">
+                                <path d="M9.293 12.95l.707.707L15.657 8l-1.414-1.414L10 10.828 5.757 6.586 4.343 8z"/>
+                            </svg>
+                        </div>
+                    </div>
+                </div>
+                <div className="hidden lg:flex">
+                    <div className="w-1/3 text-center py-8">
+                        <div className="border-r">
+                            <QuoteStatus key={this.props.price} quote_symbol={"USD"} amount={this.props.price}
+                                         subtitle={"Bitcoin price"}/>
+                        </div>
+                    </div>
+                    <div className="w-1/3 text-center py-8">
+                        <div className="border-r">
+                            <QuoteStatus key={this.state.pl} quote_symbol={"USD"} sign={true} amount={this.state.pl}
+                                         subtitle={"since last ".concat(this.state.pl_period_unit)}/>
+                        </div>
+                    </div>
+                    <div className="w-1/3 text-center py-8">
+                        <div>
+                            <QuoteStatus key={this.state.pl_perc} percentage={true} sign={true}
+                                         amount={this.state.pl_perc}
+                                         subtitle={"since last ".concat(this.state.pl_period_unit)}/>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        )
+    }
+}

websrc/components/Tables.tsx

@@ -0,0 +1,141 @@
+import React, {Component} from "react"
+import {PositionProp} from "../types";
+import {ClosePositionModal} from "./Overlays";
+
+type PositionsTableState = {
+    showConfirmation: boolean,
+    positionToClose: number
+}
+
+export class PositionsTable extends Component<{ positions: Array<PositionProp> }, PositionsTableState> {
+    constructor(props) {
+        super(props);
+        this.toggleConfirmation = this.toggleConfirmation.bind(this)
+    }
+
+    state = {
+        showConfirmation: false,
+        positionToClose: 0,
+    }
+
+    toggleConfirmation() {
+        this.setState((state) => ({
+            showConfirmation: !state.showConfirmation
+        }))
+    }
+
+    stateColor(state: string): string {
+        const lower_state = state.toLowerCase()
+        let res: string
+
+        if (lower_state.includes("profit")) {
+            res = "green"
+        } else if (lower_state.includes("break")) {
+            res = "yellow"
+        } else {
+            res = "red"
+        }
+
+        return res
+    }
+
+
+    renderTableHead() {
+        return ["status", "currency pair", "base price", "amount", "Profit/Loss", "actions"].map((entry) => {
+                return (
+                    <th scope="col"
+                        className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
+                        {entry}
+                    </th>
+                )
+            }
+        )
+    }
+
+    renderTableRows() {
+        return this.props.positions.map((position) => {
+            // TODO: move symbolToPair out of here?
+            const stateBg = "bg-".concat(this.stateColor(position.state)).concat("-100 ")
+            const stateText = "text-".concat(this.stateColor(position.state)).concat("-800 ")
+            const stateClass = "px-2 inline-flex text-xs leading-5 font-semibold rounded-full ".concat(stateBg).concat(stateText)
+
+            return (
+                <tr key={position.id}>
+                    {/* Status */}
+                    <td className="px-6 py-4 whitespace-nowrap">
+                        <span
+                            className={stateClass}>
+                          {position.state}
+                        </span>
+                    </td>
+
+                    <td className="px-6 py-1 whitespace-nowrap">
+                        <div className="text-sm text-gray-900">{position.pair.base}/{position.pair.quote}</div>
+                        {/*<div className="text-sm text-gray-500">{position.}</div>*/}
+                    </td>
+
+                    <td className="px-6 py-1 whitespace-nowrap">
+                        <div
+                            className="text-sm text-gray-900">{position.base_price.toLocaleString()} {position.pair.quote}/{position.pair.base}</div>
+                        {/*<div className="text-sm text-gray-500">Insert total % here?</div>*/}
+                    </td>
+
+                    <td className="px-6 py-1 whitespace-nowrap">
+                        <div className="text-sm text-gray-900">{position.amount.toFixed(5)} {position.pair.base}</div>
+                        <div className="text-sm text-gray-500">Insert total % here?</div>
+                    </td>
+
+                    <td className="px-6 py-1 whitespace-nowrap">
+                        <div
+                            className="text-sm text-gray-900 font-semibold">{position.profit_loss.toLocaleString()} {position.pair.quote}</div>
+                        <div className={"text-sm ".concat(stateClass)}>{position.profit_loss_percentage.toFixed(2)}%
+                        </div>
+                    </td>
+
+                    <td className="px-6 py-1 whitespace-nowrap text-right text-sm font-medium">
+                        <div className="p-2 md:w-40">
+                            <div
+                                className="p-4 flex justify-center bg-red-200 rounded-lg shadow-xs cursor-pointer hover:bg-red-500 hover:text-red-100"
+                                onClick={() => {
+                                    this.setState({
+                                        showConfirmation: true,
+                                        positionToClose: position.id
+                                    })
+                                }}>
+                                <span className="ml-2">Close</span>
+                            </div>
+                        </div>
+                    </td>
+                </tr>
+            )
+        })
+    }
+
+    render() {
+        return (
+            <div className="flex flex-col">
+                <ClosePositionModal positionId={this.state.positionToClose} toggleConfirmation={this.toggleConfirmation}
+                                    show={this.state.showConfirmation}/>
+                <div className="-my-2 overflow-x-auto sm:-mx-6 lg:-mx-8">
+                    <div className="py-2 align-middle inline-block min-w-full sm:px-6 lg:px-8">
+                        <div className="shadow overflow-hidden border-b border-gray-200 sm:rounded-lg">
+                            <table className="min-w-full divide-y divide-gray-200">
+
+                                <thead className="bg-gray-50">
+                                <tr>
+                                    {this.renderTableHead()}
+                                </tr>
+                                </thead>
+
+                                <tbody className="bg-white divide-y divide-gray-200">
+                                {this.renderTableRows()}
+                                </tbody>
+                            </table>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+        )
+    }
+}

websrc/css/.gitignore

@@ -0,0 +1 @@
+tailwind.css

websrc/css/index.css

@@ -0,0 +1,3 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;

websrc/index.tsx

@@ -0,0 +1,13 @@
+import React from "react";
+import ReactDOM from "react-dom";
+import "./css/tailwind.css";
+import App from "./components/App";
+import io from "socket.io-client";
+
+export const socket = io();
+
+socket.on("connect", function () {
+    console.log("Connected!")
+})
+
+ReactDOM.render(<App/>, document.getElementById("root"));

websrc/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "rustico",
+  "version": "1.0.0",
+  "main": "index.tsx",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/luxon": "^1.25.0",
+    "@types/react": "^17.0.0",
+    "@types/react-dom": "^17.0.0",
+    "@types/react-helmet": "^6.1.0",
+    "@types/react-plotly.js": "^2.2.4",
+    "@types/socket.io-client": "^1.4.34",
+    "parcel-bundler": "^1.12.4",
+    "react-plotly.js": "^2.5.1",
+    "typescript": "^4.1.2"
+  },
+  "dependencies": {
+    "@types/classnames": "^2.2.11",
+    "autoprefixer": "^10.1.0",
+    "classnames": "^2.2.6",
+    "css": "^3.0.0",
+    "luxon": "^1.25.0",
+    "plotly.js": "^1.58.2",
+    "postcss": "^8.2.1",
+    "postcss-cli": "^8.3.1",
+    "react": "^17.0.1",
+    "react-cryptocoins": "^1.0.11",
+    "react-dom": "^17.0.1",
+    "react-helmet": "^6.1.0",
+    "socket.io-client": "~3",
+    "tailwindcss": "^2.0.2"
+  },
+  "scripts": {
+    "build:tailwind": "tailwindcss build css/index.css -o css/tailwind.css",
+    "watch": "parcel watch index.tsx -d ../static",
+    "prestart": "yarn run build:tailwind",
+    "prebuild": "yarn run build:tailwind",
+    "start": "python ../main.py & yarn run watch"
+  }
+}

websrc/tsconfig.json

@@ -0,0 +1,12 @@
+{
+    "compilerOptions": {
+        "lib": ["esnext", "DOM"],
+        "jsx": "react",
+        "moduleResolution": "node",
+        "allowSyntheticDefaultImports": true,
+        "esModuleInterop": true,
+    },
+    "exclude": [
+        "node_modules"
+    ],
+}

websrc/types.ts

@@ -0,0 +1,77 @@
+import {EventProp} from "./components/Events";
+
+/*******************************
+ * Types
+ *******************************/
+
+export type Balance = {
+    currency: string,
+    amount: number,
+    // exchange / margin
+    kind: string,
+    quote: string,
+    quote_equivalent: number,
+}
+
+export type CurrencyPair = {
+    base: string,
+    quote: string
+}
+
+export type FirstConnectMessage = {
+    ticks: Array<number>,
+    prices: Array<number>,
+    positions: Array<PositionProp>,
+    balances: Array<Balance>
+}
+
+export type GetProfitLossMessage = {
+    start: number,
+    end: number
+}
+
+export type NewEventMessage = {
+    tick: number,
+    kind: string,
+}
+
+export type NewTickMessage = {
+    tick: number,
+    price: number,
+    positions: Array<PositionProp>,
+    balances: Array<Balance>
+}
+
+export type PositionCloseMessage = {
+    message_name: string,
+    position_id: number,
+}
+
+export type PositionProp = {
+    id: number,
+    state: string,
+    base_price: number,
+    amount: number,
+    pair: CurrencyPair,
+    profit_loss: number,
+    profit_loss_percentage: number
+}
+
+export type PutProfitLossMessage = {
+    pl: number,
+    pl_perc: number
+}
+
+/*******************************
+* ENUMS
+*******************************/
+
+export enum EventName {
+    NewTick = "new_tick",
+    FirstConnect = "first_connect",
+    NewEvent = "new_event",
+    ClosePosition = "close_position",
+    GetProfitLoss = "get_profit_loss",
+    PutProfitLoss = "put_profit_loss"
+}
+

websrc/utils.ts

@@ -0,0 +1,41 @@
+import {CurrencyPair} from "./types";
+// import * as Icon from 'react-cryptocoins'
+import {Btc, Eth, Xmr} from 'react-cryptocoins';
+
+export function symbolToPair(symbol: string): CurrencyPair {
+    const symbol_regex = "t(?<base>[a-zA-Z]{3})(?<quote>[a-zA-Z]{3})"
+
+    const match = symbol.match(symbol_regex)
+
+    return {
+        base: match.groups.base,
+        quote: match.groups.quote
+    }
+}
+
+export type SymbolAccesory = {
+    name: string,
+    icon: React.Component,
+    color: string
+}
+
+export const SymbolAccessories: Array<SymbolAccesory> = [
+    {
+        name: "BTC",
+        icon: Btc,
+        color: "yellow"
+    },
+    {
+        name: "XMR",
+        icon: Xmr,
+        color: "yellow"
+    },
+    {
+        name: "ETH",
+        icon: Eth,
+        color: "yellow"
+    }
+];
+
+
+