hummingbot 20260201.dev2__tar.gz → 20260302.dev1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hummingbot
-Version: 20260201.dev2
+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.dev2 → hummingbot-20260302.dev1}/bin/hummingbot_quickstart.py

@@ -26,12 +26,7 @@ from hummingbot.client.config.config_helpers import (
 )
 from hummingbot.client.config.security import Security
 from hummingbot.client.hummingbot_application import HummingbotApplication
-from hummingbot.client.settings import (
-    SCRIPT_STRATEGIES_PATH,
-    SCRIPT_STRATEGY_CONF_DIR_PATH,
-    STRATEGIES_CONF_DIR_PATH,
-    AllConnectorSettings,
-)
+from hummingbot.client.settings import SCRIPT_STRATEGY_CONF_DIR_PATH, STRATEGIES_CONF_DIR_PATH, AllConnectorSettings
 from hummingbot.client.ui import login_prompt
 from hummingbot.client.ui.style import load_style
 from hummingbot.core.event.events import HummingbotUIEvent
@@ -46,10 +41,11 @@ class CmdlineParser(argparse.ArgumentParser):
                           type=str,
                           required=False,
                           help="Specify a file in `conf/` to load as the strategy config file.")
-        self.add_argument("--script-conf", "-c",
+        self.add_argument("--v2",
                           type=str,
                           required=False,
-                          help="Specify a file in `conf/scripts` to configure a script strategy.")
+                          dest="v2_conf",
+                          help="V2 strategy config file name (from conf/scripts/).")
         self.add_argument("--config-password", "-p",
                           type=str,
                           required=False,
@@ -114,7 +110,7 @@ async def quick_start(args: argparse.Namespace, secrets_manager: BaseSecretsMana
     hb = HummingbotApplication.main_application(client_config_map=client_config_map, headless_mode=args.headless)
 
     # Load and start strategy if provided
-    if args.config_file_name is not None:
+    if args.v2_conf is not None or args.config_file_name is not None:
         success = await load_and_start_strategy(hb, args)
         if not success:
             logging.getLogger().error("Failed to load strategy. Exiting.")
@@ -146,44 +142,42 @@ async def wait_for_gateway_ready(hb):
 
 async def load_and_start_strategy(hb: HummingbotApplication, args: argparse.Namespace,):
     """Load and start strategy based on file type and mode."""
-    if args.config_file_name.endswith(".py"):
-        # Script strategy
-        strategy_name = args.config_file_name.replace(".py", "")
-        strategy_config_file = args.script_conf  # Optional config file for script
-
-        # Validate that the script file exists
-        script_file_path = SCRIPT_STRATEGIES_PATH / args.config_file_name
-        if not script_file_path.exists():
-            logging.getLogger().error(f"Script file not found: {script_file_path}")
+    import yaml
+
+    if args.v2_conf:
+        # V2 config-driven start: derive script from config file
+        conf_path = SCRIPT_STRATEGY_CONF_DIR_PATH / args.v2_conf
+        if not conf_path.exists():
+            logging.getLogger().error(f"V2 config file not found: {conf_path}")
             return False
 
-        # Validate that the script config file exists if provided
-        if strategy_config_file:
-            script_config_path = SCRIPT_STRATEGY_CONF_DIR_PATH / strategy_config_file
-            if not script_config_path.exists():
-                logging.getLogger().error(f"Script config file not found: {script_config_path}")
-                return False
+        with open(conf_path) as f:
+            config_data = yaml.safe_load(f) or {}
+        script_file = config_data.get("script_file_name", "")
+        if not script_file:
+            logging.getLogger().error("Config file is missing 'script_file_name' field.")
+            return False
 
-        # Set strategy_file_name to config file if provided, otherwise script file (matching start_command logic)
-        hb.strategy_file_name = strategy_config_file.split(".")[0] if strategy_config_file else strategy_name
-        hb.strategy_name = strategy_name
+        strategy_name = script_file.replace(".py", "")
+        hb.strategy_file_name = args.v2_conf
+        hb.trading_core.strategy_name = strategy_name
 
         if args.headless:
-            logging.getLogger().info(f"Starting script strategy: {strategy_name}")
+            logging.getLogger().info(f"Starting V2 script strategy: {strategy_name}")
             success = await hb.trading_core.start_strategy(
                 strategy_name,
-                strategy_config_file,  # Pass config file path if provided
-                hb.strategy_file_name + (".yml" if strategy_config_file else ".py")  # Full file name for strategy
+                args.v2_conf,
+                args.v2_conf
             )
             if not success:
                 logging.getLogger().error("Failed to start strategy")
                 return False
         else:
-            # UI mode - set properties for UIStartListener
-            if strategy_config_file:
-                hb.script_config = strategy_config_file
-    else:
-        # Regular strategy with YAML config
+            # UI mode - trigger start via listener
+            hb.script_config = args.v2_conf
+
+    elif args.config_file_name is not None:
+        # Regular strategy with YAML config (V1 flow)
         hb.strategy_file_name = args.config_file_name.split(".")[0]  # Remove .yml extension
 
         try:
@@ -239,8 +233,8 @@ async def run_application(hb: HummingbotApplication, args: argparse.Namespace, c
         # Set up UI mode with start listener
         start_listener: UIStartListener = UIStartListener(
             hb,
-            is_script=args.config_file_name.endswith(".py") if args.config_file_name else False,
-            script_config=hb.script_config,
+            is_script=args.v2_conf is not None,
+            script_config=getattr(hb, 'script_config', None),
             is_quickstart=True
         )
         hb.app.add_listener(HummingbotUIEvent.Start, start_listener)
@@ -262,8 +256,8 @@ def main():
     if args.config_file_name is None and len(os.environ.get("CONFIG_FILE_NAME", "")) > 0:
         args.config_file_name = os.environ["CONFIG_FILE_NAME"]
 
-    if args.script_conf is None and len(os.environ.get("SCRIPT_CONFIG", "")) > 0:
-        args.script_conf = os.environ["SCRIPT_CONFIG"]
+    if args.v2_conf is None and len(os.environ.get("SCRIPT_CONFIG", "")) > 0:
+        args.v2_conf = os.environ["SCRIPT_CONFIG"]
 
     if args.config_password is None and len(os.environ.get("CONFIG_PASSWORD", "")) > 0:
         args.config_password = os.environ["CONFIG_PASSWORD"]

{hummingbot-20260201.dev2 → 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.dev2 → hummingbot-20260302.dev1}/hummingbot/client/command/lphistory_command.py

@@ -102,6 +102,7 @@ class LPHistoryCommand:
                     "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:"] +
@@ -204,20 +205,35 @@ class LPHistoryCommand:
         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 values using current price
-        if current_price > 0:
-            total_open_value = total_open_base * current_price + total_open_quote
-            total_close_value = total_close_base * current_price + total_close_quote
-            total_fees_value = total_fees_base * current_price + total_fees_quote
-        else:
-            total_open_value = total_open_quote
-            total_close_value = total_close_quote
-            total_fees_value = total_fees_quote
-
-        # P&L calculation
+        # 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
-        position_pnl = total_returned - total_open_value if total_open_value > 0 else Decimal("0")
-        position_roi_pct = (position_pnl / total_open_value * 100) if total_open_value > 0 else Decimal("0")
+        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}")
@@ -234,17 +250,18 @@ class LPHistoryCommand:
         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]
 
