olas-operate-middleware 0.10.7__py3-none-any.whl → 0.10.9__py3-none-any.whl

operate/migration.py

@@ -29,11 +29,10 @@ from time import time
 
 from aea_cli_ipfs.ipfs_utils import IPFSTool
 
-from operate.constants import ZERO_ADDRESS
+from operate.constants import USER_JSON, 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,
@@ -43,11 +42,67 @@ from operate.utils import create_backup
 from operate.wallet.master import LEDGER_TYPE_TO_WALLET_CLASS, MasterWalletManager
 
 
+DEFAULT_TRADER_ENV_VARS = {
+    "GNOSIS_LEDGER_RPC": {
+        "name": "Gnosis ledger RPC",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+    "STAKING_CONTRACT_ADDRESS": {
+        "name": "Staking contract address",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+    "MECH_MARKETPLACE_CONFIG": {
+        "name": "Mech marketplace configuration",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+    "MECH_ACTIVITY_CHECKER_CONTRACT": {
+        "name": "Mech activity checker contract",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+    "MECH_CONTRACT_ADDRESS": {
+        "name": "Mech contract address",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+    "MECH_REQUEST_PRICE": {
+        "name": "Mech request price",
+        "description": "",
+        "value": "10000000000000000",
+        "provision_type": "computed",
+    },
+    "USE_MECH_MARKETPLACE": {
+        "name": "Use Mech marketplace",
+        "description": "",
+        "value": "False",
+        "provision_type": "computed",
+    },
+    "REQUESTER_STAKING_INSTANCE_ADDRESS": {
+        "name": "Requester staking instance address",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+    "PRIORITY_MECH_ADDRESS": {
+        "name": "Priority Mech address",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+}
+
+
 class MigrationManager:
     """MigrationManager"""
 
-    # TODO Backport here migration for services/config.json, etc.
-
     def __init__(
         self,
         home: Path,
@@ -62,12 +117,12 @@ class MigrationManager:
         """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}")
+        self.logger.info(f"Directories in {path}:\n{directories_str}")
 
     def migrate_user_account(self) -> None:
         """Migrates user.json"""
 
-        path = self._path / "user.json"
+        path = self._path / USER_JSON
         if not path.exists():
             return
 
@@ -102,18 +157,22 @@ class MigrationManager:
 
         self.logger.info("Migrating wallet configs done.")
 
-    @staticmethod
     def _migrate_service(  # pylint: disable=too-many-statements,too-many-locals
+        self,
         path: Path,
     ) -> bool:
         """Migrate the JSON file format if needed."""
 
         if not path.is_dir():
+            self.logger.warning(f"Service config path {path} is not a directory.")
             return False
 
         if not path.name.startswith(SERVICE_CONFIG_PREFIX) and not path.name.startswith(
             "bafybei"
         ):
+            self.logger.warning(
+                f"Service config path {path} is not a valid service config."
+            )
             return False
 
         if path.name.startswith("bafybei"):
@@ -155,6 +214,10 @@ class MigrationManager:
         if version == SERVICE_CONFIG_VERSION:
             return False
 
+        self.logger.info(
+            f"Migrating service config in {path} from version {version} to {SERVICE_CONFIG_VERSION}..."
+        )
+
         # Migration steps for older versions
         if version == 0:
             new_data = {
@@ -344,13 +407,9 @@ class MigrationManager:
         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.")
+                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()}"

operate/quickstart/claim_staking_rewards.py

@@ -25,14 +25,13 @@ import warnings
 from typing import TYPE_CHECKING, cast
 
 from operate.constants import SAFE_WEBAPP_URL
-from operate.ledger.profiles import get_staking_contract
 from operate.quickstart.run_service import (
     ask_password_if_needed,
     configure_local_config,
     get_service,
     load_local_config,
 )
-from operate.quickstart.utils import ask_yes_or_no, print_section, print_title
+from operate.quickstart.utils import ask_yes_or_no, print_section
 
 
 if TYPE_CHECKING:
@@ -74,6 +73,10 @@ def claim_staking_rewards(operate: "OperateApp", config_path: str) -> None:
 
     # reload manger and config after setting operate.password
     manager = operate.service_manager()
+    chain_config = service.chain_configs[config.principal_chain]
+    wallet = operate.wallet_manager.load(
+        ledger_type=chain_config.ledger_config.chain.ledger_type
+    )
     config = load_local_config(operate=operate, service_name=cast(str, service.name))
     assert (  # nosec
         config.principal_chain is not None
@@ -81,23 +84,8 @@ def claim_staking_rewards(operate: "OperateApp", config_path: str) -> None:
     assert config.rpc is not None, "RPC not set in quickstart config"  # nosec
     os.environ["CUSTOM_CHAIN_RPC"] = config.rpc[config.principal_chain]
 
-    chain_config = service.chain_configs[config.principal_chain]
-    sftxb = manager.get_eth_safe_tx_builder(
-        ledger_config=chain_config.ledger_config,
-    )
-    staking_contract = get_staking_contract(
-        chain=config.principal_chain,
-        staking_program_id=config.staking_program_id,
-    )
-    if not staking_contract or not sftxb.staking_rewards_claimable(
-        service_id=chain_config.chain_data.token,
-        staking_contract=staking_contract,
-    ):
-        print("No rewards to claim. Exiting.")
-        return
-
     try:
-        tx_hash = manager.claim_on_chain_from_safe(
+        manager.claim_on_chain_from_safe(
             service_config_id=service.service_config_id,
             chain=config.principal_chain,
         )
@@ -109,7 +97,8 @@ def claim_staking_rewards(operate: "OperateApp", config_path: str) -> None:
         logging.error(e)
         return
 
-    service_safe_address = chain_config.chain_data.multisig
-    print_title(f"Claim transaction done. Hash: {tx_hash.hex()}")
-    print(f"Claimed staking transferred to your service Safe {service_safe_address}.\n")
-    print(f"You may connect to service Safe at {SAFE_WEBAPP_URL}{service_safe_address}")
+    master_safe = wallet.safes[chain_config.ledger_config.chain]
+    print(
+        f"Claimed staking rewards are transferred to your Master Safe {master_safe}.\n"
+    )
+    print(f"You may connect to the Master Safe at {SAFE_WEBAPP_URL}{master_safe}")

operate/quickstart/reset_password.py

@@ -21,6 +21,7 @@
 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.quickstart.run_service import ask_confirm_password
 from operate.quickstart.utils import ask_or_get_from_env, print_section, print_title
@@ -36,7 +37,7 @@ def reset_password(operate: "OperateApp") -> None:
     print_title("Reset your password")
 
     # check if agent was started before
-    if not (operate._path / "user.json").exists():
+    if not (operate._path / USER_JSON).exists():
         print("No previous agent setup found. Exiting.")
         return
 
@@ -57,7 +58,7 @@ def reset_password(operate: "OperateApp") -> None:
     print("Resetting password of user account...")
     UserAccount.new(
         password=old_password,
-        path=operate._path / "user.json",
+        path=operate._path / USER_JSON,
     ).update(
         old_password=old_password,
         new_password=new_password,

operate/quickstart/run_service.py

@@ -34,7 +34,12 @@ from halo import Halo  # type: ignore[import]
 from web3.exceptions import Web3Exception
 
 from operate.account.user import UserAccount
-from operate.constants import IPFS_ADDRESS, NO_STAKING_PROGRAM_ID, OPERATE_HOME
+from operate.constants import (
+    IPFS_ADDRESS,
+    NO_STAKING_PROGRAM_ID,
+    OPERATE_HOME,
+    USER_JSON,
+)
 from operate.data import DATA_DIR
 from operate.data.contracts.staking_token.contract import StakingTokenContract
 from operate.ledger.profiles import STAKING, get_staking_contract
@@ -453,7 +458,7 @@ def ask_password_if_needed(operate: "OperateApp") -> None:
         password = ask_confirm_password()
         UserAccount.new(
             password=password,
-            path=operate._path / "user.json",
+            path=operate._path / USER_JSON,
         )
     else:
         _password = None

operate/services/manage.py

@@ -23,7 +23,6 @@ import asyncio
 import json
 import logging
 import os
-import tempfile
 import traceback
 import typing as t
 from collections import Counter, defaultdict
@@ -31,16 +30,24 @@ from concurrent.futures import ThreadPoolExecutor
 from contextlib import suppress
 from http import HTTPStatus
 from pathlib import Path
+from time import time
 
 import requests
 from aea.helpers.base import IPFSHash
-from aea_ledger_ethereum import EthereumCrypto, LedgerApi
+from aea_ledger_ethereum import LedgerApi
 from autonomy.chain.base import registry_contracts
 from autonomy.chain.config import CHAIN_PROFILES, ChainType
 from autonomy.chain.metadata import IPFS_URI_PREFIX
 from web3 import Web3
 
-from operate.constants import IPFS_ADDRESS, ZERO_ADDRESS
+from operate.constants import (
+    AGENT_LOG_DIR,
+    AGENT_LOG_ENV_VAR,
+    AGENT_PERSISTENT_STORAGE_DIR,
+    AGENT_PERSISTENT_STORAGE_ENV_VAR,
+    IPFS_ADDRESS,
+    ZERO_ADDRESS,
+)
 from operate.data import DATA_DIR
 from operate.data.contracts.mech_activity.contract import MechActivityContract
 from operate.data.contracts.requester_activity_checker.contract import (
@@ -48,7 +55,7 @@ from operate.data.contracts.requester_activity_checker.contract import (
 )
 from operate.data.contracts.staking_token.contract import StakingTokenContract
 from operate.keys import KeysManager
-from operate.ledger import PUBLIC_RPCS, get_currency_denom
+from operate.ledger import get_currency_denom, get_default_rpc
 from operate.ledger.profiles import (
     CONTRACTS,
     DEFAULT_MASTER_EOA_FUNDS,
@@ -695,12 +702,15 @@ class ServiceManager:
 
             env_var_to_value.update(
                 {
-                    "ETHEREUM_LEDGER_RPC": PUBLIC_RPCS[Chain.ETHEREUM],
-                    "GNOSIS_LEDGER_RPC": PUBLIC_RPCS[Chain.GNOSIS],
-                    "BASE_LEDGER_RPC": PUBLIC_RPCS[Chain.BASE],
-                    "CELO_LEDGER_RPC": PUBLIC_RPCS[Chain.CELO],
-                    "OPTIMISM_LEDGER_RPC": PUBLIC_RPCS[Chain.OPTIMISM],
-                    "MODE_LEDGER_RPC": PUBLIC_RPCS[Chain.MODE],
+                    "ARBITRUM_ONE_LEDGER_RPC": get_default_rpc(Chain.ARBITRUM_ONE),
+                    "BASE_LEDGER_RPC": get_default_rpc(Chain.BASE),
+                    "CELO_LEDGER_RPC": get_default_rpc(Chain.CELO),
+                    "ETHEREUM_LEDGER_RPC": get_default_rpc(Chain.ETHEREUM),
+                    "GNOSIS_LEDGER_RPC": get_default_rpc(Chain.GNOSIS),
+                    "MODE_LEDGER_RPC": get_default_rpc(Chain.MODE),
+                    "OPTIMISM_LEDGER_RPC": get_default_rpc(Chain.OPTIMISM),
+                    "POLYGON_LEDGER_RPC": get_default_rpc(Chain.POLYGON),
+                    "SOLANA_LEDGER_RPC": get_default_rpc(Chain.SOLANA),
                     f"{chain.upper()}_LEDGER_RPC": ledger_config.rpc,
                     "STAKING_CONTRACT_ADDRESS": target_staking_params.get(
                         "staking_contract"
@@ -730,8 +740,8 @@ class ServiceManager:
 
         # Set environment variables for the service
         for dir_name, env_var_name in (
-            ("persistent_data", "STORE_PATH"),
-            ("benchmarks", "LOG_DIR"),
+            (AGENT_PERSISTENT_STORAGE_DIR, AGENT_PERSISTENT_STORAGE_ENV_VAR),
+            (AGENT_LOG_DIR, AGENT_LOG_ENV_VAR),
         ):
             dir_path = service.path / dir_name
             dir_path.mkdir(parents=True, exist_ok=True)
@@ -1257,6 +1267,12 @@ class ServiceManager:
                 chain=chain,
                 staking_program_id=current_staking_program,
             )
+        else:
+            # at least claim the rewards if we cannot unstake yet
+            self.claim_on_chain_from_safe(
+                service_config_id=service_config_id,
+                chain=chain,
+            )
 
         if self._get_on_chain_state(service=service, chain=chain) in (
             OnChainState.ACTIVE_REGISTRATION,
@@ -1318,18 +1334,17 @@ class ServiceManager:
                 service_config_id=service_config_id, chain=chain
             )
             self.logger.info("Swapping Safe owners")
-            sftxb.swap(  # noqa: E800
-                service_id=chain_data.token,  # noqa: E800
+            owner_crypto = self.keys_manager.get_crypto_instance(
+                address=current_safe_owners[0]
+            )
+            sftxb.swap(
+                service_id=chain_data.token,
                 multisig=chain_data.multisig,  # TODO this can be read from the registry
-                owner_key=str(
-                    self.keys_manager.get(
-                        key=current_safe_owners[0]
-                    ).private_key  # TODO allow multiple owners
-                ),  # noqa: E800
+                owner_cryptos=[owner_crypto],  # TODO allow multiple owners
                 new_owner_address=(
                     safe if safe else wallet.crypto.address
                 ),  # TODO it should always be safe address
-            )  # noqa: E800
+            )
 
         if withdrawal_address is not None:
             ethereum_crypto = KeysManager().get_crypto_instance(
@@ -1457,26 +1472,18 @@ class ServiceManager:
         if agent_is_service_safe_owner:
             self.logger.info("(Agent) Enabling recovery module in service Safe.")
             try:
-                with tempfile.NamedTemporaryFile(mode="w+", delete=True) as tmp_file:
-                    private_key = self.keys_manager.get(key=agent_address).private_key
-                    tmp_file.write(private_key)
-                    tmp_file.flush()
-                    crypto = EthereumCrypto(private_key_path=tmp_file.name)
-                    EthSafeTxBuilder._new_tx(  # pylint: disable=protected-access
-                        ledger_api=sftxb.ledger_api,
-                        crypto=crypto,
-                        chain_type=ChainType(chain),
-                        safe=service_safe_address,
-                    ).add(
-                        sftxb.get_enable_module_data(
-                            module_address=recovery_module_address,
-                            safe_address=service_safe_address,
-                        )
-                    ).settle()
-                    tmp_file.seek(0)
-                    tmp_file.write("\0" * len(private_key))
-                    tmp_file.flush()
-
+                crypto = self.keys_manager.get_crypto_instance(address=agent_address)
+                EthSafeTxBuilder._new_tx(  # pylint: disable=protected-access
+                    ledger_api=sftxb.ledger_api,
+                    crypto=crypto,
+                    chain_type=ChainType(chain),
+                    safe=service_safe_address,
+                ).add(
+                    sftxb.get_enable_module_data(
+                        module_address=recovery_module_address,
+                        safe_address=service_safe_address,
+                    )
+                ).settle()
                 self.logger.info(
                     "(Agent) Recovery module enabled successfully in service Safe."
                 )
@@ -1834,7 +1841,12 @@ class ServiceManager:
         staking_program_id: t.Optional[str] = None,
         force: bool = False,
     ) -> None:
-        """Unbond service on-chain"""
+        """Unstake service on-chain"""
+        # Claim the rewards first so that they are moved to the Master Safe
+        self.claim_on_chain_from_safe(
+            service_config_id=service_config_id,
+            chain=chain,
+        )
 
         self.logger.info("unstake_service_on_chain_from_safe")
         service = self.load(service_config_id=service_config_id)
@@ -1877,38 +1889,42 @@ class ServiceManager:
         self,
         service_config_id: str,
         chain: str,
-    ) -> str:
-        """Claim rewards from Safe and returns transaction hash"""
+    ) -> int:
+        """Claim rewards from staking and returns the claimed amount"""
         self.logger.info("claim_on_chain_from_safe")
         service = self.load(service_config_id=service_config_id)
         chain_config = service.chain_configs[chain]
         ledger_config = chain_config.ledger_config
-        chain_data = chain_config.chain_data
-        staking_program_id = chain_data.user_params.staking_program_id
+        staking_program_id = chain_config.chain_data.user_params.staking_program_id
         wallet = self.wallet_manager.load(ledger_config.chain.ledger_type)
         ledger_api = wallet.ledger_api(chain=ledger_config.chain, rpc=ledger_config.rpc)
-        print(
-            f"OLAS Balance on service Safe {chain_data.multisig}: "
-            f"{get_asset_balance(ledger_api, OLAS[Chain(chain)], chain_data.multisig)}"
+        self.logger.info(
+            f"OLAS Balance on service Safe {chain_config.chain_data.multisig}: "
+            f"{get_asset_balance(ledger_api, OLAS[Chain(chain)], chain_config.chain_data.multisig)}"
         )
-        if (
-            get_staking_contract(
-                chain=ledger_config.chain,
-                staking_program_id=staking_program_id,
-            )
-            is None
-        ):
+        staking_contract = get_staking_contract(
+            chain=ledger_config.chain,
+            staking_program_id=staking_program_id,
+        )
+        if staking_contract is None:
             raise RuntimeError(
                 "No staking contract found for the current staking_program_id: "
                 f"{staking_program_id}. Not claiming the rewards."
             )
 
         sftxb = self.get_eth_safe_tx_builder(ledger_config=ledger_config)
+        if not sftxb.staking_rewards_claimable(
+            service_id=chain_config.chain_data.token,
+            staking_contract=staking_contract,
+        ):
+            self.logger.info("No staking rewards claimable")
+            return 0
+
         receipt = (
             sftxb.new_tx()
             .add(
                 sftxb.get_claiming_data(
-                    service_id=chain_data.token,
+                    service_id=chain_config.chain_data.token,
                     staking_contract=get_staking_contract(
                         chain=ledger_config.chain,
                         staking_program_id=staking_program_id,
@@ -1917,7 +1933,21 @@ class ServiceManager:
             )
             .settle()
         )
-        return receipt["transactionHash"]
+
+        # transfer claimed amount from agents safe to master safe
+        # TODO: remove after staking contract directly starts sending the rewards to master safe
+        amount_claimed = receipt["logs"][0]["data"]
+        self.logger.info(f"Claimed amount: {amount_claimed}")
+        ethereum_crypto = KeysManager().get_crypto_instance(service.agent_addresses[0])
+        transfer_erc20_from_safe(
+            ledger_api=ledger_api,
+            crypto=ethereum_crypto,
+            safe=chain_config.chain_data.multisig,
+            token=receipt["logs"][0]["address"],
+            to=wallet.safes[Chain(chain)],
+            amount=amount_claimed,
+        )
+        return amount_claimed
 
     def fund_service(  # pylint: disable=too-many-arguments,too-many-locals
         self,
@@ -2254,6 +2284,7 @@ class ServiceManager:
         task = asyncio.current_task()
         task_id = id(task) if task else "Unknown task_id"
         with ThreadPoolExecutor() as executor:
+            last_claim = 0
             while True:
                 try:
                     await loop.run_in_executor(
@@ -2285,6 +2316,22 @@ class ServiceManager:
                     logging.info(
                         f"Error occured while funding the service\n{traceback.format_exc()}"
                     )
+
+                # try claiming rewards every hour
+                if last_claim + 3600 < time():
+                    try:
+                        await loop.run_in_executor(
+                            executor,
+                            self.claim_on_chain_from_safe,
+                            service_config_id=service_config_id,
+                            chain=service.home_chain,
+                        )
+                    except Exception:  # pylint: disable=broad-except
+                        logging.info(
+                            f"Error occured while claiming rewards\n{traceback.format_exc()}"
+                        )
+                    last_claim = time()
+
                 await asyncio.sleep(60)
 
     def deploy_service_locally(
@@ -2341,12 +2388,6 @@ class ServiceManager:
             deployment.delete()
         return deployment
 
-    def log_directories(self) -> None:
-        """Log directories."""
-        directories = [f"  - {str(p)}" for p in self.path.iterdir() if p.is_dir()]
-        directories_str = "\n".join(directories)
-        self.logger.info(f"Directories in {self.path}\n: {directories_str}")
-
     def update(
         self,
         service_config_id: str,

operate/services/protocol.py

@@ -34,7 +34,6 @@ from typing import Optional, Union, cast
 from aea.configurations.data_types import PackageType
 from aea.crypto.base import Crypto, LedgerApi
 from aea.helpers.base import IPFSHash, cd
-from aea_ledger_ethereum.ethereum import EthereumCrypto
 from autonomy.chain.base import registry_contracts
 from autonomy.chain.config import ChainConfigs, ChainType, ContractConfigs
 from autonomy.chain.constants import (
@@ -722,7 +721,11 @@ class _ChainUtil:
         ).get("owners", [])
 
     def swap(  # pylint: disable=too-many-arguments,too-many-locals
-        self, service_id: int, multisig: str, owner_key: str, new_owner_address: str
+        self,
+        service_id: int,
+        multisig: str,
+        owner_cryptos: t.List[Crypto],
+        new_owner_address: str,
     ) -> None:
         """Swap safe owner."""
         logging.info(f"Swapping safe for service {service_id} [{multisig}]...")
@@ -736,11 +739,6 @@ class _ChainUtil:
             retries=ON_CHAIN_INTERACT_RETRIES,
             sleep=ON_CHAIN_INTERACT_SLEEP,
         )
-        with tempfile.TemporaryDirectory() as temp_dir:
-            key_file = Path(temp_dir, "key.txt")
-            key_file.write_text(owner_key, encoding="utf-8")
-            owner_crypto = EthereumCrypto(private_key_path=str(key_file))
-        owner_cryptos: t.List[EthereumCrypto] = [owner_crypto]
         owners = [
             manager.ledger_api.api.to_checksum_address(owner_crypto.address)
             for owner_crypto in owner_cryptos
@@ -797,7 +795,7 @@ class _ChainUtil:
         tx = registry_contracts.gnosis_safe.get_raw_safe_transaction(
             ledger_api=manager.ledger_api,
             contract_address=multisig,
-            sender_address=owner_crypto.address,
+            sender_address=owner_cryptos[0].address,
             owners=tuple(owners),  # type: ignore
             to_address=tx_params["to_address"],
             value=tx_params["ether_value"],
@@ -806,7 +804,7 @@ class _ChainUtil:
             signatures_by_owner=owner_to_signature,
             operation=SafeOperation.DELEGATE_CALL.value,
         )
-        stx = owner_crypto.sign_transaction(tx)
+        stx = owner_cryptos[0].sign_transaction(tx)
         tx_digest = manager.ledger_api.send_signed_transaction(stx)
         receipt = manager.ledger_api.api.eth.wait_for_transaction_receipt(tx_digest)
         if receipt["status"] != 1: