olas-operate-middleware 0.7.0__tar.gz → 0.8.0__tar.gz

{olas_operate_middleware-0.7.0 → olas_operate_middleware-0.8.0}/PKG-INFO

@@ -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 → olas_operate_middleware-0.8.0}/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,
         }

{olas_operate_middleware-0.7.0 → olas_operate_middleware-0.8.0}/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()
 

{olas_operate_middleware-0.7.0 → olas_operate_middleware-0.8.0}/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

{olas_operate_middleware-0.7.0 → olas_operate_middleware-0.8.0}/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

{olas_operate_middleware-0.7.0 → olas_operate_middleware-0.8.0}/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()

{olas_operate_middleware-0.7.0 → olas_operate_middleware-0.8.0}/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)