hummingbot 20260201.dev3__tar.gz → 20260302.dev1__tar.gz

{hummingbot-20260201.dev3/hummingbot.egg-info → hummingbot-20260302.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hummingbot
-Version: 20260201.dev3
+Version: 20260302.dev1
 Summary: Hummingbot
 Home-page: https://github.com/hummingbot/hummingbot
 Author: Hummingbot Foundation
@@ -45,7 +45,7 @@ Requires-Dist: tqdm>=4.67.1
 Requires-Dist: ujson>=5.7.0
 Requires-Dist: urllib3<2.0,>=1.26.15
 Requires-Dist: web3
-Requires-Dist: xrpl-py>=4.1.0
+Requires-Dist: xrpl-py>=4.4.0
 Requires-Dist: PyYaml>=0.2.5
 Dynamic: author
 Dynamic: author-email

{hummingbot-20260201.dev3 → hummingbot-20260302.dev1}/hummingbot/client/command/__init__.py

@@ -13,6 +13,7 @@ from .gateway_token_command import GatewayTokenCommand
 from .help_command import HelpCommand
 from .history_command import HistoryCommand
 from .import_command import ImportCommand
+from .lphistory_command import LPHistoryCommand
 from .mqtt_command import MQTTCommand
 from .order_book_command import OrderBookCommand
 from .rate_command import RateCommand
@@ -38,6 +39,7 @@ __all__ = [
     HelpCommand,
     HistoryCommand,
     ImportCommand,
+    LPHistoryCommand,
     OrderBookCommand,
     RateCommand,
     SillyCommands,

{hummingbot-20260201.dev3 → hummingbot-20260302.dev1}/hummingbot/client/command/command_utils.py

@@ -33,7 +33,7 @@ class GatewayCommandUtils:
         pending_msg_delay: float = 3.0
     ) -> Dict[str, Any]:
         """
-        Monitor a transaction until completion or timeout.
+        Monitor a transaction until completion or timeout by polling order status.
 
         :param app: HummingbotApplication instance (for notify method)
         :param connector: GatewayBase connector instance
@@ -48,31 +48,22 @@ class GatewayCommandUtils:
         hardware_wallet_msg_shown = False
 
         while elapsed < timeout:
+            # Directly update order status for temporary connectors (not on clock)
+            tracked_orders = connector.gateway_orders
+            if tracked_orders:
+                await connector.update_order_status(tracked_orders)
+
             order = connector.get_order(order_id)
 
             # Check if transaction is complete (success, failed, or cancelled)
             if order and order.is_done:
-                # Re-fetch the order to get the latest state
-                order = connector.get_order(order_id)
-
-                # Special case: if is_done but state is PENDING_CREATE, treat as success
-                # This occurs when the transaction is confirmed immediately after submission
-                is_pending_create = (
-                    order and
-                    hasattr(order, 'current_state') and
-                    str(order.current_state) == "OrderState.PENDING_CREATE"
-                )
-                # Special case: for approval transactions, PENDING_APPROVAL with confirmed tx is success
-                is_pending_approval = (
-                    order and
-                    hasattr(order, 'current_state') and
-                    str(order.current_state) == "OrderState.PENDING_APPROVAL" and
-                    order.exchange_order_id  # Transaction hash exists (confirmed on-chain)
-                )
+                # For LP operations (RANGE orders), is_done=True with state=OPEN means success
+                # For swap orders, check is_filled
+                is_success = order.is_filled or (not order.is_failure and not order.is_cancelled)
 
                 result = {
                     "completed": True,
-                    "success": order.is_filled or is_pending_create or is_pending_approval if order else False,
+                    "success": is_success,
                     "failed": order.is_failure if order else False,
                     "cancelled": order.is_cancelled if order else False,
                     "order": order,
@@ -80,24 +71,20 @@ class GatewayCommandUtils:
                 }
 
                 # Show appropriate message
-                if order and (order.is_filled or is_pending_create or is_pending_approval):
+                if is_success:
                     app.notify("\n✓ Transaction completed successfully!")
                     if order.exchange_order_id:
                         app.notify(f"Transaction hash: {order.exchange_order_id}")
-                elif order and order.is_failure:
+                elif order.is_failure:
                     app.notify("\n✗ Transaction failed")
-                elif order and order.is_cancelled:
+                elif order.is_cancelled:
                     app.notify("\n✗ Transaction cancelled")
-                else:
-                    # Log the actual order state for debugging
-                    state = order.current_state if order else "No order"
-                    app.notify(f"\n⚠ Transaction completed with state: {state}")
 
                 return result
 
-            # Special handling for PENDING_CREATE state
+            # Special handling for PENDING_CREATE state (hardware wallet approval)
             if order and hasattr(order, 'current_state') and str(order.current_state) == "OrderState.PENDING_CREATE":
-                if elapsed > 10 and not hardware_wallet_msg_shown:  # After 10 seconds, provide more guidance
+                if elapsed > 10 and not hardware_wallet_msg_shown:
                     app.notify("If using a hardware wallet, please approve the transaction on your device.")
                     hardware_wallet_msg_shown = True
 
@@ -124,6 +111,35 @@ class GatewayCommandUtils:
 
         return result
 
+    @staticmethod
+    def handle_transaction_result(
+        app: Any,
+        result: Dict[str, Any],
+        success_msg: str = "Transaction completed successfully!",
+        failure_msg: str = "Transaction failed. Please try again.",
+        timeout_msg: str = "Transaction timed out. Check your wallet for status."
+    ) -> bool:
+        """
+        Handle transaction result and show appropriate message.
+
+        :param app: HummingbotApplication instance (for notify method)
+        :param result: Result dict from monitor_transaction_with_timeout
+        :param success_msg: Message to show on success
+        :param failure_msg: Message to show on failure
+        :param timeout_msg: Message to show on timeout
+        :return: True if successful, False otherwise
+        """
+        if result.get("completed") and result.get("success"):
+            app.notify(f"\n✓ {success_msg}")
+            return True
+        elif result.get("failed") or (result.get("completed") and not result.get("success")):
+            app.notify(f"\n✗ {failure_msg}")
+            return False
+        elif result.get("timeout"):
+            app.notify(f"\n⚠️  {timeout_msg}")
+            return False
+        return False
+
     @staticmethod
     def format_address_display(address: str) -> str:
         """

{hummingbot-20260201.dev3 → hummingbot-20260302.dev1}/hummingbot/client/command/exit_command.py

@@ -4,6 +4,7 @@ import asyncio
 from typing import TYPE_CHECKING
 
 from hummingbot.core.utils.async_utils import safe_ensure_future
+from hummingbot.strategy.strategy_v2_base import StrategyV2Base
 
 if TYPE_CHECKING:
     from hummingbot.client.hummingbot_application import HummingbotApplication  # noqa: F401
@@ -16,8 +17,12 @@ class ExitCommand:
 
     async def exit_loop(self,  # type: HummingbotApplication
                         force: bool = False):
-        if self.trading_core.strategy_task is not None and not self.trading_core.strategy_task.cancelled():
-            self.trading_core.strategy_task.cancel()
+        # Stop strategy FIRST to prevent new orders during shutdown
+        if self.trading_core.strategy and isinstance(self.trading_core.strategy, StrategyV2Base):
+            await self.trading_core.strategy.on_stop()
+        if self.trading_core._strategy_running:
+            await self.trading_core.stop_strategy()
+
         if force is False:
             success = await self.trading_core.cancel_outstanding_orders()
             if not success:
@@ -28,6 +33,10 @@ class ExitCommand:
             # Freeze screen 1 second for better UI
             await asyncio.sleep(1)
 
+        # Stop clock to halt all remaining ticks
+        if self.trading_core._is_running:
+            await self.trading_core.stop_clock()
+
         if self.trading_core.gateway_monitor is not None:
             self.trading_core.gateway_monitor.stop_monitor()
 

{hummingbot-20260201.dev3 → hummingbot-20260302.dev1}/hummingbot/client/command/gateway_approve_command.py

@@ -189,11 +189,11 @@ class GatewayApproveCommand:
                     pending_msg_delay=3.0
                 )
 
