olas-operate-middleware 0.11.5__tar.gz → 0.12.1__tar.gz

{olas_operate_middleware-0.11.5 → olas_operate_middleware-0.12.1}/PKG-INFO

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

{olas_operate_middleware-0.11.5 → olas_operate_middleware-0.12.1}/operate/bridge/bridge_manager.py

@@ -57,52 +57,60 @@ RELAY_PROVIDER_ID = "relay-provider"
 
 NATIVE_BRIDGE_PROVIDER_CONFIGS: t.Dict[str, t.Any] = {
     "native-ethereum-to-base": {
-        "from_chain": "ethereum",
+        "from_chain": Chain.ETHEREUM.value,
         "from_bridge": "0x3154Cf16ccdb4C6d922629664174b904d80F2C35",
-        "to_chain": "base",
+        "to_chain": Chain.BASE.value,
         "to_bridge": "0x4200000000000000000000000000000000000010",
         "bridge_eta": 300,
         "bridge_contract_adaptor_class": OptimismContractAdaptor,
     },
+    "native-ethereum-to-celo": {
+        "from_chain": Chain.ETHEREUM.value,
+        "from_bridge": "0x9C4955b92F34148dbcfDCD82e9c9eCe5CF2badfe",
+        "to_chain": Chain.CELO.value,
+        "to_bridge": "0x4200000000000000000000000000000000000010",
+        "bridge_eta": 300,
+        "bridge_contract_adaptor_class": OptimismContractAdaptor,
+    },
+    "native-ethereum-to-gnosis": {
+        "from_chain": Chain.ETHEREUM.value,
+        "from_bridge": "0x88ad09518695c6c3712AC10a214bE5109a655671",
+        "to_chain": Chain.GNOSIS.value,
+        "to_bridge": "0xf6A78083ca3e2a662D6dd1703c939c8aCE2e268d",
+        "bridge_eta": 1800,
+        "bridge_contract_adaptor_class": OmnibridgeContractAdaptor,
+    },
     "native-ethereum-to-mode": {
-        "from_chain": "ethereum",
+        "from_chain": Chain.ETHEREUM.value,
         "from_bridge": "0x735aDBbE72226BD52e818E7181953f42E3b0FF21",
-        "to_chain": "mode",
+        "to_chain": Chain.MODE.value,
         "to_bridge": "0x4200000000000000000000000000000000000010",
         "bridge_eta": 300,
         "bridge_contract_adaptor_class": OptimismContractAdaptor,
     },
     "native-ethereum-to-optimism": {
-        "from_chain": "ethereum",
+        "from_chain": Chain.ETHEREUM.value,
         "from_bridge": "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1",
-        "to_chain": "optimism",
+        "to_chain": Chain.OPTIMISM.value,
         "to_bridge": "0x4200000000000000000000000000000000000010",
         "bridge_eta": 300,
         "bridge_contract_adaptor_class": OptimismContractAdaptor,
     },
-    "native-ethereum-to-gnosis": {
-        "from_chain": "ethereum",
-        "from_bridge": "0x88ad09518695c6c3712AC10a214bE5109a655671",
-        "to_chain": "gnosis",
-        "to_bridge": "0xf6A78083ca3e2a662D6dd1703c939c8aCE2e268d",
-        "bridge_eta": 1800,
-        "bridge_contract_adaptor_class": OmnibridgeContractAdaptor,
-    },
 }
 
-
-ROUTES = {
+# Routes are defined as the tuples (from_chain, from_token, to_chain, to_token)
+PREFERRED_ROUTES = {
     (
-        Chain.ETHEREUM,  # from_chain
-        USDC[Chain.ETHEREUM],  # from_token
-        Chain.OPTIMISM,  # to_chain
-        USDC[Chain.OPTIMISM],  # to_token
+        Chain.ETHEREUM,
+        USDC[Chain.ETHEREUM],
+        Chain.OPTIMISM,
+        USDC[Chain.OPTIMISM],
     ): LIFI_PROVIDER_ID,
     (
-        Chain.ETHEREUM,  # from_chain
-        USDC[Chain.ETHEREUM],  # from_token
-        Chain.BASE,  # to_chain
-        USDC[Chain.BASE],  # to_token
+        Chain.ETHEREUM,
+        USDC[Chain.ETHEREUM],
+        Chain.BASE,
+        USDC[Chain.BASE],
     ): LIFI_PROVIDER_ID,
     (Chain.ETHEREUM, ZERO_ADDRESS, Chain.GNOSIS, ZERO_ADDRESS): RELAY_PROVIDER_ID,
 }
@@ -260,24 +268,26 @@ class BridgeManager:
 
             provider_requests = []
             for params in requests_params:
-                for provider in self._native_bridge_providers.values():
-                    if provider.can_handle_request(params):
-                        provider_requests.append(provider.create_request(params=params))
-                        break
-                else:
-                    provider_id = ROUTES.get(
-                        (
-                            Chain(params["from"]["chain"]),
-                            params["from"]["token"],
-                            Chain(params["to"]["chain"]),
-                            params["to"]["token"],
-                        ),
-                        RELAY_PROVIDER_ID,
-                    )
-
-                    provider_requests.append(
-                        self._providers[provider_id].create_request(params=params)
-                    )
+                route = (
+                    Chain(params["from"]["chain"]),
+                    params["from"]["token"],
+                    Chain(params["to"]["chain"]),
+                    params["to"]["token"],
+                )
+                provider_id = PREFERRED_ROUTES.get(route)
+
+                if not provider_id:
+                    for provider in self._native_bridge_providers.values():
+                        if provider.can_handle_request(params):
+                            provider_id = provider.provider_id
+                            break
+
+                if not provider_id:
+                    provider_id = RELAY_PROVIDER_ID
+
+                provider_requests.append(
+                    self._providers[provider_id].create_request(params=params)
+                )
 
             bundle = ProviderRequestBundle(
                 id=f"{BRIDGE_REQUEST_BUNDLE_PREFIX}{uuid.uuid4()}",

{olas_operate_middleware-0.11.5 → olas_operate_middleware-0.12.1}/operate/bridge/providers/native_bridge_provider.py

@@ -53,7 +53,11 @@ from operate.data.contracts.l2_standard_bridge.contract import L2StandardBridge
 from operate.data.contracts.optimism_mintable_erc20.contract import (
     OptimismMintableERC20,
 )
-from operate.ledger import update_tx_with_gas_estimate, update_tx_with_gas_pricing
+from operate.ledger import (
+    get_default_ledger_api,
+    update_tx_with_gas_estimate,
+    update_tx_with_gas_pricing,
+)
 from operate.ledger.profiles import ERC20_TOKENS, EXPLORER_URL
 from operate.operate_types import Chain
 from operate.wallet.master import MasterWalletManager
@@ -75,13 +79,15 @@ class BridgeContractAdaptor(ABC):
     ) -> None:
         """Initialize the bridge contract adaptor."""
         super().__init__()
+        if from_chain == to_chain:
+            raise ValueError("from_chain and to_chain cannot be the same.")
         self.from_chain = from_chain
         self.from_bridge = from_bridge
         self.to_chain = to_chain
         self.to_bridge = to_bridge
         self.bridge_eta = bridge_eta
 
-    def can_handle_request(self, to_ledger_api: LedgerApi, params: t.Dict) -> bool:
+    def can_handle_request(self, params: t.Dict) -> bool:
         """Returns 'true' if the contract adaptor can handle a request for 'params'."""
         from_chain = params["from"]["chain"]
         from_token = Web3.to_checksum_address(params["from"]["token"])
@@ -158,11 +164,24 @@ class OptimismContractAdaptor(BridgeContractAdaptor):
         ),
     )
 
-    def can_handle_request(self, to_ledger_api: LedgerApi, params: t.Dict) -> bool:
+    def can_handle_request(self, params: t.Dict) -> bool:
         """Returns 'true' if the contract adaptor can handle a request for 'params'."""
 
+        if not super().can_handle_request(params):
+            return False
+
+        from_chain = params["from"]["chain"]
         from_token = Web3.to_checksum_address(params["from"]["token"])
+        from_ledger_api = get_default_ledger_api(Chain(from_chain))
+        to_chain = params["to"]["chain"]
         to_token = Web3.to_checksum_address(params["to"]["token"])
