olas-operate-middleware 0.10.7__py3-none-any.whl → 0.10.8__py3-none-any.whl

{olas_operate_middleware-0.10.7.dist-info → olas_operate_middleware-0.10.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: olas-operate-middleware
-Version: 0.10.7
+Version: 0.10.8
 Summary: 
 Author: David Vilela
 Author-email: dvilelaf@gmail.com

{olas_operate_middleware-0.10.7.dist-info → olas_operate_middleware-0.10.8.dist-info}/RECORD

@@ -1,4 +1,4 @@
-operate/__init__.py,sha256=ZQhHXOo_1L9Q5Ub_2FrZ-vu3BvORBrKgK8QcJyAsYa4,870
+operate/__init__.py,sha256=PY5BUTF5cmNI-7UwAj2jJlPl6KJ44LoY5e16p7IrE3g,1335
 operate/account/__init__.py,sha256=suJ_vBMO7hLCvLYe3MVDtLXTNDd6P03og7bvUN7fZsE,804
 operate/account/user.py,sha256=y7DqqDpqgHjbVmnfL_cN0Me_JWl3Dh6GSVt2-9FdRVw,3044
 operate/bridge/bridge_manager.py,sha256=sUfhB1pZvBrF-kBfDOfFVoNeesCe7wd4_YahUF3FZDU,17119
@@ -6,8 +6,8 @@ operate/bridge/providers/lifi_provider.py,sha256=FpAlBAA_gOt-oOHKhGaOQhhTZIL-hgY
 operate/bridge/providers/native_bridge_provider.py,sha256=gG8bSyxUoAVEF6_J9tn1qKRv1PnXuMJdMwUAVJ4GJz8,24647
 operate/bridge/providers/provider.py,sha256=i54RL7m4wMSADM_D_V_quQump_ipPTmByUc-c-AOLPQ,19687
 operate/bridge/providers/relay_provider.py,sha256=L7D-PKepsuBadarJmrNneZk0bsrh88u05uD6_2MSss4,17341
-operate/cli.py,sha256=EalpBA15TXX5i3tD-2KIQOxkFwEOqOEiGMbjh36cOHw,51168
-operate/constants.py,sha256=syGWEVyw07zK50gPS4OSSwyAbt9R6P8IttDimDt9vCY,2746
+operate/cli.py,sha256=UZmmQOmod4ytFsMl65MH5rtc881EEE3wQgYIYr-BGW0,55788
+operate/constants.py,sha256=ilmLiv0H_xKZyfqmfEdqMci-TlLQyNPp9rrxxqtkqFI,2992
 operate/data/README.md,sha256=jGPyZTvg2LCGdllvmYxmFMkkkiXb6YWatbqIkcX3kv4,879
 operate/data/__init__.py,sha256=ttC51Yqk9c4ehpIgs1Qbe7aJvzkrbbdZ1ClaCxJYByE,864
 operate/data/contracts/__init__.py,sha256=_th54_WvL0ibGy-b6St0Ne9DX-fyjsh-tNOKDn-cWrg,809
@@ -57,10 +57,10 @@ operate/data/contracts/uniswap_v2_erc20/contract.py,sha256=MwBks4QmZ3XouMT_TqWLn
 operate/data/contracts/uniswap_v2_erc20/contract.yaml,sha256=XUdz-XtKtmZgLfItbO8usP-QPbtUkAxKGn0hL7OftAg,741
 operate/data/contracts/uniswap_v2_erc20/tests/__init__.py,sha256=3Arw8dsCsJz6hVOl0t9UjFASHXbV9yp3hw6x4HqgXpU,847
 operate/data/contracts/uniswap_v2_erc20/tests/test_contract.py,sha256=FzZbw9OTcr_yvjOXpk9YcO-K40eyDARyybcfSHDg2Ps,13392
-operate/keys.py,sha256=JdnFFbzBOe9t4eS7i72EShOe25OkQdzRm_asCQHmmH0,4944
-operate/ledger/__init__.py,sha256=ksyctDd5PU_SToN9e-_N9fAap9ZNCHw48j5hHep-erA,3353
+operate/keys.py,sha256=_TAS7x9TyU9a8AMnw2FacAHUeqLB0kBSJECc3Msxv54,5207
+operate/ledger/__init__.py,sha256=TCZxTdUTCHjhYErVAjsZgSbv7YUdAzYKOe-vJDvCkGk,3963
 operate/ledger/profiles.py,sha256=7aLLf0pJTIHerpXbwpjeKE9inuwiw0FG0GgTWU_0vGE,11977
-operate/migration.py,sha256=YIJ9P8CdW2IsMm4gW9GdAJ7EKMnUfUMUB5TItiQ0dH8,15323
+operate/migration.py,sha256=mh921s8FG48XMfDu63ojrdhU7j_RZsdl5E2BvxsbkWE,16937
 operate/operate_http/__init__.py,sha256=dxCIVSUos23M4R-PFZZG6k5QrOlEiK0SxhCYSFNxh7U,4711
 operate/operate_http/exceptions.py,sha256=4UFzrn-GyDD71RhkaOyFPBynL6TrrtP3eywaaU3o4fc,1339
 operate/operate_types.py,sha256=oVOzd6K_CTbmAe1pbSFr4LCajNJ_n0y6J5Wwdf_6ev8,8102
@@ -68,9 +68,9 @@ operate/pearl.py,sha256=yrTpSXLu_ML3qT-uNxq3kScOyo31JyxBujiSMfMUbcg,1690
 operate/quickstart/analyse_logs.py,sha256=K11AWWevkddUIUzTe75J3fYVS6aLfi6kT_dAI9OjrX8,4195
 operate/quickstart/claim_staking_rewards.py,sha256=AqfLMRef2YijQtWPaTuGwX2sOItNEkoyoi6Q9SICp_I,4026
 operate/quickstart/reset_configs.py,sha256=ipPpbYyB9gQ4KOKS-xBrRi8fT5LvwctSkQi-8XiUMig,3341
-operate/quickstart/reset_password.py,sha256=p_gNmhWD4hb-QXUAiQRalPtVTVyB5TEPhs7GnScYzqs,2535
+operate/quickstart/reset_password.py,sha256=78riP7zyFM2JMa1H8Dh6pg-PtLJLQS7PFzx9SECPACQ,2571
 operate/quickstart/reset_staking.py,sha256=SB5LZq9EctG4SYn2M6oPZ7R7ARHSFLRGzAqfKkpRcy0,5111
-operate/quickstart/run_service.py,sha256=6opWEeedraCsPb6jEd44oV34jVQZJSNH8WOr-Kmo2LM,27116
+operate/quickstart/run_service.py,sha256=ruEShJadhIa0E2IsPWu41ObkzZsaWF9XkVH8Vb7uRUU,27146
 operate/quickstart/stop_service.py,sha256=CNcCucI4sqfZG0wTxxh-k14xGcbOh50UGyXqTZVQJP0,2048
 operate/quickstart/terminate_on_chain_service.py,sha256=5ENU8_mkj06i80lKUX-v1QbLU0YzKeOZDUL1e_jzySE,2914
 operate/quickstart/utils.py,sha256=rmd9e7whQIsYpRKqWBEQxMA_SHrivBg6DppFY5ECtQQ,9135
@@ -79,9 +79,9 @@ operate/services/__init__.py,sha256=isrThS-Ccu5Sc15JZgkN4uTAVaSg-NwUUSDeTyJEqLk,
 operate/services/agent_runner.py,sha256=6tJePUJmlRxlIugT2fDaCJHSrQlDnl1t9pbg3-7EmCQ,7560
 operate/services/deployment_runner.py,sha256=Su73o7cdH6fkQfj468K77J04a_TWiokJwbMyVQ25xko,27067
 operate/services/health_checker.py,sha256=2KSEDxG3YmGolUDU--648ny0UJpTAAKvxkcr_VZQv-I,9654
-operate/services/manage.py,sha256=CN_NFvXHbzoyGGyLRxmLVs_ghfxiXW1JlErUo1XRyeg,116402
-operate/services/protocol.py,sha256=FcHXPgeyOul3_3V5yF44fkxe79Ngpb7IaQh09dBOe0c,63206
-operate/services/service.py,sha256=ztZQToB2tfCUOUVSU2WJejIw3mSP6ZOUBmyB3ZmcLkI,40053
+operate/services/manage.py,sha256=AoJsa4vB3C9cyMLgKBQxsUBv9okyDqxtLjCpsG3UzdQ,115769
+operate/services/protocol.py,sha256=FoJmHz5nukI01-VYtReMsIl3JT5RgZZSLX-mf9EXQ90,62903
+operate/services/service.py,sha256=ZbkTryuK3kBkdvhxd9QDyXRxRFsGGG9WZqbLGOUPloc,39301
 operate/services/utils/__init__.py,sha256=TvioaZ1mfTRUSCtrQoLNAp4WMVXyqEJqFJM4PxSQCRU,24
 operate/services/utils/mech.py,sha256=W2x4dqodivNKXjWU-Brp40QhoUHsIMyNAO7-caMoR0Q,3821
 operate/services/utils/tendermint.py,sha256=3h9nDb2Z89T0RwUr_AaVjqtymQmsu3u6DAVCfL_k1U0,25591
@@ -89,9 +89,10 @@ operate/utils/__init__.py,sha256=DZNUgg0V9yfNfDrUynp10PErSieJkoxU0AKvsEFIhAw,467
 operate/utils/gnosis.py,sha256=CS07ZqvrO7uelkFe09VMyPBcLzKONUI1ZqFvi41BDhc,17924
 operate/utils/ssl.py,sha256=O5DrDoZD4T4qQuHP8GLwWUVxQ-1qXeefGp6uDJiF2lM,4308
 operate/wallet/__init__.py,sha256=NGiozD3XhvkBi7_FaOWQ8x1thZPK4uGpokJaeDY_o2w,813
-operate/wallet/master.py,sha256=MGXynIV0LQU3n28AceK7RlaxAtfsVowsXzisesG4iJM,30760
-olas_operate_middleware-0.10.7.dist-info/LICENSE,sha256=mdBDB-mWKV5Cz4ejBzBiKqan6Z8zVLAh9xwM64O2FW4,11339
-olas_operate_middleware-0.10.7.dist-info/METADATA,sha256=W-w08wQZ3IFB9xxQrH0dO671Gu2SDNWmmgW1HEWASiQ,2035
-olas_operate_middleware-0.10.7.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-olas_operate_middleware-0.10.7.dist-info/entry_points.txt,sha256=dM1g2I7ODApKQFcgl5J4NGA7pfBTo6qsUTXM-j2OLlw,44
-olas_operate_middleware-0.10.7.dist-info/RECORD,,
+operate/wallet/master.py,sha256=jLFLcRgO6ADok2DigpK59PFJ4mnc_0H9a4RRioYzlvw,30811
+operate/wallet/wallet_recovery_manager.py,sha256=sXEZyvFMePxQKf9NJg4HT90mPg4-7ZcTbvggMnKKzhA,7795
+olas_operate_middleware-0.10.8.dist-info/LICENSE,sha256=mdBDB-mWKV5Cz4ejBzBiKqan6Z8zVLAh9xwM64O2FW4,11339
+olas_operate_middleware-0.10.8.dist-info/METADATA,sha256=1kSqMoV3eXtdFxGckk49yl2kpcubr6PAub2RJ2nZipQ,2035
+olas_operate_middleware-0.10.8.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+olas_operate_middleware-0.10.8.dist-info/entry_points.txt,sha256=dM1g2I7ODApKQFcgl5J4NGA7pfBTo6qsUTXM-j2OLlw,44
+olas_operate_middleware-0.10.8.dist-info/RECORD,,

operate/__init__.py

@@ -20,6 +20,18 @@
 """Operate app."""
 
 import logging
+from importlib.metadata import PackageNotFoundError, version
 
 
+try:
+    # Prefer the distribution name if installed; fall back to the module name
+    __version__ = version("olas-operate-middleware")
+except PackageNotFoundError:
+    try:
+        __version__ = version("operate")
+    except PackageNotFoundError:
+        logger = logging.getLogger("operate")
+        logger.warning("Could not determine version, using 0.0.0+local")
+        __version__ = "0.0.0+local"
+
 logging.getLogger("aea").setLevel(logging.ERROR)

operate/cli.py

@@ -20,7 +20,6 @@
 """Operate app CLI module."""
 import asyncio
 import atexit
-import logging
 import multiprocessing
 import os
 import signal
@@ -46,7 +45,7 @@ from typing_extensions import Annotated
 from uvicorn.config import Config
 from uvicorn.server import Server
 
-from operate import services
+from operate import __version__, services
 from operate.account.user import UserAccount
 from operate.bridge.bridge_manager import BridgeManager
 from operate.constants import (
@@ -54,6 +53,9 @@ from operate.constants import (
     MIN_PASSWORD_LENGTH,
     OPERATE_HOME,
     SERVICES_DIR,
+    USER_JSON,
+    WALLETS_DIR,
+    WALLET_RECOVERY_DIR,
     ZERO_ADDRESS,
 )
 from operate.ledger.profiles import (
@@ -76,18 +78,28 @@ from operate.services.health_checker import HealthChecker
 from operate.utils import subtract_dicts
 from operate.utils.gnosis import get_assets_balances
 from operate.wallet.master import MasterWalletManager
+from operate.wallet.wallet_recovery_manager import (
+    WalletRecoveryError,
+    WalletRecoveryManager,
+)
 
 
 DEFAULT_MAX_RETRIES = 3
 USER_NOT_LOGGED_IN_ERROR = JSONResponse(
     content={"error": "User not logged in."}, status_code=HTTPStatus.UNAUTHORIZED
 )
+USER_LOGGED_IN_ERROR = JSONResponse(
+    content={"error": "User must be logged out to perform this operation."},
+    status_code=HTTPStatus.FORBIDDEN,
+)
 ACCOUNT_NOT_FOUND_ERROR = JSONResponse(
     content={"error": "User account not found."},
     status_code=HTTPStatus.NOT_FOUND,
 )
 TRY_TO_SHUTDOWN_PREVIOUS_INSTANCE = True
 
+logger = setup_logger(name="operate")
+
 
 def service_not_found_error(service_config_id: str) -> JSONResponse:
     """Service not found error response"""
@@ -103,7 +115,6 @@ class OperateApp:
     def __init__(
         self,
         home: t.Optional[Path] = None,
-        logger: t.Optional[logging.Logger] = None,
     ) -> None:
         """Initialize object."""
         super().__init__()
@@ -112,14 +123,13 @@ class OperateApp:
         self._keys = self._path / KEYS_DIR
         self.setup()
 
-        self.logger = logger or setup_logger(name="operate")
         services.manage.KeysManager(
             path=self._keys,
-            logger=self.logger,
+            logger=logger,
         )
         self.password: t.Optional[str] = os.environ.get("OPERATE_USER_PASSWORD")
 
-        mm = MigrationManager(self._path, self.logger)
+        mm = MigrationManager(self._path, logger)
         mm.migrate_user_account()
         mm.migrate_services(self.service_manager())
         mm.migrate_wallets(self.wallet_manager)
@@ -130,14 +140,14 @@ class OperateApp:
         self.password = password
         return UserAccount.new(
             password=password,
-            path=self._path / "user.json",
+            path=self._path / USER_JSON,
         )
 
     def update_password(self, old_password: str, new_password: str) -> None:
         """Updates current password"""
 
         if not new_password:
-            raise ValueError("'password' is required.")
+            raise ValueError("'new_password' is required.")
 
         if not (
             self.user_account.is_valid(old_password)
@@ -154,7 +164,7 @@ class OperateApp:
         """Updates current password using the mnemonic"""
 
         if not new_password:
-            raise ValueError("'password' is required.")
+            raise ValueError("'new_password' is required.")
 
         mnemonic = mnemonic.strip().lower()
         if not self.wallet_manager.is_mnemonic_valid(mnemonic):
@@ -171,37 +181,45 @@ class OperateApp:
         return services.manage.ServiceManager(
             path=self._services,
             wallet_manager=self.wallet_manager,
-            logger=self.logger,
+            logger=logger,
             skip_dependency_check=skip_dependency_check,
         )
 
     @property
     def user_account(self) -> t.Optional[UserAccount]:
         """Load user account."""
-        return (
-            UserAccount.load(self._path / "user.json")
-            if (self._path / "user.json").exists()
-            else None
-        )
+        if (self._path / USER_JSON).exists():
+            return UserAccount.load(self._path / USER_JSON)
+        return None
 
     @property
     def wallet_manager(self) -> MasterWalletManager:
-        """Load master wallet."""
+        """Load wallet manager."""
         manager = MasterWalletManager(
-            path=self._path / "wallets",
+            path=self._path / WALLETS_DIR,
             password=self.password,
-            logger=self.logger,
+            logger=logger,
         )
         manager.setup()
         return manager
 
+    @property
+    def wallet_recoverey_manager(self) -> WalletRecoveryManager:
+        """Load wallet recovery manager."""
+        manager = WalletRecoveryManager(
+            path=self._path / WALLET_RECOVERY_DIR,
+            wallet_manager=self.wallet_manager,
+            logger=self.logger,
+        )
+        return manager
+
     @property
     def bridge_manager(self) -> BridgeManager:
-        """Load master wallet."""
+        """Load bridge manager."""
         manager = BridgeManager(
             path=self._path / "bridge",
             wallet_manager=self.wallet_manager,
-            logger=self.logger,
+            logger=logger,
         )
         return manager
 
@@ -232,10 +250,9 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         )
     )
 
-    logger = setup_logger(name="operate")
     if HEALTH_CHECKER_OFF:
         logger.warning("Healthchecker is off!!!")
-    operate = OperateApp(home=home, logger=logger)
+    operate = OperateApp(home=home)
 
     funding_jobs: t.Dict[str, asyncio.Task] = {}
     health_checker = HealthChecker(
@@ -877,6 +894,21 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         deployment_json["healthcheck"] = service.get_latest_healthcheck()
         return JSONResponse(content=deployment_json)
 
+    @app.get("/api/v2/service/{service_config_id}/agent_performance")
+    @with_retries
+    async def _get_agent_performance(request: Request) -> JSONResponse:
+        """Get the service refill requirements."""
+        service_config_id = request.path_params["service_config_id"]
+
+        if not operate.service_manager().exists(service_config_id=service_config_id):
+            return service_not_found_error(service_config_id=service_config_id)
+
+        return JSONResponse(
+            content=operate.service_manager()
+            .load(service_config_id=service_config_id)
+            .get_agent_performance()
+        )
+
     @app.get("/api/v2/service/{service_config_id}/refill_requirements")
     @with_retries
     async def _get_refill_requirements(request: Request) -> JSONResponse:
@@ -1166,12 +1198,103 @@ 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")
+    @with_retries
+    async def _wallet_recovery_initiate(request: Request) -> JSONResponse:
+        """Initiate wallet recovery."""
+        if operate.user_account is None:
+            return ACCOUNT_NOT_FOUND_ERROR
+
+        if operate.password:
+            return USER_LOGGED_IN_ERROR
+
+        data = await request.json()
+        new_password = data.get("new_password")
+
+        if not new_password or len(new_password) < MIN_PASSWORD_LENGTH:
+            return JSONResponse(
+                content={
+                    "error": f"New password must be at least {MIN_PASSWORD_LENGTH} characters long."
+                },
+                status_code=HTTPStatus.BAD_REQUEST,
+            )
+
+        try:
+            output = operate.wallet_recoverey_manager.initiate_recovery(
+                new_password=new_password
+            )
+            return JSONResponse(
+                content=output,
+                status_code=HTTPStatus.OK,
+            )
+        except (ValueError, WalletRecoveryError) as e:
+            logger.error(f"_recovery_initiate error: {e}")
+            return JSONResponse(
+                content={"error": f"Failed to initiate 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()}")
+            return JSONResponse(
+                content={
+                    "error": "Failed to initiate recovery. Please check the logs."
+                },
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            )
+
+    @app.post("/api/wallet/recovery/complete")
+    @with_retries
+    async def _wallet_recovery_complete(request: Request) -> JSONResponse:
+        """Complete wallet recovery."""
+        if operate.user_account is None:
+            return ACCOUNT_NOT_FOUND_ERROR
+
+        if operate.password:
+            return USER_LOGGED_IN_ERROR
+
+        data = await request.json()
+        bundle_id = data.get("id")
+        password = data.get("password")
+        raise_if_inconsistent_owners = data.get("require_consistent_owners", True)
+
+        try:
+            operate.wallet_recoverey_manager.complete_recovery(
+                bundle_id=bundle_id,
+                password=password,
+                raise_if_inconsistent_owners=raise_if_inconsistent_owners,
+            )
+            return JSONResponse(
+                content=operate.wallet_manager.json,
+                status_code=HTTPStatus.OK,
+            )
+        except KeyError as e:
+            logger.error(f"_recovery_complete error: {e}")
+            return JSONResponse(
+                content={"error": f"Failed to complete recovery: {e}"},
+                status_code=HTTPStatus.NOT_FOUND,
+            )
+        except (ValueError, WalletRecoveryError) as e:
+            logger.error(f"_recovery_complete error: {e}")
+            return JSONResponse(
+                content={"error": f"Failed to complete recovery: {e}"},
+                status_code=HTTPStatus.BAD_REQUEST,
+            )
+        except Exception as e:  # pylint: disable=broad-except
+            logger.error(f"_recovery_complete error: {e}\n{traceback.format_exc()}")
+            return JSONResponse(
+                content={
+                    "error": "Failed to complete recovery. Please check the logs."
+                },
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            )
+
     return app
 
 
 @group(name="operate")
 def _operate() -> None:
     """Operate - deploy autonomous services."""
+    logger.info(f"Operate version: {__version__}")
 
 
 @_operate.command(name="daemon")
@@ -1188,7 +1311,6 @@ def _daemon(
 ) -> None:
     """Launch operate daemon."""
     app = create_app(home=home)
-    logger = setup_logger(name="daemon")
 
     config_kwargs = {
         "app": app,

operate/constants.py

@@ -26,9 +26,18 @@ OPERATE = ".operate"
 OPERATE_HOME = Path.cwd() / OPERATE
 SERVICES_DIR = "services"
 KEYS_DIR = "keys"
+WALLETS_DIR = "wallets"
+WALLET_RECOVERY_DIR = "wallet_recovery"
 DEPLOYMENT_DIR = "deployment"
 DEPLOYMENT_JSON = "deployment.json"
 CONFIG_JSON = "config.json"
+USER_JSON = "user.json"
+
+AGENT_PERSISTENT_STORAGE_DIR = "persistent_data"
+AGENT_PERSISTENT_STORAGE_ENV_VAR = "STORE_PATH"
+AGENT_LOG_DIR = "benchmarks"
+AGENT_LOG_ENV_VAR = "LOG_DIR"
+
 ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
 
 ON_CHAIN_INTERACT_TIMEOUT = 120.0

operate/keys.py

@@ -92,16 +92,22 @@ class KeysManager(metaclass=SingletonMeta):
             suffix=".txt",
             delete=False,  # Handle cleanup manually
         ) as temp_file:
+            temp_file_name = temp_file.name
             temp_file.write(key.private_key)
             temp_file.flush()
             temp_file.close()  # Close the file before reading
 
             # Set proper file permissions (readable by owner only)
-            os.chmod(temp_file.name, 0o600)
-            crypto = EthereumCrypto(private_key_path=temp_file.name)
+            os.chmod(temp_file_name, 0o600)
+            crypto = EthereumCrypto(private_key_path=temp_file_name)
 
             try:
-                os.unlink(temp_file.name)  # Clean up the temporary file
+                with open(temp_file_name, "r+", encoding="utf-8") as f:
+                    f.seek(0)
+                    f.write("\0" * len(key.private_key))
+                    f.flush()
+                    f.close()
+                os.unlink(temp_file_name)  # Clean up the temporary file
             except OSError as e:
                 self.logger.error(f"Failed to delete temp file {temp_file.name}: {e}")
 

operate/ledger/__init__.py

@@ -24,62 +24,76 @@ import os
 from operate.operate_types import Chain
 
 
-ETHEREUM_PUBLIC_RPC = os.environ.get("ETHEREUM_RPC", "https://ethereum.publicnode.com")
-GNOSIS_PUBLIC_RPC = os.environ.get("GNOSIS_RPC", "https://gnosis-rpc.publicnode.com")
-SOLANA_PUBLIC_RPC = os.environ.get("SOLANA_RPC", "https://api.mainnet-beta.solana.com")
+ARBITRUM_ONE_PUBLIC_RPC = os.environ.get(
+    "ARBITRUM_ONE_RPC", "https://arb1.arbitrum.io/rpc"
+)
 BASE_PUBLIC_RPC = os.environ.get("BASE_RPC", "https://mainnet.base.org")
 CELO_PUBLIC_RPC = os.environ.get("CELO_RPC", "https://forno.celo.org")
-OPTIMISM_PUBLIC_RPC = os.environ.get("OPTIMISM_RPC", "https://mainnet.optimism.io")
+ETHEREUM_PUBLIC_RPC = os.environ.get("ETHEREUM_RPC", "https://ethereum.publicnode.com")
+GNOSIS_PUBLIC_RPC = os.environ.get("GNOSIS_RPC", "https://gnosis-rpc.publicnode.com")
 MODE_PUBLIC_RPC = os.environ.get("MODE_RPC", "https://mainnet.mode.network/")
+OPTIMISM_PUBLIC_RPC = os.environ.get("OPTIMISM_RPC", "https://mainnet.optimism.io")
+POLYGON_PUBLIC_RPC = os.environ.get("POLYGON_RPC", "https://polygon-rpc.com")
+SOLANA_PUBLIC_RPC = os.environ.get("SOLANA_RPC", "https://api.mainnet-beta.solana.com")
 
-ETHEREUM_RPC = os.environ.get("ETHEREUM_RPC", "https://ethereum.publicnode.com")
-GNOSIS_RPC = os.environ.get("GNOSIS_RPC", "https://rpc-gate.autonolas.tech/gnosis-rpc/")
-SOLANA_RPC = os.environ.get("SOLANA_RPC", "https://api.mainnet-beta.solana.com")
+ARBITRUM_ONE_RPC = os.environ.get("ARBITRUM_ONE_RPC", "https://arb1.arbitrum.io/rpc")
 BASE_RPC = os.environ.get("BASE_RPC", "https://mainnet.base.org")
 CELO_RPC = os.environ.get("CELO_RPC", "https://forno.celo.org")
-OPTIMISM_RPC = os.environ.get("OPTIMISM_RPC", "https://mainnet.optimism.io")
+ETHEREUM_RPC = os.environ.get("ETHEREUM_RPC", "https://ethereum.publicnode.com")
+GNOSIS_RPC = os.environ.get("GNOSIS_RPC", "https://rpc-gate.autonolas.tech/gnosis-rpc/")
 MODE_RPC = os.environ.get("MODE_RPC", "https://mainnet.mode.network/")
+OPTIMISM_RPC = os.environ.get("OPTIMISM_RPC", "https://mainnet.optimism.io")
+POLYGON_RPC = os.environ.get("POLYGON_RPC", "https://polygon-rpc.com")
+SOLANA_RPC = os.environ.get("SOLANA_RPC", "https://api.mainnet-beta.solana.com")
 
 PUBLIC_RPCS = {
-    Chain.ETHEREUM: ETHEREUM_PUBLIC_RPC,
-    Chain.GNOSIS: GNOSIS_PUBLIC_RPC,
-    Chain.SOLANA: SOLANA_PUBLIC_RPC,
+    Chain.ARBITRUM_ONE: ARBITRUM_ONE_PUBLIC_RPC,
     Chain.BASE: BASE_PUBLIC_RPC,
     Chain.CELO: CELO_PUBLIC_RPC,
-    Chain.OPTIMISM: OPTIMISM_PUBLIC_RPC,
+    Chain.ETHEREUM: ETHEREUM_PUBLIC_RPC,
+    Chain.GNOSIS: GNOSIS_PUBLIC_RPC,
     Chain.MODE: MODE_PUBLIC_RPC,
+    Chain.OPTIMISM: OPTIMISM_PUBLIC_RPC,
+    Chain.POLYGON: POLYGON_PUBLIC_RPC,
+    Chain.SOLANA: SOLANA_PUBLIC_RPC,
 }
 
 DEFAULT_RPCS = {
-    Chain.ETHEREUM: ETHEREUM_RPC,
-    Chain.GNOSIS: GNOSIS_RPC,
-    Chain.SOLANA: SOLANA_RPC,
+    Chain.ARBITRUM_ONE: ARBITRUM_ONE_RPC,
     Chain.BASE: BASE_RPC,
     Chain.CELO: CELO_RPC,
-    Chain.OPTIMISM: OPTIMISM_RPC,
+    Chain.ETHEREUM: ETHEREUM_RPC,
+    Chain.GNOSIS: GNOSIS_RPC,
     Chain.MODE: MODE_RPC,
+    Chain.OPTIMISM: OPTIMISM_RPC,
+    Chain.POLYGON: POLYGON_RPC,
+    Chain.SOLANA: SOLANA_RPC,
 }
 
 # Base currency for each chain
 CURRENCY_DENOMS = {
-    Chain.ETHEREUM: "ETH",
-    Chain.GNOSIS: "xDAI",
-    Chain.SOLANA: "SOL",
+    Chain.ARBITRUM_ONE: "ETH",
     Chain.BASE: "ETH",
     Chain.CELO: "CELO",
-    Chain.OPTIMISM: "ETH",
+    Chain.ETHEREUM: "ETH",
+    Chain.GNOSIS: "xDAI",
     Chain.MODE: "ETH",
+    Chain.OPTIMISM: "ETH",
+    Chain.POLYGON: "POL",
+    Chain.SOLANA: "SOL",
 }
 
 # Smallest denomination for each chain
 CURRENCY_SMALLEST_UNITS = {
-    Chain.ETHEREUM: "Wei",
-    Chain.GNOSIS: "Wei",
-    Chain.SOLANA: "Lamport",
+    Chain.ARBITRUM_ONE: "Wei",
     Chain.BASE: "Wei",
     Chain.CELO: "Wei",
-    Chain.OPTIMISM: "Wei",
+    Chain.ETHEREUM: "Wei",
+    Chain.GNOSIS: "Wei",
     Chain.MODE: "Wei",
+    Chain.OPTIMISM: "Wei",
+    Chain.POLYGON: "Wei",
+    Chain.SOLANA: "Lamport",
 }
 
 

operate/migration.py

@@ -29,11 +29,10 @@ from time import time
 
 from aea_cli_ipfs.ipfs_utils import IPFSTool
 
-from operate.constants import ZERO_ADDRESS
+from operate.constants import USER_JSON, ZERO_ADDRESS
 from operate.operate_types import Chain, LedgerType
 from operate.services.manage import ServiceManager
 from operate.services.service import (
-    DEFAULT_TRADER_ENV_VARS,
     NON_EXISTENT_MULTISIG,
     SERVICE_CONFIG_PREFIX,
     SERVICE_CONFIG_VERSION,
@@ -43,11 +42,67 @@ from operate.utils import create_backup
 from operate.wallet.master import LEDGER_TYPE_TO_WALLET_CLASS, MasterWalletManager
 
 
+DEFAULT_TRADER_ENV_VARS = {
+    "GNOSIS_LEDGER_RPC": {
+        "name": "Gnosis ledger RPC",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+    "STAKING_CONTRACT_ADDRESS": {
+        "name": "Staking contract address",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+    "MECH_MARKETPLACE_CONFIG": {
+        "name": "Mech marketplace configuration",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+    "MECH_ACTIVITY_CHECKER_CONTRACT": {
+        "name": "Mech activity checker contract",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+    "MECH_CONTRACT_ADDRESS": {
+        "name": "Mech contract address",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+    "MECH_REQUEST_PRICE": {
+        "name": "Mech request price",
+        "description": "",
+        "value": "10000000000000000",
+        "provision_type": "computed",
+    },
+    "USE_MECH_MARKETPLACE": {
+        "name": "Use Mech marketplace",
+        "description": "",
+        "value": "False",
+        "provision_type": "computed",
+    },
+    "REQUESTER_STAKING_INSTANCE_ADDRESS": {
+        "name": "Requester staking instance address",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+    "PRIORITY_MECH_ADDRESS": {
+        "name": "Priority Mech address",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+}
+
+
 class MigrationManager:
     """MigrationManager"""
 
-    # TODO Backport here migration for services/config.json, etc.
-
     def __init__(
         self,
         home: Path,
@@ -62,12 +117,12 @@ class MigrationManager:
         """Log directories present in `path`."""
         directories = [f"  - {str(p)}" for p in path.iterdir() if p.is_dir()]
         directories_str = "\n".join(directories)
-        self.logger.info(f"Directories in {path}\n: {directories_str}")
+        self.logger.info(f"Directories in {path}:\n{directories_str}")
 
     def migrate_user_account(self) -> None:
         """Migrates user.json"""
 
-        path = self._path / "user.json"
+        path = self._path / USER_JSON
         if not path.exists():
             return
 
@@ -102,18 +157,22 @@ class MigrationManager:
 
         self.logger.info("Migrating wallet configs done.")
 
-    @staticmethod
     def _migrate_service(  # pylint: disable=too-many-statements,too-many-locals
+        self,
         path: Path,
     ) -> bool:
         """Migrate the JSON file format if needed."""
 
         if not path.is_dir():
+            self.logger.warning(f"Service config path {path} is not a directory.")
             return False
 
         if not path.name.startswith(SERVICE_CONFIG_PREFIX) and not path.name.startswith(
             "bafybei"
         ):
+            self.logger.warning(
+                f"Service config path {path} is not a valid service config."
+            )
             return False
 
         if path.name.startswith("bafybei"):
@@ -155,6 +214,10 @@ class MigrationManager:
         if version == SERVICE_CONFIG_VERSION:
             return False
 
+        self.logger.info(
+            f"Migrating service config in {path} from version {version} to {SERVICE_CONFIG_VERSION}..."
+        )
+
         # Migration steps for older versions
         if version == 0:
             new_data = {
@@ -344,13 +407,9 @@ class MigrationManager:
         paths = list(service_manager.path.iterdir())
         for path in paths:
             try:
-                if path.name.startswith(SERVICE_CONFIG_PREFIX) or path.name.startswith(
-                    "bafybei"
-                ):
-                    self.logger.info(f"migrate_service_configs {str(path)}")
-                    migrated = self._migrate_service(path)
-                    if migrated:
-                        self.logger.info(f"Folder {str(path)} has been migrated.")
+                migrated = self._migrate_service(path)
+                if migrated:
+                    self.logger.info(f"Folder {str(path)} has been migrated.")
             except Exception as e:  # pylint: disable=broad-except
                 self.logger.error(
                     f"Failed to migrate service: {path.name}. Exception {e}: {traceback.format_exc()}"

operate/quickstart/reset_password.py

@@ -21,6 +21,7 @@
 from typing import TYPE_CHECKING
 
 from operate.account.user import UserAccount
+from operate.constants import USER_JSON
 from operate.operate_types import LedgerType
 from operate.quickstart.run_service import ask_confirm_password
 from operate.quickstart.utils import ask_or_get_from_env, print_section, print_title
@@ -36,7 +37,7 @@ def reset_password(operate: "OperateApp") -> None:
     print_title("Reset your password")
 
     # check if agent was started before
-    if not (operate._path / "user.json").exists():
+    if not (operate._path / USER_JSON).exists():
         print("No previous agent setup found. Exiting.")
         return
 
@@ -57,7 +58,7 @@ def reset_password(operate: "OperateApp") -> None:
     print("Resetting password of user account...")
     UserAccount.new(
         password=old_password,
-        path=operate._path / "user.json",
+        path=operate._path / USER_JSON,
     ).update(
         old_password=old_password,
         new_password=new_password,

operate/quickstart/run_service.py

@@ -34,7 +34,12 @@ from halo import Halo  # type: ignore[import]
 from web3.exceptions import Web3Exception
 
 from operate.account.user import UserAccount
-from operate.constants import IPFS_ADDRESS, NO_STAKING_PROGRAM_ID, OPERATE_HOME
+from operate.constants import (
+    IPFS_ADDRESS,
+    NO_STAKING_PROGRAM_ID,
+    OPERATE_HOME,
+    USER_JSON,
+)
 from operate.data import DATA_DIR
 from operate.data.contracts.staking_token.contract import StakingTokenContract
 from operate.ledger.profiles import STAKING, get_staking_contract
@@ -453,7 +458,7 @@ def ask_password_if_needed(operate: "OperateApp") -> None:
         password = ask_confirm_password()
         UserAccount.new(
             password=password,
-            path=operate._path / "user.json",
+            path=operate._path / USER_JSON,
         )
     else:
         _password = None

operate/services/manage.py

@@ -23,7 +23,6 @@ import asyncio
 import json
 import logging
 import os
-import tempfile
 import traceback
 import typing as t
 from collections import Counter, defaultdict
@@ -34,13 +33,20 @@ from pathlib import Path
 
 import requests
 from aea.helpers.base import IPFSHash
-from aea_ledger_ethereum import EthereumCrypto, LedgerApi
+from aea_ledger_ethereum import LedgerApi
 from autonomy.chain.base import registry_contracts
 from autonomy.chain.config import CHAIN_PROFILES, ChainType
 from autonomy.chain.metadata import IPFS_URI_PREFIX
 from web3 import Web3
 
-from operate.constants import IPFS_ADDRESS, ZERO_ADDRESS
+from operate.constants import (
+    AGENT_LOG_DIR,
+    AGENT_LOG_ENV_VAR,
+    AGENT_PERSISTENT_STORAGE_DIR,
+    AGENT_PERSISTENT_STORAGE_ENV_VAR,
+    IPFS_ADDRESS,
+    ZERO_ADDRESS,
+)
 from operate.data import DATA_DIR
 from operate.data.contracts.mech_activity.contract import MechActivityContract
 from operate.data.contracts.requester_activity_checker.contract import (
@@ -730,8 +736,8 @@ class ServiceManager:
 
         # Set environment variables for the service
         for dir_name, env_var_name in (
-            ("persistent_data", "STORE_PATH"),
-            ("benchmarks", "LOG_DIR"),
+            (AGENT_PERSISTENT_STORAGE_DIR, AGENT_PERSISTENT_STORAGE_ENV_VAR),
+            (AGENT_LOG_DIR, AGENT_LOG_ENV_VAR),
         ):
             dir_path = service.path / dir_name
             dir_path.mkdir(parents=True, exist_ok=True)
@@ -1318,18 +1324,17 @@ class ServiceManager:
                 service_config_id=service_config_id, chain=chain
             )
             self.logger.info("Swapping Safe owners")
-            sftxb.swap(  # noqa: E800
-                service_id=chain_data.token,  # noqa: E800
+            owner_crypto = self.keys_manager.get_crypto_instance(
+                address=current_safe_owners[0]
+            )
+            sftxb.swap(
+                service_id=chain_data.token,
                 multisig=chain_data.multisig,  # TODO this can be read from the registry
-                owner_key=str(
-                    self.keys_manager.get(
-                        key=current_safe_owners[0]
-                    ).private_key  # TODO allow multiple owners
-                ),  # noqa: E800
+                owner_cryptos=[owner_crypto],  # TODO allow multiple owners
                 new_owner_address=(
                     safe if safe else wallet.crypto.address
                 ),  # TODO it should always be safe address
-            )  # noqa: E800
+            )
 
         if withdrawal_address is not None:
             ethereum_crypto = KeysManager().get_crypto_instance(
@@ -1457,26 +1462,18 @@ class ServiceManager:
         if agent_is_service_safe_owner:
             self.logger.info("(Agent) Enabling recovery module in service Safe.")
             try:
-                with tempfile.NamedTemporaryFile(mode="w+", delete=True) as tmp_file:
-                    private_key = self.keys_manager.get(key=agent_address).private_key
-                    tmp_file.write(private_key)
-                    tmp_file.flush()
-                    crypto = EthereumCrypto(private_key_path=tmp_file.name)
-                    EthSafeTxBuilder._new_tx(  # pylint: disable=protected-access
-                        ledger_api=sftxb.ledger_api,
-                        crypto=crypto,
-                        chain_type=ChainType(chain),
-                        safe=service_safe_address,
-                    ).add(
-                        sftxb.get_enable_module_data(
-                            module_address=recovery_module_address,
-                            safe_address=service_safe_address,
-                        )
-                    ).settle()
-                    tmp_file.seek(0)
-                    tmp_file.write("\0" * len(private_key))
-                    tmp_file.flush()
-
+                crypto = self.keys_manager.get_crypto_instance(address=agent_address)
+                EthSafeTxBuilder._new_tx(  # pylint: disable=protected-access
+                    ledger_api=sftxb.ledger_api,
+                    crypto=crypto,
+                    chain_type=ChainType(chain),
+                    safe=service_safe_address,
+                ).add(
+                    sftxb.get_enable_module_data(
+                        module_address=recovery_module_address,
+                        safe_address=service_safe_address,
+                    )
+                ).settle()
                 self.logger.info(
                     "(Agent) Recovery module enabled successfully in service Safe."
                 )
@@ -2341,12 +2338,6 @@ class ServiceManager:
             deployment.delete()
         return deployment
 
-    def log_directories(self) -> None:
-        """Log directories."""
-        directories = [f"  - {str(p)}" for p in self.path.iterdir() if p.is_dir()]
-        directories_str = "\n".join(directories)
-        self.logger.info(f"Directories in {self.path}\n: {directories_str}")
-
     def update(
         self,
         service_config_id: str,

operate/services/protocol.py

@@ -34,7 +34,6 @@ from typing import Optional, Union, cast
 from aea.configurations.data_types import PackageType
 from aea.crypto.base import Crypto, LedgerApi
 from aea.helpers.base import IPFSHash, cd
-from aea_ledger_ethereum.ethereum import EthereumCrypto
 from autonomy.chain.base import registry_contracts
 from autonomy.chain.config import ChainConfigs, ChainType, ContractConfigs
 from autonomy.chain.constants import (
@@ -722,7 +721,11 @@ class _ChainUtil:
         ).get("owners", [])
 
     def swap(  # pylint: disable=too-many-arguments,too-many-locals
-        self, service_id: int, multisig: str, owner_key: str, new_owner_address: str
+        self,
+        service_id: int,
+        multisig: str,
+        owner_cryptos: t.List[Crypto],
+        new_owner_address: str,
     ) -> None:
         """Swap safe owner."""
         logging.info(f"Swapping safe for service {service_id} [{multisig}]...")
@@ -736,11 +739,6 @@ class _ChainUtil:
             retries=ON_CHAIN_INTERACT_RETRIES,
             sleep=ON_CHAIN_INTERACT_SLEEP,
         )
-        with tempfile.TemporaryDirectory() as temp_dir:
-            key_file = Path(temp_dir, "key.txt")
-            key_file.write_text(owner_key, encoding="utf-8")
-            owner_crypto = EthereumCrypto(private_key_path=str(key_file))
-        owner_cryptos: t.List[EthereumCrypto] = [owner_crypto]
         owners = [
             manager.ledger_api.api.to_checksum_address(owner_crypto.address)
             for owner_crypto in owner_cryptos
@@ -797,7 +795,7 @@ class _ChainUtil:
         tx = registry_contracts.gnosis_safe.get_raw_safe_transaction(
             ledger_api=manager.ledger_api,
             contract_address=multisig,
-            sender_address=owner_crypto.address,
+            sender_address=owner_cryptos[0].address,
             owners=tuple(owners),  # type: ignore
             to_address=tx_params["to_address"],
             value=tx_params["ether_value"],
@@ -806,7 +804,7 @@ class _ChainUtil:
             signatures_by_owner=owner_to_signature,
             operation=SafeOperation.DELEGATE_CALL.value,
         )
-        stx = owner_crypto.sign_transaction(tx)
+        stx = owner_cryptos[0].sign_transaction(tx)
         tx_digest = manager.ledger_api.send_signed_transaction(stx)
         receipt = manager.ledger_api.api.eth.wait_for_transaction_receipt(tx_digest)
         if receipt["status"] != 1:

operate/services/service.py

@@ -63,7 +63,12 @@ from autonomy.deploy.generators.docker_compose.base import DockerComposeGenerato
 from autonomy.deploy.generators.kubernetes.base import KubernetesGenerator
 from docker import from_env
 
-from operate.constants import CONFIG_JSON, DEPLOYMENT_DIR, DEPLOYMENT_JSON
+from operate.constants import (
+    AGENT_PERSISTENT_STORAGE_ENV_VAR,
+    CONFIG_JSON,
+    DEPLOYMENT_DIR,
+    DEPLOYMENT_JSON,
+)
 from operate.keys import KeysManager
 from operate.operate_http.exceptions import NotAllowed
 from operate.operate_types import (
@@ -98,75 +103,6 @@ SERVICE_CONFIG_PREFIX = "sc-"
 NON_EXISTENT_MULTISIG = None
 NON_EXISTENT_TOKEN = -1
 
-DEFAULT_TRADER_ENV_VARS = {
-    "GNOSIS_LEDGER_RPC": {
-        "name": "Gnosis ledger RPC",
-        "description": "",
-        "value": "",
-        "provision_type": "computed",
-    },
-    "STAKING_CONTRACT_ADDRESS": {
-        "name": "Staking contract address",
-        "description": "",
-        "value": "",
-        "provision_type": "computed",
-    },
-    "MECH_MARKETPLACE_CONFIG": {
-        "name": "Mech marketplace configuration",
-        "description": "",
-        "value": "",
-        "provision_type": "computed",
-    },
-    "MECH_ACTIVITY_CHECKER_CONTRACT": {
-        "name": "Mech activity checker contract",
-        "description": "",
-        "value": "",
-        "provision_type": "computed",
-    },
-    "MECH_CONTRACT_ADDRESS": {
-        "name": "Mech contract address",
-        "description": "",
-        "value": "",
-        "provision_type": "computed",
-    },
-    "MECH_REQUEST_PRICE": {
-        "name": "Mech request price",
-        "description": "",
-        "value": "10000000000000000",
-        "provision_type": "computed",
-    },
-    "USE_MECH_MARKETPLACE": {
-        "name": "Use Mech marketplace",
-        "description": "",
-        "value": "False",
-        "provision_type": "computed",
-    },
-    "REQUESTER_STAKING_INSTANCE_ADDRESS": {
-        "name": "Requester staking instance address",
-        "description": "",
-        "value": "",
-        "provision_type": "computed",
-    },
-    "PRIORITY_MECH_ADDRESS": {
-        "name": "Priority Mech address",
-        "description": "",
-        "value": "",
-        "provision_type": "computed",
-    },
-    "TOOLS_ACCURACY_HASH": {
-        "name": "Tools accuracy hash",
-        "description": "",
-        "value": "QmWgsqncF22hPLNTyWtDzVoKPJ9gmgR1jcuLL5t31xyzzr",
-        "provision_type": "fixed",
-    },
-    "ACC_INFO_FIELDS_REQUESTS": {
-        "name": "Acc info fields requests",
-        "description": "",
-        "value": "nr_responses",
-        "provision_type": "fixed",
-    },
-}
-
 AGENT_TYPE_IDS = {"mech": 37, "optimus": 40, "modius": 40, "trader": 25}
 
 
@@ -996,6 +932,40 @@ class Service(LocalResource):
             except Exception as e:  # pylint: disable=broad-except
                 print(f"Exception deleting {healthcheck_json_path}: {e}")
 
+    def get_agent_performance(self) -> t.Dict:
+        """Return the agent activity"""
+
+        # Default values
+        agent_performance: t.Dict[str, t.Any] = {
+            "timestamp": None,
+            "metrics": [],
+            "last_activity": None,
+            "last_chat_message": None,
+        }
+
+        agent_performance_json_path = (
+            Path(
+                self.env_variables.get(
+                    AGENT_PERSISTENT_STORAGE_ENV_VAR, {"value": "."}
+                ).get("value", ".")
+            )
+            / "agent_performance.json"
+        )
+
+        if agent_performance_json_path.exists():
+            try:
+                with open(agent_performance_json_path, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                if isinstance(data, dict):
+                    agent_performance.update(data)
+            except (json.JSONDecodeError, OSError) as e:
+                # Keep default values if file is invalid
+                print(
+                    f"Error reading file 'agent_performance.json': {e}"
+                )  # TODO Use logger
+
+        return dict(sorted(agent_performance.items()))
+
     def update(
         self,
         service_template: ServiceTemplate,

operate/wallet/master.py

@@ -69,9 +69,12 @@ class MasterWallet(LocalResource):
     """Master wallet."""
 
     path: Path
-    safes: t.Optional[t.Dict[Chain, str]] = {}
-    safe_chains: t.List[Chain] = []
+    address: str
+
+    safes: t.Dict[Chain, str] = field(default_factory=dict)
+    safe_chains: t.List[Chain] = field(default_factory=list)
     ledger_type: LedgerType
+    safe_nonce: t.Optional[int] = None
 
     _key: str
     _crypto: t.Optional[Crypto] = None
@@ -229,8 +232,8 @@ class EthereumMasterWallet(MasterWallet):
     path: Path
     address: str
 
-    safes: t.Optional[t.Dict[Chain, str]] = field(default_factory=dict)  # type: ignore
-    safe_chains: t.List[Chain] = field(default_factory=list)  # type: ignore
+    safes: t.Dict[Chain, str] = field(default_factory=dict)
+    safe_chains: t.List[Chain] = field(default_factory=list)
     ledger_type: LedgerType = LedgerType.ETHEREUM
     safe_nonce: t.Optional[int] = None  # For cross-chain reusability
 

operate/wallet/wallet_recovery_manager.py

@@ -0,0 +1,210 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------------------------
+#
+#   Copyright 2025 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.
+#
+# ------------------------------------------------------------------------------
+
+"""Wallet recovery manager"""
+
+import shutil
+import typing as t
+import uuid
+from logging import Logger
+from pathlib import Path
+
+from operate.account.user import UserAccount
+from operate.constants import USER_JSON, WALLETS_DIR
+from operate.utils.gnosis import get_owners
+from operate.wallet.master import MasterWalletManager
+
+
+RECOVERY_BUNDLE_PREFIX = "eb-"
+RECOVERY_NEW_OBJECTS_DIR = "tmp"
+RECOVERY_OLD_OBJECTS_DIR = "old"
+
+
+class WalletRecoveryError(Exception):
+    """WalletRecoveryError"""
+
+
+class WalletRecoveryManager:
+    """WalletRecoveryManager"""
+
+    def __init__(
+        self,
+        path: Path,
+        logger: Logger,
+        wallet_manager: MasterWalletManager,
+    ) -> None:
+        """Initialize master wallet manager."""
+        self.path = path
+        self.logger = logger
+        self.wallet_manager = wallet_manager
+
+    def initiate_recovery(self, new_password: str) -> t.Dict:
+        """Recovery step 1"""
+        self.logger.info("[WALLET RECOVERY MANAGER] Recovery step 1 start")
+
+        try:
+            _ = self.wallet_manager.password
+        except ValueError:
+            pass
+        else:
+            raise WalletRecoveryError(
+                "Wallet recovery cannot be executed while logged in."
+            )
+
+        if not new_password:
+            raise ValueError("'new_password' must be a non-empty string.")
+
+        bundle_id = f"{RECOVERY_BUNDLE_PREFIX}{str(uuid.uuid4())}"
+        new_root = self.path / bundle_id / RECOVERY_NEW_OBJECTS_DIR
+        new_root.mkdir(parents=True, exist_ok=False)
+        UserAccount.new(new_password, new_root / USER_JSON)
+
+        new_wallets_path = new_root / WALLETS_DIR
+        new_wallet_manager = MasterWalletManager(
+            path=new_wallets_path, logger=self.logger, password=new_password
+        )
+        new_wallet_manager.setup()
+
+        output = []
+        for wallet in self.wallet_manager:
+            ledger_type = wallet.ledger_type
+            new_wallet, new_mnemonic = new_wallet_manager.create(
+                ledger_type=ledger_type
+            )
+            self.logger.info(
+                f"[WALLET RECOVERY MANAGER] Created new wallet {ledger_type=} {new_wallet.address=}"
+            )
+            output.append(
+                {
+                    "current_wallet": wallet.json,
+                    "new_wallet": new_wallet.json,
+                    "new_mnemonic": new_mnemonic,
+                }
+            )
+
+        self.logger.info("[WALLET RECOVERY MANAGER] Recovery step 1 finish")
+
+        return {
+            "id": bundle_id,
+            "wallets": output,
+        }
+
+    def complete_recovery(  # pylint: disable=too-many-locals,too-many-statements
+        self, bundle_id: str, password: str, raise_if_inconsistent_owners: bool = True
+    ) -> None:
+        """Recovery step 2"""
+        self.logger.info("[WALLET RECOVERY MANAGER] Recovery step 2 start")
+
+        def _report_issue(msg: str) -> None:
+            self.logger.warning(f"[WALLET RECOVERY MANAGER] {msg}")
+            if raise_if_inconsistent_owners:
+                raise WalletRecoveryError(f"{msg}")
+
+        try:
+            _ = self.wallet_manager.password
+        except ValueError:
+            pass
+        else:
+            raise WalletRecoveryError(
+                "Wallet recovery cannot be executed while logged in."
+            )
+
+        if not password:
+            raise ValueError("'password' must be a non-empty string.")
+
+        if not bundle_id:
+            raise ValueError("'bundle_id' must be a non-empty string.")
+
+        root = self.path.parent  # .operate root
+        wallets_path = root / WALLETS_DIR
+        new_root = self.path / bundle_id / RECOVERY_NEW_OBJECTS_DIR
+        new_wallets_path = new_root / WALLETS_DIR
+        old_root = self.path / bundle_id / RECOVERY_OLD_OBJECTS_DIR
+
+        if not new_root.exists() or not new_root.is_dir():
+            raise KeyError(f"Recovery bundle {bundle_id} does not exist.")
+
+        if old_root.exists() and old_root.is_dir():
+            raise ValueError(f"Recovery bundle {bundle_id} has been executed already.")
+
+        new_user_account = UserAccount.load(new_root / USER_JSON)
+        if not new_user_account.is_valid(password=password):
+            raise ValueError("Password is not valid.")
+
+        new_wallet_manager = MasterWalletManager(
+            path=new_wallets_path, logger=self.logger, password=password
+        )
+
+        ledger_types = {item.ledger_type for item in self.wallet_manager}
+        new_ledger_types = {item.ledger_type for item in new_wallet_manager}
+
+        if ledger_types != new_ledger_types:
+            raise WalletRecoveryError(
+                f"Ledger type mismatch: {ledger_types=}, {new_ledger_types=}."
+            )
+
+        for wallet in self.wallet_manager:
+            new_wallet = next(
+                (w for w in new_wallet_manager if w.ledger_type == wallet.ledger_type)
+            )
+
+            all_backup_owners = set()
+            for chain, safe in wallet.safes.items():
+                ledger_api = wallet.ledger_api(chain=chain)
+                owners = get_owners(ledger_api=ledger_api, safe=safe)
+                if new_wallet.address not in owners:
+                    raise WalletRecoveryError(
+                        f"Incorrect owners. Wallet {new_wallet.address} is not an owner of Safe {safe} on {chain}."
+                    )
+                if wallet.address in owners:
+                    _report_issue(
+                        f"Inconsistent owners. Current wallet {wallet.address} is still an owner of Safe {safe} on {chain}."
+                    )
+                if len(owners) != 2:
+                    _report_issue(
+                        f"Inconsistent owners. Safe {safe} on {chain} has {len(owners)} != 2 owners."
+                    )
+                all_backup_owners.update(set(owners) - {new_wallet.address})
+
+            if len(all_backup_owners) != 1:
+                _report_issue(
+                    f"Inconsistent owners. Backup owners differ across Safes on chains {', '.join(chain.value for chain in wallet.safes.keys())}. "
+                    f"Found backup owners: {', '.join(map(str, all_backup_owners))}."
+                )
+
+            new_wallet.safes = wallet.safes.copy()
+            new_wallet.safe_chains = wallet.safe_chains.copy()
+            new_wallet.safe_nonce = wallet.safe_nonce
+            new_wallet.store()
+
+        # Update configuration recovery
+        try:
+            old_root.mkdir(parents=True, exist_ok=False)
+            shutil.move(str(wallets_path), str(old_root))
+            for file in root.glob(f"{USER_JSON}*"):
+                shutil.move(str(file), str(old_root / file.name))
+
+            shutil.move(str(new_wallets_path), str(root))
+            for file in new_root.glob(f"{USER_JSON}*"):
+                shutil.move(str(file), str(root / file.name))
+
+        except Exception as e:
+            raise RuntimeError from e
+
+        self.logger.info("[WALLET RECOVERY MANAGER] Recovery step 2 finish")