Time to change BfxBot to Rustico

Changed bin name to rustico.

Cargo.toml

@@ -0,0 +1,26 @@
+[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

@@ -1,12 +0,0 @@
-<?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

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

bfxbot/bfxbot.py

@@ -1,134 +0,0 @@
-import asyncio
-from typing import Dict, List, Optional, Tuple
-
-from bfxapi import Order
-
-from bfxbot.bfxwrapper import BfxWrapper
-from bfxbot.currency import 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[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[Symbol, SymbolStatus] = {}
-
-        if isinstance(symbols, Symbol):
-            symbols = [symbols]
-
-        self.symbols: List[Symbol] = 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[Symbol.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: Symbol, 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))
-
-    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):
-        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: Symbol) -> 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__()

bfxbot/bfxwrapper.py

@@ -1,53 +0,0 @@
-from bfxapi.rest.bfx_rest import BfxRest
-from retrying_async import retry
-
-from bfxbot.currency import Symbol
-
-
-class BfxWrapper(BfxRest):
-    def __init__(self, api_key: str, api_secret: str):
-        super().__init__(API_KEY=api_key, API_SECRET=api_secret)
-
-    @retry()
-    async def get_public_ticker(self, symbol):
-        if isinstance(symbol, Symbol):
-            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, Symbol):
-            symbol = str(symbol)
-
-        return await super().get_active_orders(symbol)
-
-    async def get_current_prices(self, symbol) -> (float, float, float):
-        if isinstance(symbol, Symbol):
-            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 get_usd_balance(self):
-        balance = 0.0
-
-        wallets = await self.get_wallets()
-
-        for w in wallets:
-            if w.currency == "USD":
-                balance += w.balance
-            else:
-                current_price = await self.get_current_prices(f"t{w.currency}USD")
-                balance += current_price * w.balance
-
-        return balance

bfxbot/currency.py

@@ -1,32 +0,0 @@
-import re
-from enum import Enum
-
-
-class Symbol(Enum):
-    XMR = "XMR"
-    BTC = "BTC"
-    ETH = "ETH"
-
-    def __repr__(self):
-        return f"t{self.value}USD"
-
-    def __str__(self):
-        return self.__repr__()
-
-    @staticmethod
-    def from_str(str: str):
-        match = re.compile("t([a-zA-Z]+)USD").match(str)
-
-        if not match:
-            raise ValueError
-
-        currency = match.group(1).lower()
-
-        if currency in ("xmr"):
-            return Symbol.XMR
-        elif currency in ("btc"):
-            return Symbol.BTC
-        elif currency in ("eth"):
-            return Symbol.ETH
-        else:
-            return NotImplementedError

bfxbot/models.py

@@ -1,292 +0,0 @@
-import inspect
-import time
-from enum import Enum
-from typing import List, Dict, Tuple, Optional
-
-from bfxapi import Order, Position
-
-from bfxbot.currency import Symbol
-
-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: Symbol, 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
-
-        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

@@ -1,17 +0,0 @@
-from bfxbot.models import PositionWrapper
-
-
-def net_pl_percentage(perc: float, reference_fee_perc: float):
-    return perc - reference_fee_perc
-
-
-def pos_to_json(pw: PositionWrapper):
-    return {
-        "id": pw.position.id,
-        "amount": pw.position.amount,
-        "base_price": pw.position.base_price,
-        "state": str(pw.state()),
-        "symbol": pw.position.symbol,
-        "profit_loss": pw.net_profit_loss(),
-        "profit_loss_percentage": pw.net_profit_loss_percentage()
-    }

main.py