-                # Add token-specific success/failure message
-                if result["completed"] and result["success"]:
-                    self.notify(f"✓ Token {token} is approved for spending on {connector}")
-                elif result["completed"] and not result["success"]:
-                    self.notify(f"✗ Token {token} approval failed. Please check your transaction.")
+                GatewayCommandUtils.handle_transaction_result(
+                    self, result,
+                    success_msg=f"Token {token} is approved for spending on {connector}",
+                    failure_msg=f"Token {token} approval failed. Please try again."
+                )
 
             finally:
                 await GatewayCommandUtils.exit_interactive_mode(self)

{hummingbot-20260201.dev3 → hummingbot-20260302.dev1}/hummingbot/client/command/gateway_lp_command.py

@@ -551,13 +551,16 @@ class GatewayLPCommand:
                     prompt=f"Amount of {quote_token} (optional): "
                 )
 
-                # Parse amounts
+                # Parse amounts - track whether user explicitly provided each amount
                 base_amount = None
                 quote_amount = None
+                base_provided = False
+                quote_provided = False
 
                 if base_amount_str:
                     try:
                         base_amount = float(base_amount_str)
+                        base_provided = True
                     except ValueError:
                         self.notify("Error: Invalid base token amount")
                         return
@@ -565,6 +568,7 @@ class GatewayLPCommand:
                 if quote_amount_str:
                     try:
                         quote_amount = float(quote_amount_str)
