Qubx 0.6.16__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.17__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/cli/commands.py

@@ -140,16 +140,16 @@ def ls(directory: str):
     callback=lambda ctx, param, value: os.path.abspath(os.path.expanduser(value)),
 )
 @click.option(
-    "--strategy",
-    "-s",
-    type=click.STRING,
-    help="Strategy name to release (should match the strategy class name) or path to a config YAML file",
+    "--config",
+    "-c",
+    type=click.Path(exists=True, resolve_path=True),
+    help="Path to a config YAML file",
     required=True,
 )
 @click.option(
     "--output-dir",
     "-o",
-    type=click.STRING,
+    type=click.Path(exists=False),
     help="Output directory to put zip file.",
     default=".releases",
     show_default=True,
@@ -172,7 +172,6 @@ def ls(directory: str):
 )
 @click.option(
     "--commit",
-    "-c",
     is_flag=True,
     default=False,
     help="Commit changes and create tag in repo (default: False)",
@@ -180,7 +179,7 @@ def ls(directory: str):
 )
 def release(
     directory: str,
-    strategy: str,
+    config: str,
     tag: str | None,
     message: str | None,
     commit: bool,
@@ -189,16 +188,9 @@ def release(
     """
     Releases the strategy to a zip file.
 
-    The strategy can be specified in two ways:
-    1. As a strategy name (class name) - strategies are scanned in the given directory (NOT SUPPORTED ANYMORE !)
-    2. As a path to a config YAML file containing the strategy configuration in StrategyConfig format
-
-    If a strategy name is provided, a default configuration will be generated with:
-    - The strategy parameters from the strategy class
-    - Default exchange, connector, and instruments from the command options
-    - Standard logging configuration
+    The strategy is specified by a path to a config YAML file containing the strategy configuration in StrategyConfig format.
 
-    If a config file is provided, it must follow the StrategyConfig structure with:
+    The config file must follow the StrategyConfig structure with:
     - strategy: The strategy name or path
     - parameters: Dictionary of strategy parameters
     - exchanges: Dictionary of exchange configurations
@@ -211,7 +203,7 @@ def release(
 
     release_strategy(
         directory=directory,
-        strategy_name=strategy,
+        config_file=config,
         tag=tag,
         message=message,
         commit=commit,

qubx/cli/release.py

@@ -16,7 +16,6 @@ from qubx import logger
 from qubx.utils.misc import (
     cyan,
     generate_name,
-    get_local_qubx_folder,
     green,
     load_qubx_resources_as_text,
     magenta,
@@ -265,7 +264,7 @@ def load_strategy_from_config(config_path: Path, directory: str) -> StrategyInfo
 
 def release_strategy(
     directory: str,
-    strategy_name: str,
+    config_file: str,
     tag: str | None,
     message: str | None,
     commit: bool,
@@ -276,7 +275,7 @@ def release_strategy(
 
     Args:
         directory: str - directory to scan for strategies
-        strategy_name: str - strategy name to release or path to config file
+        config_file: str - path to config file
         tag: str - additional tag for this release
         message: str - release message
         commit: bool - commit changes and create tag in repo
@@ -288,29 +287,12 @@ def release_strategy(
 
     try:
         # - determine if strategy_name is a config file or a strategy name
-        if is_config_file(strategy_name):
-            # - load strategy from config file
-            logger.info(f"Loading strategy from config file: {strategy_name}")
-            stg_info = load_strategy_from_config(Path(strategy_name), directory)
-        else:
-            # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-            # TODO: generate default config from strategy class ? Do we really need it at all ?
-            # - find strategy by name
-            # logger.info(f"Looking for '{strategy_name}' strategy")
-
-            # strat_name = "_".join([x.split(".")[-1] for x in strategy_class_names])
-            # stg_info = StrategyInfo(name=strategy_name, classes=[find_class_by_name(directory, strategy_name)])
-
-            # stg_info = find_class_by_name(directory, strategy_name)
+        if not is_config_file(config_file):
+            raise ValueError("Try using yaml config file path")
 
-            # - generate default config
-            # strategy_config = generate_default_config(
-            # stg_info, default_exchange, default_connector, default_instruments
-            # )
-            # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-            raise ValueError(
-                "!!! Release of strategy by name is not supported anymore ! Try to use config file instead !!!"
-            )
+        # - load strategy from config file
+        logger.info(f"Loading strategy from config file: {config_file}")
+        stg_info = load_strategy_from_config(Path(config_file), directory)
 
         # - process git repo and pyproject.toml for each strategy component
         repos_paths = set()
@@ -413,9 +395,8 @@ def _save_strategy_config(stg_name: str, strategy_config: StrategyConfig, releas
 
 def _copy_strategy_file(strategy_path: str, pyproject_root: str, release_dir: str) -> None:
     """Copy the strategy file to the release directory."""
-    src_dir = os.path.basename(pyproject_root)
     rel_path = os.path.relpath(strategy_path, pyproject_root)
-    dest_file_path = os.path.join(release_dir, src_dir, rel_path)
+    dest_file_path = os.path.join(release_dir, rel_path)
 
     # Ensure the destination directory exists
     os.makedirs(os.path.dirname(dest_file_path), exist_ok=True)
@@ -428,11 +409,9 @@ def _copy_strategy_file(strategy_path: str, pyproject_root: str, release_dir: st
 def _try_copy_file(src_file: str, dest_dir: str, pyproject_root: str) -> None:
     """Try to copy the file to the release directory."""
     if os.path.exists(src_file):
-        _src_dir = os.path.basename(pyproject_root)
-
         # Get the relative path from pyproject_root
         _rel_import_path = os.path.relpath(src_file, pyproject_root)
-        _dest_import_path = os.path.join(dest_dir, _src_dir, _rel_import_path)
+        _dest_import_path = os.path.join(dest_dir, _rel_import_path)
 
         # Ensure the destination directory exists
         os.makedirs(os.path.dirname(_dest_import_path), exist_ok=True)
@@ -446,10 +425,22 @@ def _copy_dependencies(strategy_path: str, pyproject_root: str, release_dir: str
     """Copy all dependencies required by the strategy."""
     _src_dir = os.path.basename(pyproject_root)
     _imports = _get_imports(strategy_path, pyproject_root, [_src_dir])
+    # find inside of the pyproject_root a folder with the same name as the _src_dir
+    # for instance it could be like macd_crossover/src/macd_crossover
+    # or macd_crossover/macd_crossover
+    # and assign this folder to _src_root
+    _src_root = None
+    for root, dirs, files in os.walk(pyproject_root):
+        if _src_dir in dirs:
+            _src_root = os.path.join(root, _src_dir)
+            break
+
+    if _src_root is None:
+        raise ValueError(f"Could not find the source root for {_src_dir} in {pyproject_root}")
 
     for _imp in _imports:
         # Construct source path
-        _base = os.path.join(pyproject_root, *[s for s in _imp.module if s != _src_dir])
+        _base = os.path.join(_src_root, *[s for s in _imp.module if s != _src_dir])
 
         # - try to copy all available files for satisfying the import
         if os.path.isdir(_base):
@@ -521,7 +512,7 @@ def _modify_pyproject_toml(pyproject_path: str, package_name: str) -> None:
                         deps[d] = f">={version(d)}"
 
             # Replace the packages section with the new one
-            pyproject_data["tool"]["poetry"]["packages"] = [{"include": package_name}]
+            # pyproject_data["tool"]["poetry"]["packages"] = [{"include": package_name}]
 
             # Check if build section exists
             if "build" not in pyproject_data["tool"]["poetry"]:
@@ -632,7 +623,7 @@ def _handle_project_files(pyproject_root: str, release_dir: str) -> None:
     # Copy build.py if it exists
     build_src = os.path.join(pyproject_root, "build.py")
     if not os.path.exists(build_src):
-        logger.warning(f"build.py not found in {pyproject_root} using default one")
+        logger.info(f"build.py not found in {pyproject_root} using default one")
         build_src = load_qubx_resources_as_text("_build.py")
 
         # - setup project's name in default build.py

qubx/connectors/ccxt/broker.py

@@ -14,7 +14,7 @@ from qubx.core.basics import (
     Order,
 )
 from qubx.core.errors import OrderCancellationError, OrderCreationError, create_error_event
-from qubx.core.exceptions import InvalidOrderParameters
+from qubx.core.exceptions import BadRequest, InvalidOrderParameters
 from qubx.core.interfaces import (
     IAccountProcessor,
     IBroker,
@@ -37,11 +37,11 @@ class CcxtBroker(IBroker):
         time_provider: ITimeProvider,
         account: IAccountProcessor,
         data_provider: IDataProvider,
-        enable_price_match: bool = False,
-        price_match_ticks: int = 5,
         cancel_timeout: int = 30,
         cancel_retry_interval: int = 2,
         max_cancel_retries: int = 10,
+        enable_create_order_ws: bool = False,
+        enable_cancel_order_ws: bool = False,
     ):
         self._exchange = exchange
         self.ccxt_exchange_id = str(exchange.name)
@@ -49,12 +49,12 @@ class CcxtBroker(IBroker):
         self.time_provider = time_provider
         self.account = account
         self.data_provider = data_provider
-        self.enable_price_match = enable_price_match
-        self.price_match_ticks = price_match_ticks
         self._loop = AsyncThreadLoop(exchange.asyncio_loop)
         self.cancel_timeout = cancel_timeout
         self.cancel_retry_interval = cancel_retry_interval
         self.max_cancel_retries = max_cancel_retries
+        self.enable_create_order_ws = enable_create_order_ws
+        self.enable_cancel_order_ws = enable_cancel_order_ws
 
     @property
     def is_simulated_trading(self) -> bool:
@@ -209,61 +209,14 @@ class CcxtBroker(IBroker):
         Returns:
             tuple: (Order object if successful, Exception if failed)
         """
-        params = {}
-        _is_trigger_order = order_type.startswith("stop_")
-
-        if order_type == "limit" or _is_trigger_order:
-            params["timeInForce"] = time_in_force.upper()
-            if price is None:
-                return None, InvalidOrderParameters(f"Price must be specified for '{order_type}' order")
-
-        quote = self.data_provider.get_quote(instrument)
-
-        # TODO: think about automatically setting reduce only when needed
-        if not options.get("reduceOnly", False):
-            min_notional = instrument.min_notional
-            if min_notional > 0 and abs(amount) * quote.mid_price() < min_notional:
-                return None, InvalidOrderParameters(
-                    f"[{instrument.symbol}] Order amount {amount} is too small. Minimum notional is {min_notional}"
-                )
-
-        # - handle trigger (stop) orders
-        if _is_trigger_order:
-            params["triggerPrice"] = price
-            order_type = order_type.split("_")[1]
-
-        if client_id:
-            params["newClientOrderId"] = client_id
-
-        if "priceMatch" in options:
-            params["priceMatch"] = options["priceMatch"]
-
-        if instrument.is_futures():
-            params["type"] = "swap"
-
-            if time_in_force == "gtx" and price is not None and self.enable_price_match:
-                if (order_side == "buy" and quote.bid - price < self.price_match_ticks * instrument.tick_size) or (
-                    order_side == "sell" and price - quote.ask < self.price_match_ticks * instrument.tick_size
-                ):
-                    params["priceMatch"] = "QUEUE"
-                    logger.debug(f"[<y>{instrument.symbol}</y>] :: Price match is set to QUEUE. Price will be ignored.")
-
-        if "priceMatch" in params:
-            # - if price match is set, we don't need to specify the price
-            price = None
-
-        ccxt_symbol = instrument_to_ccxt_symbol(instrument)
-
         try:
-            # Type annotation issue: We need to use type ignore for CCXT API compatibility
-            r = await self._exchange.create_order(
-                symbol=ccxt_symbol,
-                type=order_type,  # type: ignore
-                side=order_side,  # type: ignore
-                amount=amount,
-                price=price,
-                params=params,
+            payload = self._prepare_order_payload(
+                instrument, order_side, order_type, amount, price, client_id, time_in_force, **options
             )
+            if self.enable_create_order_ws:
+                r = await self._exchange.create_order_ws(**payload)
+            else:
+                r = await self._exchange.create_order(**payload)
 
             if r is None:
                 msg = "(::_create_order) No response from exchange"
@@ -278,25 +231,6 @@ class CcxtBroker(IBroker):
             logger.error(
                 f"(::_create_order) [{instrument.symbol}] ORDER NOT FILLEABLE for {order_side} {amount} {order_type} : {exc}"
             )
-            exc_msg = str(exc)
-            if (
-                self.enable_price_match
-                and "priceMatch" not in options
-                and ("-5022" in exc_msg or "Post Only order will be rejected" in exc_msg)
-            ):
-                logger.debug(f"(::_create_order) [{instrument.symbol}] Trying again with price match ...")
-                options_with_price_match = options.copy()
-                options_with_price_match["priceMatch"] = "QUEUE"
-                return await self._create_order(
-                    instrument=instrument,
-                    order_side=order_side,
-                    order_type=order_type,
-                    amount=amount,
-                    price=price,
-                    client_id=client_id,
-                    time_in_force=time_in_force,
-                    **options_with_price_match,
-                )
             return None, exc
         except ccxt.InvalidOrder as exc:
             logger.error(
@@ -315,6 +249,59 @@ class CcxtBroker(IBroker):
             logger.error(traceback.format_exc())
             return None, err
 
+    def _prepare_order_payload(
+        self,
+        instrument: Instrument,
+        order_side: str,
+        order_type: str,
+        amount: float,
+        price: float | None = None,
+        client_id: str | None = None,
+        time_in_force: str = "gtc",
+        **options,
+    ) -> dict[str, Any]:
+        params = {}
+        _is_trigger_order = order_type.startswith("stop_")
+
+        if order_type == "limit" or _is_trigger_order:
+            params["timeInForce"] = time_in_force.upper()
+            if price is None:
+                raise InvalidOrderParameters(f"Price must be specified for '{order_type}' order")
+
+        quote = self.data_provider.get_quote(instrument)
+        if quote is None:
+            logger.warning(f"[<y>{instrument.symbol}</y>] :: Quote is not available for order creation.")
+            raise BadRequest(f"Quote is not available for order creation for {instrument.symbol}")
+
+        # TODO: think about automatically setting reduce only when needed
+        if not options.get("reduceOnly", False):
+            min_notional = instrument.min_notional
+            if min_notional > 0 and abs(amount) * quote.mid_price() < min_notional:
+                raise InvalidOrderParameters(
+                    f"[{instrument.symbol}] Order amount {amount} is too small. Minimum notional is {min_notional}"
+                )
+
+        # - handle trigger (stop) orders
+        if _is_trigger_order:
+            params["triggerPrice"] = price
+            order_type = order_type.split("_")[1]
+
+        if client_id:
+            params["newClientOrderId"] = client_id
+
+        if instrument.is_futures():
+            params["type"] = "swap"
+
+        ccxt_symbol = instrument_to_ccxt_symbol(instrument)
+        return {
+            "symbol": ccxt_symbol,
+            "type": order_type,
+            "side": order_side,
+            "amount": amount,
+            "price": price,
+            "params": params,
+        }
+
     async def _cancel_order_with_retry(self, order_id: str, instrument: Instrument) -> bool:
         """
         Attempts to cancel an order with retries.
@@ -332,7 +319,10 @@ class CcxtBroker(IBroker):
 
         while True:
             try:
-                await self._exchange.cancel_order_ws(order_id, symbol=instrument_to_ccxt_symbol(instrument))
+                if self.enable_cancel_order_ws:
+                    await self._exchange.cancel_order_ws(order_id, symbol=instrument_to_ccxt_symbol(instrument))
+                else:
+                    await self._exchange.cancel_order(order_id, symbol=instrument_to_ccxt_symbol(instrument))
                 return True
             except ccxt.OperationRejected as err:
                 err_msg = str(err).lower()

qubx/connectors/ccxt/data.py

@@ -224,7 +224,8 @@ class CcxtDataProvider(IDataProvider):
 
         if sub_type in self._sub_to_coro:
             logger.debug(f"Canceling existing {sub_type} subscription for {self._subscriptions[_sub_type]}")
-            self._loop.submit(self._stop_subscriber(sub_type, self._sub_to_name[sub_type]))
+            # - wait for the subscriber to stop
+            self._loop.submit(self._stop_subscriber(sub_type, self._sub_to_name[sub_type])).result()
             del self._sub_to_coro[sub_type]
             del self._sub_to_name[sub_type]
             del self._subscriptions[_sub_type]
@@ -533,7 +534,10 @@ class CcxtDataProvider(IDataProvider):
 
         async def un_watch_quote(instruments: list[Instrument]):
             symbols = [_instr_to_ccxt_symbol[i] for i in instruments]
-            await self._exchange.un_watch_tickers(symbols)
+            if hasattr(self._exchange, "un_watch_bids_asks"):
+                await getattr(self._exchange, "un_watch_bids_asks")(symbols)
+            else:
+                await self._exchange.un_watch_tickers(symbols)
 
         await self._listen_to_stream(
             subscriber=self._call_by_market_type(watch_quote, instruments),

qubx/connectors/ccxt/exchanges/__init__.py

@@ -0,0 +1,37 @@
+"""
+This module contains the CCXT connectors for the exchanges.
+"""
+
+from functools import partial
+
+import ccxt.pro as cxp
+
+from .binance.broker import BinanceCcxtBroker
+from .binance.exchange import BINANCE_UM_MM, BinancePortfolioMargin, BinanceQV, BinanceQVUSDM
+
+EXCHANGE_ALIASES = {
+    "binance": "binanceqv",
+    "binance.um": "binanceqv_usdm",
+    "binance.cm": "binancecoinm",
+    "binance.pm": "binancepm",
+    "kraken.f": "krakenfutures",
+    "binance.um.mm": "binance_um_mm",
+}
+
+CUSTOM_BROKERS = {
+    "binance": partial(BinanceCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=False),
+    "binance.um": partial(BinanceCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=False),
+    "binance.cm": partial(BinanceCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=False),
+    "binance.pm": partial(BinanceCcxtBroker, enable_create_order_ws=False, enable_cancel_order_ws=False),
+}
+
+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.exchanges.append("binanceqv")
+cxp.exchanges.append("binanceqv_usdm")
+cxp.exchanges.append("binancepm")
+cxp.exchanges.append("binancepm_usdm")
+cxp.exchanges.append("binance_um_mm")

qubx/connectors/ccxt/exchanges/binance/broker.py

@@ -0,0 +1,56 @@
+from typing import Any
+
+from qubx import logger
+from qubx.connectors.ccxt.broker import CcxtBroker
+from qubx.core.basics import Instrument
+from qubx.core.exceptions import BadRequest
+
+
+class BinanceCcxtBroker(CcxtBroker):
+    def __init__(
+        self,
+        *args,
+        enable_price_match: bool = False,
+        price_match_ticks: int = 5,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+        self.enable_price_match = enable_price_match
+        self.price_match_ticks = price_match_ticks
+
+    def _prepare_order_payload(
+        self,
+        instrument: Instrument,
+        order_side: str,
+        order_type: str,
+        amount: float,
+        price: float | None = None,
+        client_id: str | None = None,
+        time_in_force: str = "gtc",
+        **options,
+    ) -> dict[str, Any]:
+        payload = super()._prepare_order_payload(
+            instrument, order_side, order_type, amount, price, client_id, time_in_force, **options
+        )
+        params = payload.get("params", {})
+        if "priceMatch" in options:
+            params["priceMatch"] = options["priceMatch"]
+
+        quote = self.data_provider.get_quote(instrument)
+        if quote is None:
+            logger.warning(f"[<y>{instrument.symbol}</y>] :: Quote is not available for order creation.")
+            raise BadRequest(f"Quote is not available for price match for {instrument.symbol}")
+
+        if time_in_force == "gtx" and price is not None and self.enable_price_match:
+            if (order_side == "buy" and quote.bid - price < self.price_match_ticks * instrument.tick_size) or (
+                order_side == "sell" and price - quote.ask < self.price_match_ticks * instrument.tick_size
+            ):
+                params["priceMatch"] = "QUEUE"
+                logger.debug(f"[<y>{instrument.symbol}</y>] :: Price match is set to QUEUE. Price will be ignored.")
+
+        if "priceMatch" in params:
+            # - if price match is set, we don't need to specify the price
+            payload["price"] = None
+
+        payload["params"] = params
+        return payload

qubx/connectors/ccxt/{customizations.py → exchanges/binance/exchange.py}

@@ -3,13 +3,17 @@ 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,
 )
 
 
@@ -33,6 +37,80 @@ class BinanceQV(cxp.binance):
             },
         )
 
+    async def un_watch_bids_asks(self, symbols: Strings = None, params: dict = {}) -> Any:
+        """
+        unwatches best bid & ask for symbols
+
+        https://developers.binance.com/docs/binance-spot-api-docs/web-socket-api#symbol-order-book-ticker
+        https://developers.binance.com/docs/derivatives/usds-margined-futures/websocket-market-streams/All-Book-Tickers-Stream
+        https://developers.binance.com/docs/derivatives/coin-margined-futures/websocket-market-streams/All-Book-Tickers-Stream
+
+        :param str[] symbols: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        methodName = "watchBidsAsks"
+        channelName = "bookTicker"
+        symbols = self.market_symbols(symbols, None, True, False, True)
+        firstMarket = None
+        marketType = None
+        symbolsDefined = symbols is not None
+        if symbolsDefined:
+            firstMarket = self.market(symbols[0])
+        marketType, params = self.handle_market_type_and_params(methodName, firstMarket, params)
+        subType = None
+        subType, params = self.handle_sub_type_and_params(methodName, firstMarket, params)
+        rawMarketType = None
+        if self.isLinear(marketType, subType):
+            rawMarketType = "future"
+        elif self.isInverse(marketType, subType):
+            rawMarketType = "delivery"
+        elif marketType == "spot":
+            rawMarketType = marketType
+        else:
+            raise NotSupported(str(self.id) + " " + methodName + "() does not support options markets")
+        isBidAsk = True
+        subscriptionArgs = []
+        subMessageHashes = []
+        messageHashes = []
+        if symbolsDefined:
+            for i in range(0, len(symbols)):
+                symbol = symbols[i]
+                market = self.market(symbol)
+                subscriptionArgs.append(market["lowercaseId"] + "@" + channelName)
+                subMessageHashes.append(self.get_message_hash(channelName, market["symbol"], isBidAsk))
+                messageHashes.append("unsubscribe:bidsasks:" + symbol)
+        else:
+            if marketType == "spot":
+                raise ArgumentsRequired(
+                    str(self.id) + " " + methodName + "() requires symbols for this channel for spot markets"
+                )
+            subscriptionArgs.append("!" + channelName)
+            subMessageHashes.append(self.get_message_hash(channelName, None, isBidAsk))
+            messageHashes.append("unsubscribe:bidsasks")
+        streamHash = channelName
+        if symbolsDefined:
+            streamHash = channelName + "::" + ",".join(symbols)
+        url = self.urls["api"]["ws"][rawMarketType] + "/" + self.stream(rawMarketType, streamHash)
+        requestId = self.request_id(url)
+        request: dict = {
+            "method": "UNSUBSCRIBE",
+            "params": subscriptionArgs,
+            "id": requestId,
+        }
+        subscription: dict = {
+            "unsubscribe": True,
+            "id": str(requestId),
+            "subMessageHashes": subMessageHashes,
+            "messageHashes": subMessageHashes,
+            "symbols": symbols,
+            "topic": "bidsasks",
+        }
+        return await self.watch_multiple(
+            url, subMessageHashes, self.extend(request, params), subMessageHashes, subscription
+        )
+
     def parse_ohlcv(self, ohlcv, market=None):
         """
         [
@@ -397,3 +475,26 @@ class BinancePortfolioMargin(BinanceQVUSDM):
         result["timestamp"] = timestamp
         result["datetime"] = self.iso8601(timestamp)
         return result if isolated else self.safe_balance(result)
+
+
+class BINANCE_UM_MM(BinanceQVUSDM):
+    def describe(self):
+        return self.deep_extend(
+            super().describe(),
+            {
+                "urls": {
+                    "api": {
+                        "fapiPublic": "https://fapi-mm.binance.com/fapi/v1",
+                        "fapiPublicV2": "https://fapi-mm.binance.com/fapi/v2",
+                        "fapiPublicV3": "https://fapi-mm.binance.com/fapi/v3",
+                        "fapiPrivate": "https://fapi-mm.binance.com/fapi/v1",
+                        "fapiPrivateV2": "https://fapi-mm.binance.com/fapi/v2",
+                        "fapiPrivateV3": "https://fapi-mm.binance.com/fapi/v3",
+                        "future": "wss://fstream-mm.binance.com/ws",
+                        "ws-api": {
+                            "future": "wss://ws-fapi-mm.binance.com/ws-fapi/v1",
+                        },
+                    }
+                }
+            },
+        )