olas-operate-middleware 0.10.8__tar.gz → 0.10.10__tar.gz

{olas_operate_middleware-0.10.8 → olas_operate_middleware-0.10.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: olas-operate-middleware
-Version: 0.10.8
+Version: 0.10.10
 Summary: 
 Author: David Vilela
 Author-email: dvilelaf@gmail.com

{olas_operate_middleware-0.10.8 → olas_operate_middleware-0.10.10}/operate/cli.py

@@ -209,7 +209,7 @@ class OperateApp:
         manager = WalletRecoveryManager(
             path=self._path / WALLET_RECOVERY_DIR,
             wallet_manager=self.wallet_manager,
-            logger=self.logger,
+            logger=logger,
         )
         return manager
 

{olas_operate_middleware-0.10.8 → olas_operate_middleware-0.10.10}/operate/keys.py

@@ -85,6 +85,7 @@ class KeysManager(metaclass=SingletonMeta):
                 )
             )
         )
+        private_key = key.private_key
         # Create temporary file with delete=False to handle it manually
         with tempfile.NamedTemporaryFile(
             dir=self.path,
@@ -93,7 +94,7 @@ class KeysManager(metaclass=SingletonMeta):
             delete=False,  # Handle cleanup manually
         ) as temp_file:
             temp_file_name = temp_file.name
-            temp_file.write(key.private_key)
+            temp_file.write(private_key)
             temp_file.flush()
             temp_file.close()  # Close the file before reading
 
@@ -104,7 +105,7 @@ class KeysManager(metaclass=SingletonMeta):
             try:
                 with open(temp_file_name, "r+", encoding="utf-8") as f:
                     f.seek(0)
-                    f.write("\0" * len(key.private_key))
+                    f.write("\0" * len(private_key))
                     f.flush()
                     f.close()
                 os.unlink(temp_file_name)  # Clean up the temporary file

{olas_operate_middleware-0.10.8 → olas_operate_middleware-0.10.10}/operate/ledger/__init__.py

@@ -24,17 +24,17 @@ import os
 from operate.operate_types import Chain
 
 
-ARBITRUM_ONE_PUBLIC_RPC = os.environ.get(
-    "ARBITRUM_ONE_RPC", "https://arb1.arbitrum.io/rpc"
-)
-BASE_PUBLIC_RPC = os.environ.get("BASE_RPC", "https://mainnet.base.org")
-CELO_PUBLIC_RPC = os.environ.get("CELO_RPC", "https://forno.celo.org")
-ETHEREUM_PUBLIC_RPC = os.environ.get("ETHEREUM_RPC", "https://ethereum.publicnode.com")
-GNOSIS_PUBLIC_RPC = os.environ.get("GNOSIS_RPC", "https://gnosis-rpc.publicnode.com")
-MODE_PUBLIC_RPC = os.environ.get("MODE_RPC", "https://mainnet.mode.network/")
-OPTIMISM_PUBLIC_RPC = os.environ.get("OPTIMISM_RPC", "https://mainnet.optimism.io")
-POLYGON_PUBLIC_RPC = os.environ.get("POLYGON_RPC", "https://polygon-rpc.com")
-SOLANA_PUBLIC_RPC = os.environ.get("SOLANA_RPC", "https://api.mainnet-beta.solana.com")
+CHAINS = [
+    Chain.ARBITRUM_ONE,
+    Chain.BASE,
+    Chain.CELO,
+    Chain.ETHEREUM,
+    Chain.GNOSIS,
+    Chain.MODE,
+    Chain.OPTIMISM,
+    Chain.POLYGON,
+    Chain.SOLANA,
+]
 
 ARBITRUM_ONE_RPC = os.environ.get("ARBITRUM_ONE_RPC", "https://arb1.arbitrum.io/rpc")
 BASE_RPC = os.environ.get("BASE_RPC", "https://mainnet.base.org")
@@ -46,17 +46,6 @@ OPTIMISM_RPC = os.environ.get("OPTIMISM_RPC", "https://mainnet.optimism.io")
 POLYGON_RPC = os.environ.get("POLYGON_RPC", "https://polygon-rpc.com")
 SOLANA_RPC = os.environ.get("SOLANA_RPC", "https://api.mainnet-beta.solana.com")
 
