olas-operate-middleware 0.12.2__tar.gz → 0.13.0__tar.gz

{olas_operate_middleware-0.12.2 → olas_operate_middleware-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: olas-operate-middleware
-Version: 0.12.2
+Version: 0.13.0
 Summary: 
 License-File: LICENSE
 Author: David Vilela

{olas_operate_middleware-0.12.2 → olas_operate_middleware-0.13.0}/operate/cli.py

@@ -159,7 +159,6 @@ class OperateApp:  # pylint: disable=too-many-instance-attributes
         self._backup_operate_if_new_version()
 
         self._password: t.Optional[str] = os.environ.get("OPERATE_USER_PASSWORD")
-        KeysManager._instances.clear()  # reset singleton instance
         self._keys_manager: KeysManager = KeysManager(
             path=self._keys,
             logger=logger,
@@ -173,6 +172,7 @@ class OperateApp:  # pylint: disable=too-many-instance-attributes
         )
         self._wallet_manager.setup()
         self._funding_manager = FundingManager(
+            keys_manager=self._keys_manager,
             wallet_manager=self._wallet_manager,
             logger=logger,
         )
@@ -284,6 +284,7 @@ class OperateApp:  # pylint: disable=too-many-instance-attributes
         """Load service manager."""
         return services.manage.ServiceManager(
             path=self._services,
+            keys_manager=self.keys_manager,
             wallet_manager=self.wallet_manager,
             funding_manager=self.funding_manager,
             logger=logger,
@@ -302,17 +303,23 @@ class OperateApp:  # pylint: disable=too-many-instance-attributes
             return UserAccount.load(self._path / USER_JSON)
         return None
 
+    @property
+    def keys_manager(self) -> KeysManager:
+        """Load keys manager."""
+        return self._keys_manager
+
     @property
     def wallet_manager(self) -> MasterWalletManager:
         """Load wallet manager."""
         return self._wallet_manager
 
     @property
-    def wallet_recoverey_manager(self) -> WalletRecoveryManager:
+    def wallet_recovery_manager(self) -> WalletRecoveryManager:
         """Load wallet recovery manager."""
         manager = WalletRecoveryManager(
             path=self._path / WALLET_RECOVERY_DIR,
             wallet_manager=self.wallet_manager,
+            service_manager=self.service_manager(),
             logger=logger,
         )
         return manager
@@ -730,7 +737,7 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
                 status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
             )
 
-    @app.get("/api/extended/wallet")
+    @app.get("/api/wallet/extended")
     async def _get_wallet_safe(request: Request) -> t.List[t.Dict]:
         """Get wallets."""
         wallets = []
@@ -1512,9 +1519,9 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
                 status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
             )
 
-    @app.post("/api/wallet/recovery/initiate")
-    async def _wallet_recovery_initiate(request: Request) -> JSONResponse:
-        """Initiate wallet recovery."""
+    @app.post("/api/wallet/recovery/prepare")
+    async def _wallet_recovery_prepare(request: Request) -> JSONResponse:
+        """Prepare wallet recovery."""
         if operate.user_account is None:
             return ACCOUNT_NOT_FOUND_ERROR
 
@@ -1533,7 +1540,7 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
             )
 
         try:
-            output = operate.wallet_recoverey_manager.initiate_recovery(
+            output = operate.wallet_recovery_manager.prepare_recovery(
                 new_password=new_password
             )
             return JSONResponse(
@@ -1541,16 +1548,54 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
                 status_code=HTTPStatus.OK,
             )
         except (ValueError, WalletRecoveryError) as e:
-            logger.error(f"_recovery_initiate error: {e}")
+            logger.error(f"_recovery_prepare error: {e}")
             return JSONResponse(
-                content={"error": f"Failed to initiate recovery: {e}"},
+                content={"error": f"Failed to prepare recovery: {e}"},
                 status_code=HTTPStatus.BAD_REQUEST,
             )
         except Exception as e:  # pylint: disable=broad-except
-            logger.error(f"_recovery_initiate error: {e}\n{traceback.format_exc()}")
+            logger.error(f"_recovery_prepare error: {e}\n{traceback.format_exc()}")
+            return JSONResponse(
+                content={"error": "Failed to prepare recovery. Please check the logs."},
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            )
+
+    @app.get("/api/wallet/recovery/funding_requirements")
+    async def _get_recovery_funding_requirements(request: Request) -> JSONResponse:
+        """Get recovery funding requirements."""
+
+        try:
+            output = operate.wallet_recovery_manager.recovery_requirements()
+            return JSONResponse(
+                content=output,
+                status_code=HTTPStatus.OK,
+            )
+        except Exception as e:  # pylint: disable=broad-except
+            logger.error(
+                f"_recovery_funding_requirements error: {e}\n{traceback.format_exc()}"
+            )
             return JSONResponse(
                 content={
-                    "error": "Failed to initiate recovery. Please check the logs."
+                    "error": "Failed to retrieve recovery funding requirements. Please check the logs."
+                },
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            )
+
+    @app.get("/api/wallet/recovery/status")
+    async def _get_recovery_status(request: Request) -> JSONResponse:
+        """Get recovery status."""
+
+        try:
+            output = operate.wallet_recovery_manager.status()
+            return JSONResponse(
+                content=output,
+                status_code=HTTPStatus.OK,
+            )
+        except Exception as e:  # pylint: disable=broad-except
+            logger.error(f"_recovery_status error: {e}\n{traceback.format_exc()}")
+            return JSONResponse(
+                content={
+                    "error": "Failed to retrieve recovery status. Please check the logs."
                 },
                 status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
             )
@@ -1564,15 +1609,16 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         if operate.password:
             return USER_LOGGED_IN_ERROR
 
-        data = await request.json()
-        bundle_id = data.get("id")
-        password = data.get("password")
+        data = {}
+        if request.headers.get("content-type", "").startswith("application/json"):
+            body = await request.body()
+            if body:
+                data = await request.json()
+
         raise_if_inconsistent_owners = data.get("require_consistent_owners", True)
 
         try:
-            operate.wallet_recoverey_manager.complete_recovery(
-                bundle_id=bundle_id,
-                password=password,
+            operate.wallet_recovery_manager.complete_recovery(
                 raise_if_inconsistent_owners=raise_if_inconsistent_owners,
             )
             return JSONResponse(
@@ -1664,6 +1710,10 @@ def qs_start(
         bool,
         params.Boolean(help="Will skip the dependencies check for minting the service"),
     ] = False,
+    use_binary: Annotated[
+        bool,
+        params.Boolean(help="Will use the released binary to run the service"),
+    ] = False,
 ) -> None:
     """Quickstart."""
     os.environ["ATTENDED"] = attended.lower()
@@ -1674,12 +1724,17 @@ def qs_start(
         config_path=config,
         build_only=build_only,
         skip_dependency_check=skip_dependency_check,
+        use_binary=use_binary,
     )
 
 
 @_operate.command(name="quickstop")
 def qs_stop(
     config: Annotated[str, params.String(help="Quickstart config file path")],
+    use_binary: Annotated[
+        bool,
+        params.Boolean(help="Will use the released binary to run the service"),
+    ] = False,
     attended: Annotated[
         str, params.String(help="Run in attended/unattended mode (default: true")
     ] = "true",
@@ -1688,7 +1743,7 @@ def qs_stop(
     os.environ["ATTENDED"] = attended.lower()
     operate = OperateApp()
     operate.setup()
-    stop_service(operate=operate, config_path=config)
+    stop_service(operate=operate, config_path=config, use_binary=use_binary)
 
 
 @_operate.command(name="terminate")

{olas_operate_middleware-0.12.2 → olas_operate_middleware-0.13.0}/operate/keys.py

@@ -31,7 +31,7 @@ from aea_ledger_ethereum.ethereum import EthereumCrypto
 
 from operate.operate_types import LedgerType
 from operate.resource import LocalResource
-from operate.utils import SingletonMeta, unrecoverable_delete
+from operate.utils import unrecoverable_delete
 
 
 @dataclass
@@ -42,7 +42,7 @@ class Key(LocalResource):
     address: str
     private_key: str
 
-    def get_decrypted(self, password: str) -> dict:
+    def get_decrypted_json(self, password: str) -> dict:
         """Get decrypted key json."""
         return {
             "ledger": self.ledger.value,
@@ -57,7 +57,7 @@ class Key(LocalResource):
         return super().load(path)  # type: ignore
 
 
-class KeysManager(metaclass=SingletonMeta):
+class KeysManager:
     """Keys manager."""
 
     def __init__(self, **kwargs: Any) -> None:
@@ -113,6 +113,12 @@ class KeysManager(metaclass=SingletonMeta):
             )
         )
 
+    def get_decrypted(self, key: str) -> dict:
+        """Get key json."""
+        if self.password is not None:
+            return self.get(key).get_decrypted_json(self.password)
+        return self.get(key).json
+
     def get_private_key_file(self, address: str) -> Path:
         """Get the path to the private key file for the given address."""
         path = self.path / f"{address}_private_key"

{olas_operate_middleware-0.12.2 → olas_operate_middleware-0.13.0}/operate/ledger/profiles.py

@@ -246,6 +246,17 @@ DEFAULT_EOA_TOPUPS_WITHOUT_SAFE = {
     for chain, amounts in DEFAULT_EOA_TOPUPS.items()
 }
 
+DEFAULT_RECOVERY_TOPUPS = {
+    Chain.ARBITRUM_ONE: {ZERO_ADDRESS: 625_000_000_000_000},
+    Chain.BASE: {ZERO_ADDRESS: 625_000_000_000_000},
+    Chain.CELO: {ZERO_ADDRESS: 187_500_000_000_000_000},
+    Chain.ETHEREUM: {ZERO_ADDRESS: 2_500_000_000_000_000},
+    Chain.GNOSIS: {ZERO_ADDRESS: 187_500_000_000_000_000},
+    Chain.MODE: {ZERO_ADDRESS: 62_500_000_000_000},
+    Chain.OPTIMISM: {ZERO_ADDRESS: 625_000_000_000_000},
+    Chain.POLYGON: {ZERO_ADDRESS: 187_500_000_000_000_000},
+}
+
 DEFAULT_EOA_THRESHOLD = 0.5
 
 EXPLORER_URL = {

{olas_operate_middleware-0.12.2 → olas_operate_middleware-0.13.0}/operate/migration.py

@@ -33,7 +33,9 @@ from web3 import Web3
 
 from operate.constants import USER_JSON, ZERO_ADDRESS
 from operate.keys import KeysManager
-from operate.operate_types import Chain, LedgerType
+from operate.operate_types import AgentRelease as AgentReleaseType
+from operate.operate_types import AgentReleaseRepo, Chain, LedgerType
+from operate.services.agent_runner import AgentRelease
 from operate.services.manage import ServiceManager
 from operate.services.service import (
     NON_EXISTENT_MULTISIG,
@@ -160,7 +162,7 @@ class MigrationManager:
 
         self.logger.info("Migrating wallet configs done.")
 
-    def _migrate_service(  # pylint: disable=too-many-statements,too-many-locals
+    def _migrate_service(  # pylint: disable=too-many-statements,too-many-locals,too-many-branches
         self,
         path: Path,
     ) -> bool:
@@ -250,12 +252,6 @@ class MigrationManager:
                                 "nft": data.get("chain_data", {})
                                 .get("user_params", {})
                                 .get("nft"),
-                                "threshold": data.get("chain_data", {})
-                                .get("user_params", {})
-                                .get("threshold"),
-                                "use_staking": data.get("chain_data", {})
-                                .get("user_params", {})
-                                .get("use_staking"),
                                 "cost_of_bond": data.get("chain_data", {})
                                 .get("user_params", {})
                                 .get("cost_of_bond"),
@@ -277,9 +273,6 @@ class MigrationManager:
         if version < 4:
             # Add missing fields introduced in later versions, if necessary.
             for _, chain_data in data.get("chain_configs", {}).items():
-                chain_data.setdefault("chain_data", {}).setdefault(
-                    "user_params", {}
-                ).setdefault("use_mech_marketplace", False)
                 service_name = data.get("name", "")
                 agent_id = Service.determine_agent_id(service_name)
                 chain_data.setdefault("chain_data", {}).setdefault("user_params", {})[
@@ -342,6 +335,12 @@ class MigrationManager:
                 new_chain_configs[chain] = chain_data  # type: ignore
             data["chain_configs"] = new_chain_configs
 
+        if version < 6 and "service_path" in data:
+            # Redownload service path
+            package_absolute_path = path / Path(data["service_path"]).name
+            data.pop("service_path")
+            data["package_path"] = str(package_absolute_path.name)
+
         if version < 7:
             for _, chain_data in data.get("chain_configs", {}).items():
                 if chain_data["chain_data"]["multisig"] == "0xm":
@@ -371,6 +370,39 @@ class MigrationManager:
                 if chain_config["ledger_config"]["chain"] == "optimistic":
                     chain_config["ledger_config"]["chain"] = Chain.OPTIMISM.value
 
+        if version < 9:
+            agents_supported = {
+                "trader_pearl": AgentRelease(
+                    is_aea=True, owner="valory-xyz", repo="trader", release="v0.0.101"
+                ),
+                "optimus": AgentRelease(
+                    is_aea=True, owner="valory-xyz", repo="optimus", release="v0.0.103"
+                ),
+                "memeooorr": AgentRelease(
+                    is_aea=True,
+                    owner="valory-xyz",
+                    repo="meme-ooorr",
+                    release="v0.0.101",
+                ),
+            }
+            package_path = data["package_path"]
+            try:
+                release_data = agents_supported[package_path]
+            except KeyError as e:
+                raise RuntimeError(f"Found unsupported {package_path=}") from e
+
+            data["agent_release"] = AgentReleaseType(
+                is_aea=release_data.is_aea,
+                repository=AgentReleaseRepo(
+                    owner=release_data.owner,
+                    name=release_data.repo,
+                    version=release_data.release,
+                ),
+            )
+
+            if data["name"] is None:
+                data["name"] = release_data.repo
+
         data["version"] = SERVICE_CONFIG_VERSION
 
         # Redownload service path

{olas_operate_middleware-0.12.2 → olas_operate_middleware-0.13.0}/operate/operate_types.py

@@ -223,6 +223,21 @@ class EnvVariableAttributes(TypedDict):
     provision_type: ServiceEnvProvisionType
 
 
+class AgentReleaseRepo(TypedDict):
+    """Agent release repo template."""
+
+    owner: str
+    name: str
+    version: str
+
+
+class AgentRelease(TypedDict):
+    """Agent release template."""
+
+    is_aea: bool
+    repository: AgentReleaseRepo
+
+
 ConfigurationTemplates = t.Dict[str, ConfigurationTemplate]
 EnvVariables = t.Dict[str, EnvVariableAttributes]
 
@@ -235,6 +250,7 @@ class ServiceTemplate(TypedDict, total=False):
     image: str
     description: str
     service_version: str
+    agent_release: AgentRelease
     home_chain: str
     configurations: ConfigurationTemplates
     env_variables: EnvVariables

{olas_operate_middleware-0.12.2 → olas_operate_middleware-0.13.0}/operate/quickstart/reset_password.py

@@ -22,7 +22,6 @@ from typing import TYPE_CHECKING
 
 from operate.account.user import UserAccount
 from operate.constants import USER_JSON
-from operate.keys import KeysManager
 from operate.quickstart.run_service import ask_confirm_password
 from operate.quickstart.utils import ask_or_get_from_env, print_section, print_title
 
@@ -66,6 +65,6 @@ def reset_password(operate: "OperateApp") -> None:
     print('Resetting password of "ethereum" wallet...')
     operate.password = old_password
     operate.wallet_manager.update_password(new_password=new_password)
-    KeysManager().update_password(new_password=new_password)
+    operate.keys_manager.update_password(new_password=new_password)
 
     print_section("Password reset done!")

{olas_operate_middleware-0.12.2 → olas_operate_middleware-0.13.0}/operate/quickstart/run_service.py

@@ -485,7 +485,11 @@ def get_service(manager: ServiceManager, template: ServiceTemplate) -> Service:
     for service in manager.json:
         if service["name"] == template["name"]:
             old_hash = service["hash"]
-            if old_hash == template["hash"]:
+            old_version = service["agent_release"]["repository"]["version"]
+            if (
+                old_hash == template["hash"]
+                and old_version == template["agent_release"]["repository"]["version"]
+            ):
                 print(f'Loading service {template["hash"]}')
                 service = manager.load(
                     service_config_id=service["service_config_id"],
@@ -668,6 +672,7 @@ def run_service(
     config_path: str,
     build_only: bool = False,
     skip_dependency_check: bool = False,
+    use_binary: bool = False,
 ) -> None:
     """Run service."""
 
@@ -702,10 +707,17 @@ def run_service(
     manager.funding_manager.topup_service_initial(service=service)
 
     print_section("Deploying the service")
+    if use_binary:
+        use_docker = False
+        use_k8s = False
+    else:
+        use_docker = True
+        use_k8s = True
+
     manager.deploy_service_locally(
         service_config_id=service.service_config_id,
-        use_docker=True,
-        use_kubernetes=True,
+        use_docker=use_docker,
+        use_kubernetes=use_k8s,
         build_only=build_only,
     )
     if build_only:

{olas_operate_middleware-0.12.2 → olas_operate_middleware-0.13.0}/operate/quickstart/stop_service.py

@@ -37,7 +37,9 @@ if TYPE_CHECKING:
 warnings.filterwarnings("ignore", category=UserWarning)
 
 
-def stop_service(operate: "OperateApp", config_path: str) -> None:
+def stop_service(
+    operate: "OperateApp", config_path: str, use_binary: bool = False
+) -> None:
     """Stop service."""
 
     with open(config_path, "r") as config_file:
@@ -57,8 +59,13 @@ def stop_service(operate: "OperateApp", config_path: str) -> None:
     configure_local_config(template, operate)
     manager = operate.service_manager()
     service = get_service(manager, template)
+    if use_binary:
+        use_docker = False
+    else:
+        use_docker = True
+
     manager.stop_service_locally(
-        service_config_id=service.service_config_id, use_docker=True, force=True
+        service_config_id=service.service_config_id, use_docker=use_docker, force=True
     )
 
     print()

{olas_operate_middleware-0.12.2 → olas_operate_middleware-0.13.0}/operate/services/agent_runner.py

@@ -19,6 +19,7 @@
 # -------------------------------------------------------------
 """Source dode to download and run agent from the repos."""
 import hashlib
+import json
 import os
 import platform
 import shutil
@@ -32,7 +33,7 @@ import requests
 from aea.configurations.data_types import PublicId
 from aea.helpers.logging import setup_logger
 
-from operate.constants import AGENT_RUNNER_PREFIX
+from operate.constants import AGENT_RUNNER_PREFIX, CONFIG_JSON
 
 
 @dataclass
@@ -42,6 +43,7 @@ class AgentRelease:
     owner: str
     repo: str
     release: str
+    is_aea: bool
 
     @property
     def release_url(self) -> str:
@@ -64,25 +66,10 @@ class AgentRelease:
         return file_url, file_hash
 
 
-# list of agents releases supported
-AGENTS_SUPPORTED = {
-    "valory/trader": AgentRelease(
-        owner="valory-xyz", repo="trader", release="v0.27.2-1-rc.2"
-    ),
-    "valory/optimus": AgentRelease(
-        owner="valory-xyz", repo="optimus", release="v0.6.0-rc.1"
-    ),
-    "dvilela/memeooorr": AgentRelease(
-        owner="valory-xyz", repo="meme-ooorr", release="v0.0.101"
-    ),
-}
-
-
 class AgentRunnerManager:
     """Agent Runner Manager."""
 
     logger = setup_logger(name="operate.agent_runner_manager")
-    AGENTS = AGENTS_SUPPORTED
 
     @staticmethod
     def get_agent_runner_executable_name() -> str:
@@ -133,14 +120,19 @@ class AgentRunnerManager:
             raise
 
     @classmethod
-    def get_agent_release_by_public_id(cls, agent_public_id_str: str) -> AgentRelease:
+    def get_agent_release_from_service_dir(cls, service_dir: Path) -> 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!")
+        service_config_file = service_dir / CONFIG_JSON
+        service_config = json.loads(service_config_file.read_text())
+        if "agent_release" not in service_config:
+            raise ValueError(f"Agent release details are not found in {service_config}")
+        agent_release_data = service_config["agent_release"]
+        agent_release = AgentRelease(
+            is_aea=agent_release_data["is_aea"],
+            owner=agent_release_data["repository"]["owner"],
+            repo=agent_release_data["repository"]["name"],
+            release=agent_release_data["repository"]["version"],
+        )
         return agent_release
 
     @staticmethod
@@ -189,13 +181,11 @@ class AgentRunnerManager:
             raise
 
     @classmethod
-    def get_agent_runner_path(cls, service_dir: Path, agent_public_id_str: str) -> str:
+    def get_agent_runner_path(cls, service_dir: Path) -> 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
-        )
+        agent_release = cls.get_agent_release_from_service_dir(service_dir=service_dir)
 
         cls.update_agent_runner(
             target_path=agent_runner_path,
@@ -205,8 +195,8 @@ class AgentRunnerManager:
         return str(agent_runner_path)
 
 
-def get_agent_runner_path(service_dir: Path, agent_public_id_str: str) -> str:
+def get_agent_runner_path(service_dir: Path) -> 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
+        service_dir=service_dir,
     )