olas-operate-middleware 0.6.2__py3-none-any.whl → 0.7.0__py3-none-any.whl

operate/quickstart/reset_configs.py

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------------------------
+#
+#   Copyright 2023-2024 Valory AG
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+# ------------------------------------------------------------------------------
+"""Reset configurations."""
+
+import json
+from typing import Callable, Optional, TYPE_CHECKING, cast
+
+from operate.quickstart.run_service import load_local_config
+from operate.quickstart.utils import (
+    ask_or_get_from_env,
+    ask_yes_or_no,
+    check_rpc,
+    print_section,
+    print_title,
+)
+
+
+if TYPE_CHECKING:
+    from operate.cli import OperateApp
+
+
+def _ask_to_change(
+    name: str,
+    env_var: str,
+    old_value: str,
+    hidden: bool = False,
+    validator: Callable[[Optional[str]], bool] = lambda x: False if x is None else True,
+) -> str:
+    """Ask user if they want to change a configuration value."""
+    old_value_str = old_value
+    if hidden:
+        if len(old_value_str) < 4:
+            old_value_str = "*" * len(old_value_str)
+        else:
+            old_value_str = "*" * len(old_value_str[:-4]) + old_value_str[-4:]
+
+    print(f"\nCurrent '{name}' is set to: {old_value_str}")
+    if ask_yes_or_no(f"Do you want to change the '{name}'?"):
+        new_value = None
+        while not validator(new_value):
+            new_value = ask_or_get_from_env(
+                prompt=f"Enter new value for '{name}' {'[hidden]' if hidden else ''}: ",
+                env_var_name=env_var,
+                is_pass=hidden,
+            )
+
+        return str(new_value)
+
+    return old_value
+
+
+def reset_configs(operate: "OperateApp", config_path: str) -> None:
+    """Reset configurations."""
+    with open(config_path, "r") as config_file:
+        template = json.load(config_file)
+
+    operate.service_manager().migrate_service_configs()
+    operate.wallet_manager.migrate_wallet_configs()
+
+    print_title(f"Reset your {template['name']} configurations")
+
+    # check if agent was started before
+    config = load_local_config(
+        operate=operate, service_name=cast(str, template["name"])
+    )
+    if not config.path.exists():
+        print("No previous agent setup found. Exiting.")
+        return
+
+    if config.rpc is None:
+        config.rpc = {}
+
+    for chain_name in config.rpc:
+        config.rpc[chain_name] = _ask_to_change(
+            name=f"{chain_name.capitalize()} RPC URL",
+            env_var=f"{chain_name.upper()}_LEDGER_RPC",
+            old_value=config.rpc[chain_name],
+            hidden=True,
+            validator=check_rpc,
+        )
+
+    if config.user_provided_args is None:
+        config.user_provided_args = {}
+
+    for env_var in config.user_provided_args:
+        config.user_provided_args[env_var] = _ask_to_change(
+            name=env_var,
+            env_var=env_var,
+            old_value=config.user_provided_args[env_var],
+        )
+
+    config.store()
+    print_section("Configurations updated")

operate/quickstart/run_service.py

@@ -37,7 +37,14 @@ from operate.account.user import UserAccount
 from operate.constants import IPFS_ADDRESS, OPERATE_HOME
 from operate.data import DATA_DIR
 from operate.data.contracts.staking_token.contract import StakingTokenContract