-PUBLIC_RPCS = {
-    Chain.ARBITRUM_ONE: ARBITRUM_ONE_PUBLIC_RPC,
-    Chain.BASE: BASE_PUBLIC_RPC,
-    Chain.CELO: CELO_PUBLIC_RPC,
-    Chain.ETHEREUM: ETHEREUM_PUBLIC_RPC,
-    Chain.GNOSIS: GNOSIS_PUBLIC_RPC,
-    Chain.MODE: MODE_PUBLIC_RPC,
-    Chain.OPTIMISM: OPTIMISM_PUBLIC_RPC,
-    Chain.POLYGON: POLYGON_PUBLIC_RPC,
-    Chain.SOLANA: SOLANA_PUBLIC_RPC,
-}
 
 DEFAULT_RPCS = {
     Chain.ARBITRUM_ONE: ARBITRUM_ONE_RPC,

{olas_operate_middleware-0.10.8 → olas_operate_middleware-0.10.10}/operate/ledger/profiles.py

@@ -24,40 +24,33 @@ import typing as t
 from autonomy.chain.constants import CHAIN_PROFILES, DEFAULT_MULTISEND
 
 from operate.constants import NO_STAKING_PROGRAM_ID, ZERO_ADDRESS
+from operate.ledger import CHAINS
 from operate.operate_types import Chain, ContractAddresses
 
 
 # TODO: Refactor, remove the usage of CONTRACTS and use CHAIN_PROFILES from Open Autonomy instead.
-CHAINS = [
-    Chain.ARBITRUM_ONE,
-    Chain.BASE,
-    Chain.CELO,
-    Chain.ETHEREUM,
-    Chain.GNOSIS,
-    Chain.MODE,
-    Chain.OPTIMISM,
-    Chain.POLYGON,
-]
-
 CONTRACTS: t.Dict[Chain, ContractAddresses] = {}
 for _chain in CHAINS:
-    profile = CHAIN_PROFILES[_chain.value]
-    CONTRACTS[_chain] = ContractAddresses(
-        {
-            "service_registry": profile["service_registry"],
-            "service_registry_token_utility": profile["service_registry_token_utility"],
-            "service_manager": profile["service_manager_token"],
-            "gnosis_safe_proxy_factory": profile["gnosis_safe_proxy_factory"],
-            "gnosis_safe_same_address_multisig": profile[
-                "gnosis_safe_same_address_multisig"
-            ],
-            "safe_multisig_with_recovery_module": profile[
-                "safe_multisig_with_recovery_module"
-            ],
-            "recovery_module": profile["recovery_module"],
-            "multisend": DEFAULT_MULTISEND,
-        }
-    )
+    if _chain.value in CHAIN_PROFILES:
+        profile = CHAIN_PROFILES[_chain.value]
+        CONTRACTS[_chain] = ContractAddresses(
+            {
+                "service_registry": profile["service_registry"],
+                "service_registry_token_utility": profile[
+                    "service_registry_token_utility"
+                ],
+                "service_manager": profile["service_manager_token"],
+                "gnosis_safe_proxy_factory": profile["gnosis_safe_proxy_factory"],
+                "gnosis_safe_same_address_multisig": profile[
+                    "gnosis_safe_same_address_multisig"
+                ],
+                "safe_multisig_with_recovery_module": profile[
+                    "safe_multisig_with_recovery_module"
+                ],
+                "recovery_module": profile["recovery_module"],
+                "multisend": DEFAULT_MULTISEND,
+            }
+        )
 
 STAKING: t.Dict[Chain, t.Dict[str, str]] = {
     Chain.ARBITRUM_ONE: {},

{olas_operate_middleware-0.10.8 → olas_operate_middleware-0.10.10}/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}")

{olas_operate_middleware-0.10.8 → olas_operate_middleware-0.10.10}/operate/services/manage.py

@@ -30,6 +30,7 @@ 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
@@ -54,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,
@@ -701,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"
@@ -1263,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,
@@ -1831,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)
@@ -1874,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,
@@ -1914,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 = int(receipt["logs"][0]["data"].hex(), 16)
+        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,
@@ -2251,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(
@@ -2282,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(

{olas_operate_middleware-0.10.8 → olas_operate_middleware-0.10.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "olas-operate-middleware"
-version = "0.10.8"
+version = "0.10.10"
 description = ""
 authors = ["David Vilela <dvilelaf@gmail.com>", "Viraj Patel <vptl185@gmail.com>"]
 readme = "README.md"