Support for CCXT

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 ### Features
 
+* [CCXT](https://docs.ccxt.com) integration.
 * `fees.Percentage` now supports charging fees in base currency.
 * Both `BacktestingDispatcher` and `RealtimeDispatcher` now support `subscribe_event_loop_started` to register handlers that are called once when the dispatch loop starts.
 

README.md

@@ -11,15 +11,15 @@
 ## Key Features
 
 * Backtesting exchange so you can try your trading strategies before using real funds.
-* Live trading at [Binance](https://www.binance.com/) and [Bitstamp](https://www.bitstamp.net/) crypto currency exchanges.
+* Live trading at [Binance](https://www.binance.com/), [Bitstamp](https://www.bitstamp.net/) and 100+ crypto currency exchanges via [CCXT](https://docs.ccxt.com) integration.
 * Asynchronous I/O and event driven.
 
 ## Getting Started
 
 ### Installation
 
 ```
-$ pip install basana[charts]
+$ pip install basana[charts,ccxt]
 ```
 
 The examples use [TALIpp](https://github.com/nardew/talipp) for the technical indicators, pandas, statsmodels and also [Textual](https://textual.textualize.io/) if you want to run the Binance order book mirror.

basana/__init__.py

@@ -49,6 +49,7 @@
 from .core.enums import (
     OrderOperation,
     Position,
+    PrecisionMode,
 )
 
 from .core.helpers import (

basana/backtesting/charts.py

@@ -164,7 +164,7 @@ def _get_order_fills(self, op: OrderOperation) -> TimeSeries:
             for fill in order.fills:
                 base_amount = fill.balance_updates[order.pair.base_symbol]
                 quote_amount = fill.balance_updates[order.pair.quote_symbol]
-                price = -helpers.truncate_decimal(quote_amount / base_amount, pair_info.quote_precision)
+                price = -pair_info.truncate_quote(quote_amount / base_amount)
                 ret.add_value(fill.when, price)
         return ret
 

basana/backtesting/order_mgr.py

@@ -361,27 +361,23 @@ def _push_order_update(self, order: Order):
 def round_balance_updates(order: Order, balance_updates: ValueMap):
     # For the base amount we truncate instead of rounding to avoid exceeding available liquidity.
     if (base_amount := balance_updates.get(order.pair.base_symbol)) is not None:
-        balance_updates[order.pair.base_symbol] = core_helpers.truncate_decimal(
-            base_amount, order.pair_info.base_precision
-        )
+        balance_updates[order.pair.base_symbol] = order.pair_info.truncate_base(base_amount)
 
     # For the quote amount we simply round.
     if (quote_amount := balance_updates.get(order.pair.quote_symbol)) is not None:
-        balance_updates[order.pair.quote_symbol] = core_helpers.round_decimal(
-            quote_amount, order.pair_info.quote_precision
-        )
+        balance_updates[order.pair.quote_symbol] = order.pair_info.round_quote(quote_amount)
 
     balance_updates.prune()
 
 
 def round_fees(order: Order, fees: ValueMap):
-    precisions = {
-        order.pair.base_symbol: order.pair_info.base_precision,
-        order.pair.quote_symbol: order.pair_info.quote_precision,
+    round_fns = {
+        order.pair.base_symbol: lambda amount: order.pair_info.round_base(amount, rounding=decimal.ROUND_UP),
+        order.pair.quote_symbol: lambda amount: order.pair_info.round_quote(amount, rounding=decimal.ROUND_UP),
     }
-    for symbol, precision in precisions.items():
+    for symbol, round_fn in round_fns.items():
         if (amount := fees.get(symbol)) is not None:
-            fees[symbol] = core_helpers.round_decimal(amount, precision, rounding=decimal.ROUND_UP)
+            fees[symbol] = round_fn(amount)
 
     fees.prune()
 

basana/backtesting/orders.py

@@ -26,7 +26,7 @@
 from basana.backtesting import helpers, liquidity, value_map
 from basana.core import bar, logs
 from basana.core.enums import OrderOperation
-from basana.core.helpers import round_decimal, truncate_decimal
+
 from basana.core.pair import Pair, PairInfo
 
 
@@ -262,7 +262,7 @@ def try_fill(self, bar: bar.Bar, liquidity_strategy: liquidity.LiquidityStrategy
             when=bar.begin,
             balance_updates={
                 self.pair.base_symbol: amount * base_sign,
-                self.pair.quote_symbol: round_decimal(price * amount * -base_sign, self.pair_info.quote_precision)
+                self.pair.quote_symbol: self.pair_info.round_quote(price * amount * -base_sign)
             },
             fees={},
             price=price
@@ -281,7 +281,7 @@ def __init__(
 
     def try_fill(self, bar: bar.Bar, liquidity_strategy: liquidity.LiquidityStrategy) -> Optional[Fill]:
         amount = min(self.amount_pending, liquidity_strategy.available_liquidity)
-        amount = truncate_decimal(amount, self.pair_info.base_precision)
+        amount = self.pair_info.truncate_base(amount)
         if not amount:
             return None
 
@@ -314,7 +314,7 @@ def try_fill(self, bar: bar.Bar, liquidity_strategy: liquidity.LiquidityStrategy
                 when=fill_dt,
                 balance_updates={
                     self.pair.base_symbol: amount * base_sign,
-                    self.pair.quote_symbol: round_decimal(price * amount * -base_sign, self.pair_info.quote_precision)
+                    self.pair.quote_symbol: self.pair_info.round_quote(price * amount * -base_sign)
                 },
                 fees={},
                 price=price
@@ -391,7 +391,7 @@ def try_fill(self, bar: bar.Bar, liquidity_strategy: liquidity.LiquidityStrategy
                 when=fill_dt,
                 balance_updates={
                     self.pair.base_symbol: amount * base_sign,
-                    self.pair.quote_symbol: round_decimal(price * amount * -base_sign, self.pair_info.quote_precision)
+                    self.pair.quote_symbol: self.pair_info.round_quote(price * amount * -base_sign)
                 },
                 fees={},
                 price=price
@@ -487,7 +487,7 @@ def try_fill_before_stop_hit(
                 when=fill_dt,
                 balance_updates={
                     self.pair.base_symbol: amount * base_sign,
-                    self.pair.quote_symbol: round_decimal(price * amount * -base_sign, self.pair_info.quote_precision)
+                    self.pair.quote_symbol: self.pair_info.round_quote(price * amount * -base_sign)
                 },
                 fees={},
                 price=price
@@ -526,7 +526,7 @@ def try_fill_after_stop_hit(
                 when=fill_dt,
                 balance_updates={
                     self.pair.base_symbol: amount * base_sign,
-                    self.pair.quote_symbol: round_decimal(price * amount * -base_sign, self.pair_info.quote_precision)
+                    self.pair.quote_symbol: self.pair_info.round_quote(price * amount * -base_sign)
                 },
                 fees={},
                 price=price
@@ -535,7 +535,7 @@ def try_fill_after_stop_hit(
 
     def try_fill(self, bar: bar.Bar, liquidity_strategy: liquidity.LiquidityStrategy) -> Optional[Fill]:
         amount = min(self.amount_pending, liquidity_strategy.available_liquidity)
-        amount = truncate_decimal(amount, self.pair_info.base_precision)
+        amount = self.pair_info.truncate_base(amount)
         if not amount:
             return None
 
@@ -578,4 +578,4 @@ def slipped_price(
     if cap_high is not None:
         price = min(price, cap_high)
 
-    return round_decimal(price, order.pair_info.quote_precision)
+    return order.pair_info.round_quote(price)

basana/backtesting/prices.py

@@ -18,7 +18,6 @@
 from typing import Dict, Tuple
 
 from basana.backtesting import config, errors, value_map
-from basana.core import helpers as core_helpers
 from basana.core.bar import Bar, BarEvent
 from basana.core.pair import Pair
 
@@ -44,9 +43,8 @@ def get_bid_ask(self, pair: Pair) -> Tuple[Decimal, Decimal]:
 
         last_price = last_bar.close
         pair_info = self._config.get_pair_info(pair)
-        half_spread = core_helpers.truncate_decimal(
-            (last_price * self._bid_ask_spread_pct / Decimal("100")) / Decimal(2),
-            pair_info.quote_precision
+        half_spread = pair_info.truncate_quote(
+            (last_price * self._bid_ask_spread_pct / Decimal("100")) / Decimal(2)
         )
         bid = last_price - half_spread
         ask = last_price + half_spread

basana/backtesting/requests.py

@@ -15,14 +15,28 @@
 # limitations under the License.
 
 from decimal import Decimal
+from typing import Union
 import abc
 
 from basana.backtesting import errors, orders
-from basana.core import helpers
-from basana.core.enums import OrderOperation
+from basana.core.enums import OrderOperation, PrecisionMode
 from basana.core.pair import Pair, PairInfo
 
 
+def base_precision_limit(pair_info: PairInfo) -> Union[int, Decimal]:
+    if pair_info.precision_mode == PrecisionMode.TICK_SIZE:
+        assert pair_info.base_tick_size is not None
+        return pair_info.base_tick_size
+    return pair_info.base_precision
+
+
+def quote_precision_limit(pair_info: PairInfo) -> Union[int, Decimal]:
+    if pair_info.precision_mode == PrecisionMode.TICK_SIZE:
+        assert pair_info.quote_tick_size is not None
+        return pair_info.quote_tick_size
+    return pair_info.quote_precision
+
+
 class ExchangeOrder(metaclass=abc.ABCMeta):
     def __init__(
             self, operation: OrderOperation, pair: Pair, pair_info: PairInfo,
@@ -62,9 +76,11 @@ def auto_repay(self) -> bool:
     def validate(self, pair_info: PairInfo):
         if self.amount <= Decimal(0):
             raise errors.Error("Amount must be > 0")
-        if self.amount != helpers.truncate_decimal(self.amount, pair_info.base_precision):
+        if self.amount != pair_info.truncate_base(self.amount):
             raise errors.Error(
-                "{} exceeds maximum precision of {} decimal digits".format(self.amount, pair_info.base_precision)
+                "{} exceeds maximum precision of {} {}".format(
+                    self.amount, base_precision_limit(pair_info), pair_info.precision_unit
+                )
             )
 
     @abc.abstractmethod
@@ -113,9 +129,11 @@ def validate(self, pair_info: PairInfo):
         super().validate(pair_info)
         if self.limit_price <= Decimal(0):
             raise errors.Error("Limit price must be > 0")
-        if self.limit_price != helpers.truncate_decimal(self.limit_price, pair_info.quote_precision):
+        if self.limit_price != pair_info.truncate_quote(self.limit_price):
             raise errors.Error(
-                "{} exceeds maximum precision of {} decimal digits".format(self.limit_price, pair_info.quote_precision)
+                "{} exceeds maximum precision of {} {}".format(
+                    self.limit_price, quote_precision_limit(pair_info), pair_info.precision_unit
+                )
             )
 
     def create_order(self, id: str) -> orders.Order:
@@ -152,9 +170,11 @@ def validate(self, pair_info: PairInfo):
         super().validate(pair_info)
         if self.stop_price <= Decimal(0):
             raise errors.Error("Stop price must be > 0")
-        if self.stop_price != helpers.truncate_decimal(self.stop_price, pair_info.quote_precision):
+        if self.stop_price != pair_info.truncate_quote(self.stop_price):
             raise errors.Error(
-                "{} exceeds maximum precision of {} decimal digits".format(self.stop_price, pair_info.quote_precision)
+                "{} exceeds maximum precision of {} {}".format(
+                    self.stop_price, quote_precision_limit(pair_info), pair_info.precision_unit
+                )
             )
 
     def create_order(self, id: str) -> orders.Order:
@@ -197,9 +217,11 @@ def validate(self, pair_info: PairInfo):
         if self.limit_price <= Decimal(0):
             raise errors.Error("Limit price must be > 0")
         for value in [self.stop_price, self.limit_price]:
-            if value != helpers.truncate_decimal(value, pair_info.quote_precision):
+            if value != pair_info.truncate_quote(value):
                 raise errors.Error(
-                    "{} exceeds maximum precision of {} decimal digits".format(value, pair_info.quote_precision)
+                    "{} exceeds maximum precision of {} {}".format(
+                        value, quote_precision_limit(pair_info), pair_info.precision_unit
+                    )
                 )
 
     def create_order(self, id: str) -> orders.Order:

basana/core/enums.py

@@ -34,6 +34,18 @@ def __str__(self):
         }[self]
 
 
+@enum.unique
+class PrecisionMode(enum.Enum):
+    """Enumeration for precision modes."""
+
+    #:
+    DECIMAL_PLACES = 1
+    #:
+    SIGNIFICANT_DIGITS = 2
+    #:
+    TICK_SIZE = 3
+
+
 @enum.unique
 class Position(enum.Enum):
     """Enumeration for positions."""