@@ -1,123 +0,0 @@
-# #!/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.currency import Symbol
-from bfxbot.models import PositionWrapper, SymbolStatus, Event, EventKind, PositionState
-from bfxbot.utils import pos_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=[Symbol.BTC], tick_duration=20)
-strategy = TrailingStopStrategy()
-bot.set_strategy(Symbol.BTC, strategy)
-btc_eh = bot.symbol_event_handler(Symbol.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 = [], [], []
-
-    while not ticks or not prices:
-        try:
-            ticks = bot.symbol_status(Symbol.BTC).all_ticks()
-            prices = bot.symbol_status(Symbol.BTC).all_prices()
-            positions = bot.symbol_status(Symbol.BTC).current_positions()
-        except KeyError:
-            sleep(1)
-
-    socketio.emit("first_connect",
-                  {
-                      "ticks": ticks,
-                      "prices": prices,
-                      "positions": list(map(pos_to_json, positions))
-                  })
-
-
-###################################
-# 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)
-def on_new_tick(event: Event, status: SymbolStatus):
-    tick = event.tick
-    price = status.prices[event.tick]
-
-    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(pos_to_json, positions))})
-
-
-@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

@@ -1,4 +0,0 @@
-python-dotenv~=0.15.0
-sympy~=1.7
-asyncio~=3.4.3
-Flask~=1.1.2

src/bot.rs

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,764 @@
+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

@@ -0,0 +1,198 @@
+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

@@ -0,0 +1,75 @@
+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

@@ -0,0 +1,89 @@
+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

@@ -0,0 +1,100 @@
+#![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

@@ -0,0 +1,769 @@
+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

@@ -0,0 +1,674 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,449 @@
+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

@@ -0,0 +1,89 @@
+#[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

@@ -0,0 +1,25 @@
+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

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

strategy.py

@@ -1,123 +0,0 @@
-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

@@ -1,16 +0,0 @@
-<!doctype html>
-<html class="h-100">
-
-<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 class="h-100 d-flex flex-column">
-<div id="root" class="d-flex flex-fill"></div>
-<script src="{{ url_for('static', filename='index.js') }}"></script>
-</body>
-
-</html>

websrc/.gitignore

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

websrc/components/App.tsx

@@ -1,128 +0,0 @@
-import React, {Component} from "react";
-import {Col, Container, Navbar, Row} from "react-bootstrap";
-import HCard from "./HCard";
-import RPlot from "./RPlot";
-import {PositionTable} from "./Tables";
-import {EventProp, Events} from "./Events";
-import {Helmet} from "react-helmet";
-import {CurrencyDropdown} from "./Currency";
-import {CurrencyPair, FirstConnectMessage, NewEventMessage, NewTickMessage, PositionProp} from "../types";
-import {socket} from "../index";
-import {symbolToPair} from "../utils";
-
-type AppState = {
-    current_price: number,
-    current_tick: number,
-    last_update: Date,
-    positions: Array<PositionProp>,
-    events: Array<EventProp>,
-    active_pair: CurrencyPair,
-    available_pairs: Array<CurrencyPair>
-}
-
-class App extends Component<{}, AppState> {
-    event_id = 0;
-
-    state = {
-        current_price: 0,
-        current_tick: 0,
-        last_update: new Date(),
-        positions: [],
-        events: [],
-        active_pair: symbolToPair("tBTCUSD"),
-        available_pairs: []
-    }
-
-    constructor(props) {
-        super(props)
-    }
-
-    componentDidMount() {
-        console.log(this)
-
-        socket.on("first_connect", (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
-            })
-        })
-
-        socket.on("new_tick", (data: NewTickMessage) => {
-            this.setState({
-                current_price: data.price,
-                current_tick: data.tick,
-                last_update: new Date(),
-                positions: data.positions,
-            })
-        })
-
-        socket.on("new_event", (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({
-                    events: [...this.state.events, new_event]
-                })
-            }
-        })
-    }
-
-    render() {
-        return (
-            <div className="d-flex flex-fill flex-column">
-                <Helmet>
-                    {/* TODO: fix currency */}
-                    <title> Rustico
-                        - {String(this.state.active_pair.base) + "/" + String(this.state.active_pair.quote)} {String(this.state.current_price)} </title>
-                </Helmet>
-
-                <Navbar bg="light" expand="lg" className="border-bottom">
-                    <Navbar.Brand href="#" className={"mr-auto"}>Rustico - BfxBot</Navbar.Brand>
-                    <CurrencyDropdown active_pair={this.state.active_pair} pairs={this.state.available_pairs}/>
-                </Navbar>
-
-                <Container fluid className="mt-2 border flex-fill d-flex">
-                    <Row className="flex-fill">
-                        {/* Toolbar column */}
-                        <Col md={4} lg={4} className="border-right d-flex flex-column">
-                            <Row className="justify-content-center border-bottom py-2">
-                                <HCard title="Current tick:" content={String(this.state.current_tick)}
-                                       update={this.state.last_update}/>
-                                <HCard title="Current price:" content={String(this.state.current_price)}
-                                       update={this.state.last_update}/>
-                            </Row>
-                            <Row className={"flex-fill"}>
-                                {this.state.positions.length > 0 ?
-                                    <PositionTable positions={this.state.positions}/> : null}
-                            </Row>
-                            <Row className={"my-2"}>
-                                {this.state.events.length > 0 ? <Events events={this.state.events}/> : null}
-                            </Row>
-                        </Col>
-
-                        {/* Graph column */}
-                        <Col md={8} lg={8} className="flex-fill">
-                            <RPlot/>
-                        </Col>
-                    </Row>
-                </Container>
-                <footer className="footer py-3 bg-light border-top">
-                    <Container className="text-center">
-                        <span className="text-muted">Made with ❤️ by the Pepe</span>
-                    </Container>
-                </footer>
-            </div>
-        )
-    }
-}
-
-export default App;

