Qubx 0.6.29__tar.gz → 0.6.31__tar.gz

{qubx-0.6.29 → qubx-0.6.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: Qubx
-Version: 0.6.29
+Version: 0.6.31
 Summary: Qubx - Quantitative Trading Framework
 Author: Dmitry Marienko
 Author-email: dmitry.marienko@xlydian.com

{qubx-0.6.29 → qubx-0.6.31}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "Qubx"
-version = "0.6.29"
+version = "0.6.31"
 description = "Qubx - Quantitative Trading Framework"
 authors = [ "Dmitry Marienko <dmitry.marienko@xlydian.com>", "Yuriy Arabskyy <yuriy.arabskyy@xlydian.com>",]
 readme = "README.md"

{qubx-0.6.29 → qubx-0.6.31}/src/qubx/backtester/ome.py

@@ -105,11 +105,13 @@ class OrdersManagementEngine:
         if mdata.time < self._last_data_update_time_ns:
             return _exec_report
         self._last_data_update_time_ns = mdata.time
+        _mkt_state = "UNKNOWN"
 
         # - new quote
         if isinstance(mdata, Quote):
             _b, _a = mdata.bid, mdata.ask
             _bs, _as = _b, _a
+            _mkt_state = "Q: " + str(mdata)
 
             # - update BBO by new quote
             self.__prev_bbo = self.bbo
@@ -122,16 +124,19 @@ class OrdersManagementEngine:
             _b = max_buy_price - self._tick_size
             _a = min_sell_price + self._tick_size
             _bs, _as = _a, _b
+            _mkt_state = "TA: " + str(mdata)
 
         # - single trade
         elif isinstance(mdata, Trade):
             _b, _a = mdata.price - self._tick_size, mdata.price + self._tick_size
             _bs, _as = _b, _a
+            _mkt_state = "T: " + str(mdata)
 
         # - order book
         elif isinstance(mdata, OrderBook):
             _b, _a = mdata.top_bid, mdata.top_ask
             _bs, _as = _b, _a
+            _mkt_state = "OB: " + str(mdata)
 
         else:
             raise SimulationError(f"Invalid market data type: {type(mdata)} for update OME({self.instrument.symbol})")
@@ -142,7 +147,7 @@ class OrdersManagementEngine:
             for level in _asks_to_execute:
                 for order_id in self.asks[level]:
                     order = self.active_orders.pop(order_id)
-                    _exec_report.append(self._execute_order(timestamp, order.price, order, False))
+                    _exec_report.append(self._execute_order(timestamp, order.price, order, False, _mkt_state))
                 self.asks.pop(level)
 
         # - when new quote ask is lower than the highest bid order execute all affected orders
@@ -151,7 +156,7 @@ class OrdersManagementEngine:
             for level in _bids_to_execute:
                 for order_id in self.bids[level]:
                     order = self.active_orders.pop(order_id)
-                    _exec_report.append(self._execute_order(timestamp, order.price, order, False))
+                    _exec_report.append(self._execute_order(timestamp, order.price, order, False, _mkt_state))
                 self.bids.pop(level)
 
         # - processing stop orders
@@ -162,12 +167,12 @@ class OrdersManagementEngine:
             if so.side == "BUY" and _as >= so.price:
                 _exec_price = _as if not _emulate_price_exec else so.price
                 self.stop_orders.pop(soid)
-                _exec_report.append(self._execute_order(timestamp, _exec_price, so, True))
+                _exec_report.append(self._execute_order(timestamp, _exec_price, so, True, _mkt_state))
 
             elif so.side == "SELL" and _bs <= so.price:
                 _exec_price = _bs if not _emulate_price_exec else so.price
                 self.stop_orders.pop(soid)
-                _exec_report.append(self._execute_order(timestamp, _exec_price, so, True))
+                _exec_report.append(self._execute_order(timestamp, _exec_price, so, True, _mkt_state))
 
         self._last_update_time = timestamp
         return _exec_report
@@ -268,7 +273,7 @@ class OrdersManagementEngine:
 
         # - if order must be "executed" immediately
         if _exec_price is not None:
-            return self._execute_order(timestamp, _exec_price, order, True)
+            return self._execute_order(timestamp, _exec_price, order, True, "BBO: " + str(self.bbo))
 
         # - processing limit orders
         if _need_update_book:
@@ -284,10 +289,12 @@ class OrdersManagementEngine:
         return SimulatedExecutionReport(self.instrument, timestamp, order, None)
 
     def _execute_order(
-        self, timestamp: dt_64, exec_price: float, order: Order, taker: bool
+        self, timestamp: dt_64, exec_price: float, order: Order, taker: bool, market_state: str
     ) -> SimulatedExecutionReport:
         order.status = "CLOSED"
-        self._dbg(f"<red>{order.id}</red> {order.type} {order.side} {order.quantity} executed at {exec_price}")
+        self._dbg(
+            f"<red>{order.id}</red> {order.type} {order.side} {order.quantity} executed at {exec_price} ::: {market_state}"
+        )
         return SimulatedExecutionReport(
             self.instrument,
             timestamp,

{qubx-0.6.29 → qubx-0.6.31}/src/qubx/connectors/ccxt/data.py

@@ -616,9 +616,10 @@ class CcxtDataProvider(IDataProvider):
             for exch_symbol, ccxt_ticker in ccxt_tickers.items():  # type: ignore
                 instrument = ccxt_find_instrument(exch_symbol, self._exchange, _symbol_to_instrument)
                 quote = ccxt_convert_ticker(ccxt_ticker)
-                self._health_monitor.record_data_arrival(sub_type, dt_64(quote.time, "ns"))
-                self._last_quotes[instrument] = quote
-                channel.send((instrument, sub_type, quote, False))
+                if self._last_quotes[instrument] is None or quote.time > self._last_quotes[instrument].time:
+                    self._health_monitor.record_data_arrival(sub_type, dt_64(quote.time, "ns"))
+                    self._last_quotes[instrument] = quote
+                    channel.send((instrument, sub_type, quote, False))
 
         async def un_watch_quote(instruments: list[Instrument]):
             symbols = [_instr_to_ccxt_symbol[i] for i in instruments]

{qubx-0.6.29 → qubx-0.6.31}/src/qubx/connectors/ccxt/exchanges/__init__.py

@@ -8,6 +8,8 @@ import ccxt.pro as cxp
 
 from .binance.broker import BinanceCcxtBroker
 from .binance.exchange import BINANCE_UM_MM, BinancePortfolioMargin, BinanceQV, BinanceQVUSDM
+from .bitfinex.bitfinex import BitfinexF
+from .bitfinex.bitfinex_account import BitfinexAccountProcessor
 from .kraken.kraken import CustomKrakenFutures
 
 EXCHANGE_ALIASES = {
@@ -17,7 +19,7 @@ EXCHANGE_ALIASES = {
     "binance.pm": "binancepm",
     "kraken.f": "custom_krakenfutures",
     "binance.um.mm": "binance_um_mm",
-    "bitfinex.f": "bitfinex",
+    "bitfinex.f": "bitfinex_f",
 }
 
 CUSTOM_BROKERS = {
@@ -27,11 +29,16 @@ CUSTOM_BROKERS = {
     "binance.pm": partial(BinanceCcxtBroker, enable_create_order_ws=False, enable_cancel_order_ws=False),
 }
 
+CUSTOM_ACCOUNTS = {
+    "bitfinex.f": BitfinexAccountProcessor,
+}
+
 cxp.binanceqv = BinanceQV  # type: ignore
 cxp.binanceqv_usdm = BinanceQVUSDM  # type: ignore
 cxp.binancepm = BinancePortfolioMargin  # type: ignore
 cxp.binance_um_mm = BINANCE_UM_MM  # type: ignore
 cxp.custom_krakenfutures = CustomKrakenFutures  # type: ignore
+cxp.bitfinex_f = BitfinexF  # type: ignore
 
 cxp.exchanges.append("binanceqv")
 cxp.exchanges.append("binanceqv_usdm")
@@ -39,3 +46,4 @@ cxp.exchanges.append("binancepm")
 cxp.exchanges.append("binancepm_usdm")
 cxp.exchanges.append("binance_um_mm")
 cxp.exchanges.append("custom_krakenfutures")
+cxp.exchanges.append("bitfinex_f")

{qubx-0.6.29 → qubx-0.6.31}/src/qubx/connectors/ccxt/exchanges/binance/exchange.py

@@ -202,7 +202,12 @@ class BinanceQV(cxp.binance):
         executionType = self.safe_string(message, "X")
         if executionType == "INSURANCE_FUND":
             return
+
+        # - fix 2025-04-16: filter out trades with zero price
         trade = self.parse_ws_trade(message, market)
+        if trade["price"] == 0.0:
+            return
+
         tradesArray = self.safe_value(self.trades, symbol)
         if tradesArray is None:
             limit = self.safe_integer(self.options, "tradesLimit", 1000)

qubx-0.6.31/src/qubx/connectors/ccxt/exchanges/bitfinex/bitfinex.py

@@ -0,0 +1,169 @@
+from typing import Dict, List
+
+import ccxt.pro as cxp
+from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheByTimestamp
+from ccxt.async_support.base.ws.client import Client
+from ccxt.base.errors import ArgumentsRequired, BadRequest, NotSupported
+from ccxt.base.precise import Precise
+from ccxt.base.types import (
+    Any,
+    Balances,
+    Int,
+    Market,
+    Num,
+    Order,
+    OrderSide,
+    OrderType,
+    Str,
+    Strings,
+    Tickers,
+)
+
+
+class BitfinexF(cxp.bitfinex):
+    """
+    Extended binance exchange to provide quote asset volumes support
+    """
+
+    def describe(self):
+        """
+        Overriding watchTrades to use aggTrade instead of trade.
+        """
+        return self.deep_extend(
+            super().describe(),
+            {
+                "has": {
+                    "watchBidsAsks": True,
+                }
+            },
+        )
+
+    def watch_bids_asks(self, symbol: str, params: dict = {}):
+        return self.watch_order_book(symbol, None, params)
+
+    def un_watch_bids_asks(self, symbol: str, params: dict = {}):
+        if hasattr(self, "un_watch_order_book"):
+            return self.un_watch_order_book(symbol, params)
+
+    async def fetch_balance(self, params={}) -> Balances:
+        params["type"] = "margin"
+        return await super().fetch_balance(params)
+
+    async def create_order(
+        self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}
+    ):
+        params.pop("type", None)
+        if "timeInForce" in params and params["timeInForce"] == "GTX":
+            # GTX is not supported by bitfinex, so we need to convert it to PO
+            params["timeInForce"] = "PO"
+            params["postOnly"] = True
+        response = await super().create_order(symbol, type, side, amount, price, params)
+        return response
+
+    async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
+        response = await super().watch_orders(symbol, since, limit, params)
+        print(response)
+        return response
+
+    def parse_ws_order_status(self, status):
+        print(status)
+        statuses: dict = {
+            "ACTIVE": "open",
+            "CANCELED": "canceled",
+            "EXECUTED": "closed",
+            "PARTIALLY": "open",
+            "POSTONLY": "canceled",  # this status means that a postonly order got canceled on submission
+        }
+        return self.safe_string(statuses, status, status)
+
+    def parse_order_status(self, status: Str):
+        if status is None:
+            return status
+        parts = status.split(" ")
+        state = self.safe_string(parts, 0)
+        statuses: dict = {
+            "ACTIVE": "open",
+            "PARTIALLY": "open",
+            "EXECUTED": "closed",
+            "CANCELED": "canceled",
+            "INSUFFICIENT": "canceled",
+            "POSTONLY CANCELED": "canceled",
+            "POSTONLY": "canceled",
+            "RSN_DUST": "rejected",
+            "RSN_PAUSE": "rejected",
+            "IOC CANCELED": "canceled",
+            "FILLORKILL CANCELED": "canceled",
+        }
+        return self.safe_string(statuses, state, status)
+
+    def parse_position(self, position: dict, market: Market = None):
+        #
+        #    [
+        #        "tBTCUSD",                    # SYMBOL
+        #        "ACTIVE",                     # STATUS
+        #        0.0195,                       # AMOUNT
+        #        8565.0267019,                 # BASE_PRICE
+        #        0,                            # MARGIN_FUNDING
+        #        0,                            # MARGIN_FUNDING_TYPE
+        #        -0.33455568705000516,         # PL
+        #        -0.0003117550117425625,       # PL_PERC
+        #        7045.876419249083,            # PRICE_LIQ
+        #        3.0673001895895604,           # LEVERAGE
+        #        null,                         # _PLACEHOLDER
+        #        142355652,                    # POSITION_ID
+        #        1574002216000,                # MTS_CREATE
+        #        1574002216000,                # MTS_UPDATE
+        #        null,                         # _PLACEHOLDER
+        #        0,                            # TYPE
+        #        null,                         # _PLACEHOLDER
+        #        0,                            # COLLATERAL
+        #        0,                            # COLLATERAL_MIN
+        #        # META
+        #        {
+        #            "reason": "TRADE",
+        #            "order_id": 34271018124,
+        #            "liq_stage": null,
+        #            "trade_price": "8565.0267019",
+        #            "trade_amount": "0.0195",
+        #            "order_id_oppo": 34277498022
+        #        }
+        #    ]
+        #
+        positionList = self.safe_list(position, "result")
+        marketId = self.safe_string(positionList, 0)
+        amount = self.safe_string(positionList, 2)
+        timestamp = self.safe_integer(positionList, 12)
+        meta = self.safe_string(positionList, 19)
+        tradePrice = self.safe_string(meta, "trade_price")
+        tradeAmount = self.safe_string(meta, "trade_amount")
+        return self.safe_position(
+            {
+                "info": positionList,
+                "id": self.safe_string(positionList, 11),
+                "symbol": self.safe_symbol(marketId, market),
+                "notional": None,
+                "marginMode": "isolated",  # derivatives use isolated, margin uses cross, https://support.bitfinex.com/hc/en-us/articles/360035475374-Derivatives-Trading-on-Bitfinex
+                "liquidationPrice": self.safe_number(positionList, 8),
+                "entryPrice": self.safe_number(positionList, 3),
+                "unrealizedPnl": self.safe_number(positionList, 6),
+                "percentage": self.safe_number(positionList, 7),
+                "contracts": self.parse_number(amount),
+                "contractSize": None,
+                "markPrice": None,
+                "lastPrice": None,
+                "side": "long" if Precise.string_gt(amount, "0") else "short",
+                "hedged": None,
+                "timestamp": timestamp,
+                "datetime": self.iso8601(timestamp),
+                "lastUpdateTimestamp": self.safe_integer(positionList, 13),
+                "maintenanceMargin": self.safe_number(positionList, 18),
+                "maintenanceMarginPercentage": None,
+                "collateral": self.safe_number(positionList, 17),
+                "initialMargin": self.parse_number(Precise.string_mul(tradeAmount, tradePrice)),
+                "initialMarginPercentage": None,
+                "leverage": self.safe_number(positionList, 9),
+                "marginRatio": None,
+                "stopLossPrice": None,
+                "takeProfitPrice": None,
+            }
+        )

qubx-0.6.31/src/qubx/connectors/ccxt/exchanges/bitfinex/bitfinex_account.py

@@ -0,0 +1,45 @@
+import asyncio
+
+from qubx.connectors.ccxt.account import CcxtAccountProcessor
+from qubx.connectors.ccxt.utils import (
+    ccxt_convert_order_info,
+    ccxt_extract_deals_from_exec,
+    ccxt_find_instrument,
+)
+from qubx.core.basics import CtrlChannel
+
+
+class BitfinexAccountProcessor(CcxtAccountProcessor):
+    async def _subscribe_executions(self, name: str, channel: CtrlChannel):
+        _symbol_to_instrument = {}
+
+        async def _watch_orders():
+            orders = await self.exchange.watch_orders()
+            for order in orders:
+                instrument = ccxt_find_instrument(order["symbol"], self.exchange, _symbol_to_instrument)
+                order = ccxt_convert_order_info(instrument, order)
+                channel.send((instrument, "order", order, False))
+
+        async def _watch_my_trades():
+            trades = await self.exchange.watch_my_trades()
+            for trade in trades:  # type: ignore
+                instrument = ccxt_find_instrument(trade["symbol"], self.exchange, _symbol_to_instrument)
+                print(trade)
+                deals = ccxt_extract_deals_from_exec({"trades": [trade]})
+                print(deals)
+                channel.send((instrument, "deals", deals, False))
+
+        await asyncio.gather(
+            self._listen_to_stream(
+                subscriber=_watch_orders,
+                exchange=self.exchange,
+                channel=channel,
+                name=name,
+            ),
+            self._listen_to_stream(
+                subscriber=_watch_my_trades,
+                exchange=self.exchange,
+                channel=channel,
+                name=name,
+            ),
+        )

{qubx-0.6.29 → qubx-0.6.31}/src/qubx/connectors/ccxt/factory.py

@@ -7,7 +7,8 @@ from qubx.connectors.ccxt.broker import CcxtBroker
 from qubx.core.basics import CtrlChannel
 from qubx.core.interfaces import IAccountProcessor, IBroker, IDataProvider, ITimeProvider
 
-from .exchanges import CUSTOM_BROKERS, EXCHANGE_ALIASES
+from .account import CcxtAccountProcessor
+from .exchanges import CUSTOM_ACCOUNTS, CUSTOM_BROKERS, EXCHANGE_ALIASES
 
 
 def get_ccxt_exchange(
@@ -69,10 +70,18 @@ def get_ccxt_broker(
     data_provider: IDataProvider,
     **kwargs,
 ) -> IBroker:
-    broker_cls = CUSTOM_BROKERS.get(exchange_name, CcxtBroker)
+    broker_cls = CUSTOM_BROKERS.get(exchange_name.lower(), CcxtBroker)
     return broker_cls(exchange, channel, time_provider, account, data_provider, **kwargs)
 
 
+def get_ccxt_account(
+    exchange_name: str,
+    **kwargs,
+) -> IAccountProcessor:
+    account_cls = CUSTOM_ACCOUNTS.get(exchange_name.lower(), CcxtAccountProcessor)
+    return account_cls(**kwargs)
+
+
 def _get_api_credentials(
     api_key: str | None, secret: str | None, kwargs: dict[str, Any]
 ) -> tuple[str | None, str | None]:

{qubx-0.6.29 → qubx-0.6.31}/src/qubx/connectors/ccxt/utils.py

@@ -38,6 +38,9 @@ def ccxt_convert_order_info(instrument: Instrument, raw: dict[str, Any]) -> Orde
     Convert CCXT excution record to Order object
     """
     ri = raw["info"]
+    if isinstance(ri, list):
+        # we don't handle case when order info is a list
+        ri = {}
     amnt = float(ri.get("origQty", raw.get("amount")))
     price = raw["price"]
     status = raw["status"]
@@ -157,7 +160,8 @@ def ccxt_convert_positions(
             quantity=info["contracts"] * (-1 if info["side"] == "short" else 1),
             pos_average_price=info["entryPrice"],
         )
-        pos.update_market_price(pd.Timestamp(info["timestamp"], unit="ms").asm8, info["markPrice"], 1)
+        if info.get("markPrice", None) is not None:
+            pos.update_market_price(pd.Timestamp(info["timestamp"], unit="ms").asm8, info["markPrice"], 1)
         positions.append(pos)
     return positions
 

{qubx-0.6.29 → qubx-0.6.31}/src/qubx/core/context.py

@@ -430,8 +430,8 @@ class StrategyContext(IStrategyContext):
     def close_positions(self, market_type: MarketType | None = None) -> None:
         return self._trading_manager.close_positions(market_type)
 
-    def cancel_order(self, order_id: str) -> None:
-        return self._trading_manager.cancel_order(order_id)
+    def cancel_order(self, order_id: str, exchange: str | None = None) -> None:
+        return self._trading_manager.cancel_order(order_id, exchange)
 
     def cancel_orders(self, instrument: Instrument):
         return self._trading_manager.cancel_orders(instrument)

{qubx-0.6.29 → qubx-0.6.31}/src/qubx/core/helpers.py

@@ -202,6 +202,8 @@ class CachedMarketDataHolder:
         series = self._ohlcvs.get(instrument)
         if series:
             for ser in series.values():
+                if len(ser) > 0 and ser[0].time > quote.time:
+                    continue
                 ser.update(quote.time, quote.mid_price(), 0)
 
     @SW.watch("CachedMarketDataHolder")

{qubx-0.6.29 → qubx-0.6.31}/src/qubx/core/mixins/trading.py

@@ -180,7 +180,9 @@ class TradingManager(ITradingManager):
     def _adjust_size(self, instrument: Instrument, amount: float) -> float:
         size_adj = instrument.round_size_down(abs(amount))
         if size_adj < instrument.min_size:
-            raise ValueError(f"Attempt to trade size {abs(amount)} less than minimal allowed {instrument.min_size} !")
+            raise ValueError(
+                f"[{instrument.symbol}] Attempt to trade size {abs(amount)} less than minimal allowed {instrument.min_size} !"
+            )
         return size_adj
 
     def _adjust_price(self, instrument: Instrument, price: float | None, amount: float) -> float | None:

{qubx-0.6.29 → qubx-0.6.31}/src/qubx/data/tardis.py

@@ -529,6 +529,7 @@ class TardisMachineReader(DataReader):
             raise ValueError(f"Invalid data_id format: {data_id}. Expected format: 'exchange:symbol'")
 
         exchange = TARDIS_EXCHANGE_MAPPERS.get(exchange.lower(), exchange)
+        symbol = self._map_symbol(symbol, exchange)
 
         start_date, end_date = handle_start_stop(start, stop)
         if not start_date:
@@ -607,6 +608,7 @@ class TardisMachineReader(DataReader):
                             try:
                                 chunk = chunk_queue.get()
                                 if chunk is None:  # End of chunks
+                                    logger.info(f"End of chunks for {data_id}")
                                     break
 
                                 # Process and yield the chunk
@@ -877,3 +879,10 @@ class TardisMachineReader(DataReader):
     def _stream_data(self, url: str, line_queue: Queue, stop_event: threading.Event):
         """Submit the streaming coroutine to the asyncio loop"""
         return self._async_loop.submit(self._fetch_stream(url, line_queue, stop_event))
+
+    def _map_symbol(self, symbol: str, exchange: str) -> str:
+        """Map symbol to Tardis Machine API format"""
+        if exchange.lower() == "bitfinex-derivatives":
+            return f"{symbol[:3]}F0:USTF0"
+        else:
+            return symbol

{qubx-0.6.29 → qubx-0.6.31}/src/qubx/utils/runner/runner.py

@@ -21,9 +21,8 @@ from qubx.backtester.utils import (
     SimulationSetup,
     recognize_simulation_data_config,
 )
-from qubx.connectors.ccxt.account import CcxtAccountProcessor
 from qubx.connectors.ccxt.data import CcxtDataProvider
-from qubx.connectors.ccxt.factory import get_ccxt_broker, get_ccxt_exchange
+from qubx.connectors.ccxt.factory import get_ccxt_account, get_ccxt_broker, get_ccxt_exchange
 from qubx.connectors.tardis.data import TardisDataProvider
 from qubx.core.account import CompositeAccountProcessor
 from qubx.core.basics import (
@@ -464,40 +463,43 @@ def _create_account_processor(
     restored_state: RestoredState | None = None,
     read_only: bool = False,
 ) -> IAccountProcessor:
-    if paper:
-        settings = account_manager.get_exchange_settings(exchange_name)
-
-        # - TODO: here we can create  different types of simulated exchanges based on it's name etc
-        simulated_exchange = get_simulated_exchange(exchange_name, time_provider, tcc)
-
-        return SimulatedAccountProcessor(
-            account_id=exchange_name,
-            exchange=simulated_exchange,
-            channel=channel,
-            base_currency=settings.base_currency,
-            initial_capital=settings.initial_capital,
-            restored_state=restored_state,
-        )
-
-    creds = account_manager.get_exchange_credentials(exchange_name)
-    connector = exchange_config.connector
     if exchange_config.account is not None:
         connector = exchange_config.account.connector
+    elif paper:
+        connector = "paper"
+    else:
+        connector = exchange_config.connector
 
     match connector.lower():
         case "ccxt":
+            creds = account_manager.get_exchange_credentials(exchange_name)
             exchange = get_ccxt_exchange(
                 exchange_name, use_testnet=creds.testnet, api_key=creds.api_key, secret=creds.secret
             )
-            return CcxtAccountProcessor(
+            return get_ccxt_account(
                 exchange_name,
-                exchange,
-                channel,
-                time_provider,
+                account_id=exchange_name,
+                exchange=exchange,
+                channel=channel,
+                time_provider=time_provider,
                 base_currency=creds.base_currency,
                 tcc=tcc,
                 read_only=read_only,
             )
+        case "paper":
+            settings = account_manager.get_exchange_settings(exchange_name)
+
+            # - TODO: here we can create  different types of simulated exchanges based on it's name etc
+            simulated_exchange = get_simulated_exchange(exchange_name, time_provider, tcc)
+
+            return SimulatedAccountProcessor(
+                account_id=exchange_name,
+                exchange=simulated_exchange,
+                channel=channel,
+                base_currency=settings.base_currency,
+                initial_capital=settings.initial_capital,
+                restored_state=restored_state,
+            )
         case _:
             raise ValueError(f"Connector {exchange_config.connector} is not supported yet !")
 
@@ -512,19 +514,19 @@ def _create_broker(
     account_manager: AccountConfigurationManager,
     paper: bool,
 ) -> IBroker:
-    if paper:
-        assert isinstance(account, SimulatedAccountProcessor)
-        return SimulatedBroker(channel=channel, account=account, simulated_exchange=account._exchange)
-
-    creds = account_manager.get_exchange_credentials(exchange_name)
-    connector = exchange_config.connector
-    params = exchange_config.params
     if exchange_config.broker is not None:
         connector = exchange_config.broker.connector
         params = exchange_config.broker.params
+    elif paper:
+        connector = "paper"
+        params = {}
+    else:
+        connector = exchange_config.connector
+        params = exchange_config.params
 
     match connector.lower():
         case "ccxt":
+            creds = account_manager.get_exchange_credentials(exchange_name)
             _enable_mm = params.pop("enable_mm", False)
             exchange = get_ccxt_exchange(
                 exchange_name,
@@ -536,6 +538,9 @@ def _create_broker(
             return get_ccxt_broker(
                 exchange_name, exchange, channel, time_provider, account, data_provider, **exchange_config.params
             )
+        case "paper":
+            assert isinstance(account, SimulatedAccountProcessor)
+            return SimulatedBroker(channel=channel, account=account, simulated_exchange=account._exchange)
         case _:
             raise ValueError(f"Connector {exchange_config.connector} is not supported yet !")
 

qubx-0.6.29/src/qubx/connectors/ccxt/exchanges/bitfinex/bitfinex.py

@@ -1,43 +0,0 @@
-from typing import Dict, List
-
-import ccxt.pro as cxp
-from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheByTimestamp
-from ccxt.async_support.base.ws.client import Client
-from ccxt.base.errors import ArgumentsRequired, BadRequest, NotSupported
-from ccxt.base.precise import Precise
-from ccxt.base.types import (
-    Any,
-    Balances,
-    Num,
-    Order,
-    OrderSide,
-    OrderType,
-    Strings,
-    Tickers,
-)
-
-
-class MyBitfinex(cxp.bitfinex):
-    """
-    Extended binance exchange to provide quote asset volumes support
-    """
-
-    def describe(self):
-        """
-        Overriding watchTrades to use aggTrade instead of trade.
-        """
-        return self.deep_extend(
-            super().describe(),
-            {
-                "has": {
-                    "watchBidsAsks": True,
-                }
-            },
-        )
-
-    def watch_bids_asks(self, symbol: str, params: dict = {}):
-        return self.watch_order_book(symbol, None, params)
-
-    def un_watch_bids_asks(self, symbol: str, params: dict = {}):
-        if hasattr(self, "un_watch_order_book"):
-            return self.un_watch_order_book(symbol, params)