-from operate.ledger.profiles import NO_STAKING_PROGRAM_ID, STAKING, get_staking_contract
+from operate.ledger.profiles import (
+    DEFAULT_PRIORITY_MECH_ADDRESS,
+    DEFAULT_PRIORITY_MECH_SERVICE_ID,
+    NO_STAKING_PROGRAM_ID,
+    STAKING,
+    get_staking_contract,
+    get_staking_program_mech_type,
+)
 from operate.operate_types import (
     Chain,
     LedgerType,
@@ -99,8 +106,6 @@ QS_STAKING_PROGRAMS: t.Dict[Chain, t.Dict[str, str]] = {
         "quickstart_beta_mech_marketplace_expert_8": "trader",
         "mech_marketplace": "mech",
         "marketplace_supply_alpha": "mech",
-        "marketplace_demand_alpha_1": "mech",
-        "marketplace_demand_alpha_2": "mech",
     },
     Chain.OPTIMISTIC: {
         "optimus_alpha_2": "optimus",
@@ -111,8 +116,6 @@ QS_STAKING_PROGRAMS: t.Dict[Chain, t.Dict[str, str]] = {
     Chain.BASE: {
         "meme_base_alpha_2": "memeooorr",
         "marketplace_supply_alpha": "mech",
-        "marketplace_demand_alpha_1": "mech",
-        "marketplace_demand_alpha_2": "mech",
         "agents_fun_1": "memeooorr",
         "agents_fun_2": "memeooorr",
         "agents_fun_3": "memeooorr",
@@ -393,8 +396,31 @@ def configure_local_config(
     ):
         print_section("Please enter the arguments that will be used by the service.")
 
+    staking_program_mech_type = get_staking_program_mech_type(config.staking_program_id)
+
     for env_var_name, env_var_data in template["env_variables"].items():
         if env_var_data["provision_type"] == ServiceEnvProvisionType.USER:
+            # PRIORITY_MECH_ADDRESS and PRIORITY_MECH_SERVICE_ID are given dynamic default values
+            if env_var_name == "PRIORITY_MECH_ADDRESS":
+                env_var_data["value"] = DEFAULT_PRIORITY_MECH_ADDRESS[
+                    staking_program_mech_type
+                ]
+                if (
+                    env_var_name in config.user_provided_args
+                    and env_var_data["value"] != config.user_provided_args[env_var_name]
+                ):
+                    del config.user_provided_args[env_var_name]
+
+            if env_var_name == "PRIORITY_MECH_SERVICE_ID":
+                env_var_data["value"] = str(
+                    DEFAULT_PRIORITY_MECH_SERVICE_ID.get(staking_program_mech_type, 0)
+                )
+                if (
+                    env_var_name in config.user_provided_args
+                    and env_var_data["value"] != config.user_provided_args[env_var_name]
+                ):
+                    del config.user_provided_args[env_var_name]
+
             if env_var_name not in config.user_provided_args:
                 print(f"Description: {env_var_data['description']}")
                 if env_var_data["value"]:

operate/quickstart/utils.py

@@ -188,8 +188,12 @@ def ask_yes_or_no(question: str) -> bool:
     """Ask a yes/no question."""
     if os.environ.get("ATTENDED", "true").lower() != "true":
         return True
-    response = input(f"{question} (yes/no): ").strip().lower()
-    return response in ["yes", "y"]
+    while True:
+        response = input(f"{question} (yes/no): ").strip().lower()
+        if response.lower() in ("yes", "y"):
+            return True
+        if response.lower() in ("no", "n"):
+            return False
 
 
 def ask_or_get_from_env(

operate/services/agent_runner.py

@@ -18,116 +18,193 @@
 #
 # -------------------------------------------------------------
 """Source dode to download and run agent from the repos."""
+import hashlib
 import os
 import platform
 import shutil
 import stat
+from dataclasses import dataclass
 from pathlib import Path
 from tempfile import TemporaryDirectory
 from typing import Tuple
 
 import requests
 from aea.configurations.data_types import PublicId
+from aea.helpers.logging import setup_logger
 
 
+@dataclass
+class AgentRelease:
+    """Agent release dataclass."""
+
+    owner: str
+    repo: str
+    release: str
+
+    @property
+    def release_url(self) -> str:
+        """Get release  api url."""
+        return f"https://api.github.com/repos/{self.owner}/{self.repo}/releases/tags/{self.release}"
+
+    def get_url_and_hash(self, asset_name: str) -> tuple[str, str]:
+        """Get download url and asset sha256 hash."""
+        release_data = requests.get(self.release_url).json()
+
+        assets_filtered = [i for i in release_data["assets"] if i["name"] == asset_name]
+        if not assets_filtered:
+            raise ValueError(
+                f"Asset {asset_name} not found in release {self.release_url}"
+            )
+        asset = assets_filtered[0]
+        file_hash = asset["digest"]
+        file_url = asset["browser_download_url"]
+
+        return file_url, file_hash
+
+
+# list of agents releases supported
 AGENTS_SUPPORTED = {
-    "valory": {
-        "trader": "https://github.com/valory-xyz/trader/releases/download/v0.0.101/",
-        "optimus": "https://github.com/valory-xyz/optimus/releases/download/v0.0.101/",
-    },
-    "dvilela": {
-        "memeooorr": "https://github.com/valory-xyz/meme-ooorr-test/releases/download/v0.0.3/"
-    },
+    "valory/trader": AgentRelease(
+        owner="valory-xyz", repo="trader", release="v0.0.101"
+    ),
+    "valory/optimus": AgentRelease(
+        owner="valory-xyz", repo="optimus", release="v0.0.103"
+    ),
+    "dvilela/memeooorr": AgentRelease(
+        owner="valory-xyz", repo="meme-ooorr-test", release="v0.0.101"
+    ),
 }
 
 
-def get_agent_runner_executable_name() -> str:
-    """Get runner executable name by platform running."""
-    if platform.system() == "Darwin":
-        os_name = "macos"
-    elif platform.system() == "Windows":
-        os_name = "windows"
-    else:
-        raise ValueError("Platform not supported!")
-
-    if platform.machine().lower() in ("x86_64", "amd64"):
-        arch = "x64"
-    elif platform.machine().lower() == "arm64":
-        arch = "arm64"
-        if os_name == "windows":
-            raise ValueError("Windows arm64 is not supported!")
-    else:
-        raise ValueError(f"unsupported arch: {platform.machine()}")
-
-    exec_name = f"agent_runner_{os_name}_{arch}"
-    if platform.system() == "Windows":
-        exec_name += ".exe"
-    return exec_name
-
-
-def parse_agent(public_id_str: str) -> Tuple[str, str]:
-    """Get authorn and name from agent public string id."""
-    public_id = PublicId.from_str(public_id_string=public_id_str)
-    return (public_id.author, public_id.name)
-
-
-def download_file(url: str, save_path: Path) -> None:
-    """Download file of agent runner."""
-    try:
-        # Send a GET request to the URL
-        response = requests.get(url, stream=True)
-        response.raise_for_status()  # Raise an error for bad status codes (4xx or 5xx)
-
-        # Open the file in binary write mode and save the content
-        with open(save_path, "wb") as file:
-            for chunk in response.iter_content(chunk_size=8192):
-                file.write(chunk)
-
-        print(f"File downloaded and saved to {save_path}")
-    except requests.exceptions.RequestException as e:
-        print(f"Error downloading file: {e}")
-        raise
-
-
-def download_agent_runner(
-    target_path: Path, agent_runner_name: str, agent_public_id_str: str
-) -> None:
-    """Download agent runner."""
-    agent_author, agent_name = parse_agent(public_id_str=agent_public_id_str)
-    if agent_author not in AGENTS_SUPPORTED:
-        raise ValueError(f"No agents supported for author {agent_author}")
-    if agent_name not in AGENTS_SUPPORTED[agent_author]:
-        raise ValueError(
-            f"No agent named {agent_name} supported for author {agent_author}"
+class AgentRunnerManager:
+    """Agent Runner Manager."""
+
+    logger = setup_logger(name="operate.agent_runner_manager")
+    AGENTS = AGENTS_SUPPORTED
+
+    @staticmethod
+    def get_agent_runner_executable_name() -> str:
+        """Get runner executable name by platform running."""
+        if platform.system() == "Darwin":
+            os_name = "macos"
+        elif platform.system() == "Windows":
+            os_name = "windows"
+        else:
+            raise ValueError("Platform not supported!")
+
+        if platform.machine().lower() in ("x86_64", "amd64"):
+            arch = "x64"
+        elif platform.machine().lower() == "arm64":
+            arch = "arm64"
+            if os_name == "windows":
+                raise ValueError("Windows arm64 is not supported!")
+        else:
+            raise ValueError(f"unsupported arch: {platform.machine()}")
+
+        exec_name = f"agent_runner_{os_name}_{arch}"
+        if platform.system() == "Windows":
+            exec_name += ".exe"
+        return exec_name
+
+    @staticmethod
+    def parse_agent(public_id_str: str) -> Tuple[str, str]:
+        """Get authorn and name from agent public string id."""
+        public_id = PublicId.from_str(public_id_string=public_id_str)
+        return (public_id.author, public_id.name)
+
+    @classmethod
+    def download_file(cls, url: str, save_path: Path) -> None:
+        """Download file of agent runner."""
+        try:
+            # Send a GET request to the URL
+            response = requests.get(url, stream=True)
+            response.raise_for_status()  # Raise an error for bad status codes (4xx or 5xx)
+
+            # Open the file in binary write mode and save the content
+            with open(save_path, "wb") as file:
+                for chunk in response.iter_content(chunk_size=8192):
+                    file.write(chunk)
+
+            cls.logger.info(f"File downloaded and saved to {save_path}")
+        except requests.exceptions.RequestException as e:
+            cls.logger.error(f"Error downloading file: {e}")
+            raise
+
+    @classmethod
+    def get_agent_release_by_public_id(cls, agent_public_id_str: str) -> AgentRelease:
+        """Get agent release object according to public id."""
+        agent_author, agent_name = cls.parse_agent(public_id_str=agent_public_id_str)
+
+        agent_name = f"{agent_author}/{agent_name}"
+        agent_release = cls.AGENTS.get(agent_name, None)
+        if agent_release is None:
+            raise ValueError(f"{agent_name} is not supported!")
+        return agent_release
+
+    @staticmethod
+    def get_local_file_sha256(path: Path) -> str:
+        """Get local file sha256."""
+        sha256_hash = hashlib.sha256()
+        with open(path, "rb") as f:
+            for byte_block in iter(lambda: f.read(4096), b""):
+                sha256_hash.update(byte_block)
+        return "sha256:" + sha256_hash.hexdigest()
+
+    @classmethod
+    def update_agent_runner(
+        cls, target_path: Path, agent_runner_name: str, agent_release: AgentRelease
+    ) -> None:
+        """Download agent runner."""
+        download_url, remote_file_hash = agent_release.get_url_and_hash(
+            agent_runner_name
         )
-    repo_url = AGENTS_SUPPORTED[agent_author][agent_name]
-    download_url = f"{repo_url}{agent_runner_name}"
-    try:
-        with TemporaryDirectory() as tmp_dir:
-            tmp_file = Path(tmp_dir) / "agent_runner"
-            download_file(download_url, tmp_file)
-            shutil.copy2(tmp_file, target_path)
-            if os.name == "posix":
-                target_path.chmod(target_path.stat().st_mode | stat.S_IEXEC)
-    except Exception:
-        # remove in cae of errors
-        if target_path.exists():
-            target_path.unlink(missing_ok=True)
-        raise
 
+        if target_path.exists():
+            # check sha
+            current_file_hash = cls.get_local_file_sha256(target_path)
+            if remote_file_hash == current_file_hash:
+                cls.logger.info(
+                    "local and remote files hashes are match, nothing to download"
+                )
+                return
+            cls.logger.info(
+                "local and remote files hashes does not  match, go to download"
+            )
+        else:
+            cls.logger.info("local file not found, go to download")
+
+        try:
+            with TemporaryDirectory() as tmp_dir:
+                tmp_file = Path(tmp_dir) / "agent_runner"
+                cls.download_file(download_url, tmp_file)
+                shutil.copy2(tmp_file, target_path)
+                if os.name == "posix":
+                    target_path.chmod(target_path.stat().st_mode | stat.S_IEXEC)
+        except Exception:
+            # remove in caae of errors
+            if target_path.exists():
+                target_path.unlink(missing_ok=True)
+            raise
+
+    @classmethod
+    def get_agent_runner_path(cls, service_dir: Path, agent_public_id_str: str) -> str:
+        """Get path to the agent runner bin palced."""
+        agent_runner_name = cls.get_agent_runner_executable_name()
+        agent_runner_path: Path = service_dir / agent_runner_name
+        agent_release = cls.get_agent_release_by_public_id(
+            agent_public_id_str=agent_public_id_str
+        )
 
-def get_agent_runner_path(service_dir: Path, agent_public_id_str: str) -> str:
-    """Get path to the agent runner bin palced."""
-    agent_runner_name = get_agent_runner_executable_name()
-    agent_runner_path: Path = service_dir / agent_runner_name
-
-    if agent_runner_path.exists():
-        print(f"agent runner {agent_runner_path} already exists. dont download it.")
-    else:
-        print(f"agent runner {agent_runner_path} does not exists. downloading it.")
-        download_agent_runner(
+        cls.update_agent_runner(
             target_path=agent_runner_path,
             agent_runner_name=agent_runner_name,
-            agent_public_id_str=agent_public_id_str,
+            agent_release=agent_release,
         )
-    return str(agent_runner_path)
+        return str(agent_runner_path)
+
+
+def get_agent_runner_path(service_dir: Path, agent_public_id_str: str) -> str:
+    """Get path to the agent runner bin placed."""
+    return AgentRunnerManager.get_agent_runner_path(
+        service_dir=service_dir, agent_public_id_str=agent_public_id_str
+    )

operate/services/manage.py

@@ -52,12 +52,14 @@ from operate.ledger import PUBLIC_RPCS, get_currency_denom
 from operate.ledger.profiles import (
     CONTRACTS,
     DEFAULT_MASTER_EOA_FUNDS,
-    DEFAULT_MECH_MARKETPLACE_PRIORITY_MECH,
+    DEFAULT_PRIORITY_MECH_ADDRESS,
+    DEFAULT_PRIORITY_MECH_SERVICE_ID,
     OLAS,
     STAKING,
     USDC,
     WRAPPED_NATIVE_ASSET,
     get_staking_contract,
+    get_staking_program_mech_type,
 )
 from operate.operate_types import (
     Chain,
@@ -106,6 +108,9 @@ HTTP_OK = 200
 URI_HASH_POSITION = 7
 IPFS_GATEWAY = "https://gateway.autonolas.tech/ipfs/"
 DEFAULT_TOPUP_THRESHOLD = 0.5
+# At the moment, we only support running one agent per service locally on a machine.
+# If multiple agents are provided in the service.yaml file, only the 0th index config will be used.
+NUM_LOCAL_AGENT_INSTANCES = 1
 
 
 class ServiceManager:
@@ -227,7 +232,7 @@ class ServiceManager:
         if not service.keys:
             service.keys = [
                 self.keys_manager.get(self.keys_manager.create())
-                for _ in range(service.helper.config.number_of_agents)
+                for _ in range(NUM_LOCAL_AGENT_INSTANCES)
             ]
             service.store()
 
@@ -267,7 +272,7 @@ class ServiceManager:
         if not service.keys:
             service.keys = [
                 self.keys_manager.get(self.keys_manager.create())
-                for _ in range(service.helper.config.number_of_agents)
+                for _ in range(NUM_LOCAL_AGENT_INSTANCES)
             ]
             service.store()
 
@@ -437,7 +442,7 @@ class ServiceManager:
                 ocm.mint(
                     package_path=service.package_absolute_path_absolute_path,
                     agent_id=staking_params["agent_ids"][0],
-                    number_of_slots=service.helper.config.number_of_agents,
+                    number_of_slots=NUM_LOCAL_AGENT_INSTANCES,
                     cost_of_bond=(
                         staking_params["min_staking_deposit"]
                         if user_params.use_staking
@@ -551,6 +556,10 @@ class ServiceManager:
         self.logger.info(f"Service state: {on_chain_state.name}")
 
         current_staking_program = self._get_current_staking_program(service, chain)
+        staking_program_mech_type = get_staking_program_mech_type(
+            user_params.staking_program_id
+        )
+        self.logger.info(f"{staking_program_mech_type=}")
         fallback_params = dict(  # nosec
             staking_contract=NULL_ADDRESS,
             agent_ids=[user_params.agent_id],
@@ -599,6 +608,9 @@ class ServiceManager:
                 use_mech_marketplace = False
                 mech_marketplace_address = ZERO_ADDRESS
                 priority_mech_address = ZERO_ADDRESS
+                priority_mech_service_id = DEFAULT_PRIORITY_MECH_SERVICE_ID.get(
+                    staking_program_mech_type, 0
+                )
 
             except Exception:  # pylint: disable=broad-except
                 # Try if activity checker is a RequesterActivityChecker contract
@@ -635,17 +647,35 @@ class ServiceManager:
                     else:
                         agent_mech = (
                             priority_mech_address
-                        ) = DEFAULT_MECH_MARKETPLACE_PRIORITY_MECH
+                        ) = DEFAULT_PRIORITY_MECH_ADDRESS[staking_program_mech_type]
+
+                    if (
+                        "PRIORITY_MECH_SERVICE_ID" in service.env_variables
+                        and service.env_variables["PRIORITY_MECH_SERVICE_ID"][
+                            "provision_type"
+                        ]
+                        == ServiceEnvProvisionType.USER
+                    ):
+                        priority_mech_service_id = service.env_variables[
+                            "PRIORITY_MECH_SERVICE_ID"
+                        ]["value"]
+                    else:
+                        priority_mech_service_id = DEFAULT_PRIORITY_MECH_SERVICE_ID.get(
+                            staking_program_mech_type, 0
+                        )
 
                 except Exception:  # pylint: disable=broad-except
                     self.logger.warning(
                         "Cannot determine type of activity checker contract. Using default parameters. "
                         "NOTE: This will be an exception in the future!"
                     )
-                    agent_mech = "0x77af31De935740567Cf4fF1986D04B2c964A786a"  # nosec
+                    agent_mech = DEFAULT_PRIORITY_MECH_ADDRESS[
+                        staking_program_mech_type
+                    ]
                     use_mech_marketplace = False
                     mech_marketplace_address = ZERO_ADDRESS
                     priority_mech_address = ZERO_ADDRESS
+                    priority_mech_service_id = 0
 
             env_var_to_value.update(
                 {
@@ -666,7 +696,7 @@ class ServiceManager:
                         f'{{"mech_marketplace_address":"{mech_marketplace_address}",'
                         f'"priority_mech_address":"{priority_mech_address}",'
                         f'"priority_mech_staking_instance_address":"0x998dEFafD094817EF329f6dc79c703f1CF18bC90",'
-                        f'"priority_mech_service_id":{service.env_variables.get("PRIORITY_MECH_SERVICE_ID", {"value": 975})["value"]},'
+                        f'"priority_mech_service_id":{priority_mech_service_id},'
                         f'"requester_staking_instance_address":"{target_staking_params.get("staking_contract")}",'
                         f'"response_timeout":300}}'
                     ),
@@ -709,7 +739,7 @@ class ServiceManager:
                 )
                 protocol_asset_requirements[target_staking_params["staking_token"]] = (
                     target_staking_params["min_staking_deposit"]
-                    * service.helper.config.number_of_agents
+                    * NUM_LOCAL_AGENT_INSTANCES
                 )
             else:
                 protocol_asset_requirements = {}
@@ -791,7 +821,7 @@ class ServiceManager:
                         sftxb.get_mint_tx_data(
                             package_path=service.package_absolute_path,
                             agent_id=agent_id,
-                            number_of_slots=service.helper.config.number_of_agents,
+                            number_of_slots=NUM_LOCAL_AGENT_INSTANCES,
                             cost_of_bond=(
                                 target_staking_params["min_staking_deposit"]
                                 if user_params.use_staking
@@ -841,7 +871,7 @@ class ServiceManager:
                     sftxb.get_mint_tx_data(
                         package_path=service.package_absolute_path,
                         agent_id=agent_id,
-                        number_of_slots=service.helper.config.number_of_agents,
+                        number_of_slots=NUM_LOCAL_AGENT_INSTANCES,
                         cost_of_bond=(
                             target_staking_params["min_staking_deposit"]
                             if user_params.use_staking
@@ -2504,7 +2534,7 @@ class ServiceManager:
         chain_config = service.chain_configs[chain]
         user_params = chain_config.chain_data.user_params
         ledger_config = chain_config.ledger_config
-        number_of_agents = service.helper.config.number_of_agents
+        number_of_agents = NUM_LOCAL_AGENT_INSTANCES
         os.environ["CUSTOM_CHAIN_RPC"] = ledger_config.rpc
         sftxb = self.get_eth_safe_tx_builder(ledger_config=ledger_config)
         service_asset_requirements: defaultdict = defaultdict(int)

operate/services/service.py

@@ -320,13 +320,19 @@ class HostDeploymentGenerator(BaseDeploymentGenerator):
         tendermint_executable = str(
             Path(os.path.dirname(sys.executable)) / "tendermint"
         )
-        tendermint_executable = "tendermint"
+
         if platform.system() == "Windows":
             env["PATH"] = os.path.dirname(sys.executable) + ";" + os.environ["PATH"]
             tendermint_executable = str(
                 Path(os.path.dirname(sys.executable)) / "tendermint.exe"
             )
-            tendermint_executable = "tendermint.exe"
+
+        if not (getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS")):
+            # we dont run inside pyinstaller, mean DEV mode!
+            tendermint_executable = "tendermint"
+            if platform.system() == "Windows":
+                tendermint_executable = "tendermint.exe"
+
         subprocess.run(  # pylint: disable=subprocess-run-check # nosec
             args=[
                 tendermint_executable,
@@ -1251,6 +1257,8 @@ class Service(LocalResource):
                 config  # type: ignore
             )
 
+            self.chain_configs[chain].ledger_config.rpc = config["rpc"]
+
         self.store()
 
     def consume_env_variables(self) -> None: