olas-operate-middleware 0.10.19__py3-none-any.whl → 0.11.0__py3-none-any.whl

operate/services/manage.py

@@ -19,18 +19,15 @@
 # ------------------------------------------------------------------------------
 """Service manager."""
 
-import asyncio
 import json
 import logging
 import os
 import traceback
 import typing as t
 from collections import Counter, defaultdict
-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
@@ -38,14 +35,16 @@ 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 (
     AGENT_LOG_DIR,
     AGENT_LOG_ENV_VAR,
     AGENT_PERSISTENT_STORAGE_DIR,
     AGENT_PERSISTENT_STORAGE_ENV_VAR,
+    DEFAULT_TOPUP_THRESHOLD,
     IPFS_ADDRESS,
+    MIN_AGENT_BOND,
+    MIN_SECURITY_DEPOSIT,
     ZERO_ADDRESS,
 )
 from operate.data import DATA_DIR
@@ -53,21 +52,20 @@ from operate.data.contracts.mech_activity.contract import MechActivityContract
 from operate.data.contracts.requester_activity_checker.contract import (
     RequesterActivityCheckerContract,
 )
-from operate.data.contracts.staking_token.contract import StakingTokenContract
 from operate.keys import KeysManager
-from operate.ledger import get_currency_denom, get_default_rpc
+from operate.ledger import get_default_rpc
 from operate.ledger.profiles import (
     CONTRACTS,
-    DEFAULT_MASTER_EOA_FUNDS,
+    DEFAULT_EOA_THRESHOLD,
+    DEFAULT_EOA_TOPUPS,
     DEFAULT_PRIORITY_MECH,
     OLAS,
-    STAKING,
-    USDC,
     WRAPPED_NATIVE_ASSET,
     get_staking_contract,
 )
 from operate.operate_types import (
     Chain,
+    ChainAmounts,
     FundingValues,
     LedgerConfig,
     MechMarketplaceConfig,
@@ -75,7 +73,13 @@ from operate.operate_types import (
     ServiceEnvProvisionType,
     ServiceTemplate,
 )
-from operate.services.protocol import EthSafeTxBuilder, OnChainManager, StakingState
+from operate.services.funding_manager import FundingManager
+from operate.services.protocol import (
+    EthSafeTxBuilder,
+    OnChainManager,
+    StakingManager,
+    StakingState,
+)
 from operate.services.service import (
     ChainConfig,
     Deployment,
@@ -87,14 +91,16 @@ from operate.services.service import (
     Service,
 )
 from operate.services.utils.mech import deploy_mech
-from operate.utils.gnosis import drain_eoa, get_asset_balance, get_assets_balances
-from operate.utils.gnosis import transfer as transfer_from_safe
-from operate.utils.gnosis import transfer_erc20_from_safe
-from operate.wallet.master import MasterWalletManager
+from operate.utils.gnosis import (
+    get_asset_balance,
+    get_assets_balances,
+    transfer_erc20_from_safe,
+)
+from operate.wallet.master import InsufficientFundsException, MasterWalletManager
 
 
 # pylint: disable=redefined-builtin
-DEFAULT_TOPUP_THRESHOLD = 0.5
+
 # At the moment, we only support running one agent per service locally on a machine.
 # If multiple agents are provided in the service.yaml file, only the 0th index config will be used.
 NUM_LOCAL_AGENT_INSTANCES = 1
@@ -107,6 +113,7 @@ class ServiceManager:
         self,
         path: Path,
         wallet_manager: MasterWalletManager,
+        funding_manager: FundingManager,
         logger: logging.Logger,
         skip_dependency_check: t.Optional[bool] = False,
     ) -> None:
@@ -121,6 +128,7 @@ class ServiceManager:
         self.path = path
         self.keys_manager = KeysManager()
         self.wallet_manager = wallet_manager
+        self.funding_manager = funding_manager
         self.logger = logger
         self.skip_depencency_check = skip_dependency_check
 
@@ -415,18 +423,26 @@ class ServiceManager:
             and (
                 on_chain_hash != service.hash
                 or current_agent_id != staking_params["agent_ids"][0]
-                or current_agent_bond != staking_params["min_staking_deposit"]
+                or (
+                    user_params.use_staking
+                    and current_agent_bond != staking_params["min_staking_deposit"]
+                )
+                # TODO Missing complete this check for non-staked services it should compare the current_agent_bond from the protocol, now it's only read for the staking contract.
                 or on_chain_description != service.description
             )
         )
         current_staking_program = self._get_current_staking_program(service, chain)
 