+        to_ledger_api = get_default_ledger_api(Chain(to_chain))
+
+        if from_token == ZERO_ADDRESS and to_token == ZERO_ADDRESS:
+            if not self._l1_standard_bridge_contract.supports_bridge_eth_to(
+                ledger_api=from_ledger_api, contract_address=self.from_bridge
+            ):
+                return False
 
         if to_token != ZERO_ADDRESS:
             try:
@@ -176,7 +195,7 @@ class OptimismContractAdaptor(BridgeContractAdaptor):
             except Exception:  # pylint: disable=broad-except
                 return False
 
-        return super().can_handle_request(to_ledger_api, params)
+        return True
 
     def build_bridge_tx(
         self, from_ledger_api: LedgerApi, provider_request: ProviderRequest
@@ -288,13 +307,13 @@ class OmnibridgeContractAdaptor(BridgeContractAdaptor):
         ),
     )
 
-    def can_handle_request(self, to_ledger_api: LedgerApi, params: t.Dict) -> bool:
+    def can_handle_request(self, params: t.Dict) -> bool:
         """Returns 'true' if the contract adaptor can handle a request for 'params'."""
         from_token = Web3.to_checksum_address(params["from"]["token"])
         if from_token == ZERO_ADDRESS:
             return False
 
-        return super().can_handle_request(to_ledger_api, params)
+        return super().can_handle_request(params)
 
     def build_bridge_tx(
         self, from_ledger_api: LedgerApi, provider_request: ProviderRequest
@@ -428,16 +447,10 @@ class NativeBridgeProvider(Provider):
 
     def can_handle_request(self, params: t.Dict) -> bool:
         """Returns 'true' if the provider can handle a request for 'params'."""
-
         if not super().can_handle_request(params):
             return False
 
-        to_chain = params["to"]["chain"]
-        chain = Chain(to_chain)
-        wallet = self.wallet_manager.load(chain.ledger_type)
-        to_ledger_api = wallet.ledger_api(chain)
-
-        if not self.bridge_contract_adaptor.can_handle_request(to_ledger_api, params):
+        if not self.bridge_contract_adaptor.can_handle_request(params):
             return False
 
         return True

{olas_operate_middleware-0.11.5 → olas_operate_middleware-0.12.1}/operate/cli.py

@@ -64,6 +64,7 @@ from operate.constants import (
     WALLET_RECOVERY_DIR,
     ZERO_ADDRESS,
 )
+from operate.keys import KeysManager
 from operate.ledger.profiles import (
     DEFAULT_EOA_TOPUPS,
     DEFAULT_NEW_SAFE_FUNDS,
@@ -143,7 +144,7 @@ def service_not_found_error(service_config_id: str) -> JSONResponse:
     )
 
 
-class OperateApp:
+class OperateApp:  # pylint: disable=too-many-instance-attributes
     """Operate app."""
 
     def __init__(
@@ -157,11 +158,13 @@ class OperateApp:
         self.setup()
         self._backup_operate_if_new_version()
 
-        services.manage.KeysManager(
+        self._password: t.Optional[str] = os.environ.get("OPERATE_USER_PASSWORD")
+        KeysManager._instances.clear()  # reset singleton instance
+        self._keys_manager: KeysManager = KeysManager(
             path=self._keys,
             logger=logger,
+            password=self._password,
         )
-        self._password: t.Optional[str] = os.environ.get("OPERATE_USER_PASSWORD")
         self.settings = Settings(path=self._path)
 
         self._wallet_manager = MasterWalletManager(
@@ -174,11 +177,11 @@ class OperateApp:
             logger=logger,
         )
 
-        mm = MigrationManager(self._path, logger)
-        mm.migrate_user_account()
-        mm.migrate_services(self.service_manager())
-        mm.migrate_wallets(self.wallet_manager)
-        mm.migrate_qs_configs()
+        self._migration_manager = MigrationManager(self._path, logger)
+        self._migration_manager.migrate_user_account()
+        self._migration_manager.migrate_services(self.service_manager())
+        self._migration_manager.migrate_wallets(self.wallet_manager)
+        self._migration_manager.migrate_qs_configs()
 
     @property
     def password(self) -> t.Optional[str]:
@@ -189,7 +192,9 @@ class OperateApp:
     def password(self, value: t.Optional[str]) -> None:
         """Set the password."""
         self._password = value
+        self._keys_manager.password = value
         self._wallet_manager.password = value
+        self._migration_manager.migrate_keys(self._keys_manager)
 
     def _backup_operate_if_new_version(self) -> None:
         """Backup .operate directory if this is a new version."""
@@ -256,6 +261,7 @@ class OperateApp:
         wallet_manager = self.wallet_manager
         wallet_manager.password = old_password
         wallet_manager.update_password(new_password)
+        self._keys_manager.update_password(new_password)
         self.user_account.update(old_password, new_password)
 
     def update_password_with_mnemonic(self, mnemonic: str, new_password: str) -> None:

{olas_operate_middleware-0.11.5 → olas_operate_middleware-0.12.1}/operate/data/contracts/l1_standard_bridge/contract.py

@@ -45,6 +45,26 @@ class L1StandardBridge(Contract):
 
     contract_id = PublicId.from_str("valory/l1_standard_bridge:0.1.0")
 
+    @classmethod
+    def supports_bridge_eth_to(
+        cls,
+        ledger_api: LedgerApi,
+        contract_address: str,
+    ) -> bool:
+        """Checks if native ETH bridging via `bridgeETHTo` is supported."""
+        contract_instance = cls.get_instance(
+            ledger_api=ledger_api, contract_address=contract_address
+        )        
+        try:
+            contract_instance.functions.bridgeETHTo(
+                "0x0000000000000000000000000000000000000000",
+                0,
+                b""
+            ).call({"from": PLACEHOLDER_NATIVE_TOKEN_ADDRESS, "value": 0})
+            return True
+        except Exception:  # pylint: disable=broad-except
+            return False
+
     @classmethod
     def build_bridge_eth_to_tx(
         cls,

{olas_operate_middleware-0.11.5 → olas_operate_middleware-0.12.1}/operate/data/contracts/l1_standard_bridge/contract.yaml

@@ -8,7 +8,7 @@ aea_version: '>=1.0.0, <2.0.0'
 fingerprint:
   __init__.py: bafybeifsbxn6hlccnpgqnpvaz3ph6ajl4is4mcyerr6aqp7heggagcphye
   build/L1StandardBridge.json: bafybeidq6jt7zmedtuxbbyggiqhu7w6543bunyd2vrbibg6y2svxsi2q5m
-  contract.py: bafybeib2kiztts3436vccvraeura3jb23oihgzxgrt3biakbed24edcaai
+  contract.py: bafybeienitro6gds2ny7guziwdu3uapmj3xxuzmqyvsect4zqmrouity2e
 fingerprint_ignore_patterns: []
 contracts: []
 class_name: L1StandardBridge

{olas_operate_middleware-0.11.5 → olas_operate_middleware-0.12.1}/operate/keys.py

@@ -21,17 +21,17 @@
 
 import json
 import os
-import shutil
 import tempfile
 from dataclasses import dataclass
+from logging import Logger
 from pathlib import Path
-from typing import Any
+from typing import Any, Optional
 
 from aea_ledger_ethereum.ethereum import EthereumCrypto
 
 from operate.operate_types import LedgerType
 from operate.resource import LocalResource
-from operate.utils import SingletonMeta
+from operate.utils import SingletonMeta, unrecoverable_delete
 
 
 @dataclass
@@ -42,6 +42,15 @@ class Key(LocalResource):
     address: str
     private_key: str
 
+    def get_decrypted(self, password: str) -> dict:
+        """Get decrypted key json."""
+        return {
+            "ledger": self.ledger.value,
+            "address": self.address,
+            "private_key": "0x"
+            + EthereumCrypto.decrypt(self.private_key, password=password),
+        }
+
     @classmethod
     def load(cls, path: Path) -> "Key":
         """Load a service"""
@@ -61,13 +70,41 @@ class KeysManager(metaclass=SingletonMeta):
         if "path" not in kwargs:
             raise ValueError("Path must be provided for KeysManager")
 
-        self.path = kwargs["path"]
-        self.logger = kwargs["logger"]
+        self.path: Path = kwargs["path"]
+        self.logger: Logger = kwargs["logger"]
+        self.password: Optional[str] = kwargs.get("password")
         self.path.mkdir(exist_ok=True, parents=True)
 
+    def private_key_to_crypto(
+        self, private_key: str, password: Optional[str]
+    ) -> EthereumCrypto:
+        """Convert private key string to EthereumCrypto instance."""
+        with tempfile.NamedTemporaryFile(
+            dir=self.path,
+            mode="w",
+            suffix=".txt",
+            delete=False,  # Handle cleanup manually
+        ) as temp_file:
+            temp_file_name = temp_file.name
+            temp_file.write(private_key)
+            temp_file.flush()
+            temp_file.close()  # Close the file before reading
+
+            # Set proper file permissions (readable by owner only)
+            os.chmod(temp_file_name, 0o600)
+            crypto = EthereumCrypto(private_key_path=temp_file_name, password=password)
+
+            try:
+                unrecoverable_delete(
+                    Path(temp_file.name)
+                )  # Clean up the temporary file
+            except OSError as e:
+                self.logger.error(f"Failed to delete temp file {temp_file.name}: {e}")
+
+        return crypto
+
     def get(self, key: str) -> Key:
         """Get key object."""
-        KeysManager.migrate_format(self.path / key)
         return Key.from_json(  # type: ignore
             obj=json.loads(
                 (self.path / key).read_text(
@@ -91,46 +128,20 @@ class KeysManager(metaclass=SingletonMeta):
 
     def get_crypto_instance(self, address: str) -> EthereumCrypto:
         """Get EthereumCrypto instance for the given address."""
-        key: Key = Key.from_json(  # type: ignore
-            obj=json.loads(
-                (self.path / address).read_text(
-                    encoding="utf-8",
-                )
-            )
-        )
-        private_key = key.private_key
-        # Create temporary file with delete=False to handle it manually
-        with tempfile.NamedTemporaryFile(
-            dir=self.path,
-            mode="w",
-            suffix=".txt",
-            delete=False,  # Handle cleanup manually
-        ) as temp_file:
-            temp_file_name = temp_file.name
-            temp_file.write(private_key)
-            temp_file.flush()
-            temp_file.close()  # Close the file before reading
-
-            # Set proper file permissions (readable by owner only)
-            os.chmod(temp_file_name, 0o600)
-            crypto = EthereumCrypto(private_key_path=temp_file_name)
-
-            try:
-                with open(temp_file_name, "r+", encoding="utf-8") as f:
-                    f.seek(0)
-                    f.write("\0" * len(private_key))
-                    f.flush()
-                    f.close()
-                os.unlink(temp_file_name)  # Clean up the temporary file
-            except OSError as e:
-                self.logger.error(f"Failed to delete temp file {temp_file.name}: {e}")
-
-        return crypto
+        key: Key = self.get(address)
+        return self.private_key_to_crypto(key.private_key, self.password)
 
     def create(self) -> str:
         """Creates new key."""
         self.path.mkdir(exist_ok=True, parents=True)
-        crypto = EthereumCrypto()
+        crypto = EthereumCrypto(password=self.password)
+        key = Key(
+            ledger=LedgerType.ETHEREUM,
+            address=crypto.address,
+            private_key=crypto.encrypt(password=self.password)
+            if self.password is not None
+            else crypto.private_key,
+        )
         for path in (
             self.path / f"{crypto.address}.bak",
             self.path / crypto.address,
@@ -140,12 +151,8 @@ class KeysManager(metaclass=SingletonMeta):
 
             path.write_text(
                 json.dumps(
-                    Key(
-                        ledger=LedgerType.ETHEREUM,
-                        address=crypto.address,
-                        private_key=crypto.private_key,
-                    ).json,
-                    indent=4,
+                    key.json,
+                    indent=2,
                 ),
                 encoding="utf-8",
             )
@@ -156,25 +163,23 @@ class KeysManager(metaclass=SingletonMeta):
         """Delete key."""
         os.remove(self.path / key)
 
-    @classmethod
-    def migrate_format(cls, path: Path) -> bool:
-        """Migrate the JSON file format if needed."""
-        migrated = False
-        backup_path = path.with_suffix(".bak")
-        if not backup_path.is_file():
-            shutil.copyfile(path, backup_path)
-            migrated = True
-
-        with open(path, "r", encoding="utf-8") as file:
-            data = json.load(file)
-
-        old_to_new_ledgers = {0: "ethereum", 1: "solana"}
-        if data.get("ledger") in old_to_new_ledgers:
-            data["ledger"] = old_to_new_ledgers.get(data["ledger"])
-            migrated = True
-
-        if migrated:
-            with open(path, "w", encoding="utf-8") as file:
-                json.dump(data, file, indent=2)
-
-        return migrated
+    def update_password(self, new_password: str) -> None:
+        """Update password for all keys."""
+        for key_file in self.path.iterdir():
+            if not key_file.is_file() or key_file.suffix == ".bak":
+                continue
+
+            key = self.get(key_file.name)
+            crypto = self.get_crypto_instance(key_file.name)
+            encrypted_private_key = crypto.encrypt(password=new_password)
+            key.private_key = encrypted_private_key
+            key.path = self.path / key_file.name
+            key.store()
+
+            backup_path = self.path / f"{key.address}.bak"
+            backup_path.write_text(
+                json.dumps(key.json, indent=2),
+                encoding="utf-8",
+            )
+
+        self.password = new_password

{olas_operate_middleware-0.11.5 → olas_operate_middleware-0.12.1}/operate/migration.py

@@ -28,8 +28,11 @@ from pathlib import Path
 from time import time
 
 from aea_cli_ipfs.ipfs_utils import IPFSTool
+from aea_ledger_ethereum import EthereumCrypto
+from web3 import Web3
 
 from operate.constants import USER_JSON, ZERO_ADDRESS
+from operate.keys import KeysManager
 from operate.operate_types import Chain, LedgerType
 from operate.services.manage import ServiceManager
 from operate.services.service import (
@@ -38,7 +41,7 @@ from operate.services.service import (
     SERVICE_CONFIG_VERSION,
     Service,
 )
-from operate.utils import create_backup
+from operate.utils import create_backup, unrecoverable_delete
 from operate.wallet.master import LEDGER_TYPE_TO_WALLET_CLASS, MasterWalletManager
 
 
@@ -454,3 +457,65 @@ class MigrationManager:
             self.logger.info(
                 "[MIGRATION MANAGER] Migrated quickstart config: %s.", qs_config.name
             )
+
+    def migrate_keys(self, keys_manager: KeysManager) -> None:
+        """Migrate keys format if needed."""
+        self.logger.info("Migrating keys...")
+
+        for key_file in keys_manager.path.iterdir():
+            if (
+                not key_file.is_file()
+                or key_file.suffix == ".bak"
+                or not Web3.is_address(key_file.name)
+            ):
+                self.logger.warning(f"Skipping non-key file: {key_file}")
+                continue
+
+            migrated = False
+            backup_path = key_file.with_suffix(".bak")
+
+            try:
+                with open(key_file, "r", encoding="utf-8") as file:
+                    data = json.load(file)
+            except Exception as e:  # pylint: disable=broad-except
+                self.logger.error(
+                    f"Failed to read key file: {key_file}\n"
+                    f"Key file content:\n{key_file.read_text(encoding='utf-8')}\n"
+                    f"Exception {e}: {traceback.format_exc()}"
+                )
+                raise e
+
+            old_to_new_ledgers = {0: "ethereum", 1: "solana"}
+            if data.get("ledger") in old_to_new_ledgers:
+                data["ledger"] = old_to_new_ledgers.get(data["ledger"])
+                with open(key_file, "w", encoding="utf-8") as file:
+                    json.dump(data, file, indent=2)
+
+                migrated = True
+
+            private_key = data.get("private_key")
+            if (
+                private_key
+                and keys_manager.password is not None
+                and private_key.startswith("0x")
+            ):
+                crypto: EthereumCrypto = keys_manager.private_key_to_crypto(
+                    private_key=private_key,
+                    password=None,
+                )
+                encrypted_private_key = crypto.encrypt(password=keys_manager.password)
+                data["private_key"] = encrypted_private_key
+                if backup_path.exists():
+                    unrecoverable_delete(backup_path)
+
+                migrated = True
+
+            if migrated:
+                with open(key_file, "w", encoding="utf-8") as file:
+                    json.dump(data, file, indent=2)
+
+            if not backup_path.exists():
+                shutil.copyfile(key_file, backup_path)
+
+            if migrated:
+                self.logger.info(f"Key {key_file.name} has been migrated.")

{olas_operate_middleware-0.11.5 → olas_operate_middleware-0.12.1}/operate/quickstart/reset_password.py

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