+                        quote_provided = True
                     except ValueError:
                         self.notify("Error: Invalid quote token amount")
                         return
@@ -596,9 +600,12 @@ class GatewayLPCommand:
                         slippage_pct=slippage_pct
                     )
 
-                    # Update amounts based on quote
-                    base_amount = quote_result.get("baseTokenAmount", base_amount)
-                    quote_amount = quote_result.get("quoteTokenAmount", quote_amount)
+                    # Only update amounts that weren't explicitly provided by user
+                    # (respects user entering 0 for single-sided positions)
+                    if not base_provided:
+                        base_amount = quote_result.get("baseTokenAmount", base_amount)
+                    if not quote_provided:
+                        quote_amount = quote_result.get("quoteTokenAmount", quote_amount)
 
                     # Show if position is base or quote limited
                     if quote_result.get("baseLimited"):
@@ -608,12 +615,12 @@ class GatewayLPCommand:
 
                 else:
                     # For AMM, need both amounts for quote
-                    if not base_amount or not quote_amount:
+                    if not base_provided or not quote_provided:
                         # If only one amount provided, calculate the other based on pool ratio
                         pool_ratio = pool_info.base_token_amount / pool_info.quote_token_amount
-                        if base_amount and not quote_amount:
+                        if base_provided and not quote_provided:
                             quote_amount = base_amount / pool_ratio
-                        elif quote_amount and not base_amount:
+                        elif quote_provided and not base_provided:
                             base_amount = quote_amount * pool_ratio
 
                     # Get quote for AMM
@@ -626,9 +633,11 @@ class GatewayLPCommand:
                         slippage_pct=slippage_pct
                     )
 
-                    # Update amounts based on quote
-                    base_amount = quote_result.get("baseTokenAmount", base_amount)
-                    quote_amount = quote_result.get("quoteTokenAmount", quote_amount)
+                    # Only update amounts that weren't explicitly provided by user
+                    if not base_provided:
+                        base_amount = quote_result.get("baseTokenAmount", base_amount)
+                    if not quote_provided:
+                        quote_amount = quote_result.get("quoteTokenAmount", quote_amount)
 
                     # Show if position is base or quote limited
                     if quote_result.get("baseLimited"):
@@ -755,8 +764,11 @@ class GatewayLPCommand:
                     pending_msg_delay=5.0
                 )
 