websrc/components/Currency.tsx

@@ -1,45 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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/HCard.tsx

@@ -1,40 +0,0 @@
-import React, {Component} from 'react';
-import {Card, Col, Row} from 'react-bootstrap';
-
-type CardProps = {
-    title: string,
-    content: string,
-    update: Date
-}
-
-
-class HCard extends Component<CardProps> {
-    constructor(props: CardProps) {
-        super(props)
-    }
-
-    render() {
-        return (
-            <Card bg="light" style={{minWidth: "15rem"}} className="mx-auto">
-                <Row className="no-gutters">
-                    <Col md={7} className="border-right my-auto">
-                        <h5 className="text-center my-auto">{this.props.title}</h5>
-                    </Col>
-
-                    <Col md={5}>
-                        <Card.Body>
-                            <Card.Text className="text-center my-auto">
-                                {this.props.content}
-                            </Card.Text>
-                        </Card.Body>
-                    </Col>
-                </Row>
-                <Card.Text className="border-top text-center">
-                    <small className="text-muted my-auto mx-2">Last
-                        updated {this.props.update.toLocaleTimeString('en-GB')}</small>
-                </Card.Text>
-            </Card>);
-    }
-}
-
-export default HCard;

websrc/components/RPlot.tsx

@@ -1,175 +0,0 @@
-import React, {Component} from "react"
-import Plot from "react-plotly.js"
-
-import {socket} from '../';
-import {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("first_connect", (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("new_tick", (data: NewTickMessage) => {
-            const new_x = [...this.state.x, data.tick];
-            const new_y = [...this.state.y, data.price];
-
-            // cutting to up to 500 entries (last 500)
-            const x = new_x.slice(Math.max(new_x.length - 500, 0));
-            const y = new_y.slice(Math.max(new_y.length - 500, 0));
-
-            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({
-                x: x,
-                y: y,
-                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: 50,
-                        r: 50,
-                        b: 50,
-                        t: 50,
-                        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: '90%'}}
-            />
-        )
-    }
-
-}
-
-export default RPlot;

websrc/components/RToast.tsx

@@ -1,48 +0,0 @@
-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/Tables.tsx

@@ -1,87 +0,0 @@
-import React, {Component} from "react"
-import {Badge, Button, Container, Table} from "react-bootstrap"
-import {socket} from '../';
-import {PositionCloseMessage, PositionProp} from "../types";
-
-
-export class PositionTable extends Component<{ positions: Array<PositionProp> }> {
-    constructor(props) {
-        super(props)
-    }
-
-    stateVariantFromStr(state: string): string {
-        const lower_state = state.toLowerCase()
-        let res: string;
-
-        if (lower_state.includes("profit")) {
-            res = "success"
-        } else if (lower_state.includes("break")) {
-            res = "primary"
-        } else {
-            res = "danger"
-        }
-
-        return res
-    }
-
-    plColorFromStr(amount: number): string {
-        if (amount > 0) {
-            return "success"
-        } else {
-            return "danger"
-        }
-    }
-
-    tableData() {
-        return this.props.positions.map((position: PositionProp) => {
-            let row_bg = "";
-
-            if (!position.state.toLowerCase().includes("break")) {
-                row_bg = "table-" + this.plColorFromStr(position.profit_loss)
-            }
-
-            return (<tr key={position.id} className={row_bg}>
-                <td className={"align-middle"}><Badge
-                    variant={this.stateVariantFromStr(position.state)}>{position.state}</Badge></td>
-                <td className={"align-middle"}>{position.symbol}</td>
-                <td className={"align-middle"}>{position.base_price.toFixed(2)}</td>
-                <td className={"align-middle"}>{position.amount.toFixed(5)}</td>
-                <td className={"align-middle"}>{position.profit_loss.toFixed(2)}</td>
-                <td className={"align-middle"}>{position.profit_loss_percentage.toFixed(2)} %</td>
-                <td className={"align-middle"}><Button size={"sm"} variant={"danger"} onClick={() => {
-                    const message: PositionCloseMessage = {
-                        message_name: "close_position",
-                        position_id: position.id,
-                    }
-                    socket.emit(message.message_name, (message))
-                }}>Close</Button></td>
-            </tr>)
-        })
-    }
-
-    render() {
-        return (
-            <Container className="d-flex flex-column mt-2">
-                <div className="border-bottom">
-                    <h2>Open positions</h2>
-                </div>
-                <Table id="positions" size="sm" hover striped bordered className="mt-2 text-center align-middle">
-                    <thead>
-                    <tr>
-                        <th>State</th>
-                        <th>Symbol</th>
-                        <th>Base price</th>
-                        <th>Amount</th>
-                        <th>P/L</th>
-                        <th>P/L %</th>
-                        <th>Action</th>
-                    </tr>
-                    </thead>
-                    <tbody>
-                    {this.tableData()}
-                    </tbody>
-                </Table>
-            </Container>
-        )
-    }
-}

websrc/index.tsx

@@ -1,13 +0,0 @@
-import React from "react";
-import ReactDOM from "react-dom";
-import "bootstrap/dist/css/bootstrap.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

@@ -1,32 +0,0 @@
-{
-  "name": "rustico",
-  "version": "1.0.0",
-  "main": "intex.tsx",
-  "license": "MIT",
-  "devDependencies": {
-    "@types/react": "~16",
-    "@types/react-dom": "~16",
-    "@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": {
-    "bootstrap": "^4.5.3",
-    "plotly.js": "^1.58.2",
-    "react": "~16",
-    "react-bootstrap": "^1.4.0",
-    "react-dom": "~16",
-    "react-helmet": "^6.1.0",
-    "socket.io-client": "~2"
-  },
-  "resolutions": {
-    "@types/react": "~16",
-    "@types/react-dom": "~16",
-    "react": "~16",
-    "react-dom": "~16",
-    "socket.io-parser": "~2"
-  }
-}

websrc/tsconfig.json

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

websrc/types.ts

@@ -1,39 +0,0 @@
-import {EventProp} from "./components/Events";
-
-export type PositionProp = {
-    id: number,
-    state: string,
-    base_price: number,
-    amount: number,
-    symbol: string,
-    profit_loss: number,
-    profit_loss_percentage: number
-}
-
-export type FirstConnectMessage = {
-    ticks: Array<number>,
-    prices: Array<number>,
-    positions: Array<PositionProp>
-}
-
-export type NewEventMessage = {
-    tick: number,
-    kind: string,
-}
-
-export type NewTickMessage = {
-    tick: number,
-    price: number,
-    positions: Array<PositionProp>
-}
-
-export type PositionCloseMessage = {
-    message_name: string,
-    position_id: number,
-}
-
-export type CurrencyPair = {
-    base: string,
-    quote: string
-}
-

websrc/utils.ts

@@ -1,12 +0,0 @@
-import {CurrencyPair} from "./types";
-
-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
-    }
-}