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

{olas_operate_middleware-0.7.0.dist-info → olas_operate_middleware-0.8.0.dist-info}/METADATA

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

{olas_operate_middleware-0.7.0.dist-info → olas_operate_middleware-0.8.0.dist-info}/RECORD

@@ -5,8 +5,8 @@ operate/bridge/bridge_manager.py,sha256=ZLUqrjB78F8skaGTz43WDzM3i7UQod60b19OCczl
 operate/bridge/providers/lifi_provider.py,sha256=FpAlBAA_gOt-oOHKhGaOQhhTZIL-hgYYo4IIw1FN7mo,14153
 operate/bridge/providers/native_bridge_provider.py,sha256=ZTLBdh9ttPWpX8IYvHyVU5y3pg1B1DG_vQ9DHVquDfw,24666
 operate/bridge/providers/provider.py,sha256=U-mgf02lS9g4tGgmDJZ4GQKX9kbf4bPQY-oNWsp3kUk,19813
-operate/bridge/providers/relay_provider.py,sha256=x1tLvH8wG5zoUoYWuN-se0PkKmHSbiBhTVR01MSLYck,16745
-operate/cli.py,sha256=QUo7vITNhXvFqNyyS1tYAjWD5E0KDuOvn_DEwiX31ms,47527
+operate/bridge/providers/relay_provider.py,sha256=krwui645N-Q0xmc3goDSUxJSpJYfxX18st_GQGKlF_A,16750
+operate/cli.py,sha256=lhX4eViV1lKx6jlLr7pmbGiNLeq2pkqlYXupZRRh9X0,47862
 operate/constants.py,sha256=oFkCw3p3fPA4MDft61e_tSIxNhpqWBauUpQF3ZSn9QI,2662
 operate/data/README.md,sha256=jGPyZTvg2LCGdllvmYxmFMkkkiXb6YWatbqIkcX3kv4,879
 operate/data/__init__.py,sha256=ttC51Yqk9c4ehpIgs1Qbe7aJvzkrbbdZ1ClaCxJYByE,864
@@ -55,27 +55,27 @@ operate/data/contracts/uniswap_v2_erc20/tests/__init__.py,sha256=3Arw8dsCsJz6hVO
 operate/data/contracts/uniswap_v2_erc20/tests/test_contract.py,sha256=FzZbw9OTcr_yvjOXpk9YcO-K40eyDARyybcfSHDg2Ps,13392
 operate/keys.py,sha256=soJfdXJvHo8ytWH6ShIndjUpkShPg3KzirLs7MoFe8I,3764
 operate/ledger/__init__.py,sha256=kC-SYcdOQcX-v4TIWpwkSdM8L0yimEmbaL33XNY4S7Q,3361
-operate/ledger/profiles.py,sha256=qaI-9yjeU9S1Qed_FIHH4mphQJ1jcrJyLJZn3R8ZqWY,13366
+operate/ledger/profiles.py,sha256=9o_04W6rjv3Dr73PUuDOfhFM1Sn4JrmHjEBwhVdHepE,12374
 operate/migration.py,sha256=asWzYYSLhp0QmWov1eyEb9iGjzwZNOPDed01Z3Jnnn8,1819
 operate/operate_http/__init__.py,sha256=dxCIVSUos23M4R-PFZZG6k5QrOlEiK0SxhCYSFNxh7U,4711
 operate/operate_http/exceptions.py,sha256=4UFzrn-GyDD71RhkaOyFPBynL6TrrtP3eywaaU3o4fc,1339
-operate/operate_types.py,sha256=XI4O_zbcXWVM64I4WN5LBIQ-uV9kbgAk0ri8TAlgd90,8020
+operate/operate_types.py,sha256=Ff6rpJIgoJ-wludFtW7nufAVkUyZ3_1TShCcn2KS8GQ,8228
 operate/pearl.py,sha256=yrTpSXLu_ML3qT-uNxq3kScOyo31JyxBujiSMfMUbcg,1690
 operate/quickstart/analyse_logs.py,sha256=18y0JRGEryLILM_Aj2nINyMlUodA42DaypjWLev1ENs,4297
-operate/quickstart/claim_staking_rewards.py,sha256=-cFsDM_qKyCo2PEqhDAeYp7cLK2DkT0yATT3zutXo_k,4143
+operate/quickstart/claim_staking_rewards.py,sha256=VVRhYQmWJ9xWigWA6vABugIllzC1VCoehnA_Wpg4DG4,4135
 operate/quickstart/reset_configs.py,sha256=t-gVt0_-Th-LADfVmjxxKXjE2if5w-MuEscGFyMw2u0,3450
 operate/quickstart/reset_password.py,sha256=_HHnwX032WKNja5koegQIy4By0rFXGcdQRgVlusf5GA,2644
-operate/quickstart/reset_staking.py,sha256=3FxL0XB59eomND-pphRCzZoysOdesexdcG0CWRjIh0c,5165
-operate/quickstart/run_service.py,sha256=f-3ZtdAazUi6YkKRu0vSLZQj8mJzbLERDjaLYpr9Oqo,27425
+operate/quickstart/reset_staking.py,sha256=f1_cM7QJWrCySpGJyHaDvpHbd_we39fHzBAlGLfHB_M,5157
+operate/quickstart/run_service.py,sha256=b2194M2TRi5Me4gZnC-TpWpajeh5eAgkNGwKpHpOK1A,27292
 operate/quickstart/stop_service.py,sha256=ENuFBd3KaTs0NFTy-6ECrp5XI8MRJcIOUevWF82WSt4,2094