-                if result["completed"] and result["success"]:
-                    self.notify("\n✓ Liquidity added successfully!")
+                if GatewayCommandUtils.handle_transaction_result(
+                    self, result,
+                    success_msg="Liquidity added successfully!",
+                    failure_msg="Failed to add liquidity. Please try again."
+                ):
                     self.notify(f"Use 'gateway lp {connector} position-info' to view your position")
 
             finally:
@@ -1016,12 +1028,18 @@ class GatewayLPCommand:
                         pending_msg_delay=5.0
                     )
 
-                    if result["completed"] and result["success"]:
-                        if close_position:
-                            self.notify("\n✓ Position closed successfully!")
-                        else:
-                            self.notify(f"\n✓ {percentage}% liquidity removed successfully!")
-                            self.notify(f"Use 'gateway lp {connector} position-info' to view remaining position")
+                    if close_position:
+                        GatewayCommandUtils.handle_transaction_result(
+                            self, result,
+                            success_msg="Position closed successfully!",
+                            failure_msg="Failed to close position. Please try again."
+                        )
+                    elif GatewayCommandUtils.handle_transaction_result(
+                        self, result,
+                        success_msg=f"{percentage}% liquidity removed successfully!",
+                        failure_msg="Failed to remove liquidity. Please try again."
+                    ):
+                        self.notify(f"Use 'gateway lp {connector} position-info' to view remaining position")
 
                 finally:
                     await GatewayCommandUtils.exit_interactive_mode(self)

{hummingbot-20260201.dev3 → hummingbot-20260302.dev1}/hummingbot/client/command/gateway_swap_command.py

@@ -313,13 +313,8 @@ class GatewaySwapCommand:
                 self.notify(f"Order created: {order_id}")
                 self.notify("Monitoring transaction status...")
 
-                # Register the connector temporarily so events can be processed
-                # This allows MarketsRecorder to capture order events if it's running
-                if hasattr(self, 'connector_manager') and self.connector_manager:
-                    self.connector_manager.connectors[swap_connector.name] = swap_connector
-
                 # Use the common transaction monitoring helper