+        self.logger.info(f"{chain_data.token=}")
+        self.logger.info(f"{user_params.use_staking=}")
         self.logger.info(f"{current_staking_program=}")
         self.logger.info(f"{user_params.staking_program_id=}")
         self.logger.info(f"{on_chain_hash=}")
         self.logger.info(f"{service.hash=}")
         self.logger.info(f"{current_agent_id=}")
-        self.logger.info(f"{staking_params['agent_ids'][0]=}")
+        self.logger.info(f"{staking_params['agent_ids']=}")
+        self.logger.info(f"{current_agent_bond=}")
+        self.logger.info(f"{staking_params['min_staking_deposit']=}")
         self.logger.info(f"{is_first_mint=}")
         self.logger.info(f"{is_update=}")
 
@@ -595,7 +611,7 @@ class ServiceManager:
                 ]
 
             except Exception as e:  # pylint: disable=broad-except
-                self.logger.error(f"{e}: {traceback.format_exc()}")
+                self.logger.debug(f"{e}: {traceback.format_exc()}")
                 self.logger.warning(
                     "Cannot determine type of activity checker contract. Using default parameters. "
                     "NOTE: This will be an exception in the future!"
@@ -815,7 +831,12 @@ class ServiceManager:
                 # on_chain_hash != service.hash or  # noqa
                 current_agent_id != target_staking_params["agent_ids"][0]
                 # TODO This has to be removed for Optimus (needs to be properly implemented). Needs to be put back for Trader!
-                or current_agent_bond != target_staking_params["min_staking_deposit"]
+                or (
+                    user_params.use_staking
+                    and current_agent_bond
+                    != target_staking_params["min_staking_deposit"]
+                )
+                # TODO Missing complete this check for non-staked services it should compare the current_agent_bond from the protocol, now it's only read for the staking contract.
                 or current_staking_params["staking_token"]
                 != target_staking_params["staking_token"]
                 or on_chain_description != service.description
@@ -823,12 +844,13 @@ class ServiceManager:
         )
 
         self.logger.info(f"{chain_data.token=}")
+        self.logger.info(f"{user_params.use_staking=}")
         self.logger.info(f"{current_staking_program=}")
         self.logger.info(f"{user_params.staking_program_id=}")
         self.logger.info(f"{on_chain_hash=}")
         self.logger.info(f"{service.hash=}")
         self.logger.info(f"{current_agent_id=}")
-        self.logger.info(f"{target_staking_params['agent_ids'][0]=}")
+        self.logger.info(f"{target_staking_params['agent_ids']=}")
         self.logger.info(f"{current_agent_bond=}")
         self.logger.info(f"{target_staking_params['min_staking_deposit']=}")
         self.logger.info(f"{is_first_mint=}")
@@ -941,7 +963,6 @@ class ServiceManager:
             self._get_on_chain_state(service=service, chain=chain)
             == OnChainState.PRE_REGISTRATION
         ):
-            # TODO Verify that this is incorrect: cost_of_bond = staking_params["min_staking_deposit"]
             cost_of_bond = user_params.cost_of_bond
             if user_params.use_staking:
                 token_utility = target_staking_params["service_registry_token_utility"]
@@ -978,7 +999,7 @@ class ServiceManager:
                 self.logger.info(
                     f"Approved {token_utility_allowance} OLAS from {safe} to {token_utility}"
                 )
-                cost_of_bond = 1
+                cost_of_bond = MIN_AGENT_BOND
 
             self.logger.info("Activating service")
 
@@ -988,7 +1009,9 @@ class ServiceManager:
                 address=safe,
             )
 
