olas-operate-middleware 0.8.2__py3-none-any.whl → 0.10.0__py3-none-any.whl

operate/ledger/__init__.py

@@ -46,7 +46,7 @@ PUBLIC_RPCS = {
     Chain.SOLANA: SOLANA_PUBLIC_RPC,
     Chain.BASE: BASE_PUBLIC_RPC,
     Chain.CELO: CELO_PUBLIC_RPC,
-    Chain.OPTIMISTIC: OPTIMISM_PUBLIC_RPC,
+    Chain.OPTIMISM: OPTIMISM_PUBLIC_RPC,
     Chain.MODE: MODE_PUBLIC_RPC,
 }
 
@@ -56,7 +56,7 @@ DEFAULT_RPCS = {
     Chain.SOLANA: SOLANA_RPC,
     Chain.BASE: BASE_RPC,
     Chain.CELO: CELO_RPC,
-    Chain.OPTIMISTIC: OPTIMISM_RPC,
+    Chain.OPTIMISM: OPTIMISM_RPC,
     Chain.MODE: MODE_RPC,
 }
 
@@ -67,7 +67,7 @@ CURRENCY_DENOMS = {
     Chain.SOLANA: "SOL",
     Chain.BASE: "ETH",
     Chain.CELO: "CELO",
-    Chain.OPTIMISTIC: "ETH",
+    Chain.OPTIMISM: "ETH",
     Chain.MODE: "ETH",
 }
 
@@ -78,7 +78,7 @@ CURRENCY_SMALLEST_UNITS = {
     Chain.SOLANA: "Lamport",
     Chain.BASE: "Wei",
     Chain.CELO: "Wei",
-    Chain.OPTIMISTIC: "Wei",
+    Chain.OPTIMISM: "Wei",
     Chain.MODE: "Wei",
 }
 

operate/ledger/profiles.py

@@ -21,12 +21,10 @@
 
 import typing as t
 
-from operate.constants import ZERO_ADDRESS
+from operate.constants import NO_STAKING_PROGRAM_ID, ZERO_ADDRESS
 from operate.operate_types import Chain, ContractAddresses
 
 
