feat: add orchestrator support and LP history API

- Add SwapExecutor to executor orchestrator registry
- Fix orchestrator exit hang (break vs continue in stop loop)
- Fix position hold edge cases (division by zero, NaN handling)
- Add LP history JSON API via MQTT endpoint
- Add lphistory JSON export for API consumption
- Add simple_xemm_gateway example script

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: fengtality

hummingbot/client/command/lphistory_command.py

@@ -2,7 +2,7 @@
 import time
 from datetime import datetime
 from decimal import Decimal
-from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Tuple
 
 import pandas as pd
 
@@ -69,6 +69,44 @@ def lphistory(self,  # type: HummingbotApplication
 
             safe_ensure_future(self._lp_performance_report(start_time, updates, precision))
 
+    def get_lp_history_json(self,  # type: HummingbotApplication
+                            days: float = 0) -> List[Dict[str, Any]]:
+        """Get LP history as JSON for MQTT/API consumption."""
+        if self.strategy_file_name is None:
+            return []
+        start_time = get_timestamp(days) if days > 0 else self.init_time
+        with self.trading_core.trade_fill_db.get_new_session() as session:
+            updates: List[RangePositionUpdate] = self._get_lp_updates_from_session(
+                int(start_time * 1e3),
+                session=session,
+                config_file_path=self.strategy_file_name
+            )
+            return [self._lp_update_to_json(u) for u in updates]
+
+    @staticmethod
+    def _lp_update_to_json(update: RangePositionUpdate) -> Dict[str, Any]:
+        """Convert a RangePositionUpdate record to JSON format for API."""
+        return {
+            "id": update.hb_id,
+            "timestamp": update.timestamp,
+            "tx_hash": update.tx_hash,
+            "market": update.market,
+            "trading_pair": update.trading_pair,
+            "order_action": update.order_action,
+            "position_address": update.position_address,
+            "lower_price": update.lower_price,
+            "upper_price": update.upper_price,
+            "mid_price": update.mid_price,
+            "base_amount": update.base_amount,
+            "quote_amount": update.quote_amount,
+            "base_fee": update.base_fee,
+            "quote_fee": update.quote_fee,
+            "trade_fee": update.trade_fee,
+            "trade_fee_in_quote": update.trade_fee_in_quote,
+            "position_rent": update.position_rent,
+            "position_rent_refunded": update.position_rent_refunded,
+        }
+
     def _get_lp_updates_from_session(
         self,  # type: HummingbotApplication
         start_timestamp: int,
@@ -243,28 +281,17 @@ async def _report_pair_performance(self,  # type: HummingbotApplication
         closed_position_count = len(closed_positions)
         lines.append(f"Positions Opened: {open_position_count + closed_position_count}  |  Positions Closed: {closed_position_count}")
 
-        # Closed Positions table - grouped by side (buy=quote only, sell=base only, both=double-sided)
-        # Determine side based on ADD amounts: base only=sell, quote only=buy, both=both
-        buy_positions = [(o, c) for o, c in zip(opens, closes) if o.base_amount == 0 or o.base_amount is None]
-        sell_positions = [(o, c) for o, c in zip(opens, closes) if o.quote_amount == 0 or o.quote_amount is None]
-        both_positions = [(o, c) for o, c in zip(opens, closes)
-                          if (o, c) not in buy_positions and (o, c) not in sell_positions]
+        # Closed Positions summary
+        total_volume_base = sum(Decimal(str(o.base_amount or 0)) + Decimal(str(c.base_amount or 0)) for o, c in zip(opens, closes))
+        total_volume_quote = sum(Decimal(str(o.quote_amount or 0)) + Decimal(str(c.quote_amount or 0)) for o, c in zip(opens, closes))
 
-        # Column order matches side values: both(0), buy(1), sell(2)
-        pos_columns = ["", "both", "buy", "sell"]
         pos_data = [
-            [f"{'Number of positions':<27}", len(both_positions), len(buy_positions), len(sell_positions)],
-            [f"{f'Total volume ({base})':<27}",
-             smart_round(sum(Decimal(str(o.base_amount or 0)) + Decimal(str(c.base_amount or 0)) for o, c in both_positions), precision),
-             smart_round(sum(Decimal(str(o.base_amount or 0)) + Decimal(str(c.base_amount or 0)) for o, c in buy_positions), precision),
-             smart_round(sum(Decimal(str(o.base_amount or 0)) + Decimal(str(c.base_amount or 0)) for o, c in sell_positions), precision)],
-            [f"{f'Total volume ({quote})':<27}",
-             smart_round(sum(Decimal(str(o.quote_amount or 0)) + Decimal(str(c.quote_amount or 0)) for o, c in both_positions), precision),
-             smart_round(sum(Decimal(str(o.quote_amount or 0)) + Decimal(str(c.quote_amount or 0)) for o, c in buy_positions), precision),
-             smart_round(sum(Decimal(str(o.quote_amount or 0)) + Decimal(str(c.quote_amount or 0)) for o, c in sell_positions), precision)],
+            ["Number of positions     ", closed_position_count],
+            [f"Total volume ({base})   ", smart_round(total_volume_base, precision)],
+            [f"Total volume ({quote})  ", smart_round(total_volume_quote, precision)],
         ]
-        pos_df = pd.DataFrame(data=pos_data, columns=pos_columns)
-        lines.extend(["", "  Closed Positions:"] + ["    " + line for line in pos_df.to_string(index=False).split("\n")])
+        pos_df = pd.DataFrame(data=pos_data)
+        lines.extend(["", "  Closed Positions:"] + ["    " + line for line in pos_df.to_string(index=False, header=False).split("\n")])
 
         # Assets table
         assets_columns = ["", "add", "remove", "fees"]

hummingbot/remote_iface/messages.py

@@ -107,6 +107,19 @@ class Response(RPCMessage.Response):
         trades: Optional[List[Any]] = []
 
 
+class LPHistoryCommandMessage(RPCMessage):
+    class Request(RPCMessage.Request):
+        days: Optional[float] = 0
+        verbose: Optional[bool] = False
+        precision: Optional[int] = None
+        async_backend: Optional[bool] = True
+
+    class Response(RPCMessage.Response):
+        status: Optional[int] = MQTT_STATUS_CODE.SUCCESS
+        msg: Optional[str] = ''
+        lp_updates: Optional[List[Any]] = []
+
+
 class BalanceLimitCommandMessage(RPCMessage):
     class Request(RPCMessage.Request):
         exchange: str

hummingbot/remote_iface/mqtt.py

@@ -40,6 +40,7 @@
     ImportCommandMessage,
     InternalEventMessage,
     LogMessage,
+    LPHistoryCommandMessage,
     NotifyMessage,
     StartCommandMessage,
     StatusCommandMessage,
@@ -57,6 +58,7 @@ class CommandTopicSpecs:
     IMPORT: str = '/import'
     STATUS: str = '/status'
     HISTORY: str = '/history'
+    LP_HISTORY: str = '/lphistory'
     BALANCE_LIMIT: str = '/balance/limit'
     BALANCE_PAPER: str = '/balance/paper'
 
@@ -95,6 +97,7 @@ def __init__(self,
         self._import_uri = f'{topic_prefix}{TopicSpecs.COMMANDS.IMPORT}'
         self._status_uri = f'{topic_prefix}{TopicSpecs.COMMANDS.STATUS}'
         self._history_uri = f'{topic_prefix}{TopicSpecs.COMMANDS.HISTORY}'
+        self._lp_history_uri = f'{topic_prefix}{TopicSpecs.COMMANDS.LP_HISTORY}'
         self._balance_limit_uri = f'{topic_prefix}{TopicSpecs.COMMANDS.BALANCE_LIMIT}'
         self._balance_paper_uri = f'{topic_prefix}{TopicSpecs.COMMANDS.BALANCE_PAPER}'
 
@@ -131,6 +134,11 @@ def _init_commands(self):
             msg_type=HistoryCommandMessage,
             on_request=self._on_cmd_history
         )
+        self._node.create_rpc(
+            rpc_name=self._lp_history_uri,
+            msg_type=LPHistoryCommandMessage,
+            on_request=self._on_cmd_lp_history
+        )
         self._node.create_rpc(
             rpc_name=self._balance_limit_uri,
             msg_type=BalanceLimitCommandMessage,
@@ -315,6 +323,20 @@ def _on_cmd_history(self, msg: HistoryCommandMessage.Request):
             response.msg = str(e)
         return response
 
+    def _on_cmd_lp_history(self, msg: LPHistoryCommandMessage.Request):
+        response = LPHistoryCommandMessage.Response()
+        try:
+            if msg.async_backend:
+                self._hb_app.lphistory(msg.days, msg.verbose, msg.precision)
+            else:
+                lp_updates = self._hb_app.get_lp_history_json(msg.days)
+                if lp_updates:
+                    response.lp_updates = lp_updates
+        except Exception as e:
+            response.status = MQTT_STATUS_CODE.ERROR
+            response.msg = str(e)
+        return response
+
     def _on_cmd_balance_limit(self, msg: BalanceLimitCommandMessage.Request):
         response = BalanceLimitCommandMessage.Response()
         try:

hummingbot/strategy_v2/executors/data_types.py

@@ -14,7 +14,7 @@
 class ExecutorConfigBase(BaseModel):
     id: str = None  # Make ID optional
     type: Literal["position_executor", "dca_executor", "grid_executor", "order_executor",
-                  "xemm_executor", "arbitrage_executor", "twap_executor", "lp_executor"]
+                  "xemm_executor", "arbitrage_executor", "twap_executor", "lp_executor", "swap_executor"]
     timestamp: Optional[float] = None
     controller_id: str = "main"
 

hummingbot/strategy_v2/executors/executor_orchestrator.py

@@ -20,6 +20,7 @@
 from hummingbot.strategy_v2.executors.lp_executor.lp_executor import LPExecutor
 from hummingbot.strategy_v2.executors.order_executor.order_executor import OrderExecutor
 from hummingbot.strategy_v2.executors.position_executor.position_executor import PositionExecutor
+from hummingbot.strategy_v2.executors.swap_executor.swap_executor import SwapExecutor
 from hummingbot.strategy_v2.executors.twap_executor.twap_executor import TWAPExecutor
 from hummingbot.strategy_v2.executors.xemm_executor.xemm_executor import XEMMExecutor
 from hummingbot.strategy_v2.models.executor_actions import (
@@ -33,7 +34,7 @@
 
 
 class PositionHold:
-    def __init__(self, connector_name: str, trading_pair: str, side: TradeType):
+    def __init__(self, connector_name: str, trading_pair: str, side: TradeType = None):
         self.connector_name = connector_name
         self.trading_pair = trading_pair
         self.side = side
@@ -67,6 +68,7 @@ def add_orders_from_executor(self, executor: ExecutorInfo):
             # Update metrics incrementally
             executed_amount_base = Decimal(str(order.get("executed_amount_base", 0)))
             executed_amount_quote = Decimal(str(order.get("executed_amount_quote", 0)))
+
             is_buy = order.get("trade_type") == "BUY"
 
             # Update volume traded in quote
@@ -80,16 +82,10 @@ def add_orders_from_executor(self, executor: ExecutorInfo):
                 self.sell_amount_base += executed_amount_base
                 self.sell_amount_quote += executed_amount_quote
 
-            # Update fees
+            # Update fees (tx fees paid)
             self.cum_fees_quote += Decimal(str(order.get("cumulative_fee_paid_quote", 0)))
 
     def get_position_summary(self, mid_price: Decimal):
-        # Handle NaN quote amounts by calculating them lazily
-        if self.buy_amount_quote.is_nan() and self.buy_amount_base > 0:
-            self.buy_amount_quote = self.buy_amount_base * mid_price
-        if self.sell_amount_quote.is_nan() and self.sell_amount_base > 0:
-            self.sell_amount_quote = self.sell_amount_base * mid_price
-
         # Calculate buy and sell breakeven prices
         buy_breakeven_price = self.buy_amount_quote / self.buy_amount_base if self.buy_amount_base > 0 else Decimal("0")
         sell_breakeven_price = self.sell_amount_quote / self.sell_amount_base if self.sell_amount_base > 0 else Decimal("0")
@@ -112,13 +108,13 @@ def get_position_summary(self, mid_price: Decimal):
                 # Long position: remaining buy amount
                 remaining_base = net_amount_base
                 remaining_quote = self.buy_amount_quote - (matched_amount_base * buy_breakeven_price)
-                breakeven_price = remaining_quote / remaining_base
+                breakeven_price = remaining_quote / remaining_base if remaining_base != 0 else Decimal("0")
                 unrealized_pnl_quote = (mid_price - breakeven_price) * remaining_base
             else:
                 # Short position: remaining sell amount
                 remaining_base = abs(net_amount_base)
                 remaining_quote = self.sell_amount_quote - (matched_amount_base * sell_breakeven_price)
-                breakeven_price = remaining_quote / remaining_base
+                breakeven_price = remaining_quote / remaining_base if remaining_base != 0 else Decimal("0")
                 unrealized_pnl_quote = (breakeven_price - mid_price) * remaining_base
 
         return PositionSummary(
@@ -147,6 +143,7 @@ class ExecutorOrchestrator:
         "xemm_executor": XEMMExecutor,
         "order_executor": OrderExecutor,
         "lp_executor": LPExecutor,
+        "swap_executor": SwapExecutor,
     }
 
     @classmethod
@@ -255,7 +252,7 @@ def _load_position_from_db(self, controller_id: str, db_position: Position):
     def _create_initial_positions(self):
         """
         Create initial positions from config overrides.
-        Uses NaN for quote amounts initially - they will be calculated lazily when needed.
+        Quote amounts are calculated using current mid_price.
         """
         for controller_id, initial_positions in self.initial_positions_by_controller.items():
             if controller_id not in self.cached_performance:
@@ -264,22 +261,28 @@ def _create_initial_positions(self):
                 self.positions_held[controller_id] = []
 
             for position_config in initial_positions:
+                # Get mid_price for quote amount calculation
+                mid_price = self.strategy.market_data_provider.get_price_by_type(
+                    position_config.connector_name, position_config.trading_pair, PriceType.MidPrice
+                )
+                quote_amount = position_config.amount * mid_price
+
                 # Create PositionHold object
                 position_hold = PositionHold(
                     position_config.connector_name,
                     position_config.trading_pair,
                     position_config.side
                 )
 
-                # Set amounts based on side, using NaN for quote amounts
+                # Set amounts based on side
                 if position_config.side == TradeType.BUY:
                     position_hold.buy_amount_base = position_config.amount
-                    position_hold.buy_amount_quote = Decimal("NaN")  # Will be calculated lazily
+                    position_hold.buy_amount_quote = quote_amount
                     position_hold.sell_amount_base = Decimal("0")
                     position_hold.sell_amount_quote = Decimal("0")
                 else:
                     position_hold.sell_amount_base = position_config.amount
-                    position_hold.sell_amount_quote = Decimal("NaN")  # Will be calculated lazily
+                    position_hold.sell_amount_quote = quote_amount
                     position_hold.buy_amount_base = Decimal("0")
                     position_hold.buy_amount_quote = Decimal("0")
 
@@ -305,7 +308,7 @@ async def stop(self, max_executors_close_attempts: int = 3):
         for i in range(max_executors_close_attempts):
             if all([executor.executor_info.is_done for executors_list in self.active_executors.values()
                     for executor in executors_list]):
-                continue
+                break  # All executors are done, exit early
             await asyncio.sleep(2.0)
         # Store all positions and executors
         self.store_all_positions()
@@ -466,7 +469,7 @@ def _update_positions_from_done_executors(self):
                 if existing_position:
                     existing_position.add_orders_from_executor(executor_info)
                 else:
-                    # Create new position
+                    # Create new position (handles both spot/perp and LP)
                     position = PositionHold(
                         executor_info.connector_name,
                         executor_info.trading_pair,

hummingbot/strategy_v2/models/executors_info.py

@@ -10,12 +10,13 @@
 from hummingbot.strategy_v2.executors.lp_executor.data_types import LPExecutorConfig
 from hummingbot.strategy_v2.executors.order_executor.data_types import OrderExecutorConfig
 from hummingbot.strategy_v2.executors.position_executor.data_types import PositionExecutorConfig
+from hummingbot.strategy_v2.executors.swap_executor.data_types import SwapExecutorConfig
 from hummingbot.strategy_v2.executors.twap_executor.data_types import TWAPExecutorConfig
 from hummingbot.strategy_v2.executors.xemm_executor.data_types import XEMMExecutorConfig
 from hummingbot.strategy_v2.models.base import RunnableStatus
 from hummingbot.strategy_v2.models.executors import CloseType
 
-AnyExecutorConfig = Union[PositionExecutorConfig, DCAExecutorConfig, GridExecutorConfig, XEMMExecutorConfig, ArbitrageExecutorConfig, OrderExecutorConfig, TWAPExecutorConfig, LPExecutorConfig]
+AnyExecutorConfig = Union[PositionExecutorConfig, DCAExecutorConfig, GridExecutorConfig, XEMMExecutorConfig, ArbitrageExecutorConfig, OrderExecutorConfig, TWAPExecutorConfig, LPExecutorConfig, SwapExecutorConfig]
 
 
 class ExecutorInfo(BaseModel):