-            if native_balance < cost_of_bond:
+            if (
+                native_balance < cost_of_bond
+            ):  # TODO check that this is the security deposit
                 message = f"Cannot activate service: address {safe} {native_balance=} < {cost_of_bond=}."
                 self.logger.error(message)
                 raise ValueError(message)
@@ -1040,7 +1063,7 @@ class ServiceManager:
                 self.logger.info(
                     f"Approved {token_utility_allowance} OLAS from {safe} to {token_utility}"
                 )
-                cost_of_bond = 1 * len(service.agent_addresses)
+                cost_of_bond = MIN_AGENT_BOND
 
             self.logger.info(
                 f"Registering agent instances: {chain_data.token} -> {service.agent_addresses}"
@@ -1052,7 +1075,7 @@ class ServiceManager:
                 address=safe,
             )
 
-            if native_balance < cost_of_bond:
+            if native_balance < cost_of_bond * len(service.agent_addresses):
                 message = f"Cannot register agent instances: address {safe} {native_balance=} < {cost_of_bond=}."
                 self.logger.error(message)
                 raise ValueError(message)
@@ -1067,27 +1090,21 @@ class ServiceManager:
             ).settle()
 
         # Deploy service
+        is_initial_funding = False
         if (
             self._get_on_chain_state(service=service, chain=chain)
             == OnChainState.FINISHED_REGISTRATION
         ):
             self.logger.info("Deploying service")
 
-            reuse_multisig = True
             info = sftxb.info(token_id=chain_data.token)
             service_safe_address = info["multisig"]
             if service_safe_address == ZERO_ADDRESS:
                 reuse_multisig = False
-
-            self.logger.info(f"{reuse_multisig=}")
-
-            is_recovery_module_enabled = (
-                True  # Ensure is true for non-deployed multisigs
-            )
-            if (
-                service_safe_address is not None
-                and service_safe_address != ZERO_ADDRESS
-            ):
+                is_initial_funding = True
+                is_recovery_module_enabled = True
+            else:
+                reuse_multisig = True
                 is_recovery_module_enabled = (
                     registry_contracts.gnosis_safe.is_module_enabled(
                         ledger_api=sftxb.ledger_api,
@@ -1096,6 +1113,7 @@ class ServiceManager:
                     ).get("enabled")
                 )
 
+            self.logger.info(f"{reuse_multisig=}")
             self.logger.info(f"{is_recovery_module_enabled=}")
 
             messages = sftxb.get_deploy_data_from_safe(
@@ -1114,6 +1132,9 @@ class ServiceManager:
         chain_data.instances = info["instances"]
         chain_data.multisig = info["multisig"]
 
+        if is_initial_funding:
+            self.funding_manager.fund_service_initial(service)
+
         # TODO: yet another agent specific logic for mech, which should be abstracted
         if all(
             var in service.env_variables
@@ -1225,7 +1246,6 @@ class ServiceManager:
         self,
         service_config_id: str,
         chain: str,
-        withdrawal_address: t.Optional[str] = None,
     ) -> None:
         """Terminate service on-chain"""
 
@@ -1235,10 +1255,7 @@ class ServiceManager:
         ledger_config = chain_config.ledger_config
         chain_data = chain_config.chain_data
         wallet = self.wallet_manager.load(ledger_config.chain.ledger_type)
-        safe = wallet.safes[Chain(chain)]  # type: ignore
-
-        if withdrawal_address:
-            withdrawal_address = Web3.to_checksum_address(withdrawal_address)
+        master_safe = wallet.safes[Chain(chain)]  # type: ignore
 
         # TODO fixme
         os.environ["CUSTOM_CHAIN_RPC"] = ledger_config.rpc
@@ -1263,23 +1280,23 @@ class ServiceManager:
             )
 
         # Cannot unstake, terminate flow.
-        if is_staked and not can_unstake and withdrawal_address is None:
+        if is_staked and not can_unstake:
             self.logger.info("Service cannot be terminated on-chain: cannot unstake.")
             return
-
         # Unstake the service if applies
-        if is_staked and (can_unstake or withdrawal_address is not None):
+        if is_staked and can_unstake:
             self.unstake_service_on_chain_from_safe(
                 service_config_id=service_config_id,
                 chain=chain,
                 staking_program_id=current_staking_program,
             )
+        # At least claim the rewards if we cannot unstake yet
         elif is_staked:
-            # at least claim the rewards if we cannot unstake yet
             self.claim_on_chain_from_safe(
                 service_config_id=service_config_id,
                 chain=chain,
             )
+            return
 
         if self._get_on_chain_state(service=service, chain=chain) in (
             OnChainState.ACTIVE_REGISTRATION,
@@ -1309,38 +1326,58 @@ class ServiceManager:
         counter_current_safe_owners = Counter(s.lower() for s in current_safe_owners)
         counter_instances = Counter(s.lower() for s in service.agent_addresses)
 
-        if withdrawal_address is not None:
-            # we don't drain signer yet, because the owner swapping tx may need to happen
-            self.drain_service_safe(
-                service_config_id=service_config_id,
-                withdrawal_address=withdrawal_address,
-                chain=Chain(chain),
-            )
-
         if counter_current_safe_owners == counter_instances:
-            if withdrawal_address is None:
-                self.logger.info("Service funded for safe swap")
-                self.fund_service(
-                    service_config_id=service_config_id,
-                    funding_values={
-                        ZERO_ADDRESS: {
-                            "agent": {
-                                "topup": chain_data.user_params.fund_requirements[
-                                    ZERO_ADDRESS
-                                ].agent,
-                                "threshold": chain_data.user_params.fund_requirements[
-                                    ZERO_ADDRESS
-                                ].agent,
-                            },
-                            "safe": {"topup": 0, "threshold": 0},
+            requirements = ChainAmounts(
+                {
+                    chain: {
+                        current_safe_owners[0]: {
+                            ZERO_ADDRESS: chain_data.user_params.fund_requirements[
+                                ZERO_ADDRESS
+                            ].agent
                         }
-                    },
+                    }
+                }
+            )
+            balances = ChainAmounts(
+                {
+                    chain: {
+                        current_safe_owners[0]: {
+                            ZERO_ADDRESS: get_asset_balance(
+                                ledger_api=sftxb.ledger_api,
+                                asset_address=ZERO_ADDRESS,
+                                address=service.agent_addresses[0],
+                            )
+                        }
+                    }
+                }
+            )
+            if balances < requirements * DEFAULT_EOA_THRESHOLD:
+                self.logger.info("[SERVICE MANAGER] Funding agent EOA for Safe swap.")
+                shortfalls = ChainAmounts.shortfalls(
+                    requirements=requirements, balances=balances
                 )
+                try:
+                    self.funding_manager.fund_chain_amounts(shortfalls)
+                except InsufficientFundsException as e:
+                    recovery_module_address = CONTRACTS[Chain(chain)]["recovery_module"]
+                    is_recovery_module_enabled = (
+                        registry_contracts.gnosis_safe.is_module_enabled(
+                            ledger_api=sftxb.ledger_api,
+                            contract_address=chain_data.multisig,
+                            module_address=recovery_module_address,
+                        ).get("enabled")
+                    )
+                    if is_recovery_module_enabled:
+                        self.logger.info(
+                            "[SERVICE MANAGER] Could not fund Agent EOA for service swap, but recovery module is enabled."
+                        )
+                        return
+                    raise e
 
             self._enable_recovery_module(
                 service_config_id=service_config_id, chain=chain
             )
-            self.logger.info("Swapping Safe owners")
+            self.logger.info("[SERVICE MANAGER] Swapping Safe owners")
             owner_crypto = self.keys_manager.get_crypto_instance(
                 address=current_safe_owners[0]
             )
@@ -1349,25 +1386,10 @@ class ServiceManager:
                 multisig=chain_data.multisig,  # TODO this can be read from the registry
                 owner_cryptos=[owner_crypto],  # TODO allow multiple owners
                 new_owner_address=(
-                    safe if safe else wallet.crypto.address
+                    master_safe if master_safe else wallet.crypto.address
                 ),  # TODO it should always be safe address
             )
 
-        if withdrawal_address is not None:
-            ethereum_crypto = KeysManager().get_crypto_instance(
-                service.agent_addresses[0]
-            )
-            # drain all native tokens from service signer key
-            drain_eoa(
-                ledger_api=self.wallet_manager.load(
-                    ledger_config.chain.ledger_type
-                ).ledger_api(chain=ledger_config.chain, rpc=ledger_config.rpc),
-                crypto=ethereum_crypto,
-                withdrawal_address=withdrawal_address,
-                chain_id=ledger_config.chain.id,
-            )
-            self.logger.info(f"{service.name} signer drained")
-
     def _execute_recovery_module_flow_from_safe(  # pylint: disable=too-many-locals
         self,
         service_config_id: str,
@@ -1510,82 +1532,14 @@ class ServiceManager:
                 f"Cannot enable recovery module. Safe {service_safe_address} has inconsistent owners."
             )
 
-    def _get_current_staking_program(
+    def _get_current_staking_program(  # pylint: disable=no-self-use
         self, service: Service, chain: str
     ) -> t.Optional[str]:
-        chain_config = service.chain_configs[chain]
-        ledger_config = chain_config.ledger_config
-        sftxb = self.get_eth_safe_tx_builder(ledger_config=ledger_config)
-        service_id = chain_config.chain_data.token
-        ledger_api = sftxb.ledger_api
-
-        if service_id == NON_EXISTENT_TOKEN:
-            return None
-
-        service_registry = registry_contracts.service_registry.get_instance(
-            ledger_api=ledger_api,
-            contract_address=CONTRACTS[ledger_config.chain]["service_registry"],
+        staking_manager = StakingManager(Chain(chain))
+        return staking_manager.get_current_staking_program(
+            service_id=service.chain_configs[chain].chain_data.token
         )
 
-        service_owner = service_registry.functions.ownerOf(service_id).call()
-
-        # TODO Implement in Staking Manager. Implemented here for performance issues.
-        staking_ctr = t.cast(
-            StakingTokenContract,
-            StakingTokenContract.from_dir(
-                directory=str(DATA_DIR / "contracts" / "staking_token")
-            ),
-        )
-
-        try:
-            state = StakingState(
-                staking_ctr.get_instance(
-                    ledger_api=ledger_api,
-                    contract_address=service_owner,
-                )
-                .functions.getStakingState(service_id)
-                .call()
-            )
-        except Exception:  # pylint: disable=broad-except
-            # Service owner is not a staking contract
-
-            # TODO The exception caught here should be ContractLogicError.
-            # This exception is typically raised when the contract reverts with
-            # a reason string. However, in some cases, the error message
-            # does not contain a reason string, which means web3.py raises
-            # a generic ValueError instead. It should be properly analyzed
-            # what exceptions might be raised by web3.py in this case. To
-            # avoid any issues we are simply catching all exceptions.
-            return None
-
-        if state == StakingState.UNSTAKED:
-            return None
-
-        for staking_program_id, val in STAKING[ledger_config.chain].items():
-            if val == service_owner:
-                return staking_program_id
-
-        # Fallback, if not possible to determine staking_program_id it means it's an "inner" staking contract
-        # (e.g., in the case of DualStakingToken). Loop trough all the known contracts.
-        for staking_program_id, staking_program_address in STAKING[
-            ledger_config.chain
-        ].items():
-            state = StakingState(
-                staking_ctr.get_instance(
-                    ledger_api=ledger_api,
-                    contract_address=staking_program_address,
-                )
-                .functions.getStakingState(service_id)
-                .call()
-            )
-
-            if state in (StakingState.STAKED, StakingState.EVICTED):
-                return staking_program_id
-
-        # it's staked, but we don't know which staking program
-        # so the staking_program_id should be an arbitrary staking contract
-        return service_owner
-
     def unbond_service_on_chain(
         self, service_config_id: str, chain: t.Optional[str] = None
     ) -> None:
@@ -1892,6 +1846,16 @@ class ServiceManager:
             )
         ).settle()
 
+    def claim_all_on_chain_from_safe(self) -> None:
+        """Claim rewards from all services and chains"""
+        self.logger.info("claim_all_on_chain_from_safe")
+        services, _ = self.get_all_services()
+        for service in services:
+            self.claim_on_chain_from_safe(
+                service_config_id=service.service_config_id,
+                chain=service.home_chain,
+            )
+
     def claim_on_chain_from_safe(
         self,
         service_config_id: str,
@@ -1904,6 +1868,14 @@ class ServiceManager:
         ledger_config = chain_config.ledger_config
         wallet = self.wallet_manager.load(ledger_config.chain.ledger_type)
         ledger_api = wallet.ledger_api(chain=ledger_config.chain, rpc=ledger_config.rpc)
+
+        if (
+            chain_config.chain_data.token == NON_EXISTENT_TOKEN
+            or chain_config.chain_data.multisig == ZERO_ADDRESS
+        ):
+            self.logger.info("Service is not minted or Safe not deployed.")
+            return 0
+
         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)}"
@@ -1916,10 +1888,11 @@ class ServiceManager:
             staking_program_id=current_staking_program,
         )
         if staking_contract is None:
-            raise RuntimeError(
+            self.logger.warning(
                 "No staking contract found for the "
                 f"{current_staking_program=}. Not claiming the rewards."
             )
+            return 0
 
         sftxb = self.get_eth_safe_tx_builder(ledger_config=ledger_config)
         if not sftxb.staking_rewards_claimable(
@@ -1964,22 +1937,13 @@ class ServiceManager:
     def fund_service(  # pylint: disable=too-many-arguments,too-many-locals
         self,
         service_config_id: str,
-        funding_values: t.Optional[FundingValues] = None,
-        from_safe: bool = True,
-        task_id: t.Optional[str] = None,
+        amounts: ChainAmounts,
     ) -> None:
         """Fund service if required."""
         service = self.load(service_config_id=service_config_id)
+        self.funding_manager.fund_service(service=service, amounts=amounts)
 
-        for chain in service.chain_configs.keys():
-            self.logger.info(f"[FUNDING_JOB] [{task_id=}] Funding {chain=}")
-            self.fund_service_single_chain(
-                service_config_id=service_config_id,
-                funding_values=funding_values,
-                from_safe=from_safe,
-                chain=chain,
-            )
-
+    # TODO deprecate
     def fund_service_single_chain(  # pylint: disable=too-many-arguments,too-many-locals,too-many-statements
         self,
         service_config_id: str,
@@ -2012,7 +1976,10 @@ class ServiceManager:
                     else:
                         on_chain_operations_buffer = (
                             chain_data.user_params.cost_of_bond
-                            * (1 + len(service.agent_addresses))
+                            * (
+                                MIN_SECURITY_DEPOSIT
+                                + MIN_AGENT_BOND * len(service.agent_addresses)
+                            )
                         )
 
             asset_funding_values = (
@@ -2057,10 +2024,13 @@ class ServiceManager:
                         to_transfer = max(
                             min(available_balance, target_balance - agent_balance), 0
                         )
+                        if to_transfer <= 0:
+                            continue
+
                         self.logger.info(
                             f"[FUNDING_JOB] Transferring {to_transfer} units (asset {asset_address}) to agent {agent_address}"
                         )
-                        wallet.transfer_asset(
+                        wallet.transfer(
                             asset=asset_address,
                             to=agent_address,
                             amount=int(to_transfer),
@@ -2129,7 +2099,7 @@ class ServiceManager:
                     # when not enough funds are present, and the FE doesn't let the user to start the agent.
                     # Ideally this error should be allowed, and then the FE should ask the user for more funds.
                     with suppress(RuntimeError):
-                        wallet.transfer_asset(
+                        wallet.transfer(
                             asset=asset_address,
                             to=t.cast(str, chain_data.multisig),
                             amount=int(to_transfer),
@@ -2137,6 +2107,7 @@ class ServiceManager:
                             rpc=rpc or ledger_config.rpc,
                         )
 
+    # TODO Deprecate
     # TODO This method is possibly not used anymore
     def fund_service_erc20(  # pylint: disable=too-many-arguments,too-many-locals
         self,
@@ -2174,9 +2145,12 @@ class ServiceManager:
                     agent_topup
                     or chain_data.user_params.fund_requirements[ZERO_ADDRESS].agent
                 )
+                if to_transfer <= 0:
+                    continue
+
                 self.logger.info(f"Transferring {to_transfer} units to {agent_address}")
-                wallet.transfer_erc20(
-                    token=token,
+                wallet.transfer(
+                    asset=token,
                     to=agent_address,
                     amount=int(to_transfer),
                     chain=ledger_config.chain,
@@ -2201,150 +2175,36 @@ class ServiceManager:
                 safe_topup
                 or chain_data.user_params.fund_requirements[ZERO_ADDRESS].safe
             )
+            if to_transfer <= 0:
+                return
+
             self.logger.info(
                 f"Transferring {to_transfer} units to {chain_data.multisig}"
             )
-            wallet.transfer_erc20(
-                token=token,
+            wallet.transfer(
+                asset=token,
                 to=t.cast(str, chain_data.multisig),
                 amount=int(to_transfer),
                 chain=ledger_config.chain,
                 rpc=rpc or ledger_config.rpc,
             )
 
-    def drain_service_safe(  # pylint: disable=too-many-locals
-        self,
-        service_config_id: str,
-        withdrawal_address: str,
-        chain: Chain,
-    ) -> None:
-        """Drain the funds out of the service safe."""
-        self.logger.info(
-            f"Draining the safe of service: {service_config_id} on chain {chain.value}"
-        )
-        service = self.load(service_config_id=service_config_id)
-        chain_config = service.chain_configs[chain.value]
-        ledger_config = chain_config.ledger_config
-        chain_data = chain_config.chain_data
-        wallet = self.wallet_manager.load(ledger_config.chain.ledger_type)
-        ledger_api = wallet.ledger_api(chain=ledger_config.chain, rpc=ledger_config.rpc)
-        ethereum_crypto = KeysManager().get_crypto_instance(service.agent_addresses[0])
-        withdrawal_address = Web3.to_checksum_address(withdrawal_address)
-
-        # drain ERC20 tokens from service safe
-        for token_name, token_address in (
-            ("OLAS", OLAS[chain]),
-            (
-                f"W{get_currency_denom(chain)}",
-                WRAPPED_NATIVE_ASSET[chain],
-            ),
-            ("USDC", USDC[chain]),
-        ):
-            token_instance = registry_contracts.erc20.get_instance(
-                ledger_api=ledger_api,
-                contract_address=token_address,
-            )
-            balance = token_instance.functions.balanceOf(chain_data.multisig).call()
-            if balance == 0:
-                self.logger.info(
-                    f"No {token_name} to drain from service safe: {chain_data.multisig}"
-                )
-                continue
-
-            self.logger.info(
-                f"Draining {balance} {token_name} out of service safe: {chain_data.multisig}"
-            )
-            transfer_erc20_from_safe(
-                ledger_api=ledger_api,
-                crypto=ethereum_crypto,
-                safe=chain_data.multisig,
-                token=token_address,
-                to=withdrawal_address,
-                amount=balance,
-            )
-
-        # drain native asset from service safe
-        balance = ledger_api.get_balance(chain_data.multisig)
-        if balance == 0:
-            self.logger.info(
-                f"No {get_currency_denom(chain)} to drain from service safe: {chain_data.multisig}"
-            )
-        else:
-            self.logger.info(
-                f"Draining {balance} {get_currency_denom(chain)} out of service safe: {chain_data.multisig}"
-            )
-            transfer_from_safe(
-                ledger_api=ledger_api,
-                crypto=ethereum_crypto,
-                safe=chain_data.multisig,
-                to=withdrawal_address,
-                amount=balance,
-            )
-
-        self.logger.info(f"{service.name} safe drained ({service_config_id=})")
-
-    async def funding_job(
-        self,
-        service_config_id: str,
-        loop: t.Optional[asyncio.AbstractEventLoop] = None,
-        from_safe: bool = True,
+    def drain(
+        self, service_config_id: str, chain_str: str, withdrawal_address: str
     ) -> None:
-        """Start a background funding job."""
-        loop = loop or asyncio.get_event_loop()
+        """Drain service safe and agent EOAs."""
         service = self.load(service_config_id=service_config_id)
-        chain_config = service.chain_configs[service.home_chain]
-        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(
-                        executor,
-                        self.fund_service,
-                        service_config_id,  # Service id
-                        {
-                            asset_address: {
-                                "agent": {
-                                    "topup": fund_requirements.agent,
-                                    "threshold": int(
-                                        fund_requirements.agent
-                                        * DEFAULT_TOPUP_THRESHOLD
-                                    ),
-                                },
-                                "safe": {
-                                    "topup": fund_requirements.safe,
-                                    "threshold": int(
-                                        fund_requirements.safe * DEFAULT_TOPUP_THRESHOLD
-                                    ),
-                                },
-                            }
-                            for asset_address, fund_requirements in chain_config.chain_data.user_params.fund_requirements.items()
-                        },
-                        from_safe,
-                        task_id,
-                    )
-                except Exception:  # pylint: disable=broad-except
-                    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.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)
+        chain = Chain(chain_str)
+        self.funding_manager.drain_service_safe(
+            service=service,
+            withdrawal_address=withdrawal_address,
+            chain=chain,
+        )
+        self.funding_manager.drain_agents_eoas(
+            service=service,
+            withdrawal_address=withdrawal_address,
+            chain=chain,
+        )
 
     def deploy_service_locally(
         self,
@@ -2418,6 +2278,14 @@ class ServiceManager:
         )
         return service
 
+    def funding_requirements(  # pylint: disable=too-many-locals,too-many-statements,too-many-nested-blocks
+        self, service_config_id: str
+    ) -> t.Dict:
+        """Get the funding requirements for a service."""
+        service = self.load(service_config_id=service_config_id)
+        return self.funding_manager.funding_requirements(service)
+
+    # TODO deprecate
     def refill_requirements(  # pylint: disable=too-many-locals,too-many-statements,too-many-nested-blocks
         self, service_config_id: str
     ) -> t.Dict:
@@ -2621,6 +2489,7 @@ class ServiceManager:
             "allow_start_agent": allow_start_agent,
         }
 
+    # TODO deprecate
     def _compute_bonded_assets(  # pylint: disable=too-many-locals
         self, service_config_id: str, chain: str
     ) -> t.Dict:
@@ -2736,6 +2605,7 @@ class ServiceManager:
 
         return dict(bonded_assets)
 
+    # TODO deprecate
     def _compute_protocol_asset_requirements(  # pylint: disable=too-many-locals
         self, service_config_id: str, chain: str
     ) -> t.Dict:
@@ -2768,6 +2638,7 @@ class ServiceManager:
             ),
         )
 
+        # TODO address this comment in FundingManager
         # This computation assumes the service will be/has been minted with these
         # parameters. Otherwise, these values should be retrieved on-chain as follows:
         # - agent_bonds: by combining the output of ServiceRegistry .getAgentParams .getService
@@ -2783,6 +2654,7 @@ class ServiceManager:
 
         return dict(service_asset_requirements)
 
+    # TODO deprecate
     @staticmethod
     def _compute_refill_requirement(
         asset_funding_values: t.Dict,
@@ -2863,12 +2735,13 @@ class ServiceManager:
             "recommended_refill": recommended_refill,
         }
 
+    # TODO deprecate
     @staticmethod
     def get_master_eoa_native_funding_values(
         master_safe_exists: bool, chain: Chain, balance: int
     ) -> t.Dict:
         """Get Master EOA native funding values."""
 
-        topup = DEFAULT_MASTER_EOA_FUNDS[chain][ZERO_ADDRESS]
+        topup = DEFAULT_EOA_TOPUPS[chain][ZERO_ADDRESS]
         threshold = topup / 2 if master_safe_exists else topup
         return {"topup": topup, "threshold": threshold, "balance": balance}