olas-operate-middleware 0.1.0rc59__py3-none-any.whl → 0.13.2__py3-none-any.whl

operate/data/contracts/{service_staking_token → staking_token}/contract.py

@@ -17,7 +17,7 @@
 #
 # ------------------------------------------------------------------------------
 
-"""This module contains the class to connect to the `ServiceStakingTokenMechUsage` contract."""
+"""This module contains the class to connect to the `StakingToken` contract."""
 
 from enum import Enum
 
@@ -27,18 +27,10 @@ from aea.contracts.base import Contract
 from aea.crypto.base import LedgerApi
 
 
-class StakingState(Enum):
-    """Staking state enumeration for the staking."""
+class StakingTokenContract(Contract):
+    """The Staking Token contract."""
 
-    UNSTAKED = 0
-    STAKED = 1
-    EVICTED = 2
-
-
-class ServiceStakingTokenContract(Contract):
-    """The Service Staking contract."""
-
-    contract_id = PublicId.from_str("valory/service_staking_token:0.1.0")
+    contract_id = PublicId.from_str("valory/staking_token:0.1.0")
 
     @classmethod
     def get_service_staking_state(
@@ -50,7 +42,7 @@ class ServiceStakingTokenContract(Contract):
         """Check whether the service is staked."""
         contract_instance = cls.get_instance(ledger_api, contract_address)
         res = contract_instance.functions.getStakingState(service_id).call()
-        return dict(data=StakingState(res))
+        return dict(data=res)
 
     @classmethod
     def build_stake_tx(
@@ -121,6 +113,28 @@ class ServiceStakingTokenContract(Contract):
         ts = contract.functions.getNextRewardCheckpointTimestamp().call()
         return dict(data=ts)
 
+    @classmethod
+    def ts_checkpoint(
+        cls,
+        ledger_api: LedgerApi,
+        contract_address: str,
+    ) -> JSONLike:
+        """Retrieve the checkpoint's timestamp."""
+        contract = cls.get_instance(ledger_api, contract_address)
+        ts_checkpoint = contract.functions.tsCheckpoint().call()
+        return dict(data=ts_checkpoint)
+
+    @classmethod
+    def liveness_ratio(
+        cls,
+        ledger_api: LedgerApi,
+        contract_address: str,
+    ) -> JSONLike:
+        """Retrieve the liveness ratio."""
+        contract = cls.get_instance(ledger_api, contract_address)
+        liveness_ratio = contract.functions.livenessRatio().call()
+        return dict(data=liveness_ratio)
+
     @classmethod
     def get_liveness_period(
         cls,

operate/data/contracts/staking_token/contract.yaml

@@ -0,0 +1,23 @@
+name: staking_token
+author: valory
+version: 0.1.0
+type: contract
+description: Service staking token contract
+license: Apache-2.0
+aea_version: '>=1.0.0, <2.0.0'
+fingerprint:
+  __init__.py: bafybeicmgkagyhgwn2ktcdjbprijalbdyj26cvza4d3b7uvmehvy4mmr3i
+  build/StakingToken.json: bafybeibhcwyawq377innrpq4ytpw5kotufjqo7cyd2rjhyit34mnbks5b4
+  contract.py: bafybeigjt7a2biiorp4vmj4d3qkm3xbbohnawoetywojye5akhavlvkrxm
+fingerprint_ignore_patterns: []
+contracts: []
+class_name: StakingTokenContract
+contract_interface_paths:
+  ethereum: build/StakingToken.json
+dependencies:
+  open-aea-ledger-ethereum:
+    version: <2,>=1.53.0
+  open-aea-test-autonomy:
+    version: <1,>=0.14.14.post1
+  web3:
+    version: <7,>=6.0.0

operate/data/contracts/uniswap_v2_erc20/contract.yaml

@@ -8,7 +8,9 @@ aea_version: '>=1.0.0, <2.0.0'
 fingerprint:
   __init__.py: bafybeia75xbvf6zogcloppdcu2zrwcl6d46ebj2zmm6dkge6eno3k6ysw4
   build/IUniswapV2ERC20.json: bafybeid45gy6x5ah5ub5p2obdhph36skpoy5qdhikwwfso7f3655iqnpc4
-  contract.py: bafybeiarfpumhdmxh24xuiv6jprjq5f6qlrfrlxisz5enbvvbhotafp37e
+  contract.py: bafybeidxnb72n5xz4fvvxogbk2xk2vz4jvtsqa3berolr34v7cug3snism
+  tests/__init__.py: bafybeigj3ngmfmyy4nw4xipxbqnx4nd42aqidqmmduwpx6hurssjqqkirq
+  tests/test_contract.py: bafybeigaf7kyhuy4qn5dww2r62hffhytab3uhmjummsaiazzvqetvomyi4
 fingerprint_ignore_patterns: []
 contracts: []
 class_name: UniswapV2ERC20Contract

operate/data/contracts/uniswap_v2_erc20/tests/__init__.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------------------------
+#
+#   Copyright 2021-2022 Valory AG
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+# ------------------------------------------------------------------------------
+
+"""Tests package for valory/uniswap_v2_erc20 contract."""

operate/data/contracts/uniswap_v2_erc20/tests/test_contract.py

@@ -0,0 +1,363 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------------------------
+#
+#   Copyright 2021-2022 Valory AG
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+# ------------------------------------------------------------------------------
+
+"""Tests for valory/uniswap_v2_erc20 contract."""
+
+from pathlib import Path
+from typing import Dict
+from unittest import mock
+
+from aea.test_tools.test_contract import BaseContractTestCase
+
+from operate.data.contracts.uniswap_v2_erc20.contract import UniswapV2ERC20Contract
+
+PACKAGE_DIR = Path(__file__).parent.parent
+
+
+CONTRACT_ADDRESS = "0xa6B71E26C5e0845f74c812102Ca7114b6a896AB2"
+ADDRESS_ONE = "0x46F415F7BF30f4227F98def9d2B22ff62738fD68"
+ADDRESS_TWO = "0x7A1236d5195e31f1F573AD618b2b6FEFC85C5Ce6"
+ADDRESS_THREE = "0x7A1236d5195e31f1F573AD618b2b6FEFC85C5Ce6"
+NONCE = 0
+CHAIN_ID = 1
+MAX_ALLOWANCE = 2**256 - 1
+
+
+class TestUniswapV2ERC20Contract(BaseContractTestCase):
+    """Test TestUniswapV2ERC20Contract."""
+
+    path_to_contract = PACKAGE_DIR
+    ledger_identifier = "ethereum"
+    contract: UniswapV2ERC20Contract
+    owner_address = ADDRESS_ONE
+    sender_address = ADDRESS_TWO
+    gas_price = 100
+
+    @classmethod
+    def finish_contract_deployment(cls) -> str:
+        """Finish the contract deployment."""
+        contract_address = CONTRACT_ADDRESS
+        return contract_address
+
+    @classmethod
+    def _deploy_contract(cls, contract, ledger_api, deployer_crypto, gas) -> Dict:  # type: ignore
+        """Deploy contract."""
+        return {}
+
+    def test_approve(self) -> None:
+        """Test approve."""
+        eth_value = 0
+        gas = 100
+        spender_address = ADDRESS_THREE
+        approval_value = 100
+        data = self.contract.get_instance(
+            self.ledger_api, self.contract_address
+        ).encodeABI(fn_name="approve", args=[spender_address, approval_value])
+        with mock.patch.object(
+            self.ledger_api.api.eth, "get_transaction_count", return_value=NONCE
+        ):
+            with mock.patch.object(
+                self.ledger_api.api.manager, "request_blocking", return_value=CHAIN_ID
+            ):
+                result = self.contract.approve(
+                    self.ledger_api,
+                    self.contract_address,
+                    spender_address,
+                    approval_value,
+                    sender_address=self.sender_address,
+                    gas=gas,
+                    gasPrice=self.gas_price,
+                )
+        assert result == {
+            "chainId": CHAIN_ID,
+            "data": data,
+            "gas": gas,
+            "gasPrice": self.gas_price,
+            "nonce": NONCE,
+            "to": CONTRACT_ADDRESS,
+            "value": eth_value,
+        }
+
+    def test_transfer(self) -> None:
+        """Test transfer."""
+        eth_value = 0
+        gas = 100
+        spender_address = ADDRESS_THREE
+        value = 100
+        data = self.contract.get_instance(
+            self.ledger_api, self.contract_address
+        ).encodeABI(fn_name="transfer", args=[spender_address, value])
+        with mock.patch.object(
+            self.ledger_api.api.eth, "get_transaction_count", return_value=NONCE
+        ):
+            with mock.patch.object(
+                self.ledger_api.api.manager, "request_blocking", return_value=CHAIN_ID
+            ):
+                result = self.contract.transfer(
+                    self.ledger_api,
+                    self.contract_address,
+                    spender_address,
+                    value,
+                    sender_address=self.sender_address,
+                    gas=gas,
+                    gasPrice=self.gas_price,
+                )
+        assert result == {
+            "chainId": CHAIN_ID,
+            "data": data,
+            "gas": gas,
+            "gasPrice": self.gas_price,
+            "nonce": NONCE,
+            "to": CONTRACT_ADDRESS,
+            "value": eth_value,
+        }
+
+    def test_transfer_from(self) -> None:
+        """Test transfer_from."""
+        eth_value = 0
+        gas = 100
+        from_address = ADDRESS_THREE
+        to_address = ADDRESS_ONE
+        value = 100
+        data = self.contract.get_instance(
+            self.ledger_api, self.contract_address
+        ).encodeABI(fn_name="transferFrom", args=[from_address, to_address, value])
+        with mock.patch.object(
+            self.ledger_api.api.eth, "get_transaction_count", return_value=NONCE
+        ):
+            with mock.patch.object(
+                self.ledger_api.api.manager, "request_blocking", return_value=CHAIN_ID
+            ):
+                result = self.contract.transfer_from(
+                    self.ledger_api,
+                    self.contract_address,
+                    from_address,
+                    to_address,
+                    value,
+                    sender_address=self.sender_address,
+                    gas=gas,
+                    gasPrice=self.gas_price,
+                )
+        assert result == {
+            "chainId": CHAIN_ID,
+            "data": data,
+            "gas": gas,
+            "gasPrice": self.gas_price,
+            "nonce": NONCE,
+            "to": CONTRACT_ADDRESS,
+            "value": eth_value,
+        }
+
+    def test_permit(self) -> None:
+        """Test permit."""
+        eth_value = 0
+        gas = 100
+        owner_address = ADDRESS_THREE
+        spender_address = CONTRACT_ADDRESS
+        value = 100
+        deadline = 10
+        v = 10
+        r = b""
+        s = b""
+        data = self.contract.get_instance(
+            self.ledger_api, self.contract_address
+        ).encodeABI(
+            fn_name="permit",
+            args=[owner_address, spender_address, value, deadline, v, r, s],
+        )
+        with mock.patch.object(
+            self.ledger_api.api.eth, "get_transaction_count", return_value=NONCE
+        ):
+            with mock.patch.object(
+                self.ledger_api.api.manager, "request_blocking", return_value=CHAIN_ID
+            ):
+                result = self.contract.permit(
+                    self.ledger_api,
+                    self.contract_address,
+                    owner_address,
+                    spender_address,
+                    value,
+                    deadline,
+                    v,
+                    r,
+                    s,
+                    sender_address=self.sender_address,
+                    gas=gas,
+                    gasPrice=self.gas_price,
+                )
+        assert result == {
+            "chainId": CHAIN_ID,
+            "data": data,
+            "gas": gas,
+            "gasPrice": self.gas_price,
+            "nonce": NONCE,
+            "to": CONTRACT_ADDRESS,
+            "value": eth_value,
+        }
+
+    def test_allowance(self) -> None:
+        """Test allowance."""
+        owner_address = ADDRESS_ONE
+        spender_address = ADDRESS_THREE
+        with mock.patch.object(
+            self.ledger_api.api.manager,
+            "request_blocking",
+            return_value="0x0000000000000000000000000000000000000000000000000000000000000000",
+        ):
+            result = self.contract.allowance(
+                self.ledger_api,
+                self.contract_address,
+                owner_address,
+                spender_address,
+            )
+        assert result == 0
+
+    def test_balance_of(self) -> None:
+        """Test balance_of."""
+        owner_address = ADDRESS_THREE
+        with mock.patch.object(
+            self.ledger_api.api.manager,
+            "request_blocking",
+            return_value="0x0000000000000000000000000000000000000000000000000000000000000000",
+        ):
+            result = self.contract.balance_of(
+                self.ledger_api, self.contract_address, owner_address
+            )
+        assert result == 0
+
+    def test_get_approve_data(self) -> None:
+        """Test get_method_data with approve."""
+
+        result = self.contract.get_method_data(
+            ledger_api=self.ledger_api,
+            contract_address=self.contract_address,
+            method_name="approve",
+            spender=ADDRESS_ONE,
+            value=MAX_ALLOWANCE,
+        )
+        assert result == {
+            "data": b"\t^\xa7\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+            b"F\xf4\x15\xf7\xbf0\xf4\"\x7f\x98\xde\xf9\xd2\xb2/\xf6'8\xfdh"
+            b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
+            b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
+        }
+
+    def test_get_transfer_data(self) -> None:
+        """Test get_method_data with transfer."""
+
+        result = self.contract.get_method_data(
+            ledger_api=self.ledger_api,
+            contract_address=self.contract_address,
+            method_name="transfer",
+            to=ADDRESS_ONE,
+            value=1,
+        )
+        assert result == {
+            "data": b"\xa9\x05\x9c\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+            b"F\xf4\x15\xf7\xbf0\xf4\"\x7f\x98\xde\xf9\xd2\xb2/\xf6'8\xfdh"
+            b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+            b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01"
+        }
+
+    def test_get_transfer_from_data(self) -> None:
+        """Test get_method_data with transfer_from."""
+
+        # "from" is a reserved word, so must be passed as kwargs
+        kwargs = {"from": ADDRESS_TWO, "to": ADDRESS_ONE, "value": 1}
+
+        result = self.contract.get_method_data(
+            ledger_api=self.ledger_api,
+            contract_address=self.contract_address,
+            method_name="transfer_from",
+            **kwargs
+        )
+        assert result == {
+            "data": b"#\xb8r\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00z\x126\xd5"
+            b"\x19^1\xf1\xf5s\xada\x8b+o\xef\xc8\\\\\xe6\x00\x00\x00\x00"
+            b'\x00\x00\x00\x00\x00\x00\x00\x00F\xf4\x15\xf7\xbf0\xf4"'
+            b"\x7f\x98\xde\xf9\xd2\xb2/\xf6'8\xfdh\x00\x00\x00\x00\x00\x00\x00\x00"
+            b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+            b"\x00\x00\x00\x00\x00\x00\x00\x01"
+        }
+
+    def test_get_permit_data(self) -> None:
+        """Test get_method_data with permit."""
+
+        result = self.contract.get_method_data(
+            ledger_api=self.ledger_api,
+            contract_address=self.contract_address,
+            method_name="permit",
+            owner=ADDRESS_ONE,
+            spender=ADDRESS_TWO,
+            value=1,
+            deadline=300,
+            v=0,
+            r=b"0",
+            s=b"0",
+        )
+
+        assert result == {
+            "data": b"\xd5\x05\xac\xcf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+            b"F\xf4\x15\xf7\xbf0\xf4\"\x7f\x98\xde\xf9\xd2\xb2/\xf6'8\xfdh"
+            b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00z\x126\xd5\x19^1\xf1"
+            b"\xf5s\xada\x8b+o\xef\xc8\\\\\xe6\x00\x00\x00\x00\x00\x00\x00\x00"
+            b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+            b"\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"
+            b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+            b"\x00\x00\x00\x00\x00\x00\x01,\x00\x00\x00\x00\x00\x00\x00\x00"
+            b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+            b"\x00\x00\x00\x00\x00\x00\x00\x000\x00\x00\x00\x00\x00\x00\x00"
+            b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+            b"\x00\x00\x00\x00\x00\x00\x00\x000\x00\x00\x00\x00\x00\x00\x00"
+            b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+            b"\x00\x00\x00\x00\x00\x00\x00\x00"
+        }
+
+    def test_get_allowance_data(self) -> None:
+        """Test get_method_data with allowance."""
+
+        result = self.contract.get_method_data(
+            ledger_api=self.ledger_api,
+            contract_address=self.contract_address,
+            method_name="allowance",
+            owner=ADDRESS_ONE,
+            spender=ADDRESS_TWO,
+        )
+
+        assert result == {
+            "data": b"\xddb\xed>\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+            b"F\xf4\x15\xf7\xbf0\xf4\"\x7f\x98\xde\xf9\xd2\xb2/\xf6'8\xfdh"
+            b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00z\x126\xd5\x19^1\xf1"
+            b"\xf5s\xada\x8b+o\xef\xc8\\\\\xe6"
+        }
+
+    def test_get_balance_of_data(self) -> None:
+        """Test get_method_data with balance_of."""
+
+        result = self.contract.get_method_data(
+            ledger_api=self.ledger_api,
+            contract_address=self.contract_address,
+            method_name="balance_of",
+            owner=ADDRESS_ONE,
+        )
+
+        assert result == {
+            "data": b"p\xa0\x821\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+            b"F\xf4\x15\xf7\xbf0\xf4\"\x7f\x98\xde\xf9\xd2\xb2/\xf6'8\xfdh"
+        }

operate/keys.py

@@ -20,17 +20,18 @@
 """Keys manager."""
 
 import json
-import logging
 import os
-import typing as t
+import tempfile
 from dataclasses import dataclass
+from logging import Logger
 from pathlib import Path
+from typing import Any, Optional
 
-from aea.helpers.logging import setup_logger
 from aea_ledger_ethereum.ethereum import EthereumCrypto
 
+from operate.operate_types import LedgerType
 from operate.resource import LocalResource
-from operate.types import LedgerType
+from operate.utils import unrecoverable_delete
 
 
 @dataclass
@@ -41,35 +42,66 @@ class Key(LocalResource):
     address: str
     private_key: str
 
+    def get_decrypted_json(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"""
         return super().load(path)  # type: ignore
 
 
-Keys = t.List[Key]
-
-
 class KeysManager:
     """Keys manager."""
 
-    def __init__(
-        self,
-        path: Path,
-        logger: t.Optional[logging.Logger] = None,
-    ) -> None:
+    def __init__(self, **kwargs: Any) -> None:
         """
         Initialize keys manager
 
         :param path: Path to keys storage.
         :param logger: logging.Logger object.
         """
-        self.path = path
-        self.logger = logger or setup_logger(name="operate.keys")
-
-    def setup(self) -> None:
-        """Setup service manager."""
-        self.path.mkdir(exist_ok=True)
+        if "path" not in kwargs:
+            raise ValueError("Path must be provided for KeysManager")
+
+        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."""
@@ -81,26 +113,79 @@ class KeysManager:
             )
         )
 
+    def get_decrypted(self, key: str) -> dict:
+        """Get key json."""
+        if self.password is not None:
+            return self.get(key).get_decrypted_json(self.password)
+        return self.get(key).json
+
+    def get_private_key_file(self, address: str) -> Path:
+        """Get the path to the private key file for the given address."""
+        path = self.path / f"{address}_private_key"
+
+        if path.is_file():
+            return path
+
+        key = self.get(address)
+        private_key = key.private_key
+        path.write_text(private_key, encoding="utf-8")
+        os.chmod(path, 0o600)
+        return path
+
+    def get_crypto_instance(self, address: str) -> EthereumCrypto:
+        """Get EthereumCrypto instance for the given address."""
+        key: Key = self.get(address)
+        return self.private_key_to_crypto(key.private_key, self.password)
+
     def create(self) -> str:
         """Creates new key."""
-        crypto = EthereumCrypto()
-        path = self.path / crypto.address
-        if path.is_file():
-            return crypto.address
-
-        path.write_text(
-            json.dumps(
-                Key(
-                    ledger=LedgerType.ETHEREUM,
-                    address=crypto.address,
-                    private_key=crypto.private_key,
-                ).json,
-                indent=4,
-            ),
-            encoding="utf-8",
+        self.path.mkdir(exist_ok=True, parents=True)
+        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,
+        ):
+            if path.is_file():
+                continue
+
+            path.write_text(
+                json.dumps(
+                    key.json,
+                    indent=2,
+                ),
+                encoding="utf-8",
+            )
+
         return crypto.address
 
     def delete(self, key: str) -> None:
         """Delete key."""
         os.remove(self.path / key)
+
+    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