-operate/quickstart/terminate_on_chain_service.py,sha256=2UVN03plvjo72a8LY9caTT8a-x6Ndn-7u70Ap2lvBdg,3031
-operate/quickstart/utils.py,sha256=F3Hv47Da_mmtUhGrWSc2O0lQ7OnNA0WPks83-Qdj9TE,9217
+operate/quickstart/terminate_on_chain_service.py,sha256=ZsUSZp-xiAaUipU3nXqZzIiu-KIX_x0r2baFdgFTeQE,3023
+operate/quickstart/utils.py,sha256=rv70bktB31q6uw5hNkT6u5yo0kdpG5DCQQrQ7000W80,9172
 operate/resource.py,sha256=iuLlUepc18XTk1rEeC3Skt1R0v6cHST9rQxR6h4Ldg0,5179
 operate/services/__init__.py,sha256=isrThS-Ccu5Sc15JZgkN4uTAVaSg-NwUUSDeTyJEqLk,855
-operate/services/agent_runner.py,sha256=1EQB6XfzShJf3F_84m0tgqip59HlKYZiRUVLR5kgWEU,7565
+operate/services/agent_runner.py,sha256=6tJePUJmlRxlIugT2fDaCJHSrQlDnl1t9pbg3-7EmCQ,7560
 operate/services/deployment_runner.py,sha256=eP1bnT3PdkYtPxi-4sZ6-Wopz8u88NkeZx7vOB2vkzc,22217
 operate/services/health_checker.py,sha256=pXtzFTLv4PK1OSbDCZ_RnOnvX31mPYRR16tbC7BsUNw,9754
-operate/services/manage.py,sha256=gIvgeKztouUGf-ln5pqOJHviag06lLks6DHWwTIbyBI,109730
+operate/services/manage.py,sha256=oDp4kMBAynPYqe3b2LM4kR9xefNxPVmmvO50XwTxFZQ,110310
 operate/services/protocol.py,sha256=0LcZk-zzQ2hYzZAkn_KIQGgT32Bq3_UsbBl7Ert3Ho8,60157
 operate/services/service.py,sha256=2fQeRbjc4PBzRQ4jD9peKjAwBMKABS_hNoe-BrRutPc,47250
 operate/services/utils/__init__.py,sha256=TvioaZ1mfTRUSCtrQoLNAp4WMVXyqEJqFJM4PxSQCRU,24
@@ -85,8 +85,8 @@ operate/utils/__init__.py,sha256=cFNP2XFpjJmDLskN0SzAk5FPdqaeN2Jn4MyVbFHmH2M,307
 operate/utils/gnosis.py,sha256=Z1IgGfQgKIrI7EyBpGFbJ2RFaeD4Fk_7D4P-_ZQfH6Q,17705
 operate/wallet/__init__.py,sha256=NGiozD3XhvkBi7_FaOWQ8x1thZPK4uGpokJaeDY_o2w,813
 operate/wallet/master.py,sha256=FQrchjWhJKgif3IXztxS0SHm7aVaAJYFQ-FEXQgxQes,31021
-olas_operate_middleware-0.7.0.dist-info/LICENSE,sha256=mdBDB-mWKV5Cz4ejBzBiKqan6Z8zVLAh9xwM64O2FW4,11339
-olas_operate_middleware-0.7.0.dist-info/METADATA,sha256=u4RwsPCZL1PJe6VTNP-613ObAqqMPkS7nUHxC5WkuoE,2034
-olas_operate_middleware-0.7.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-olas_operate_middleware-0.7.0.dist-info/entry_points.txt,sha256=dM1g2I7ODApKQFcgl5J4NGA7pfBTo6qsUTXM-j2OLlw,44
-olas_operate_middleware-0.7.0.dist-info/RECORD,,
+olas_operate_middleware-0.8.0.dist-info/LICENSE,sha256=mdBDB-mWKV5Cz4ejBzBiKqan6Z8zVLAh9xwM64O2FW4,11339
+olas_operate_middleware-0.8.0.dist-info/METADATA,sha256=8L8vv-OR6f3STUGttsNhvOr9Gb-C4-vZ4mhm5E18p2A,2034
+olas_operate_middleware-0.8.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+olas_operate_middleware-0.8.0.dist-info/entry_points.txt,sha256=dM1g2I7ODApKQFcgl5J4NGA7pfBTo6qsUTXM-j2OLlw,44
+olas_operate_middleware-0.8.0.dist-info/RECORD,,

operate/bridge/providers/relay_provider.py

@@ -173,7 +173,7 @@ class RelayProvider(Provider):
             "destinationChainId": Chain(to_chain).id,
             "recipient": to_address,
             "destinationCurrency": to_token,
-            "amount": to_amount,
+            "amount": str(to_amount),
             "tradeType": "EXACT_OUTPUT",
             "enableTrueExactOutput": False,
         }

operate/cli.py

@@ -75,12 +75,13 @@ from operate.utils.gnosis import get_assets_balances
 from operate.wallet.master import MasterWalletManager
 
 
-DEFAULT_HARDHAT_KEY = (
-    "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
-).encode()
 DEFAULT_MAX_RETRIES = 3
 USER_NOT_LOGGED_IN_ERROR = JSONResponse(
-    content={"error": "User not logged in!"}, status_code=HTTPStatus.UNAUTHORIZED
+    content={"error": "User not logged in."}, status_code=HTTPStatus.UNAUTHORIZED
+)
+ACCOUNT_NOT_FOUND_ERROR = JSONResponse(
+    content={"error": "User account not found."},
+    status_code=HTTPStatus.NOT_FOUND,
 )
 
 
@@ -130,7 +131,7 @@ class OperateApp:
         """Updates current password"""
 
         if not new_password:
-            raise ValueError("You must provide a new password.")
+            raise ValueError("'password' is required.")
 
         if not (
             self.user_account.is_valid(old_password)
@@ -147,7 +148,7 @@ class OperateApp:
         """Updates current password using the mnemonic"""
 
         if not new_password:
-            raise ValueError("You must provide a new password.")
+            raise ValueError("'password' is required.")
 
         mnemonic = mnemonic.strip().lower()
         if not self.wallet_manager.is_mnemonic_valid(mnemonic):
@@ -352,30 +353,27 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
             """Call the endpoint."""
             logger.info(f"Calling `{f.__name__}` with retries enabled")
             retries = 0
-            errors = []
             while retries < DEFAULT_MAX_RETRIES:
                 try:
                     return await f(request)
                 except (APIError, ProjectError) as e:
                     logger.error(f"Error {e}\n{traceback.format_exc()}")
-                    error = {"traceback": traceback.format_exc()}
-                    if "has active endpoints" in e.explanation:
-                        error["error"] = "Service is already running"
+                    if "has active endpoints" in str(e):
+                        error_msg = "Service is already running."
                     else:
-                        error["error"] = str(e)
-                    errors.append(error)
+                        error_msg = "Service deployment failed. Please check the logs."
                     return JSONResponse(
-                        content={"errors": errors},
+                        content={"error": error_msg},
                         status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
                     )
                 except Exception as e:  # pylint: disable=broad-except
-                    errors.append(
-                        {"error": str(e.args[0]), "traceback": traceback.format_exc()}
-                    )
-                    logger.error(f"Error {str(e.args[0])}\n{traceback.format_exc()}")
+                    logger.error(f"Error {str(e)}\n{traceback.format_exc()}")
                 retries += 1
             return JSONResponse(
-                content={"errors": errors}, status_code=HTTPStatus.INTERNAL_SERVER_ERROR
+                content={
+                    "error": "Operation failed after multiple attempts. Please try again later."
+                },
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
             )
 
         return _call
@@ -413,7 +411,7 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         """Setup account."""
         if operate.user_account is not None:
             return JSONResponse(
-                content={"error": "Account already exists"},
+                content={"error": "Account already exists."},
                 status_code=HTTPStatus.CONFLICT,
             )
 
@@ -436,10 +434,7 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
     ) -> t.Dict:
         """Update password."""
         if operate.user_account is None:
-            return JSONResponse(
-                content={"error": "Account does not exist."},
-                status_code=HTTPStatus.CONFLICT,
-            )
+            return ACCOUNT_NOT_FOUND_ERROR
 
         data = await request.json()
         old_password = data.get("old_password")
@@ -449,7 +444,7 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         if not old_password and not mnemonic:
             return JSONResponse(
                 content={
-                    "error": "You must provide exactly one of 'old_password' or 'mnemonic' (seed phrase).",
+                    "error": "Exactly one of 'old_password' or 'mnemonic' (seed phrase) is required.",
                 },
                 status_code=HTTPStatus.BAD_REQUEST,
             )
@@ -457,7 +452,7 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         if old_password and mnemonic:
             return JSONResponse(
                 content={
-                    "error": "You must provide exactly one of 'old_password' or 'mnemonic' (seed phrase), but not both.",
+                    "error": "Exactly one of 'old_password' or 'mnemonic' (seed phrase) is required.",
                 },
                 status_code=HTTPStatus.BAD_REQUEST,
             )
@@ -465,7 +460,7 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         if not new_password or len(new_password) < MIN_PASSWORD_LENGTH:
             return JSONResponse(
                 content={
-                    "error": f"Password must be at least {MIN_PASSWORD_LENGTH} characters long."
+                    "error": f"New password must be at least {MIN_PASSWORD_LENGTH} characters long."
                 },
                 status_code=HTTPStatus.BAD_REQUEST,
             )
@@ -474,27 +469,31 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
             if old_password:
                 operate.update_password(old_password, new_password)
                 return JSONResponse(
-                    content={"error": None, "message": "Password updated."}
+                    content={"error": None, "message": "Password updated successfully."}
                 )
             if mnemonic:
                 operate.update_password_with_mnemonic(mnemonic, new_password)
                 return JSONResponse(
                     content={
                         "error": None,
-                        "message": "Password updated using seed phrase.",
+                        "message": "Password updated successfully using seed phrase.",
                     }
                 )
 
             return JSONResponse(
-                content={"error": None, "message": "Password not updated."}
+                content={"error": "Password update failed."},
+                status_code=HTTPStatus.BAD_REQUEST,
             )
         except ValueError as e:
+            logger.error(f"Password update error: {e}\n{traceback.format_exc()}")
             return JSONResponse(
-                content={"error": str(e)}, status_code=HTTPStatus.BAD_REQUEST
+                content={"error": f"Failed to update password: {str(e)}"},
+                status_code=HTTPStatus.BAD_REQUEST,
             )
         except Exception as e:  # pylint: disable=broad-except
+            logger.error(f"Password update error: {e}\n{traceback.format_exc()}")
             return JSONResponse(
-                content={"error": str(e), "traceback": traceback.format_exc()},
+                content={"error": "Failed to update password. Please check the logs."},
                 status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
             )
 
@@ -503,21 +502,18 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
     async def _validate_password(request: Request) -> t.Dict:
         """Validate password."""
         if operate.user_account is None:
-            return JSONResponse(
-                content={"error": "Account does not exist"},
-                status_code=HTTPStatus.BAD_REQUEST,
-            )
+            return ACCOUNT_NOT_FOUND_ERROR
 
         data = await request.json()
         if not operate.user_account.is_valid(password=data["password"]):
             return JSONResponse(
-                content={"error": "Password is not valid"},
+                content={"error": "Password is not valid."},
                 status_code=HTTPStatus.UNAUTHORIZED,
             )
 
         operate.password = data["password"]
         return JSONResponse(
-            content={"message": "Login successful"},
+            content={"message": "Login successful."},
             status_code=HTTPStatus.OK,
         )
 
@@ -535,16 +531,10 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
     async def _create_wallet(request: Request) -> t.List[t.Dict]:
         """Create wallet"""
         if operate.user_account is None:
-            return JSONResponse(
-                content={"error": "Cannot create wallet; User account does not exist!"},
-                status_code=HTTPStatus.BAD_REQUEST,
-            )
+            return ACCOUNT_NOT_FOUND_ERROR
 
         if operate.password is None:
-            return JSONResponse(
-                content={"error": "You need to login before creating a wallet"},
-                status_code=HTTPStatus.UNAUTHORIZED,
-            )
+            return USER_NOT_LOGGED_IN_ERROR
 
         data = await request.json()
         ledger_type = LedgerType(data["ledger_type"])
@@ -564,23 +554,15 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
     async def _get_private_key(request: Request) -> t.List[t.Dict]:
         """Get Master EOA private key."""
         if operate.user_account is None:
-            return JSONResponse(
-                content={
-                    "error": "Cannot retrieve private key; User account does not exist!"
-                },
-                status_code=HTTPStatus.BAD_REQUEST,
-            )
+            return ACCOUNT_NOT_FOUND_ERROR
 
         data = await request.json()
         password = data.get("password")
-        error = None
         if operate.password is None:
-            error = {"error": "You need to login before retrieving the private key"}
+            return USER_NOT_LOGGED_IN_ERROR
         if operate.password != password:
-            error = {"error": "Password is not valid"}
-        if error is not None:
             return JSONResponse(
-                content=error,
+                content={"error": "Password is not valid."},
                 status_code=HTTPStatus.UNAUTHORIZED,
             )
 
@@ -618,12 +600,15 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         manager = operate.wallet_manager
         if not manager.exists(ledger_type=ledger_type):
             return JSONResponse(
-                content={"error": "Wallet does not exist"},
+                content={"error": "No Master EOA found for this chain."},
                 status_code=HTTPStatus.NOT_FOUND,
             )
         safes = manager.load(ledger_type=ledger_type).safes
         if safes is None or safes.get(chain) is None:
-            return JSONResponse(content={"error": "No safes found"})
+            return JSONResponse(
+                content={"error": "No Master Safe found for this chain."},
+                status_code=HTTPStatus.NOT_FOUND,
+            )
 
         return JSONResponse(
             content={
@@ -637,23 +622,17 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
     ) -> t.List[t.Dict]:
         """Create wallet safe"""
         if operate.user_account is None:
-            return JSONResponse(
-                content={"error": "Cannot create safe; User account does not exist!"},
-                status_code=HTTPStatus.BAD_REQUEST,
-            )
+            return ACCOUNT_NOT_FOUND_ERROR
 
         if operate.password is None:
-            return JSONResponse(
-                content={"error": "You need to login before creating a safe"},
-                status_code=HTTPStatus.UNAUTHORIZED,
-            )
+            return USER_NOT_LOGGED_IN_ERROR
 
         data = await request.json()
 
         if "initial_funds" in data and "transfer_excess_assets" in data:
             return JSONResponse(
                 content={
-                    "error": "You can only specify 'initial_funds' or 'transfer_excess_assets', but not both."
+                    "error": "Only specify one of 'initial_funds' or 'transfer_excess_assets', but not both."
                 },
                 status_code=HTTPStatus.BAD_REQUEST,
             )
@@ -664,14 +643,17 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         ledger_type = chain.ledger_type
         manager = operate.wallet_manager
         if not manager.exists(ledger_type=ledger_type):
-            return JSONResponse(content={"error": "Wallet does not exist"})
+            return JSONResponse(
+                content={"error": "No Master EOA found for this chain."},
+                status_code=HTTPStatus.NOT_FOUND,
+            )
 
         wallet = manager.load(ledger_type=ledger_type)
         if wallet.safes is not None and wallet.safes.get(chain) is not None:
             return JSONResponse(
                 content={
                     "safe": wallet.safes.get(chain),
-                    "message": f"Safe already exists {chain=}.",
+                    "message": "Safe already exists for this chain.",
                 }
             )
 
@@ -725,14 +707,15 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
                     "create_tx": create_tx,
                     "transfer_txs": transfer_txs,
                     "safe": safes.get(chain),
-                    "message": "Safe created!",
-                }
+                    "message": "Safe created successfully",
+                },
+                status_code=HTTPStatus.CREATED,
             )
         except Exception as e:  # pylint: disable=broad-except
-            logger.error(traceback.format_exc())
+            logger.error(f"Safe creation failed: {e}\n{traceback.format_exc()}")
             return JSONResponse(
                 status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                content={"error": str(e), "traceback": traceback.format_exc()},
+                content={"error": "Failed to create safe. Please check the logs."},
             )
 
     @app.put("/api/wallet/safe")
@@ -741,22 +724,16 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         """Update wallet safe"""
         # TODO: Extract login check as decorator
         if operate.user_account is None:
-            return JSONResponse(
-                content={"error": "Cannot update safe; User account does not exist!"},
-                status_code=HTTPStatus.BAD_REQUEST,
-            )
+            return ACCOUNT_NOT_FOUND_ERROR
 
         if operate.password is None:
-            return JSONResponse(
-                content={"error": "You need to login before updating a safe."},
-                status_code=HTTPStatus.UNAUTHORIZED,
-            )
+            return USER_NOT_LOGGED_IN_ERROR
 
         data = await request.json()
 
         if "chain" not in data:
             return JSONResponse(
-                content={"error": "You need to specify a chain to update a safe."},
+                content={"error": "'chain' is required."},
                 status_code=HTTPStatus.BAD_REQUEST,
             )
 
@@ -765,7 +742,7 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         manager = operate.wallet_manager
         if not manager.exists(ledger_type=ledger_type):
             return JSONResponse(
-                content={"error": "Wallet does not exist"},
+                content={"error": "No Master EOA found for this chain."},
                 status_code=HTTPStatus.BAD_REQUEST,
             )
 