-        pos_columns = ["", "buy", "sell", "both"]
+        # Column order matches side values: both(0), buy(1), sell(2)
+        pos_columns = ["", "both", "buy", "sell"]
         pos_data = [
-            [f"{'Number of positions':<27}", len(buy_positions), len(sell_positions), len(both_positions)],
+            [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),
-             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 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),
-             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 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")])
@@ -269,11 +286,12 @@ class LPHistoryCommand:
             ["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([
-            ["LP P&L                  ", f"{smart_round(position_pnl, precision)} {quote}"],
+            ["Net P&L                 ", f"{smart_round(net_pnl, precision)} {quote}"],
             ["Return %                ", f"{float(position_roi_pct):.2f}%"],
         ])
         perf_df = pd.DataFrame(data=perf_data)

{hummingbot-20260201.dev2 → hummingbot-20260302.dev1}/hummingbot/client/command/start_command.py

@@ -43,18 +43,16 @@ class StartCommand(GatewayChainApiManager):
 
     def start(self,  # type: HummingbotApplication
               log_level: Optional[str] = None,
-              script: Optional[str] = None,
-              conf: Optional[str] = None,
+              v2_conf: Optional[str] = None,
               is_quickstart: Optional[bool] = False):
         if threading.current_thread() != threading.main_thread():