-NO_STAKING_PROGRAM_ID = "no_staking"
-
 CONTRACTS: t.Dict[Chain, ContractAddresses] = {
     Chain.GNOSIS: ContractAddresses(
         {
@@ -38,7 +36,7 @@ CONTRACTS: t.Dict[Chain, ContractAddresses] = {
             "multisend": "0x40A2aCCbd92BCA938b02010E17A5b8929b49130D",
         }
     ),
-    Chain.OPTIMISTIC: ContractAddresses(
+    Chain.OPTIMISM: ContractAddresses(
         {
             "service_manager": "0xFbBEc0C8b13B38a9aC0499694A69a10204c5E2aB",
             "service_registry": "0x3d77596beb0f130a4415df3D2D8232B3d3D31e44",
@@ -123,7 +121,7 @@ STAKING: t.Dict[Chain, t.Dict[str, str]] = {
         "marketplace_demand_alpha_1": "0x9d6e7aB0B5B48aE5c146936147C639fEf4575231",
         "marketplace_demand_alpha_2": "0x9fb17E549FefcCA630dd92Ea143703CeE4Ea4340",
     },
-    Chain.OPTIMISTIC: {
+    Chain.OPTIMISM: {
         "optimus_alpha_1": "0x88996bbdE7f982D93214881756840cE2c77C4992",
         "optimus_alpha_2": "0xBCA056952D2A7a8dD4A002079219807CFDF9fd29",
         "optimus_alpha_3": "0x0f69f35652B1acdbD769049334f1AC580927E139",
@@ -170,7 +168,7 @@ DEFAULT_PRIORITY_MECH = {  # maps mech marketplace address to its default priori
 # ERC20 token addresses
 OLAS: t.Dict[Chain, str] = {
     Chain.GNOSIS: "0xcE11e14225575945b8E6Dc0D4F2dD4C570f79d9f",
-    Chain.OPTIMISTIC: "0xFC2E6e6BCbd49ccf3A5f029c79984372DcBFE527",
+    Chain.OPTIMISM: "0xFC2E6e6BCbd49ccf3A5f029c79984372DcBFE527",
     Chain.BASE: "0x54330d28ca3357F294334BDC454a032e7f353416",
     Chain.ETHEREUM: "0x0001A500A6B18995B03f44bb040A5fFc28E45CB0",
     Chain.MODE: "0xcfD1D50ce23C46D3Cf6407487B2F8934e96DC8f9",
@@ -178,7 +176,7 @@ OLAS: t.Dict[Chain, str] = {
 
 USDC: t.Dict[Chain, str] = {
     Chain.GNOSIS: "0xDDAfbb505ad214D7b80b1f830fcCc89B60fb7A83",
-    Chain.OPTIMISTIC: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+    Chain.OPTIMISM: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
     Chain.BASE: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
     Chain.ETHEREUM: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
     Chain.MODE: "0xd988097fb8612cc24eeC14542bC03424c656005f",
@@ -186,7 +184,7 @@ USDC: t.Dict[Chain, str] = {
 
 WRAPPED_NATIVE_ASSET = {
     Chain.GNOSIS: "0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d",
-    Chain.OPTIMISTIC: "0x4200000000000000000000000000000000000006",
+    Chain.OPTIMISM: "0x4200000000000000000000000000000000000006",
     Chain.BASE: "0x4200000000000000000000000000000000000006",
     Chain.ETHEREUM: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
     Chain.MODE: "0x4200000000000000000000000000000000000006",
@@ -209,7 +207,7 @@ DEFAULT_NEW_SAFE_FUNDS: t.Dict[Chain, t.Dict[str, int]] = {
     Chain.MODE: {
         ZERO_ADDRESS: int(1e15 / 4),
     },
-    Chain.OPTIMISTIC: {
+    Chain.OPTIMISM: {
         ZERO_ADDRESS: int(1e15 / 4),
     },
 }
@@ -219,7 +217,7 @@ DEFAULT_MASTER_EOA_FUNDS = {
     Chain.ETHEREUM: {ZERO_ADDRESS: 20_000_000_000_000_000},
     Chain.GNOSIS: {ZERO_ADDRESS: 1_500_000_000_000_000_000},
     Chain.MODE: {ZERO_ADDRESS: 500_000_000_000_000},
-    Chain.OPTIMISTIC: {ZERO_ADDRESS: 5_000_000_000_000_000},
+    Chain.OPTIMISM: {ZERO_ADDRESS: 5_000_000_000_000_000},
 }
 
 EXPLORER_URL = {
@@ -239,7 +237,7 @@ EXPLORER_URL = {
         "tx": "https://modescan.io/tx/{tx_hash}",
         "address": "https://modescan.io/address/{address}",
     },
-    Chain.OPTIMISTIC: {
+    Chain.OPTIMISM: {
         "tx": "https://optimistic.etherscan.io/tx/{tx_hash}",
         "address": "https://optimistic.etherscan.io/address/{address}",
     },

operate/migration.py

@@ -22,9 +22,25 @@
 
 import json
 import logging
+import shutil
+import traceback
 from pathlib import Path
+from time import time
 
+from aea_cli_ipfs.ipfs_utils import IPFSTool
+
+from operate.constants import 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,
+    Service,
+)
 from operate.utils import create_backup
+from operate.wallet.master import LEDGER_TYPE_TO_WALLET_CLASS, MasterWalletManager
 
 
 class MigrationManager:
@@ -42,6 +58,12 @@ class MigrationManager:
         self._path = home
         self.logger = logger
 
+    def log_directories(self, path: Path) -> None:
+        """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}")
+
     def migrate_user_account(self) -> None:
         """Migrates user.json"""
 
@@ -61,3 +83,307 @@ class MigrationManager:
             json.dump(new_data, f, indent=4)
 
         self.logger.info("[MIGRATION MANAGER] Migrated user.json.")
+
+    def migrate_wallets(self, wallet_manager: MasterWalletManager) -> None:
+        """Migrate old wallet config formats to new ones, if applies."""
+        self.logger.info("Migrating wallet configs...")
+
+        for ledger_type in LedgerType:
+            if not wallet_manager.exists(ledger_type=ledger_type):
+                continue
+
+            wallet_class = LEDGER_TYPE_TO_WALLET_CLASS.get(ledger_type)
+            if wallet_class is None:
+                continue
+
+            migrated = wallet_class.migrate_format(path=wallet_manager.path)
+            if migrated:
+                self.logger.info(f"Wallet {wallet_class} has been migrated.")
+
+        self.logger.info("Migrating wallet configs done.")
+
+    @staticmethod
+    def _migrate_service(  # pylint: disable=too-many-statements,too-many-locals
+        path: Path,
+    ) -> bool:
+        """Migrate the JSON file format if needed."""
+
+        if not path.is_dir():
+            return False
+
+        if not path.name.startswith(SERVICE_CONFIG_PREFIX) and not path.name.startswith(
+            "bafybei"
+        ):
+            return False
+
+        if path.name.startswith("bafybei"):
+            backup_name = f"backup_{int(time())}_{path.name}"
+            backup_path = path.parent / backup_name
+            shutil.copytree(path, backup_path)
+            deployment_path = backup_path / "deployment"
+            if deployment_path.is_dir():
+                shutil.rmtree(deployment_path)
+
+        with open(
+            path / Service._file,  # pylint: disable=protected-access
+            "r",
+            encoding="utf-8",
+        ) as file:
+            data = json.load(file)
+
+        version = data.get("version", 0)
+        if version > SERVICE_CONFIG_VERSION:
+            raise RuntimeError(
+                f"Service configuration in {path} has version {version}, which means it was created with a newer version of olas-operate-middleware. Only configuration versions <= {SERVICE_CONFIG_VERSION} are supported by this version of olas-operate-middleware."
+            )
+
+        # Complete missing env vars for trader
+        if "trader" in data["name"].lower():
+            data.setdefault("env_variables", {})
+
+            for key, value in DEFAULT_TRADER_ENV_VARS.items():
+                if key not in data["env_variables"]:
+                    data["env_variables"][key] = value
+
+            with open(
+                path / Service._file,  # pylint: disable=protected-access
+                "w",
+                encoding="utf-8",
+            ) as file:
+                json.dump(data, file, indent=2)
+
+        if version == SERVICE_CONFIG_VERSION:
+            return False
+
+        # Migration steps for older versions
+        if version == 0:
+            new_data = {
+                "version": 2,
+                "hash": data.get("hash"),
+                "keys": data.get("keys"),
+                "home_chain_id": "100",  # This is the default value for version 2 - do not change, will be corrected below
+                "chain_configs": {
+                    "100": {  # This is the default value for version 2 - do not change, will be corrected below
+                        "ledger_config": {
+                            "rpc": data.get("ledger_config", {}).get("rpc"),
+                            "type": data.get("ledger_config", {}).get("type"),
+                            "chain": data.get("ledger_config", {}).get("chain"),
+                        },
+                        "chain_data": {
+                            "instances": data.get("chain_data", {}).get(
+                                "instances", []
+                            ),
+                            "token": data.get("chain_data", {}).get("token"),
+                            "multisig": data.get("chain_data", {}).get("multisig"),
+                            "staked": data.get("chain_data", {}).get("staked", False),
+                            "on_chain_state": data.get("chain_data", {}).get(
+                                "on_chain_state", 3
+                            ),
+                            "user_params": {
+                                "staking_program_id": "pearl_alpha",
+                                "nft": data.get("chain_data", {})
+                                .get("user_params", {})
+                                .get("nft"),
+                                "threshold": data.get("chain_data", {})
+                                .get("user_params", {})
+                                .get("threshold"),
+                                "use_staking": data.get("chain_data", {})
+                                .get("user_params", {})
+                                .get("use_staking"),
+                                "cost_of_bond": data.get("chain_data", {})
+                                .get("user_params", {})
+                                .get("cost_of_bond"),
+                                "fund_requirements": data.get("chain_data", {})
+                                .get("user_params", {})
+                                .get("fund_requirements", {}),
+                                "agent_id": data.get("chain_data", {})
+                                .get("user_params", {})
+                                .get("agent_id", "14"),
+                            },
+                        },
+                    }
+                },
+                "service_path": data.get("service_path", ""),
+                "name": data.get("name", ""),
+            }
+            data = new_data
+
+        if version < 4:
+            # Add missing fields introduced in later versions, if necessary.
+            for _, chain_data in data.get("chain_configs", {}).items():
+                chain_data.setdefault("chain_data", {}).setdefault(
+                    "user_params", {}
+                ).setdefault("use_mech_marketplace", False)
+                service_name = data.get("name", "")
+                agent_id = Service.determine_agent_id(service_name)
+                chain_data.setdefault("chain_data", {}).setdefault("user_params", {})[
+                    "agent_id"
+                ] = agent_id
+
+            data["description"] = data.setdefault("description", data.get("name"))
+            data["hash_history"] = data.setdefault(
+                "hash_history", {int(time()): data["hash"]}
+            )
+
+            if "service_config_id" not in data:
+                service_config_id = Service.get_new_service_config_id(path)
+                new_path = path.parent / service_config_id
+                data["service_config_id"] = service_config_id
+                path = path.rename(new_path)
+
+            old_to_new_ledgers = ["ethereum", "solana"]
+            for key_data in data["keys"]:
+                key_data["ledger"] = old_to_new_ledgers[key_data["ledger"]]
+
+            old_to_new_chains = [
+                "ethereum",
+                "goerli",
+                "gnosis",
+                "solana",
+                "optimism",
+                "base",
+                "mode",
+            ]
+            new_chain_configs = {}
+            for chain_id, chain_data in data["chain_configs"].items():
+                chain_data["ledger_config"]["chain"] = old_to_new_chains[
+                    chain_data["ledger_config"]["chain"]
+                ]
+                del chain_data["ledger_config"]["type"]
+                new_chain_configs[Chain.from_id(int(chain_id)).value] = chain_data  # type: ignore
+
+            data["chain_configs"] = new_chain_configs
+            data["home_chain"] = data.setdefault("home_chain", Chain.from_id(int(data.get("home_chain_id", "100"))).value)  # type: ignore
+            del data["home_chain_id"]
+
+            if "env_variables" not in data:
+                if data["name"] == "valory/trader_pearl":
+                    data["env_variables"] = DEFAULT_TRADER_ENV_VARS
+                else:
+                    data["env_variables"] = {}
+
+        if version < 5:
+            new_chain_configs = {}
+            for chain, chain_data in data["chain_configs"].items():
+                fund_requirements = chain_data["chain_data"]["user_params"][
+                    "fund_requirements"
+                ]
+                if ZERO_ADDRESS not in fund_requirements:
+                    chain_data["chain_data"]["user_params"]["fund_requirements"] = {
+                        ZERO_ADDRESS: fund_requirements
+                    }
+
+                new_chain_configs[chain] = chain_data  # type: ignore
+            data["chain_configs"] = new_chain_configs
+
+        if version < 7:
+            for _, chain_data in data.get("chain_configs", {}).items():
+                if chain_data["chain_data"]["multisig"] == "0xm":
+                    chain_data["chain_data"]["multisig"] = NON_EXISTENT_MULTISIG
+
+            data["agent_addresses"] = [key["address"] for key in data["keys"]]
+            del data["keys"]
+
+        if version < 8:
+            if data["home_chain"] == "optimistic":
+                data["home_chain"] = Chain.OPTIMISM.value
+
+            if "optimistic" in data["chain_configs"]:
+                data["chain_configs"]["optimism"] = data["chain_configs"].pop(
+                    "optimistic"
+                )
+
+            for _, chain_config in data["chain_configs"].items():
+                if chain_config["ledger_config"]["chain"] == "optimistic":
+                    chain_config["ledger_config"]["chain"] = Chain.OPTIMISM.value
+
+        data["version"] = SERVICE_CONFIG_VERSION
+
+        # Redownload service path
+        if "service_path" in data:
+            package_absolute_path = path / Path(data["service_path"]).name
+            data.pop("service_path")
+        else:
+            package_absolute_path = path / data["package_path"]
+
+        if package_absolute_path.exists() and package_absolute_path.is_dir():
+            shutil.rmtree(package_absolute_path)
+
+        package_absolute_path = Path(
+            IPFSTool().download(
+                hash_id=data["hash"],
+                target_dir=path,
+            )
+        )
+        data["package_path"] = str(package_absolute_path.name)
+
+        with open(
+            path / Service._file,  # pylint: disable=protected-access
+            "w",
+            encoding="utf-8",
+        ) as file:
+            json.dump(data, file, indent=2)
+
+        return True
+
+    def migrate_services(self, service_manager: ServiceManager) -> None:
+        """Migrate old service config formats to new ones, if applies."""
+        self.log_directories(service_manager.path)
+        self.logger.info("Migrating service configs...")
+
+        bafybei_count = sum(
+            1
+            for path in service_manager.path.iterdir()
+            if path.name.startswith("bafybei")
+        )
+        if bafybei_count > 1:
+            raise RuntimeError(
+                f"Your services folder contains {bafybei_count} folders starting with 'bafybei'. This is an unintended situation. Please contact support."
+            )
+
+        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.")
+            except Exception as e:  # pylint: disable=broad-except
+                self.logger.error(
+                    f"Failed to migrate service: {path.name}. Exception {e}: {traceback.format_exc()}"
+                )
+
+        self.logger.info("Migrating service configs done.")
+        self.log_directories(service_manager.path)
+
+    def migrate_qs_configs(self) -> None:
+        """Migrates quickstart configs."""
+
+        for qs_config in self._path.glob("*-quickstart-config.json"):
+            if not qs_config.exists():
+                continue
+
+            migrated = False
+            with open(qs_config, "r", encoding="utf-8") as f:
+                data = json.load(f)
+
+            if "optimistic" in data.get("rpc", {}):
+                data["rpc"]["optimism"] = data["rpc"].pop("optimistic")
+                migrated = True
+
+            if "optimistic" == data.get("principal_chain", ""):
+                data["principal_chain"] = "optimism"
+                migrated = True
+
+            if not migrated:
+                continue
+
+            with open(qs_config, "w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2)
+
+            self.logger.info(
+                "[MIGRATION MANAGER] Migrated quickstart config: %s.", qs_config.name
+            )

operate/operate_types.py

@@ -28,16 +28,10 @@ from autonomy.chain.config import ChainType
 from autonomy.chain.constants import CHAIN_NAME_TO_CHAIN_ID
 from typing_extensions import TypedDict
 
+from operate.constants import NO_STAKING_PROGRAM_ID
 from operate.resource import LocalResource
 
 
-_ACTIONS = {
-    "status": 0,
-    "build": 1,
-    "deploy": 2,
-    "stop": 3,
-}
-
 CHAIN_NAME_TO_CHAIN_ID["solana"] = 900
 
 _CHAIN_ID_TO_CHAIN_NAME = {
@@ -127,20 +121,6 @@ for name in dir(ChainMixin):
         setattr(Chain, name, getattr(ChainMixin, name))
 
 
-class Action(enum.IntEnum):
-    """Action payload."""
-
-    STATUS = 0
-    BUILD = 1
-    DEPLOY = 2
-    STOP = 3
-
-    @classmethod
-    def from_string(cls, action: str) -> "Action":
-        """Load from string."""
-        return cls(_ACTIONS[action])
-
-
 class DeploymentStatus(enum.IntEnum):
     """Status payload."""
 
@@ -208,9 +188,6 @@ class ConfigurationTemplate(TypedDict):
     nft: str
     rpc: str
     agent_id: int
-    threshold: int
-    use_staking: bool
-    use_mech_marketplace: bool
     cost_of_bond: int
     fund_requirements: t.Dict[str, FundRequirementsTemplate]
     fallback_chain_params: t.Optional[t.Dict]
@@ -275,13 +252,18 @@ class OnChainUserParams(LocalResource):
 
     staking_program_id: str
     nft: str
-    threshold: int
     agent_id: int
-    use_staking: bool
-    use_mech_marketplace: bool
     cost_of_bond: int
     fund_requirements: OnChainTokenRequirements
 
+    @property
+    def use_staking(self) -> bool:
+        """Check if staking is used."""
+        return (
+            self.staking_program_id is not None
+            and self.staking_program_id != NO_STAKING_PROGRAM_ID
+        )
+
     @classmethod
     def from_json(cls, obj: t.Dict) -> "OnChainUserParams":
         """Load a service"""

operate/quickstart/analyse_logs.py

@@ -25,7 +25,7 @@ import sys
 from pathlib import Path
 from typing import List, TYPE_CHECKING, Union
 
-from operate.constants import DEPLOYMENT
+from operate.constants import DEPLOYMENT_DIR
 
 
 if TYPE_CHECKING:
@@ -38,10 +38,10 @@ def find_build_directory(config_file: Path, operate: "OperateApp") -> Path:
         config = json.load(f)
         config_service_hash = config.get("hash")
 
-    services = operate.service_manager()._get_all_services()
+    services = operate.service_manager().get_all_services()
     for service in services:
         if service.hash == config_service_hash:
-            build_dir = service.path / DEPLOYMENT
+            build_dir = service.path / DEPLOYMENT_DIR
             if not build_dir.exists():
                 print(f"{config.get('name')} not deployed.")
                 sys.exit(1)
@@ -107,9 +107,6 @@ def analyse_logs(
         print(f"Config file '{config_file}' not found.")
         sys.exit(1)
 
-    operate.service_manager().migrate_service_configs()
-    operate.wallet_manager.migrate_wallet_configs()
-
     # Auto-detect the logs directory
     build_dir = find_build_directory(config_file, operate)
     logs_dir = build_dir / "persistent_data" / "logs"

operate/quickstart/claim_staking_rewards.py

@@ -48,9 +48,6 @@ def claim_staking_rewards(operate: "OperateApp", config_path: str) -> None:
 
     print_section(f"Claim staking rewards for {template['name']}")
 
-    operate.service_manager().migrate_service_configs()
-    operate.wallet_manager.migrate_wallet_configs()
-
     # check if agent was started before
     config = load_local_config(
         operate=operate, service_name=cast(str, template["name"])
@@ -70,10 +67,10 @@ def claim_staking_rewards(operate: "OperateApp", config_path: str) -> None:
 
     print("")
 
+    ask_password_if_needed(operate)
     config = configure_local_config(template, operate)
     manager = operate.service_manager()
     service = get_service(manager, template)
-    ask_password_if_needed(operate)
 
     # reload manger and config after setting operate.password
     manager = operate.service_manager()

operate/quickstart/reset_configs.py

@@ -70,9 +70,6 @@ def reset_configs(operate: "OperateApp", config_path: str) -> None:
     with open(config_path, "r") as config_file:
         template = json.load(config_file)
 
-    operate.service_manager().migrate_service_configs()
-    operate.wallet_manager.migrate_wallet_configs()
-
     print_title(f"Reset your {template['name']} configurations")
 
     # check if agent was started before

operate/quickstart/reset_password.py

@@ -35,9 +35,6 @@ def reset_password(operate: "OperateApp") -> None:
     """Reset password."""
     print_title("Reset your password")
 
-    operate.service_manager().migrate_service_configs()
-    operate.wallet_manager.migrate_wallet_configs()
-
     # check if agent was started before
     if not (operate._path / "user.json").exists():
         print("No previous agent setup found. Exiting.")

operate/quickstart/reset_staking.py

@@ -22,7 +22,8 @@ import json
 import os
 from typing import TYPE_CHECKING, cast
 
-from operate.ledger.profiles import NO_STAKING_PROGRAM_ID, get_staking_contract
+from operate.constants import NO_STAKING_PROGRAM_ID
+from operate.ledger.profiles import get_staking_contract
 from operate.quickstart.run_service import (
     CUSTOM_PROGRAM_ID,
     ask_password_if_needed,
@@ -44,9 +45,6 @@ def reset_staking(operate: "OperateApp", config_path: str) -> None:
     with open(config_path, "r") as config_file:
         template = json.load(config_file)
 
-    operate.service_manager().migrate_service_configs()
-    operate.wallet_manager.migrate_wallet_configs()
-
     print_title("Reset your staking program preference")
 
     # check if agent was started before
@@ -57,6 +55,7 @@ def reset_staking(operate: "OperateApp", config_path: str) -> None:
         print("No previous agent setup found. Exiting.")
         return
 
+    ask_password_if_needed(operate)
     config = configure_local_config(template, operate)
     assert (  # nosec
         config.principal_chain is not None
@@ -82,7 +81,6 @@ def reset_staking(operate: "OperateApp", config_path: str) -> None:
         print("Cancelled.")
         return
 
-    ask_password_if_needed(operate)
     manager = operate.service_manager()
     service = get_service(manager, template)