-                await GatewayCommandUtils.monitor_transaction_with_timeout(
+                result = await GatewayCommandUtils.monitor_transaction_with_timeout(
                     app=self,
                     connector=swap_connector,
                     order_id=order_id,
@@ -328,6 +323,12 @@ class GatewaySwapCommand:
                     pending_msg_delay=3.0
                 )
 
+                GatewayCommandUtils.handle_transaction_result(
+                    self, result,
+                    success_msg="Swap completed successfully!",
+                    failure_msg="Swap failed. Please try again."
+                )
+
                 # Clean up - remove temporary connector and stop network
                 if hasattr(self, 'connector_manager') and self.connector_manager:
                     self.connector_manager.connectors.pop(swap_connector.name, None)

hummingbot-20260302.dev1/hummingbot/client/command/lphistory_command.py

@@ -0,0 +1,303 @@
+import threading
+import time
+from datetime import datetime
+from decimal import Decimal
+from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple
+
+import pandas as pd
+
+from hummingbot.core.rate_oracle.rate_oracle import RateOracle
+from hummingbot.core.utils.async_utils import safe_ensure_future
+from hummingbot.model.range_position_update import RangePositionUpdate
+
+if TYPE_CHECKING:
+    from hummingbot.client.hummingbot_application import HummingbotApplication  # noqa: F401
+
+
+def get_timestamp(days_ago: float = 0.) -> float:
+    return time.time() - (60. * 60. * 24. * days_ago)
+
+
+def smart_round(value: Decimal, precision: Optional[int] = None) -> str:
+    """Round decimal value smartly for display."""
+    if precision is not None:
+        return f"{float(value):.{precision}f}"
+    # Auto precision based on magnitude
+    abs_val = abs(float(value))
+    if abs_val == 0:
+        return "0"
+    elif abs_val >= 1000:
+        return f"{float(value):.2f}"
+    elif abs_val >= 1:
+        return f"{float(value):.4f}"
+    else:
+        return f"{float(value):.6f}"
+
+
+class LPHistoryCommand:
+    def lphistory(self,  # type: HummingbotApplication
+                  days: float = 0,
+                  verbose: bool = False,
+                  precision: Optional[int] = None
+                  ):
+        """
+        Display LP position history and performance metrics.
+        Works with any LP strategy that writes RangePositionUpdate records.
+        """
+        if threading.current_thread() != threading.main_thread():
+            self.ev_loop.call_soon_threadsafe(self.lphistory, days, verbose, precision)
+            return
+
+        if self.strategy_file_name is None:
+            self.notify("\n  Please first import a strategy config file of which to show LP history.")
+            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
+            )
+            if not updates:
+                self.notify("\n  No LP position updates to report.")
+                return
+
+            if verbose:
+                self._list_lp_updates(updates)
+
+            safe_ensure_future(self._lp_performance_report(start_time, updates, precision))
+
+    def _get_lp_updates_from_session(
+        self,  # type: HummingbotApplication
+        start_timestamp: int,
+        session,
+        config_file_path: str = None
+    ) -> List[RangePositionUpdate]:
+        """Query RangePositionUpdate records from database."""
+        query = session.query(RangePositionUpdate).filter(
+            RangePositionUpdate.timestamp >= start_timestamp
+        )
+        if config_file_path:
+            query = query.filter(RangePositionUpdate.config_file_path == config_file_path)
+        return query.order_by(RangePositionUpdate.timestamp).all()
+
+    def _list_lp_updates(self,  # type: HummingbotApplication
+                         updates: List[RangePositionUpdate]):
+        """Display list of LP updates in a table."""
+        lines = []
+
+        if len(updates) > 0:
+            data = []
+            for u in updates:
+                # Parse timestamp (stored in milliseconds)
+                ts = datetime.fromtimestamp(u.timestamp / 1000).strftime('%Y-%m-%d %H:%M:%S')
+                data.append({
+                    "Time": ts,
+                    "Action": u.order_action or "",
+                    "Pair": u.trading_pair or "",
+                    "Position": (u.position_address[:8] + "...") if u.position_address else "",
+                    "Base Amt": f"{u.base_amount:.4f}" if u.base_amount else "0",
+                    "Quote Amt": f"{u.quote_amount:.4f}" if u.quote_amount else "0",
+                    "Base Fee": f"{u.base_fee:.6f}" if u.base_fee else "-",
+                    "Quote Fee": f"{u.quote_fee:.6f}" if u.quote_fee else "-",
+                    "Tx Fee": f"{u.trade_fee_in_quote:.6f}" if u.trade_fee_in_quote else "-",
+                })
+            df = pd.DataFrame(data)
+            lines.extend(["", "  LP Position Updates:"] +
+                         ["    " + line for line in df.to_string(index=False).split("\n")])
+        else:
+            lines.extend(["\n  No LP position updates in this session."])
+
+        self.notify("\n".join(lines))
+
+    async def _get_current_price(self, trading_pair: str) -> Decimal:  # type: HummingbotApplication
+        """Get current price from RateOracle (same as history command)."""
+        try:
+            price = await RateOracle.get_instance().stored_or_live_rate(trading_pair)
+            if price is not None:
+                return Decimal(str(price))
+        except Exception:
+            pass
+        return Decimal("0")
+
+    async def _lp_performance_report(self,  # type: HummingbotApplication
+                                     start_time: float,
+                                     updates: List[RangePositionUpdate],
+                                     precision: Optional[int] = None):
+        """Calculate and display LP performance metrics."""
+        lines = []
+        current_time = get_timestamp()
+
+        # Header
+        lines.extend([
+            f"\nStart Time: {datetime.fromtimestamp(start_time).strftime('%Y-%m-%d %H:%M:%S')}",
+            f"Current Time: {datetime.fromtimestamp(current_time).strftime('%Y-%m-%d %H:%M:%S')}",
+            f"Duration: {pd.Timedelta(seconds=int(current_time - start_time))}"
+        ])
+
+        # Group by (market, trading_pair) like history command
+        market_info: Set[Tuple[str, str]] = set((u.market or "unknown", u.trading_pair or "UNKNOWN") for u in updates)
+
+        # Report for each market/trading pair
+        for market, trading_pair in market_info:
+            pair_updates = [u for u in updates if u.market == market and u.trading_pair == trading_pair]
+            await self._report_pair_performance(lines, market, trading_pair, pair_updates, precision)
+
+        self.notify("\n".join(lines))
+
+    async def _report_pair_performance(self,  # type: HummingbotApplication
+                                       lines: List[str],
+                                       market: str,
+                                       trading_pair: str,
+                                       updates: List[RangePositionUpdate],
+                                       precision: Optional[int] = None):
+        """Calculate and format performance for a single trading pair (closed positions only)."""
+        # Group updates by position_address
+        positions: Dict[str, Dict[str, RangePositionUpdate]] = {}
+        for u in updates:
+            addr = u.position_address or "unknown"
+            if addr not in positions:
+                positions[addr] = {}
+            positions[addr][u.order_action] = u
+
+        # Only include closed positions (those with both ADD and REMOVE)
+        closed_positions = {addr: pos for addr, pos in positions.items()
+                            if "ADD" in pos and "REMOVE" in pos}
+
+        if not closed_positions:
+            lines.append(f"\n{market} / {trading_pair}")
+            lines.append("\n  No closed positions to report.")
+            return
+
+        # Extract opens and closes from closed positions only
+        opens = [pos["ADD"] for pos in closed_positions.values()]
+        closes = [pos["REMOVE"] for pos in closed_positions.values()]
+
+        # Parse tokens from trading pair
+        parts = trading_pair.split("-")
+        base = parts[0] if len(parts) >= 2 else "BASE"
+        quote = parts[1] if len(parts) >= 2 else "QUOTE"
+
+        # Get current price - try live first, fall back to most recent close
+        current_price = await self._get_current_price(trading_pair)
+        if current_price == 0:
+            for u in reversed(closes):
+                if u.mid_price:
+                    current_price = Decimal(str(u.mid_price))
+                    break
+
+        # Calculate totals for opens
+        total_open_base = sum(Decimal(str(u.base_amount or 0)) for u in opens)
+        total_open_quote = sum(Decimal(str(u.quote_amount or 0)) for u in opens)
+
+        # Calculate totals for closes
+        total_close_base = sum(Decimal(str(u.base_amount or 0)) for u in closes)
+        total_close_quote = sum(Decimal(str(u.quote_amount or 0)) for u in closes)
+
+        # Calculate total fees collected
+        total_fees_base = sum(Decimal(str(u.base_fee or 0)) for u in closes)
+        total_fees_quote = sum(Decimal(str(u.quote_fee or 0)) for u in closes)
+
+        # Calculate total rent
+        total_position_rent = sum(Decimal(str(u.position_rent or 0)) for u in opens)
+        total_position_rent_refunded = sum(Decimal(str(u.position_rent_refunded or 0)) for u in closes)
+        net_rent = total_position_rent - total_position_rent_refunded
+
+        # Calculate total transaction fees (from both ADD and REMOVE operations)
+        total_tx_fees = sum(Decimal(str(u.trade_fee_in_quote or 0)) for u in opens)
+        total_tx_fees += sum(Decimal(str(u.trade_fee_in_quote or 0)) for u in closes)
+
+        # Calculate values using stored mid_price from each transaction (for accurate realized P&L)
+        # Each ADD valued at its mid_price, each REMOVE valued at its mid_price
+        total_open_value = Decimal("0")
+        for u in opens:
+            mid_price = Decimal(str(u.mid_price)) if u.mid_price else current_price
+            base_amt = Decimal(str(u.base_amount or 0))
+            quote_amt = Decimal(str(u.quote_amount or 0))
+            total_open_value += base_amt * mid_price + quote_amt
+
+        total_close_value = Decimal("0")
+        total_fees_value = Decimal("0")
+        for u in closes:
+            mid_price = Decimal(str(u.mid_price)) if u.mid_price else current_price
+            base_amt = Decimal(str(u.base_amount or 0))
+            quote_amt = Decimal(str(u.quote_amount or 0))
+            base_fee = Decimal(str(u.base_fee or 0))
+            quote_fee = Decimal(str(u.quote_fee or 0))
+            total_close_value += base_amt * mid_price + quote_amt
+            total_fees_value += base_fee * mid_price + quote_fee
+
+        # P&L calculation (including transaction fees)
+        total_returned = total_close_value + total_fees_value
+        gross_pnl = total_returned - total_open_value if total_open_value > 0 else Decimal("0")
+        net_pnl = gross_pnl - total_tx_fees
+        position_roi_pct = (net_pnl / total_open_value * 100) if total_open_value > 0 else Decimal("0")
+
+        # Header with market info
+        lines.append(f"\n{market} / {trading_pair}")
+
+        # Count open and closed positions
+        open_position_count = len([addr for addr, pos in positions.items() if "ADD" in pos and "REMOVE" not in pos])
+        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]
+
+        # 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)],
+        ]
+        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")])
+
+        # Assets table
+        assets_columns = ["", "add", "remove", "fees"]
+        assets_data = [
+            [f"{base:<17}",
+             smart_round(total_open_base, precision),
+             smart_round(total_close_base, precision),
+             smart_round(total_fees_base, precision)],
+            [f"{quote:<17}",
+             smart_round(total_open_quote, precision),
+             smart_round(total_close_quote, precision),
+             smart_round(total_fees_quote, precision)],
+        ]
+        assets_df = pd.DataFrame(data=assets_data, columns=assets_columns)
+        lines.extend(["", "  Assets:"] + ["    " + line for line in assets_df.to_string(index=False).split("\n")])
+
+        # Performance table
+        perf_data = [
+            ["Total add value         ", f"{smart_round(total_open_value, precision)} {quote}"],
+            ["Total remove value      ", f"{smart_round(total_close_value, precision)} {quote}"],
+            ["Fees collected          ", f"{smart_round(total_fees_value, precision)} {quote}"],
+            ["Transaction fees        ", f"{smart_round(total_tx_fees, precision)} {quote}"],
+        ]
+        if net_rent != 0:
+            perf_data.append(["Rent paid (net)         ", f"{smart_round(net_rent, precision)} SOL"])
+        perf_data.extend([
+            ["Net P&L                 ", f"{smart_round(net_pnl, precision)} {quote}"],
+            ["Return %                ", f"{float(position_roi_pct):.2f}%"],
+        ])
+        perf_df = pd.DataFrame(data=perf_data)
+        lines.extend(["", "  Performance:"] +
+                     ["    " + line for line in perf_df.to_string(index=False, header=False).split("\n")])
+
+        # Note about open positions
+        if open_position_count > 0:
+            lines.append(f"\n  Note: {open_position_count} position(s) still open. P&L excludes unrealized gains/losses.")

{hummingbot-20260201.dev3 → hummingbot-20260302.dev1}/hummingbot/client/ui/parser.py

@@ -91,6 +91,15 @@ def load_parser(hummingbot: "HummingbotApplication", command_tabs) -> ThrowingAr
                                 dest="precision", help="Level of precions for values displayed")
     history_parser.set_defaults(func=hummingbot.history)
 
+    lphistory_parser = subparsers.add_parser("lphistory", help="See LP position history and performance")
+    lphistory_parser.add_argument("-d", "--days", type=float, default=0, dest="days",
+                                  help="How many days in the past (can be decimal value)")
+    lphistory_parser.add_argument("-v", "--verbose", action="store_true", default=False,
+                                  dest="verbose", help="List all LP position updates")
+    lphistory_parser.add_argument("-p", "--precision", default=None, type=int,
+                                  dest="precision", help="Level of precision for values displayed")
+    lphistory_parser.set_defaults(func=hummingbot.lphistory)
+
     gateway_parser = subparsers.add_parser("gateway", help="Helper commands for Gateway server.")
     gateway_parser.set_defaults(func=hummingbot.gateway)
     gateway_subparsers = gateway_parser.add_subparsers()