@@ -778,12 +755,12 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
 
         backup_owner_updated = wallet.update_backup_owner(
             chain=chain,
-            backup_owner=backup_owner,  # Optional value, it's fine to provide 'None' (set no backup owner/remove backup owner)
+            backup_owner=backup_owner,
         )
         message = (
-            "Backup owner updated."
+            "Backup owner updated successfully"
             if backup_owner_updated
-            else "No changes on backup owner. The backup owner provided matches the current one."
+            else "Backup owner is already set to this address"
         )
         return JSONResponse(
             content={
@@ -968,7 +945,7 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         withdrawal_address = (await request.json()).get("withdrawal_address")
         if withdrawal_address is None:
             return JSONResponse(
-                content={"error": "withdrawal_address is required"},
+                content={"error": "'withdrawal_address' is required"},
                 status_code=HTTPStatus.BAD_REQUEST,
             )
 
@@ -1010,13 +987,13 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
                 from_safe=False,
             )
         except Exception as e:  # pylint: disable=broad-except
-            logger.error(traceback.format_exc())
+            logger.error(f"Withdrawal failed: {e}\n{traceback.format_exc()}")
             return JSONResponse(
                 status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                content={"error": str(e), "traceback": traceback.format_exc()},
+                content={"error": "Failed to withdraw funds. Please check the logs."},
             )
 
-        return JSONResponse(content={"error": None})
+        return JSONResponse(content={"error": None, "message": "Withdrawal successful"})
 
     @app.post("/api/bridge/bridge_refill_requirements")
     @with_retries
@@ -1037,19 +1014,26 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
                 status_code=HTTPStatus.OK,
             )
         except ValueError as e:
+            logger.error(f"Bridge refill requirements error: {e}")
             return JSONResponse(
-                content={"error": str(e)}, status_code=HTTPStatus.BAD_REQUEST
+                content={"error": "Invalid bridge request parameters."},
+                status_code=HTTPStatus.BAD_REQUEST,
             )
         except Exception as e:  # pylint: disable=broad-except
+            logger.error(
+                f"Bridge refill requirements error: {e}\n{traceback.format_exc()}"
+            )
             return JSONResponse(
-                content={"error": str(e), "traceback": traceback.format_exc()},
+                content={
+                    "error": "Failed to get bridge requirements. Please check the logs."
+                },
                 status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
             )
 
     @app.post("/api/bridge/execute")
     @with_retries
     async def _bridge_execute(request: Request) -> JSONResponse:
-        """Get the bridge refill requirements."""
+        """Execute bridge transaction."""
         if operate.password is None:
             return USER_NOT_LOGGED_IN_ERROR
 
@@ -1062,12 +1046,17 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
                 status_code=HTTPStatus.OK,
             )
         except ValueError as e:
+            logger.error(f"Bridge execute error: {e}")
             return JSONResponse(
-                content={"error": str(e)}, status_code=HTTPStatus.BAD_REQUEST
+                content={"error": "Invalid bundle ID or transaction failed."},
+                status_code=HTTPStatus.BAD_REQUEST,
             )
         except Exception as e:  # pylint: disable=broad-except
+            logger.error(f"Bridge execute error: {e}\n{traceback.format_exc()}")
             return JSONResponse(
-                content={"error": str(e), "traceback": traceback.format_exc()},
+                content={
+                    "error": "Failed to execute bridge transaction. Please check the logs."
+                },
                 status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
             )
 
@@ -1081,7 +1070,7 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
     @app.get("/api/bridge/status/{id}")
     @with_retries
     async def _bridge_status(request: Request) -> JSONResponse:
-        """Get the bridge refill requirements."""
+        """Get bridge transaction status."""
 
         quote_bundle_id = request.path_params["id"]
 
@@ -1093,12 +1082,17 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
                 status_code=HTTPStatus.OK,
             )
         except ValueError as e:
+            logger.error(f"Bridge status error: {e}")
             return JSONResponse(
-                content={"error": str(e)}, status_code=HTTPStatus.BAD_REQUEST
+                content={"error": "Invalid bundle ID."},
+                status_code=HTTPStatus.BAD_REQUEST,
             )
         except Exception as e:  # pylint: disable=broad-except
+            logger.error(f"Bridge status error: {e}\n{traceback.format_exc()}")
             return JSONResponse(
-                content={"error": str(e), "traceback": traceback.format_exc()},
+                content={
+                    "error": "Failed to get bridge status. Please check the logs."
+                },
                 status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
             )
 
@@ -1114,20 +1108,35 @@ def _operate() -> None:
 def _daemon(
     host: Annotated[str, params.String(help="HTTP server host string")] = "localhost",
     port: Annotated[int, params.Integer(help="HTTP server port")] = 8000,
+    ssl_keyfile: Annotated[str, params.String(help="Path to SSL key file")] = "",
+    ssl_certfile: Annotated[
+        str, params.String(help="Path to SSL certificate file")
+    ] = "",
     home: Annotated[
         t.Optional[Path], params.Directory(long_flag="--home", help="Home directory")
     ] = None,
 ) -> None:
     """Launch operate daemon."""
     app = create_app(home=home)
