olas-operate-middleware 0.13.1__py3-none-any.whl → 0.13.3__py3-none-any.whl

operate/services/utils/tendermint.py

@@ -42,6 +42,8 @@ import requests
 from flask import Flask, Response, jsonify, request
 from werkzeug.exceptions import InternalServerError, NotFound
 
+from operate.constants import DEFAULT_TIMEOUT
+
 
 ENCODING = "utf-8"
 DEFAULT_LOG_FILE = "com.log"
@@ -474,7 +476,7 @@ class PeriodDumper:
             os.chmod(path, stat.S_IWRITE)
             func(path)
         except (FileNotFoundError, OSError):
-            return
+            pass
 
     def dump_period(self) -> None:
         """Dump tendermint run data for replay"""
@@ -532,7 +534,7 @@ def create_app(  # pylint: disable=too-many-statements
             )
             priv_key_data = json.loads(priv_key_file.read_text(encoding=ENCODING))
             del priv_key_data["priv_key"]
-            status = requests.get(TM_STATUS_ENDPOINT).json()
+            status = requests.get(TM_STATUS_ENDPOINT, timeout=DEFAULT_TIMEOUT).json()
             priv_key_data["peer_id"] = status["result"]["node_info"]["id"]
             return {
                 "params": priv_key_data,
@@ -600,7 +602,7 @@ def create_app(  # pylint: disable=too-many-statements
             endpoint = f"{tendermint_params.rpc_laddr.replace('tcp', 'http').replace(non_routable, loopback)}/block"
             height = request.args.get("height")
             params = {"height": height} if height is not None else None
-            res = requests.get(endpoint, params)
+            res = requests.get(endpoint, params, timeout=DEFAULT_TIMEOUT)
             app_hash_ = res.json()["result"]["block"]["header"]["app_hash"]
             return jsonify({"app_hash": app_hash_}), res.status_code
         except Exception as e:  # pylint: disable=W0703

operate/utils/gnosis.py

@@ -170,9 +170,7 @@ def create_safe(
     """Create gnosis safe."""
     salt_nonce = salt_nonce or _get_nonce()
 
-    def _build(  # pylint: disable=unused-argument
-        *args: t.Any, **kwargs: t.Any
-    ) -> t.Dict:
+    def _build() -> t.Dict:
         tx = registry_contracts.gnosis_safe.get_deploy_transaction(
             ledger_api=ledger_api,
             deployer_address=crypto.address,
@@ -183,30 +181,26 @@ def create_safe(
         del tx["contract_address"]
         return tx
 
-    tx_settler = TxSettler(
-        ledger_api=ledger_api,
-        crypto=crypto,
-        chain_type=ChainProfile.CUSTOM,
-        timeout=ON_CHAIN_INTERACT_TIMEOUT,
-        retries=ON_CHAIN_INTERACT_RETRIES,
-        sleep=ON_CHAIN_INTERACT_SLEEP,
-    )
-    setattr(  # noqa: B010
-        tx_settler,
-        "build",
-        _build,
-    )
-    receipt = tx_settler.transact(
-        method=lambda: {},
-        contract="",
-        kwargs={},
+    tx_settler = (
+        TxSettler(
+            ledger_api=ledger_api,
+            crypto=crypto,
+            chain_type=ChainProfile.CUSTOM,
+            timeout=ON_CHAIN_INTERACT_TIMEOUT,
+            retries=ON_CHAIN_INTERACT_RETRIES,
+            sleep=ON_CHAIN_INTERACT_SLEEP,
+            tx_builder=_build,
+        )
+        .transact()
+        .settle()
     )
-    tx_hash = receipt.get("transactionHash", "").hex()
-    instance = registry_contracts.gnosis_safe_proxy_factory.get_instance(
-        ledger_api=ledger_api,
-        contract_address="0xa6b71e26c5e0845f74c812102ca7114b6a896ab2",
+    (event,) = tx_settler.get_events(
+        contract=registry_contracts.gnosis_safe_proxy_factory.get_instance(
+            ledger_api=ledger_api,
+            contract_address="0xa6b71e26c5e0845f74c812102ca7114b6a896ab2",
+        ),
+        event_name="ProxyCreation",
     )
-    (event,) = instance.events.ProxyCreation().process_receipt(receipt)
     safe_address = event["args"]["proxy"]
 
     if backup_owner is not None:
@@ -231,7 +225,7 @@ def create_safe(
                 )
                 time.sleep(next_delay)
 
-    return safe_address, salt_nonce, tx_hash
+    return safe_address, salt_nonce, tx_settler.tx_hash
 
 
 def get_owners(ledger_api: LedgerApi, safe: str) -> t.List[str]:
@@ -248,16 +242,14 @@ def send_safe_txs(
     ledger_api: LedgerApi,
     crypto: Crypto,
     to: t.Optional[str] = None,
-) -> t.Optional[str]:
+) -> str:
     """Send internal safe transaction."""
     owner = ledger_api.api.to_checksum_address(
         crypto.address,
     )
     to_address = to or safe
 
-    def _build_tx(  # pylint: disable=unused-argument
-        *args: t.Any, **kwargs: t.Any
-    ) -> t.Optional[str]:
+    def _build_tx() -> t.Optional[str]:
         safe_tx_hash = registry_contracts.gnosis_safe.get_raw_safe_transaction_hash(
             ledger_api=ledger_api,
             contract_address=safe,
@@ -290,25 +282,22 @@ def send_safe_txs(
             nonce=ledger_api.api.eth.get_transaction_count(owner),
         )
 
-    tx_settler = TxSettler(
-        ledger_api=ledger_api,
-        crypto=crypto,
-        chain_type=Chain.from_id(
-            ledger_api._chain_id  # pylint: disable=protected-access
-        ),
-        timeout=ON_CHAIN_INTERACT_TIMEOUT,
-        retries=ON_CHAIN_INTERACT_RETRIES,
-        sleep=ON_CHAIN_INTERACT_SLEEP,
-    )
-    setattr(tx_settler, "build", _build_tx)  # noqa: B010
-    tx_receipt = tx_settler.transact(
-        method=lambda: {},
-        contract="",
-        kwargs={},
-        dry_run=False,
+    return (
+        TxSettler(
+            ledger_api=ledger_api,
+            crypto=crypto,
+            chain_type=Chain.from_id(
+                ledger_api._chain_id  # pylint: disable=protected-access
+            ),
+            tx_builder=_build_tx,
+            timeout=ON_CHAIN_INTERACT_TIMEOUT,
+            retries=ON_CHAIN_INTERACT_RETRIES,
+            sleep=ON_CHAIN_INTERACT_SLEEP,
+        )
+        .transact()
+        .settle()
+        .tx_hash
     )
-    tx_hash = tx_receipt.get("transactionHash", "").hex()
-    return tx_hash
 
 
 def add_owner(
@@ -322,8 +311,8 @@ def add_owner(
         ledger_api=ledger_api,
         contract_address=safe,
     )
-    txd = instance.encodeABI(
-        fn_name="addOwnerWithThreshold",
+    txd = instance.encode_abi(
+        abi_element_identifier="addOwnerWithThreshold",
         args=[
             owner,
             1,
@@ -368,8 +357,8 @@ def swap_owner(
         ledger_api=ledger_api,
         contract_address=safe,
     )
-    txd = instance.encodeABI(
-        fn_name="swapOwner",
+    txd = instance.encode_abi(
+        abi_element_identifier="swapOwner",
         args=[
             prev_owner,
             old_owner,
@@ -398,8 +387,8 @@ def remove_owner(
         ledger_api=ledger_api,
         contract_address=safe,
     )
-    txd = instance.encodeABI(
-        fn_name="removeOwner",
+    txd = instance.encode_abi(
+        abi_element_identifier="removeOwner",
         args=[
             prev_owner,
             owner,
@@ -420,16 +409,14 @@ def transfer(
     safe: str,
     to: str,
     amount: t.Union[float, int],
-) -> t.Optional[str]:
+) -> str:
     """Transfer assets from safe to given address."""
     amount = int(amount)
     owner = ledger_api.api.to_checksum_address(
         crypto.address,
     )
 
-    def _build_tx(  # pylint: disable=unused-argument
-        *args: t.Any, **kwargs: t.Any
-    ) -> t.Optional[str]:
+    def _build_tx() -> t.Optional[str]:
         safe_tx_hash = registry_contracts.gnosis_safe.get_raw_safe_transaction_hash(
             ledger_api=ledger_api,
             contract_address=safe,
@@ -462,25 +449,22 @@ def transfer(
             nonce=ledger_api.api.eth.get_transaction_count(owner),
         )
 
-    tx_settler = TxSettler(
-        ledger_api=ledger_api,
-        crypto=crypto,
-        chain_type=Chain.from_id(
-            ledger_api._chain_id  # pylint: disable=protected-access
-        ),
-        timeout=ON_CHAIN_INTERACT_TIMEOUT,
-        retries=ON_CHAIN_INTERACT_RETRIES,
-        sleep=ON_CHAIN_INTERACT_SLEEP,
-    )
-    setattr(tx_settler, "build", _build_tx)  # noqa: B010
-    tx_receipt = tx_settler.transact(
-        method=lambda: {},
-        contract="",
-        kwargs={},
-        dry_run=False,
+    return (
+        TxSettler(
+            ledger_api=ledger_api,
+            crypto=crypto,
+            chain_type=Chain.from_id(
+                ledger_api._chain_id  # pylint: disable=protected-access
+            ),
+            tx_builder=_build_tx,
+            timeout=ON_CHAIN_INTERACT_TIMEOUT,
+            retries=ON_CHAIN_INTERACT_RETRIES,
+            sleep=ON_CHAIN_INTERACT_SLEEP,
+        )
+        .transact()
+        .settle()
+        .tx_hash
     )
-    tx_hash = tx_receipt.get("transactionHash", "").hex()
-    return tx_hash
 
 
 def transfer_erc20_from_safe(
@@ -497,8 +481,8 @@ def transfer_erc20_from_safe(
         ledger_api=ledger_api,
         contract_address=token,
     )
-    txd = instance.encodeABI(
-        fn_name="transfer",
+    txd = instance.encode_abi(
+        abi_element_identifier="transfer",
         args=[
             to,
             amount,
@@ -547,18 +531,8 @@ def drain_eoa(
     chain_id: int,
 ) -> t.Optional[str]:
     """Drain all the native tokens from the crypto wallet."""
-    tx_helper = TxSettler(
-        ledger_api=ledger_api,
-        crypto=crypto,
-        chain_type=ChainProfile.CUSTOM,
-        timeout=ON_CHAIN_INTERACT_TIMEOUT,
-        retries=ON_CHAIN_INTERACT_RETRIES,
-        sleep=ON_CHAIN_INTERACT_SLEEP,
-    )
 
-    def _build_tx(  # pylint: disable=unused-argument
-        *args: t.Any, **kwargs: t.Any
-    ) -> t.Dict:
+    def _build_tx() -> t.Dict:
         """Build transaction"""
         chain_fee = estimate_transfer_tx_fee(
             chain=Chain.from_id(chain_id),
@@ -595,13 +569,20 @@ def drain_eoa(
 
         return tx
 
-    setattr(tx_helper, "build", _build_tx)  # noqa: B010
     try:
-        tx_receipt = tx_helper.transact(
-            method=lambda: {},
-            contract="",
-            kwargs={},
-            dry_run=False,
+        return (
+            TxSettler(
+                ledger_api=ledger_api,
+                crypto=crypto,
+                chain_type=ChainProfile.CUSTOM,
+                timeout=ON_CHAIN_INTERACT_TIMEOUT,
+                retries=ON_CHAIN_INTERACT_RETRIES,
+                sleep=ON_CHAIN_INTERACT_SLEEP,
+                tx_builder=_build_tx,
+            )
+            .transact()
+            .settle()
+            .tx_hash
         )
     except ChainInteractionError as e:
         if "No balance to drain from wallet" in str(e):
@@ -610,12 +591,6 @@ def drain_eoa(
 
         raise e
 
-    tx_hash = tx_receipt.get("transactionHash", None)
-    if tx_hash is not None:
-        return tx_hash.hex()
-
-    return None
-
 
 def get_asset_balance(
     ledger_api: LedgerApi,

operate/wallet/master.py

@@ -75,14 +75,12 @@ class MasterWallet(LocalResource):
 
     path: Path
     address: str
-
-    safes: t.Dict[Chain, str] = field(default_factory=dict)
-    safe_chains: t.List[Chain] = field(default_factory=list)
+    safes: t.Dict[Chain, str]
+    safe_chains: t.List[Chain]
     ledger_type: LedgerType
     safe_nonce: t.Optional[int] = None
 
     _key: str
-    _mnemonic: str
     _crypto: t.Optional[Crypto] = None
     _password: t.Optional[str] = None
     _crypto_cls: t.Type[Crypto]
@@ -111,10 +109,15 @@ class MasterWallet(LocalResource):
         """Key path."""
         return self.path / self._key
 
+    @classmethod
+    def mnemonic_filename(cls) -> str:
+        """Return deterministic mnemonic filename per ledger type."""
+        return f"{cls.ledger_type.value.lower()}.mnemonic.json"
+
     @property
     def mnemonic_path(self) -> Path:
         """Mnemonic path."""
-        return self.path / self._mnemonic
+        return self.path / self.__class__.mnemonic_filename()
 
     @staticmethod
     def ledger_api(
@@ -250,7 +253,6 @@ class EthereumMasterWallet(MasterWallet):
 
     _file = ledger_type.config_file
     _key = ledger_type.key_file
-    _mnemonic = ledger_type.mnemonic_file
     _crypto_cls = EthereumCrypto
 
     def _pre_transfer_checks(
@@ -284,7 +286,7 @@ class EthereumMasterWallet(MasterWallet):
 
     def _transfer_from_eoa(
         self, to: str, amount: int, chain: Chain, rpc: t.Optional[str] = None
-    ) -> t.Optional[str]:
+    ) -> str:
         """Transfer funds from EOA wallet."""
         balance = self.get_balance(chain=chain, from_safe=False)
         tx_fee = estimate_transfer_tx_fee(
@@ -306,18 +308,8 @@ class EthereumMasterWallet(MasterWallet):
         )
 
         ledger_api = t.cast(EthereumApi, self.ledger_api(chain=chain, rpc=rpc))
-        tx_helper = TxSettler(
-            ledger_api=ledger_api,
-            crypto=self.crypto,
-            chain_type=ChainProfile.CUSTOM,
-            timeout=ON_CHAIN_INTERACT_TIMEOUT,
-            retries=ON_CHAIN_INTERACT_RETRIES,
-            sleep=ON_CHAIN_INTERACT_SLEEP,
-        )
 
-        def _build_tx(  # pylint: disable=unused-argument
-            *args: t.Any, **kwargs: t.Any
-        ) -> t.Dict:
+        def _build_tx() -> t.Dict:
             """Build transaction"""
             max_priority_fee_per_gas = os.getenv("MAX_PRIORITY_FEE_PER_GAS", None)
             max_fee_per_gas = os.getenv("MAX_FEE_PER_GAS", None)
@@ -339,10 +331,20 @@ class EthereumMasterWallet(MasterWallet):
                 raise_on_try=True,
             )
 
-        setattr(tx_helper, "build", _build_tx)  # noqa: B010
-        tx_receipt = tx_helper.transact(lambda x: x, "", kwargs={})
-        tx_hash = tx_receipt.get("transactionHash", "").hex()
-        return tx_hash
+        return (
+            TxSettler(
+                ledger_api=ledger_api,
+                crypto=self.crypto,
+                chain_type=ChainProfile.CUSTOM,
+                timeout=ON_CHAIN_INTERACT_TIMEOUT,
+                retries=ON_CHAIN_INTERACT_RETRIES,
+                sleep=ON_CHAIN_INTERACT_SLEEP,
+                tx_builder=_build_tx,
+            )
+            .transact()
+            .settle()
+            .tx_hash
+        )
 
     def _transfer_from_safe(
         self, to: str, amount: int, chain: Chain, rpc: t.Optional[str] = None
@@ -389,7 +391,7 @@ class EthereumMasterWallet(MasterWallet):
         amount: int,
         chain: Chain,
         rpc: t.Optional[str] = None,
-    ) -> t.Optional[str]:
+    ) -> str:
         """Transfer erc20 from EOA wallet."""
         to = self._pre_transfer_checks(
             to=to, amount=amount, chain=chain, from_safe=False, asset=token
@@ -397,18 +399,8 @@ class EthereumMasterWallet(MasterWallet):
 
         wallet_address = self.address
         ledger_api = t.cast(EthereumApi, self.ledger_api(chain=chain, rpc=rpc))
-        tx_settler = TxSettler(
-            ledger_api=ledger_api,
-            crypto=self.crypto,
-            chain_type=ChainProfile.CUSTOM,
-            timeout=ON_CHAIN_INTERACT_TIMEOUT,
-            retries=ON_CHAIN_INTERACT_RETRIES,
-            sleep=ON_CHAIN_INTERACT_SLEEP,
-        )
 
-        def _build_transfer_tx(  # pylint: disable=unused-argument
-            *args: t.Any, **kargs: t.Any
-        ) -> t.Dict:
+        def _build_transfer_tx() -> t.Dict:
             # TODO Backport to OpenAEA
             instance = registry_contracts.erc20.get_instance(
                 ledger_api=ledger_api,
@@ -427,15 +419,20 @@ class EthereumMasterWallet(MasterWallet):
             update_tx_with_gas_estimate(tx, ledger_api)
             return tx
 
-        setattr(tx_settler, "build", _build_transfer_tx)  # noqa: B010
-        tx_receipt = tx_settler.transact(
-            method=lambda: {},
-            contract="",
-            kwargs={},
-            dry_run=False,
+        return (
+            TxSettler(
+                ledger_api=ledger_api,
+                crypto=self.crypto,
+                chain_type=ChainProfile.CUSTOM,
+                timeout=ON_CHAIN_INTERACT_TIMEOUT,
+                retries=ON_CHAIN_INTERACT_RETRIES,
+                sleep=ON_CHAIN_INTERACT_SLEEP,
+                tx_builder=_build_transfer_tx,
+            )
+            .transact()
+            .settle()
+            .tx_hash
         )
-        tx_hash = tx_receipt.get("transactionHash", "").hex()
-        return tx_hash
 
     def transfer(  # pylint: disable=too-many-arguments
         self,
@@ -572,7 +569,7 @@ class EthereumMasterWallet(MasterWallet):
         # Backport support on aea
 
         eoa_wallet_path = path / cls._key
-        eoa_mnemonic_path = path / cls._mnemonic
+        eoa_mnemonic_path = path / cls.mnemonic_filename()
 
         if eoa_wallet_path.exists():
             raise FileExistsError(f"Wallet file already exists at {eoa_wallet_path}.")
@@ -611,12 +608,10 @@ class EthereumMasterWallet(MasterWallet):
 
     def decrypt_mnemonic(self, password: str) -> t.Optional[t.List[str]]:
         """Retrieve the mnemonic"""
-        eoa_mnemonic_path = self.path / self.ledger_type.mnemonic_file
-
-        if not eoa_mnemonic_path.exists():
+        if not self.mnemonic_path.exists():
             return None
 
-        encrypted_mnemonic = EncryptedData.load(eoa_mnemonic_path)
+        encrypted_mnemonic = EncryptedData.load(self.mnemonic_path)
         mnemonic = encrypted_mnemonic.decrypt(password).decode("utf-8")
         return mnemonic.split()
 
@@ -722,6 +717,9 @@ class EthereumMasterWallet(MasterWallet):
                 "The master wallet cannot be set as the Safe backup owner."
             )
 
+        if self.address not in owners:
+            return False
+
         owners.remove(self.address)
         old_backup_owner = owners[0] if owners else None
 
@@ -769,7 +767,9 @@ class EthereumMasterWallet(MasterWallet):
             chain_str = chain.value
             ledger_api = self.ledger_api(chain=chain, rpc=rpc)
             owners = get_owners(ledger_api=ledger_api, safe=safe)
-            owners.remove(self.address)
+
+            if self.address in owners:
+                owners.remove(self.address)
 
             balances[chain_str] = {self.address: {}, safe: {}}
 
@@ -781,8 +781,8 @@ class EthereumMasterWallet(MasterWallet):
                 balances[chain_str][safe][asset] = self.get_balance(
                     chain=chain, asset=asset, from_safe=True
                 )
-            wallet_json["safes"][chain.value] = {
-                wallet_json["safes"][chain.value]: {
+            wallet_json["safes"][chain_str] = {
+                safe: {
                     "backup_owners": owners,
                     "balances": balances[chain_str][safe],
                 }
@@ -791,6 +791,9 @@ class EthereumMasterWallet(MasterWallet):
 
         wallet_json["balances"] = balances
         wallet_json["extended_json"] = True
+        wallet_json["all_safes_have_backup_owner"] = all(
+            len(owners) > 0 for owners in owner_sets
+        )
         wallet_json["consistent_safe_address"] = len(set(self.safes.values())) == 1
         wallet_json["consistent_backup_owner"] = len(owner_sets) == 1
         wallet_json["consistent_backup_owner_count"] = all(