Add use_uuid_client_order_ids config option

Author: cjdsellers

RELEASES.md

@@ -4,8 +4,9 @@ Released on 16th March 2025 (UTC).
 
 ### Enhancements
 - Added `CryptoOption` instrument, supporting inverse and fractional sizes
-- Added catalog consolidation functions of several parquet files into one (#2421), thanks @faysou
 - Added `Cache.prices(...)` to return a map of latest price per instrument for a price type
+- Added `use_uuid_client_order_ids` config option for `StrategyConfig`
+- Added catalog consolidation functions of several parquet files into one (#2421), thanks @faysou
 - Added FDUSD (First Digital USD) crypto `Currency` constant
 - Added initial leverage, `margin_mode` and `position_mode` config options for Bybit (#2441), thanks @sunlei
 - Updated parquet catalog in Rust with recent features (#2442), thanks @faysou

nautilus_trader/common/factories.pxd

@@ -57,6 +57,8 @@ cdef class OrderFactory:
     """The order factories trader ID.\n\n:returns: `TraderId`"""
     cdef readonly StrategyId strategy_id
     """The order factories trading strategy ID.\n\n:returns: `StrategyId`"""
+    cdef readonly bint use_uuid_client_order_ids
+    """If UUID4's should be used for client order ID values.\n\n:returns: `bool`"""
 
     cpdef void set_client_order_id_count(self, int count)
     cpdef void set_order_list_id_count(self, int count)

nautilus_trader/common/factories.pyx

@@ -63,17 +63,9 @@ cdef class OrderFactory:
         The clock for the factory.
     cache : CacheFacade, optional
         The cache facade for the order factory.
-    initial_order_id_count : int, optional
-        The initial order ID count for the factory.
-    initial_order_list_id_count : int, optional
-        The initial order list ID count for the factory.
-
-    Raises
-    ------
-    ValueError
-        If `initial_order_id_count` is negative (< 0).
-    ValueError
-        If `initial_order_list_id_count` is negative (< 0).
+    use_uuid_client_order_ids : bool, default False
+        If UUID4's should be used for client order ID values.
+
     """
 
     def __init__(
@@ -82,25 +74,23 @@ cdef class OrderFactory:
         StrategyId strategy_id not None,
         Clock clock not None,
         CacheFacade cache: CacheFacade | None = None,
-        int initial_order_id_count=0,
-        int initial_order_list_id_count=0,
-    ):
+        bint use_uuid_client_order_ids = False,
+    ) -> None:
         self._clock = clock
         self._cache = cache
         self.trader_id = trader_id
         self.strategy_id = strategy_id
+        self.use_uuid_client_order_ids = use_uuid_client_order_ids
 
         self._order_id_generator = ClientOrderIdGenerator(
             trader_id=trader_id,
             strategy_id=strategy_id,
             clock=clock,
-            initial_count=initial_order_id_count,
         )
         self._order_list_id_generator = OrderListIdGenerator(
             trader_id=trader_id,
             strategy_id=strategy_id,
             clock=clock,
-            initial_count=initial_order_list_id_count,
         )
 
     cpdef void set_client_order_id_count(self, int count):
@@ -146,7 +136,11 @@ cdef class OrderFactory:
         ClientOrderId
 
         """
+        if self.use_uuid_client_order_ids:
+            return ClientOrderId(UUID4().value)
+
         cdef ClientOrderId client_order_id = self._order_id_generator.generate()
+
         if self._cache is not None:
             while self._cache.order(client_order_id) is not None:
                 client_order_id = self._order_id_generator.generate()
@@ -263,7 +257,7 @@ cdef class OrderFactory:
 
         """
         if client_order_id is None:
-            client_order_id = self._order_id_generator.generate()
+            client_order_id = self.generate_client_order_id()
         return MarketOrder(
             trader_id=self.trader_id,
             strategy_id=self.strategy_id,
@@ -362,7 +356,7 @@ cdef class OrderFactory:
 
         """
         if client_order_id is None:
-            client_order_id = self._order_id_generator.generate()
+            client_order_id = self.generate_client_order_id()
         return LimitOrder(
             trader_id=self.trader_id,
             strategy_id=self.strategy_id,
@@ -466,7 +460,7 @@ cdef class OrderFactory:
 
         """
         if client_order_id is None:
-            client_order_id = self._order_id_generator.generate()
+            client_order_id = self.generate_client_order_id()
         return StopMarketOrder(
             trader_id=self.trader_id,
             strategy_id=self.strategy_id,
@@ -580,7 +574,7 @@ cdef class OrderFactory:
 
         """
         if client_order_id is None:
-            client_order_id = self._order_id_generator.generate()
+            client_order_id = self.generate_client_order_id()
         return StopLimitOrder(
             trader_id=self.trader_id,
             strategy_id=self.strategy_id,
@@ -670,7 +664,7 @@ cdef class OrderFactory:
 
         """
         if client_order_id is None:
-            client_order_id = self._order_id_generator.generate()
+            client_order_id = self.generate_client_order_id()
         return MarketToLimitOrder(
             trader_id=self.trader_id,
             strategy_id=self.strategy_id,
@@ -769,7 +763,7 @@ cdef class OrderFactory:
 
         """
         if client_order_id is None:
-            client_order_id = self._order_id_generator.generate()
+            client_order_id = self.generate_client_order_id()
         return MarketIfTouchedOrder(
             trader_id=self.trader_id,
             strategy_id=self.strategy_id,
@@ -883,7 +877,7 @@ cdef class OrderFactory:
 
         """
         if client_order_id is None:
-            client_order_id = self._order_id_generator.generate()
+            client_order_id = self.generate_client_order_id()
         return LimitIfTouchedOrder(
             trader_id=self.trader_id,
             strategy_id=self.strategy_id,
@@ -996,7 +990,7 @@ cdef class OrderFactory:
 
         """
         if client_order_id is None:
-            client_order_id = self._order_id_generator.generate()
+            client_order_id = self.generate_client_order_id()
         return TrailingStopMarketOrder(
             trader_id=self.trader_id,
             strategy_id=self.strategy_id,
@@ -1125,7 +1119,7 @@ cdef class OrderFactory:
 
         """
         if client_order_id is None:
-            client_order_id = self._order_id_generator.generate()
+            client_order_id = self.generate_client_order_id()
         return TrailingStopLimitOrder(
             trader_id=self.trader_id,
             strategy_id=self.strategy_id,
@@ -1284,11 +1278,11 @@ cdef class OrderFactory:
         cdef OrderListId order_list_id = self._order_list_id_generator.generate()
 
         if entry_client_order_id is None:
-            entry_client_order_id = self._order_id_generator.generate()
+            entry_client_order_id = self.generate_client_order_id()
         if sl_client_order_id is None:
-            sl_client_order_id = self._order_id_generator.generate()
+            sl_client_order_id = self.generate_client_order_id()
         if tp_client_order_id is None:
-            tp_client_order_id = self._order_id_generator.generate()
+            tp_client_order_id = self.generate_client_order_id()
 
         ########################################################################
         # ENTRY ORDER

nautilus_trader/trading/config.py

@@ -39,6 +39,8 @@ class StrategyConfig(NautilusConfig, kw_only=True, frozen=True):
     order_id_tag : str, optional
         The unique order ID tag for the strategy. Must be unique
         amongst all running strategies for a particular trader ID.
+    use_uuid_client_order_ids : bool, default False
+        If UUID4's should be used for client order ID values.
     oms_type : OmsType, optional
         The order management system type for the strategy. This will determine
         how the `ExecutionEngine` handles position IDs.
@@ -61,6 +63,7 @@ class StrategyConfig(NautilusConfig, kw_only=True, frozen=True):
 
     strategy_id: StrategyId | None = None
     order_id_tag: str | None = None
+    use_uuid_client_order_ids: bool = False
     oms_type: str | None = None
     external_order_claims: list[InstrumentId] | None = None
     manage_contingent_orders: bool = False

nautilus_trader/trading/strategy.pxd

@@ -67,6 +67,8 @@ cdef class Strategy(Actor):
     """The order factory for the strategy.\n\n:returns: `OrderFactory`"""
     cdef readonly str order_id_tag
     """The order ID tag for the strategy.\n\n:returns: `str`"""
+    cdef readonly bint use_uuid_client_order_ids
+    """If UUID4's should be used for client order ID values.\n\n:returns: `bool`"""
     cdef readonly OmsType oms_type
     """The order management system for the strategy.\n\n:returns: `OmsType`"""
     cdef readonly list external_order_claims

nautilus_trader/trading/strategy.pyx

@@ -144,6 +144,7 @@ cdef class Strategy(Actor):
         component_id = type(self).__name__ if config.strategy_id is None else config.strategy_id
         self.id = StrategyId(f"{component_id}-{config.order_id_tag}")
         self.order_id_tag = str(config.order_id_tag)
+        self.use_uuid_client_order_ids = config.use_uuid_client_order_ids
         self._log = Logger(name=component_id)
 
         oms_type = config.oms_type or OmsType.UNSPECIFIED
@@ -287,6 +288,7 @@ cdef class Strategy(Actor):
             strategy_id=self.id,
             clock=clock,
             cache=cache,
+            use_uuid_client_order_ids=self.use_uuid_client_order_ids
         )
 
         self._manager = OrderManager(

tests/unit_tests/common/test_factories.py

@@ -46,6 +46,22 @@ def test_generate_client_order_id(self):
         # Assert
         assert result == ClientOrderId("O-19700101-000000-000-001-1")
 
+    def test_generate_uuid_client_order_id(self):
+        # Arrange
+        order_factory = OrderFactory(
+            trader_id=self.trader_id,
+            strategy_id=self.strategy_id,
+            clock=TestClock(),
+            use_uuid_client_order_ids=True,
+        )
+
+        # Act
+        result = order_factory.generate_client_order_id()
+
+        # Assert
+        assert order_factory.use_uuid_client_order_ids
+        assert len(result.value) == 36
+
     def test_generate_order_list_id(self):
         # Arrange, Act
         result = self.order_factory.generate_order_list_id()

tests/unit_tests/trading/test_strategy.py

@@ -190,6 +190,7 @@ def test_strategy_to_importable_config_with_no_specific_config(self) -> None:
         assert result.config == {
             "strategy_id": None,
             "order_id_tag": None,
+            "use_uuid_client_order_ids": False,
             "oms_type": None,
             "external_order_claims": None,
             "manage_contingent_orders": False,
@@ -219,9 +220,10 @@ def test_strategy_to_importable_config(self) -> None:
         assert result.strategy_path == "nautilus_trader.trading.strategy:Strategy"
         assert result.config_path == "nautilus_trader.trading.config:StrategyConfig"
         assert result.config == {
-            "oms_type": None,
-            "order_id_tag": "001",
             "strategy_id": "ALPHA-01",
+            "order_id_tag": "001",
+            "use_uuid_client_order_ids": False,
+            "oms_type": None,
             "external_order_claims": ["ETHUSDT-PERP.DYDX"],
             "manage_contingent_orders": True,
             "manage_gtd_expiry": True,