-
-    server = Server(
-        Config(
-            app=app,
-            host=host,
-            port=port,
+    logger = setup_logger(name="daemon")
+
+    config_kwargs = {
+        "app": app,
+        "host": host,
+        "port": port,
+    }
+
+    # Use SSL certificates if ssl_keyfile and ssl_certfile are provided
+    if ssl_keyfile and ssl_certfile:
+        logger.info(f"Using SSL certificates: {ssl_certfile}")
+        config_kwargs.update(
+            {
+                "ssl_keyfile": ssl_keyfile,
+                "ssl_certfile": ssl_certfile,
+            }
         )
-    )
+
+    server = Server(Config(**config_kwargs))
     app._server = server  # pylint: disable=protected-access
     server.run()
 

operate/ledger/profiles.py

@@ -19,7 +19,6 @@
 
 """Chain profiles."""
 
-import enum
 import typing as t
 
 from operate.constants import ZERO_ADDRESS
@@ -156,26 +155,15 @@ STAKING: t.Dict[Chain, t.Dict[str, str]] = {
 }
 
 
-class StakingProgramMechType(enum.Enum):
-    """Staking program mech type."""
-
-    LEGACY_MECH = "legacy_mech"
-    LEGACY_MECH_MARKETPLACE = "legacy_mech_marketplace"
-    MECH_MARKETPLACE = "mech_marketplace"
-
-    def __str__(self) -> str:
-        """Get the string representation of the enum."""
-        return self.value
-
-
-DEFAULT_PRIORITY_MECH_ADDRESS = {
-    StakingProgramMechType.LEGACY_MECH: "0x77af31De935740567Cf4fF1986D04B2c964A786a",
-    StakingProgramMechType.LEGACY_MECH_MARKETPLACE: "0x552cEA7Bc33CbBEb9f1D90c1D11D2C6daefFd053",
-    StakingProgramMechType.MECH_MARKETPLACE: "0xC05e7412439bD7e91730a6880E18d5D5873F632C",
-}
-DEFAULT_PRIORITY_MECH_SERVICE_ID = {
-    StakingProgramMechType.LEGACY_MECH_MARKETPLACE: 975,
-    StakingProgramMechType.MECH_MARKETPLACE: 2182,
+DEFAULT_PRIORITY_MECH = {  # maps mech marketplace address to its default priority mech address and service id
+    "0x4554fE75c1f5576c1d7F765B2A036c199Adae329": (
+        "0x552cEA7Bc33CbBEb9f1D90c1D11D2C6daefFd053",
+        975,
+    ),
+    "0x735FAAb1c4Ec41128c367AFb5c3baC73509f70bB": (
+        "0xC05e7412439bD7e91730a6880E18d5D5873F632C",
+        2182,
+    ),
 }
 
 
@@ -269,17 +257,3 @@ def get_staking_contract(
         staking_program_id,
         staking_program_id,
     )
-
-
-def get_staking_program_mech_type(
-    staking_program_id: t.Optional[str],
-) -> StakingProgramMechType:
-    """Get the staking program mech type based on the staking program ID."""
-    if staking_program_id is None:
-        return StakingProgramMechType.LEGACY_MECH
-
-    if staking_program_id.startswith("quickstart_beta_mech_marketplace_expert"):
-        return StakingProgramMechType.MECH_MARKETPLACE
-    if "mech_marketplace" in staking_program_id:
-        return StakingProgramMechType.LEGACY_MECH_MARKETPLACE
-    return StakingProgramMechType.LEGACY_MECH

operate/operate_types.py

@@ -329,3 +329,13 @@ class AssetFundingValues(TypedDict):
 
 
 FundingValues = t.Dict[str, AssetFundingValues]  # str is the asset address
+
+
+@dataclass
+class MechMarketplaceConfig:
+    """Mech Marketplace config."""
+
+    use_mech_marketplace: bool
+    mech_marketplace_address: str
+    priority_mech_address: str
+    priority_mech_service_id: int

operate/quickstart/claim_staking_rewards.py

@@ -73,7 +73,7 @@ def claim_staking_rewards(operate: "OperateApp", config_path: str) -> None:
     config = configure_local_config(template, operate)
     manager = operate.service_manager()
     service = get_service(manager, template)
-    ask_password_if_needed(operate, config)
+    ask_password_if_needed(operate)
 
     # reload manger and config after setting operate.password
     manager = operate.service_manager()

operate/quickstart/reset_staking.py

@@ -82,7 +82,7 @@ def reset_staking(operate: "OperateApp", config_path: str) -> None:
         print("Cancelled.")
         return
 
-    ask_password_if_needed(operate, config)
+    ask_password_if_needed(operate)
     manager = operate.service_manager()
     service = get_service(manager, template)
 

operate/quickstart/run_service.py

@@ -37,14 +37,7 @@ 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 (
-    DEFAULT_PRIORITY_MECH_ADDRESS,
-    DEFAULT_PRIORITY_MECH_SERVICE_ID,
-    NO_STAKING_PROGRAM_ID,
-    STAKING,
-    get_staking_contract,
-    get_staking_program_mech_type,
-)
+from operate.ledger.profiles import NO_STAKING_PROGRAM_ID, STAKING, get_staking_contract
 from operate.operate_types import (
     Chain,
     LedgerType,
@@ -208,9 +201,6 @@ def configure_local_config(
             )
         os.environ[f"{chain.upper()}_LEDGER_RPC"] = config.rpc[chain]
 
-    if config.password_migrated is None:
-        config.password_migrated = False
-
     config.principal_chain = template["home_chain"]
 
     home_chain = Chain.from_string(config.principal_chain)
@@ -396,15 +386,18 @@ 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)
+    service_manager = operate.service_manager()
+    mech_configs = service_manager.get_mech_configs(
+        chain=config.principal_chain,
+        ledger_api=ledger_api,
+        staking_program_id=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
-                ]
+                env_var_data["value"] = mech_configs.priority_mech_address
                 if (
                     env_var_name in config.user_provided_args
                     and env_var_data["value"] != config.user_provided_args[env_var_name]
@@ -412,9 +405,7 @@ def configure_local_config(
                     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)
-                )
+                env_var_data["value"] = mech_configs.priority_mech_service_id
                 if (
                     env_var_name in config.user_provided_args
                     and env_var_data["value"] != config.user_provided_args[env_var_name]
@@ -456,7 +447,7 @@ def configure_local_config(
     return config
 
 
-def ask_password_if_needed(operate: "OperateApp", config: QuickstartConfig) -> None:
+def ask_password_if_needed(operate: "OperateApp") -> None:
     """Ask password if needed."""
     if operate.user_account is None:
         print_section("Set up local user account")
@@ -466,8 +457,6 @@ def ask_password_if_needed(operate: "OperateApp", config: QuickstartConfig) -> N
             password=password,
             path=operate._path / "user.json",
         )
-        config.password_migrated = True
-        config.store()
     else:
         _password = None
         while _password is None:
@@ -620,8 +609,8 @@ def _ask_funds_from_requirements(
     return False
 
 
-def ensure_enough_funds(operate: "OperateApp", service: Service) -> None:
-    """Ensure enough funds."""
+def _maybe_create_master_eoa(operate: "OperateApp") -> None:
+    """Maybe create the Master EOA."""
     if not operate.wallet_manager.exists(ledger_type=LedgerType.ETHEREUM):
         print("Creating the Master EOA...")
         wallet, mnemonic = operate.wallet_manager.create(
@@ -636,9 +625,12 @@ def ensure_enough_funds(operate: "OperateApp", service: Service) -> None:
         ask_or_get_from_env(
             "Press enter to continue...", False, "CONTINUE", raise_if_missing=False
         )
-    else:
-        wallet = operate.wallet_manager.load(ledger_type=LedgerType.ETHEREUM)
 
+
+def ensure_enough_funds(operate: "OperateApp", service: Service) -> None:
+    """Ensure enough funds."""
+    _maybe_create_master_eoa(operate)
+    wallet = operate.wallet_manager.load(ledger_type=LedgerType.ETHEREUM)
     manager = operate.service_manager()
 
     backup_owner = None
@@ -677,11 +669,12 @@ def run_service(
 
     operate.service_manager().migrate_service_configs()
     operate.wallet_manager.migrate_wallet_configs()
+    ask_password_if_needed(operate)
+    _maybe_create_master_eoa(operate)
 
     config = configure_local_config(template, operate)
     manager = operate.service_manager()
     service = get_service(manager, template)
-    ask_password_if_needed(operate, config)
 
     # reload manger and config after setting operate.password
     manager = operate.service_manager(skip_dependency_check=skip_dependency_check)

operate/quickstart/terminate_on_chain_service.py

@@ -62,7 +62,7 @@ def terminate_service(operate: "OperateApp", config_path: str) -> None:
         return
 
     config = configure_local_config(template, operate)
-    ask_password_if_needed(operate, config)
+    ask_password_if_needed(operate)
     manager = operate.service_manager()
     service = get_service(manager, template)
     ensure_enough_funds(operate, service)

operate/quickstart/utils.py

@@ -277,7 +277,6 @@ class QuickstartConfig(LocalResource):
 
     path: Path
     rpc: Optional[Dict[str, str]] = None
-    password_migrated: Optional[bool] = None
     staking_program_id: Optional[str] = None
     principal_chain: Optional[str] = None
     user_provided_args: Optional[Dict[str, str]] = None

operate/services/agent_runner.py

@@ -71,7 +71,7 @@ AGENTS_SUPPORTED = {
         owner="valory-xyz", repo="optimus", release="v0.0.103"
     ),
     "dvilela/memeooorr": AgentRelease(
-        owner="valory-xyz", repo="meme-ooorr-test", release="v0.0.101"
+        owner="valory-xyz", repo="meme-ooorr", release="v0.0.101"
     ),
 }
 

operate/services/manage.py

@@ -36,7 +36,7 @@ from pathlib import Path
 import requests
 from aea.helpers.base import IPFSHash
 from aea.helpers.logging import setup_logger
-from aea_ledger_ethereum import EthereumCrypto
+from aea_ledger_ethereum import EthereumCrypto, LedgerApi
 from autonomy.chain.base import registry_contracts
 from autonomy.chain.config import CHAIN_PROFILES, ChainType
 
@@ -52,19 +52,18 @@ from operate.ledger import PUBLIC_RPCS, get_currency_denom
 from operate.ledger.profiles import (
     CONTRACTS,
     DEFAULT_MASTER_EOA_FUNDS,
-    DEFAULT_PRIORITY_MECH_ADDRESS,
-    DEFAULT_PRIORITY_MECH_SERVICE_ID,
+    DEFAULT_PRIORITY_MECH,
     OLAS,
     STAKING,
     USDC,
     WRAPPED_NATIVE_ASSET,
     get_staking_contract,
-    get_staking_program_mech_type,
 )
 from operate.operate_types import (
     Chain,
     FundingValues,
     LedgerConfig,
+    MechMarketplaceConfig,
     OnChainState,
     ServiceEnvProvisionType,
     ServiceTemplate,
@@ -520,6 +519,103 @@ class ServiceManager:
                 chain=chain,
             )
 
+    def get_mech_configs(
+        self,
+        chain: str,
+        ledger_api: LedgerApi,
+        staking_program_id: str | None = None,
+    ) -> MechMarketplaceConfig:
+        """Get the mech configs."""
+        sftxb = self.get_eth_safe_tx_builder(
+            ledger_config=LedgerConfig(
+                chain=Chain(chain),
+                rpc=ledger_api.api.provider.endpoint_uri,
+            )
+        )
+        staking_contract = get_staking_contract(
+            chain=chain,
+            staking_program_id=staking_program_id,
+        )
+        if staking_contract is None:
+            return MechMarketplaceConfig(
+                use_mech_marketplace=False,
+                mech_marketplace_address=ZERO_ADDRESS,
+                priority_mech_address=ZERO_ADDRESS,
+                priority_mech_service_id=0,
+            )
+
+        target_staking_params = sftxb.get_staking_params(
+            staking_contract=get_staking_contract(
+                chain=chain,
+                staking_program_id=staking_program_id,
+            ),
+        )
+
+        try:
+            # Try if activity checker is a MechActivityChecker contract
+            mech_activity_contract = t.cast(
+                MechActivityContract,
+                MechActivityContract.from_dir(
+                    directory=str(DATA_DIR / "contracts" / "mech_activity")
+                ),
+            )
+
+            priority_mech_address = (
+                mech_activity_contract.get_instance(
+                    ledger_api=ledger_api,
+                    contract_address=target_staking_params["activity_checker"],
+                )
+                .functions.agentMech()
+                .call()
+            )
+            use_mech_marketplace = False
+            mech_marketplace_address = ZERO_ADDRESS
+            priority_mech_service_id = 0
+
+        except Exception:  # pylint: disable=broad-except
+            # Try if activity checker is a RequesterActivityChecker contract
+            try:
+                requester_activity_checker = t.cast(
+                    RequesterActivityCheckerContract,
+                    RequesterActivityCheckerContract.from_dir(
+                        directory=str(
+                            DATA_DIR / "contracts" / "requester_activity_checker"
+                        )
+                    ),
+                )
+
+                mech_marketplace_address = (
+                    requester_activity_checker.get_instance(
+                        ledger_api=ledger_api,
+                        contract_address=target_staking_params["activity_checker"],
+                    )
+                    .functions.mechMarketplace()
+                    .call()
+                )
+
+                use_mech_marketplace = True
+                priority_mech_address, priority_mech_service_id = DEFAULT_PRIORITY_MECH[
+                    mech_marketplace_address
+                ]
+
+            except Exception as e:  # pylint: disable=broad-except
+                self.logger.error(f"{e}: {traceback.format_exc()}")
+                self.logger.warning(
+                    "Cannot determine type of activity checker contract. Using default parameters. "
+                    "NOTE: This will be an exception in the future!"
+                )
+                priority_mech_address = "0x77af31De935740567Cf4fF1986D04B2c964A786a"
+                use_mech_marketplace = False
+                mech_marketplace_address = ZERO_ADDRESS
+                priority_mech_service_id = 0
+
+        return MechMarketplaceConfig(
+            use_mech_marketplace=use_mech_marketplace,
+            mech_marketplace_address=mech_marketplace_address,
+            priority_mech_address=priority_mech_address,
+            priority_mech_service_id=priority_mech_service_id,
+        )
+
     def _deploy_service_onchain_from_safe(  # pylint: disable=too-many-statements,too-many-locals
         self,
         service_config_id: str,
@@ -556,10 +652,6 @@ 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],
@@ -588,94 +680,29 @@ class ServiceManager:
         # TODO A customized, arbitrary computation mechanism should be devised.
         env_var_to_value = {}
         if chain == service.home_chain:
-            # Try if activity checker is a MechActivityChecker contract
-            try:
-                mech_activity_contract = t.cast(
-                    MechActivityContract,
-                    MechActivityContract.from_dir(
-                        directory=str(DATA_DIR / "contracts" / "mech_activity")
-                    ),
-                )
-
-                agent_mech = (
-                    mech_activity_contract.get_instance(
-                        ledger_api=sftxb.ledger_api,
-                        contract_address=target_staking_params["activity_checker"],
-                    )
-                    .functions.agentMech()
-                    .call()
-                )
-                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
-                try:
-                    requester_activity_checker = t.cast(
-                        RequesterActivityCheckerContract,
-                        RequesterActivityCheckerContract.from_dir(
-                            directory=str(
-                                DATA_DIR / "contracts" / "requester_activity_checker"
-                            )
-                        ),
-                    )
-
-                    mech_marketplace_address = (
-                        requester_activity_checker.get_instance(
-                            ledger_api=sftxb.ledger_api,
-                            contract_address=target_staking_params["activity_checker"],
-                        )
-                        .functions.mechMarketplace()
-                        .call()
-                    )
+            mech_configs: MechMarketplaceConfig = self.get_mech_configs(
+                chain=chain,
+                ledger_api=sftxb.ledger_api,
+                staking_program_id=user_params.staking_program_id,
+            )
 
-                    use_mech_marketplace = True
-                    if (
-                        "PRIORITY_MECH_ADDRESS" in service.env_variables
-                        and service.env_variables["PRIORITY_MECH_ADDRESS"][
-                            "provision_type"
-                        ]
-                        == ServiceEnvProvisionType.USER
-                    ):
-                        agent_mech = priority_mech_address = service.env_variables[
-                            "PRIORITY_MECH_ADDRESS"
-                        ]["value"]
-                    else:
-                        agent_mech = (
-                            priority_mech_address
-                        ) = 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
-                        )
+            if (
+                "PRIORITY_MECH_ADDRESS" in service.env_variables
+                and service.env_variables["PRIORITY_MECH_ADDRESS"]["provision_type"]
+                == ServiceEnvProvisionType.USER
+            ):
+                mech_configs.priority_mech_address = service.env_variables[
+                    "PRIORITY_MECH_ADDRESS"
+                ]["value"]
 
-                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 = 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
+            if (
+                "PRIORITY_MECH_SERVICE_ID" in service.env_variables
+                and service.env_variables["PRIORITY_MECH_SERVICE_ID"]["provision_type"]
+                == ServiceEnvProvisionType.USER
+            ):
+                mech_configs.priority_mech_service_id = service.env_variables[
+                    "PRIORITY_MECH_SERVICE_ID"
+                ]["value"]
 
             env_var_to_value.update(
                 {
@@ -693,10 +720,10 @@ class ServiceManager:
                         "staking_contract"
                     ),
                     "MECH_MARKETPLACE_CONFIG": (
-                        f'{{"mech_marketplace_address":"{mech_marketplace_address}",'
-                        f'"priority_mech_address":"{priority_mech_address}",'
+                        f'{{"mech_marketplace_address":"{mech_configs.mech_marketplace_address}",'
+                        f'"priority_mech_address":"{mech_configs.priority_mech_address}",'
                         f'"priority_mech_staking_instance_address":"0x998dEFafD094817EF329f6dc79c703f1CF18bC90",'
-                        f'"priority_mech_service_id":{priority_mech_service_id},'
+                        f'"priority_mech_service_id":{mech_configs.priority_mech_service_id},'
                         f'"requester_staking_instance_address":"{target_staking_params.get("staking_contract")}",'
                         f'"response_timeout":300}}'
                     ),
@@ -706,9 +733,9 @@ class ServiceManager:
                     "MECH_ACTIVITY_CHECKER_CONTRACT": target_staking_params.get(
                         "activity_checker"
                     ),
-                    "MECH_CONTRACT_ADDRESS": agent_mech,
+                    "MECH_CONTRACT_ADDRESS": mech_configs.priority_mech_address,
                     "MECH_REQUEST_PRICE": "10000000000000000",
-                    "USE_MECH_MARKETPLACE": use_mech_marketplace,
+                    "USE_MECH_MARKETPLACE": mech_configs.use_mech_marketplace,
                 }
             )