-            self.ev_loop.call_soon_threadsafe(self.start, log_level, script)
+            self.ev_loop.call_soon_threadsafe(self.start, log_level, v2_conf)
             return
-        safe_ensure_future(self.start_check(log_level, script, conf, is_quickstart), loop=self.ev_loop)
+        safe_ensure_future(self.start_check(log_level, v2_conf, is_quickstart), loop=self.ev_loop)
 
     async def start_check(self,  # type: HummingbotApplication
                           log_level: Optional[str] = None,
-                          script: Optional[str] = None,
-                          conf: Optional[str] = None,
+                          v2_conf: Optional[str] = None,
                           is_quickstart: Optional[bool] = False):
 
         if self._in_start_check or (
@@ -85,10 +83,16 @@ class StartCommand(GatewayChainApiManager):
                     self.strategy_file_name = None
                     raise
 
-        if script:
-            file_name = script.split(".")[0]
+        if v2_conf:
+            config_data = self._peek_config(v2_conf)
+            script_file = config_data.get("script_file_name", "")
+            if not script_file:
+                self.notify("Config file is missing 'script_file_name' field. Start aborted.")
+                self._in_start_check = False
+                return
+            file_name = script_file.replace(".py", "")
             self.trading_core.strategy_name = file_name
-            self.strategy_file_name = conf if conf else file_name
+            self.strategy_file_name = v2_conf
         elif not await self.status_check_all(notify_success=False):
             self.notify("Status checks failed. Start aborted.")
             self._in_start_check = False
@@ -108,9 +112,9 @@ class StartCommand(GatewayChainApiManager):
         # Delegate strategy initialization to trading_core
         try:
             strategy_config = None
-            if self.trading_core.is_script_strategy(self.trading_core.strategy_name):
-                if self.strategy_file_name and self.strategy_file_name != self.trading_core.strategy_name:
-                    strategy_config = self.strategy_file_name
+            if self.trading_core.is_v2_strategy(self.trading_core.strategy_name):
+                # Config is always required for V2 strategies
+                strategy_config = self.strategy_file_name
 
             success = await self.trading_core.start_strategy(
                 self.trading_core.strategy_name,
@@ -141,6 +145,16 @@ class StartCommand(GatewayChainApiManager):
             self._mqtt.patch_loggers()
             self._mqtt.start_market_events_fw()
 
+    def _peek_config(self, conf_name: str) -> dict:
+        """Read minimal fields from a config file without full loading."""
+        import yaml
+
+        from hummingbot.client.settings import SCRIPT_STRATEGY_CONF_DIR_PATH
+
+        conf_path = SCRIPT_STRATEGY_CONF_DIR_PATH / conf_name
+        with open(conf_path) as f:
+            return yaml.safe_load(f) or {}
+
     async def confirm_oracle_conversion_rate(self,  # type: HummingbotApplication
                                              ) -> bool:
         try:

{hummingbot-20260201.dev2 → hummingbot-20260302.dev1}/hummingbot/client/command/stop_command.py

@@ -3,7 +3,7 @@ import threading
 from typing import TYPE_CHECKING
 
 from hummingbot.core.utils.async_utils import safe_ensure_future
-from hummingbot.strategy.script_strategy_base import ScriptStrategyBase
+from hummingbot.strategy.strategy_v2_base import StrategyV2Base
 
 if TYPE_CHECKING:
     from hummingbot.client.hummingbot_application import HummingbotApplication  # noqa: F401
@@ -28,7 +28,7 @@ class StopCommand:
             appnope.nap()
 
         # Handle script strategy specific cleanup first
-        if self.trading_core.strategy and isinstance(self.trading_core.strategy, ScriptStrategyBase):
+        if self.trading_core.strategy and isinstance(self.trading_core.strategy, StrategyV2Base):
             await self.trading_core.strategy.on_stop()
 
         # Stop strategy if running

{hummingbot-20260201.dev2 → hummingbot-20260302.dev1}/hummingbot/client/hummingbot_application.py

@@ -190,6 +190,7 @@ class HummingbotApplication(*commands):
 
                 args = self.parser.parse_args(args=command_split)
                 kwargs = vars(args)
+
                 if not hasattr(args, "func"):
                     if not self.headless_mode:
                         self.app.handle_tab_command(self, command_split[0], kwargs)

{hummingbot-20260201.dev2 → hummingbot-20260302.dev1}/hummingbot/client/ui/completer.py

@@ -71,8 +71,6 @@ class HummingbotCompleter(Completer):
         self._gateway_token_completer = WordCompleter(["<symbol_or_address>"], ignore_case=True)
         self._gateway_token_action_completer = WordCompleter(["update"], ignore_case=True)
         self._strategy_completer = WordCompleter(STRATEGIES, ignore_case=True)
-        self._script_strategy_completer = WordCompleter(file_name_list(str(SCRIPT_STRATEGIES_PATH), "py"))
-        self._script_conf_completer = WordCompleter(["--conf"], ignore_case=True)
         self._scripts_config_completer = WordCompleter(file_name_list(str(SCRIPT_STRATEGY_CONF_DIR_PATH), "yml"))
         self._strategy_v2_create_config_completer = self.get_strategies_v2_with_config()
         self._controller_completer = self.get_available_controllers()
@@ -369,21 +367,13 @@ class HummingbotCompleter(Completer):
         return (len(parts) == 1 and args_after_token.endswith(" ")) or \
                (len(parts) == 2 and not args_after_token.endswith(" "))
 
-    def _complete_script_strategy_files(self, document: Document) -> bool:
+    def _complete_v2_config_files(self, document: Document) -> bool:
         text_before_cursor: str = document.text_before_cursor
-        return text_before_cursor.startswith("start --script ") and "--conf" not in text_before_cursor and ".py" not in text_before_cursor
-
-    def _complete_conf_param_script_strategy_config(self, document: Document) -> bool:
-        text_before_cursor: str = document.text_before_cursor
-        return text_before_cursor.startswith("start --script ") and "--conf" not in text_before_cursor
-
-    def _complete_script_strategy_config(self, document: Document) -> bool:
-        text_before_cursor: str = document.text_before_cursor
-        return text_before_cursor.startswith("start --script ") and "--conf" in text_before_cursor
+        return text_before_cursor.startswith("start --v2 ")
 
     def _complete_strategy_v2_files_with_config(self, document: Document) -> bool:
         text_before_cursor: str = document.text_before_cursor
-        return text_before_cursor.startswith("create --script-config ")
+        return text_before_cursor.startswith("create --v2-config ")
 
     def _complete_controllers_config(self, document: Document) -> bool:
         text_before_cursor: str = document.text_before_cursor
@@ -434,15 +424,7 @@ class HummingbotCompleter(Completer):
         :param document:
         :param complete_event:
         """
-        if self._complete_script_strategy_files(document):
-            for c in self._script_strategy_completer.get_completions(document, complete_event):
-                yield c
-
-        elif self._complete_conf_param_script_strategy_config(document):
-            for c in self._script_conf_completer.get_completions(document, complete_event):
-                yield c
-
-        elif self._complete_script_strategy_config(document):
+        if self._complete_v2_config_files(document):
             for c in self._scripts_config_completer.get_completions(document, complete_event):
                 yield c
 

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

@@ -46,7 +46,7 @@ def load_parser(hummingbot: "HummingbotApplication", command_tabs) -> ThrowingAr
     connect_parser.set_defaults(func=hummingbot.connect)
 
     create_parser = subparsers.add_parser("create", help="Create a new bot")
-    create_parser.add_argument("--script-config", dest="script_to_config", nargs="?", default=None, help="Name of the v2 strategy")
+    create_parser.add_argument("--v2-config", dest="script_to_config", nargs="?", default=None, help="Name of the v2 strategy (from conf/scripts/)")
     create_parser.add_argument("--controller-config", dest="controller_name", nargs="?", default=None, help="Name of the controller")
     create_parser.set_defaults(func=hummingbot.create)
 
@@ -70,9 +70,8 @@ def load_parser(hummingbot: "HummingbotApplication", command_tabs) -> ThrowingAr
     config_parser.set_defaults(func=hummingbot.config)
 
     start_parser = subparsers.add_parser("start", help="Start the current bot")
-    # start_parser.add_argument("--log-level", help="Level of logging")
-    start_parser.add_argument("--script", type=str, dest="script", help="Script strategy file name")
-    start_parser.add_argument("--conf", type=str, dest="conf", help="Script config file name")
+    start_parser.add_argument("--v2", type=str, dest="v2_conf",
+                              help="V2 strategy config file name (from conf/scripts/)")
 
     start_parser.set_defaults(func=hummingbot.start)