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

operate/services/health_checker.py

@@ -21,6 +21,7 @@
 import asyncio
 import json
 import logging
+import time
 import typing as t
 from concurrent.futures import ThreadPoolExecutor
 from http import HTTPStatus
@@ -40,6 +41,8 @@ class HealthChecker:
     PORT_UP_TIMEOUT_DEFAULT = 300  # seconds
     REQUEST_TIMEOUT_DEFAULT = 90  # seconds
     NUMBER_OF_FAILS_DEFAULT = 60
+    FAILFAST_NUM = 15
+    FAILFAST_TIMEOUT = 15 * 60  # 15 minutes
 
     def __init__(
         self,
@@ -121,7 +124,7 @@ class HealthChecker:
                     )
                     return False
 
-    async def healthcheck_job(
+    async def healthcheck_job(  # pylint: disable=too-many-statements
         self,
         service_config_id: str,
     ) -> None:
@@ -214,7 +217,24 @@ class HealthChecker:
                     if exception is not None:
                         raise exception
 
+            async def _stop(
+                service_manager: ServiceManager, service_config_id: str
+            ) -> None:
+                def _do_stop() -> None:
+                    service_manager.stop_service_locally(
+                        service_config_id=service_config_id
+                    )
+
+                loop = asyncio.get_event_loop()
+                with ThreadPoolExecutor() as executor:
+                    future = loop.run_in_executor(executor, _do_stop)
+                    await future
+                    exception = future.exception()
+                    if exception is not None:
+                        raise exception
+
             # upper cycle
+            failfast_records: t.List[float] = []
             while True:
                 self.logger.info(
                     f"[HEALTH_CHECKER] {service_config_id} wait for port ready"
@@ -224,6 +244,7 @@ class HealthChecker:
                     self.logger.info(
                         f"[HEALTH_CHECKER]  {service_config_id} port is ready, checking health every {self.sleep_period}"
                     )
+                    failfast_records = []
                     await _check_health(
                         number_of_fails=self.number_of_fails,
                         sleep_period=self.sleep_period,
@@ -236,7 +257,22 @@ class HealthChecker:
 
                 # perform restart
                 # TODO: blocking!!!!!!!
-                await _restart(self._service_manager, service_config_id)
+                while True:
+                    # we count every restart till success (port is up and healtcheck started)
+                    failfast_records.append(time.time())
+                    try:
+                        await _restart(self._service_manager, service_config_id)
+                        break
+                    except Exception:  # pylint: disable=broad-except
+                        if (len(failfast_records) >= self.FAILFAST_NUM) or (
+                            time.time() - failfast_records[0]
+                        ) > self.FAILFAST_TIMEOUT:
+                            await _stop(self._service_manager, service_config_id)
+                            raise
+
+                        self.logger.exception(f"Restart problem: {service_config_id}")
+                        await asyncio.sleep(30)
+
         except Exception:
             self.logger.exception(
                 f"Problems running healthcheck job for {service_config_id}"

operate/services/manage.py

@@ -1551,7 +1551,7 @@ class ServiceManager:
                 f"Cannot enable recovery module. Safe {service_safe_address} has inconsistent owners."
             )
 
-    def _get_current_staking_program(  # pylint: disable=no-self-use
+    def _get_current_staking_program(
         self, service: Service, chain: str
     ) -> t.Optional[str]:
         staking_manager = StakingManager(Chain(chain))
@@ -1940,7 +1940,7 @@ class ServiceManager:
 
         # 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)
+        amount_claimed = int(receipt["logs"][0]["data"].to_0x_hex(), 16)
         self.logger.info(f"Claimed amount: {amount_claimed}")
         ethereum_crypto = self.keys_manager.get_crypto_instance(
             service.agent_addresses[0]
@@ -2352,9 +2352,9 @@ class ServiceManager:
                 allow_start_agent = False
 
             # Protocol asset requirements
-            protocol_asset_requirements[
-                chain
-            ] = self._compute_protocol_asset_requirements(service_config_id, chain)
+            protocol_asset_requirements[chain] = (
+                self._compute_protocol_asset_requirements(service_config_id, chain)
+            )
             service_asset_requirements = chain_data.user_params.fund_requirements
 
             # Bonded assets
@@ -2461,15 +2461,12 @@ class ServiceManager:
                     asset_address
                 ] = recommended_refill
 
-                total_requirements[chain].setdefault(master_safe, {})[
-                    asset_address
-                ] = sum(
-                    agent_asset_funding_values[address]["topup"]
-                    for address in agent_asset_funding_values
-                ) + protocol_asset_requirements[
-                    chain
-                ].get(
-                    asset_address, 0
+                total_requirements[chain].setdefault(master_safe, {})[asset_address] = (
+                    sum(
+                        agent_asset_funding_values[address]["topup"]
+                        for address in agent_asset_funding_values
+                    )
+                    + protocol_asset_requirements[chain].get(asset_address, 0)
                 )
 
                 if asset_address == ZERO_ADDRESS and any(
@@ -2498,9 +2495,9 @@ class ServiceManager:
                 ZERO_ADDRESS
             ] = eoa_recommended_refill
 
-            total_requirements[chain].setdefault(master_eoa, {})[
-                ZERO_ADDRESS
-            ] = eoa_funding_values["topup"]
+            total_requirements[chain].setdefault(master_eoa, {})[ZERO_ADDRESS] = (
+                eoa_funding_values["topup"]
+            )
 
         is_refill_required = any(
             amount > 0

operate/services/protocol.py

@@ -58,6 +58,7 @@ from autonomy.cli.helpers.chain import ServiceHelper as ServiceManager
 from eth_utils import to_bytes
 from hexbytes import HexBytes
 from web3.contract import Contract
+from web3.types import TxReceipt
 
 from operate.constants import (
     NO_STAKING_PROGRAM_ID,
@@ -121,9 +122,7 @@ class GnosisSafeTransaction:
         self._txs.append(tx)
         return self
 
-    def build(  # pylint: disable=unused-argument
-        self, *args: t.Any, **kwargs: t.Any
-    ) -> t.Dict:
+    def build(self) -> t.Dict:
         """Build the transaction."""
         multisend_data = bytes.fromhex(
             registry_contracts.multisend.get_tx_data(
@@ -175,22 +174,21 @@ class GnosisSafeTransaction:
         update_tx_with_gas_estimate(tx, self.ledger_api)
         return t.cast(t.Dict, tx)
 
-    def settle(self) -> t.Dict:
+    def settle(self) -> TxReceipt:
         """Settle the transaction."""
-        tx_settler = TxSettler(
-            ledger_api=self.ledger_api,
-            crypto=self.crypto,
-            chain_type=self.chain_type,
-            timeout=ON_CHAIN_INTERACT_TIMEOUT,
-            retries=ON_CHAIN_INTERACT_RETRIES,
-            sleep=ON_CHAIN_INTERACT_SLEEP,
-        )
-        setattr(tx_settler, "build", self.build)  # noqa: B010
-        return tx_settler.transact(
-            method=lambda: {},
-            contract="",
-            kwargs={},
-            dry_run=False,
+        return (
+            TxSettler(
+                ledger_api=self.ledger_api,
+                crypto=self.crypto,
+                chain_type=self.chain_type,
+                tx_builder=self.build,
+                timeout=ON_CHAIN_INTERACT_TIMEOUT,
+                retries=ON_CHAIN_INTERACT_RETRIES,
+                sleep=ON_CHAIN_INTERACT_SLEEP,
+            )
+            .transact()
+            .settle()
+            .tx_receipt
         )
 
 
@@ -401,7 +399,7 @@ class StakingManager:
         staking_contract: str,
         key: Path,
         password: str,
-    ) -> None:
+    ) -> str:
         """Stake the service"""
         och = OnChainHelper(
             key=key, chain_type=ChainType(self.chain.value), password=password
@@ -411,62 +409,52 @@ class StakingManager:
             service_id=service_id, staking_contract=staking_contract
         )
 
-        tx_settler = TxSettler(
-            ledger_api=och.ledger_api,
-            crypto=och.crypto,
-            chain_type=och.chain_type,
-            timeout=ON_CHAIN_INTERACT_TIMEOUT,
-            retries=ON_CHAIN_INTERACT_RETRIES,
-            sleep=ON_CHAIN_INTERACT_SLEEP,
-        )
-
         # we make use of the ERC20 contract to build the approval transaction
         # since it has the same interface as ERC721 we might want to create
         # a ERC721 contract package
         # this is very bad way to do it but it works because the ERC721 contract expects two arguments
         # for approve call (spender, token_id), and the ERC20 contract wrapper used here from open-autonomy
         # passes the amount as the second argument.
-        def _build_approval_tx(  # pylint: disable=unused-argument
-            *args: t.Any, **kargs: t.Any
-        ) -> t.Dict:
-            return registry_contracts.erc20.get_approve_tx(
+        TxSettler(
+            ledger_api=och.ledger_api,
+            crypto=och.crypto,
+            chain_type=och.chain_type,
+            timeout=ON_CHAIN_INTERACT_TIMEOUT,
+            retries=ON_CHAIN_INTERACT_RETRIES,
+            sleep=ON_CHAIN_INTERACT_SLEEP,
+            tx_builder=lambda: registry_contracts.erc20.get_approve_tx(
                 ledger_api=och.ledger_api,
                 contract_address=service_registry,
                 spender=staking_contract,
                 sender=och.crypto.address,
                 amount=service_id,  # TODO: This is a workaround and it should be fixed
-            )
+            ),
+        ).transact().settle()
 
-        setattr(tx_settler, "build", _build_approval_tx)  # noqa: B010
-        tx_settler.transact(
-            method=lambda: {},
-            contract="",
-            kwargs={},
-            dry_run=False,
-        )
-
-        def _build_staking_tx(  # pylint: disable=unused-argument
-            *args: t.Any, **kargs: t.Any
-        ) -> t.Dict:
-            return och.ledger_api.build_transaction(
-                contract_instance=self.staking_ctr.get_instance(
-                    ledger_api=och.ledger_api,
-                    contract_address=staking_contract,
+        return (
+            TxSettler(
+                ledger_api=och.ledger_api,
+                crypto=och.crypto,
+                chain_type=och.chain_type,
+                timeout=ON_CHAIN_INTERACT_TIMEOUT,
+                retries=ON_CHAIN_INTERACT_RETRIES,
+                sleep=ON_CHAIN_INTERACT_SLEEP,
+                tx_builder=lambda: och.ledger_api.build_transaction(
+                    contract_instance=self.staking_ctr.get_instance(
+                        ledger_api=och.ledger_api,
+                        contract_address=staking_contract,
+                    ),
+                    method_name="stake",
+                    method_args={"serviceId": service_id},
+                    tx_args={
+                        "sender_address": och.crypto.address,
+                    },
+                    raise_on_try=True,
                 ),
-                method_name="stake",
-                method_args={"serviceId": service_id},
-                tx_args={
-                    "sender_address": och.crypto.address,
-                },
-                raise_on_try=True,
             )
-
-        setattr(tx_settler, "build", _build_staking_tx)  # noqa: B010
-        tx_settler.transact(
-            method=lambda: {},
-            contract="",
-            kwargs={},
-            dry_run=False,
+            .transact()
+            .settle()
+            .tx_hash
         )
 
     def check_if_unstaking_possible(
@@ -506,43 +494,36 @@ class StakingManager:
         staking_contract: str,
         key: Path,
         password: str,
-    ) -> None:
+    ) -> str:
         """Unstake the service"""
         och = OnChainHelper(
             key=key, chain_type=ChainType(self.chain.value), password=password
         )
 
-        tx_settler = TxSettler(
-            ledger_api=och.ledger_api,
-            crypto=och.crypto,
-            chain_type=och.chain_type,
-            timeout=ON_CHAIN_INTERACT_TIMEOUT,
-            retries=ON_CHAIN_INTERACT_RETRIES,
-            sleep=ON_CHAIN_INTERACT_SLEEP,
-        )
-
-        def _build_unstaking_tx(  # pylint: disable=unused-argument
-            *args: t.Any, **kargs: t.Any
-        ) -> t.Dict:
-            return och.ledger_api.build_transaction(
-                contract_instance=self.staking_ctr.get_instance(
-                    ledger_api=och.ledger_api,
-                    contract_address=staking_contract,
+        return (
+            TxSettler(
+                ledger_api=och.ledger_api,
+                crypto=och.crypto,
+                chain_type=och.chain_type,
+                timeout=ON_CHAIN_INTERACT_TIMEOUT,
+                retries=ON_CHAIN_INTERACT_RETRIES,
+                sleep=ON_CHAIN_INTERACT_SLEEP,
+                tx_builder=lambda: och.ledger_api.build_transaction(
+                    contract_instance=self.staking_ctr.get_instance(
+                        ledger_api=och.ledger_api,
+                        contract_address=staking_contract,
+                    ),
+                    method_name="unstake",
+                    method_args={"serviceId": service_id},
+                    tx_args={
+                        "sender_address": och.crypto.address,
+                    },
+                    raise_on_try=True,
                 ),
-                method_name="unstake",
-                method_args={"serviceId": service_id},
-                tx_args={
-                    "sender_address": och.crypto.address,
-                },
-                raise_on_try=True,
             )
-
-        setattr(tx_settler, "build", _build_unstaking_tx)  # noqa: B010
-        tx_settler.transact(
-            method=lambda: {},
-            contract="",
-            kwargs={},
-            dry_run=False,
+            .transact()
+            .settle()
+            .tx_hash
         )
 
     def get_stake_approval_tx_data(
@@ -559,8 +540,8 @@ class StakingManager:
         return registry_contracts.erc20.get_instance(
             ledger_api=self.ledger_api,
             contract_address=service_registry,
-        ).encodeABI(
-            fn_name="approve",
+        ).encode_abi(
+            abi_element_identifier="approve",
             args=[
                 staking_contract,
                 service_id,
@@ -576,8 +557,8 @@ class StakingManager:
         return self.staking_ctr.get_instance(
             ledger_api=self.ledger_api,
             contract_address=staking_contract,
-        ).encodeABI(
-            fn_name="stake",
+        ).encode_abi(
+            abi_element_identifier="stake",
             args=[service_id],
         )
 
@@ -590,8 +571,8 @@ class StakingManager:
         return self.staking_ctr.get_instance(
             ledger_api=self.ledger_api,
             contract_address=staking_contract,
-        ).encodeABI(
-            fn_name="unstake",
+        ).encode_abi(
+            abi_element_identifier="unstake",
             args=[service_id],
         )
 
@@ -600,8 +581,8 @@ class StakingManager:
         return self.staking_ctr.get_instance(
             ledger_api=self.ledger_api,
             contract_address=staking_contract,
-        ).encodeABI(
-            fn_name="claim",
+        ).encode_abi(
+            abi_element_identifier="claim",
             args=[service_id],
         )
 
@@ -612,8 +593,8 @@ class StakingManager:
         return self.staking_ctr.get_instance(
             ledger_api=self.ledger_api,
             contract_address=staking_contract,
-        ).encodeABI(
-            fn_name="forcedUnstake",
+        ).encode_abi(
+            abi_element_identifier="forcedUnstake",
             args=[service_id],
         )
 
@@ -1320,8 +1301,8 @@ class EthSafeTxBuilder(_ChainUtil):
         instance = self.service_manager_instance
         if update_token is None:
             safe = self.safe
-            txd = instance.encodeABI(
-                fn_name="create",
+            txd = instance.encode_abi(
+                abi_element_identifier="create",
                 args=[
                     safe,
                     token or ETHEREUM_ERC20,
@@ -1332,8 +1313,8 @@ class EthSafeTxBuilder(_ChainUtil):
                 ],
             )
         else:
-            txd = instance.encodeABI(
-                fn_name="update",
+            txd = instance.encode_abi(
+                abi_element_identifier="update",
                 args=[
                     token or ETHEREUM_ERC20,
                     manager.metadata_hash,
@@ -1362,8 +1343,8 @@ class EthSafeTxBuilder(_ChainUtil):
             ledger_api=self.ledger_api,
             contract_address=erc20_contract,
         )
-        txd = instance.encodeABI(
-            fn_name="approve",
+        txd = instance.encode_abi(
+            abi_element_identifier="approve",
             args=[spender, amount],
         )
         return {
@@ -1379,8 +1360,8 @@ class EthSafeTxBuilder(_ChainUtil):
             ledger_api=self.ledger_api,
             contract_address=self.service_manager_address,
         )
-        txd = instance.encodeABI(
-            fn_name="activateRegistration",
+        txd = instance.encode_abi(
+            abi_element_identifier="activateRegistration",
             args=[service_id],
         )
         return {
@@ -1403,8 +1384,8 @@ class EthSafeTxBuilder(_ChainUtil):
             ledger_api=self.ledger_api,
             contract_address=self.service_manager_address,
         )
-        txd = instance.encodeABI(
-            fn_name="registerAgents",
+        txd = instance.encode_abi(
+            abi_element_identifier="registerAgents",
             args=[
                 service_id,
                 instances,
@@ -1478,8 +1459,8 @@ class EthSafeTxBuilder(_ChainUtil):
                     SAFE_MULTISIG_WITH_RECOVERY_MODULE_CONTRACT.name
                 ).contracts[self.chain_type]
 
-        deploy_data = registry_instance.encodeABI(
-            fn_name="deploy",
+        deploy_data = registry_instance.encode_abi(
+            abi_element_identifier="deploy",
             args=[
                 service_id,
                 gnosis_safe_multisig,
@@ -1544,8 +1525,8 @@ class EthSafeTxBuilder(_ChainUtil):
         ).get("tx_hash")
 
         # Build approveHash message
-        approve_hash_data = safe_b_instance.encodeABI(
-            fn_name="approveHash",
+        approve_hash_data = safe_b_instance.encode_abi(
+            abi_element_identifier="approveHash",
             args=[safe_tx_hash],
         )
         approve_hash_message = {
@@ -1556,8 +1537,8 @@ class EthSafeTxBuilder(_ChainUtil):
         }
 
         # Build execTransaction message
-        exec_data = safe_b_instance.encodeABI(
-            fn_name="execTransaction",
+        exec_data = safe_b_instance.encode_abi(
+            abi_element_identifier="execTransaction",
             args=[
                 multisend_address,
                 multisend_tx["value"],
@@ -1607,8 +1588,8 @@ class EthSafeTxBuilder(_ChainUtil):
         txs.append(
             {
                 "to": token,
-                "data": erc20_instance.encodeABI(
-                    fn_name="transfer",
+                "data": erc20_instance.encode_abi(
+                    abi_element_identifier="transfer",
                     args=[to, amount],
                 ),
                 "operation": MultiSendOperation.CALL,
@@ -1636,8 +1617,8 @@ class EthSafeTxBuilder(_ChainUtil):
         ).get("tx_hash")
 
         # Build approveHash message
-        approve_hash_data = safe_b_instance.encodeABI(
-            fn_name="approveHash",
+        approve_hash_data = safe_b_instance.encode_abi(
+            abi_element_identifier="approveHash",
             args=[safe_tx_hash],
         )
         approve_hash_message = {
@@ -1648,8 +1629,8 @@ class EthSafeTxBuilder(_ChainUtil):
         }
 
         # Build execTransaction message
-        exec_data = safe_b_instance.encodeABI(
-            fn_name="execTransaction",
+        exec_data = safe_b_instance.encode_abi(
+            abi_element_identifier="execTransaction",
             args=[
                 multisend_address,
                 multisend_tx["value"],
@@ -1678,8 +1659,8 @@ class EthSafeTxBuilder(_ChainUtil):
             ledger_api=self.ledger_api,
             contract_address=self.service_manager_address,
         )
-        txd = instance.encodeABI(
-            fn_name="terminate",
+        txd = instance.encode_abi(
+            abi_element_identifier="terminate",
             args=[service_id],
         )
         return {
@@ -1695,8 +1676,8 @@ class EthSafeTxBuilder(_ChainUtil):
             ledger_api=self.ledger_api,
             contract_address=self.service_manager_address,
         )
-        txd = instance.encodeABI(
-            fn_name="unbond",
+        txd = instance.encode_abi(
+            abi_element_identifier="unbond",
             args=[service_id],
         )
         return {
@@ -1844,8 +1825,8 @@ class EthSafeTxBuilder(_ChainUtil):
         #     ledger_api=self.ledger_api,  # noqa: E800
         #     contract_address=self.contracts["recovery_module"],  # noqa: E800
         # )  # noqa: E800
-        txd = instance.encodeABI(
-            fn_name="recoverAccess",
+        txd = instance.encode_abi(
+            abi_element_identifier="recoverAccess",
             args=[service_id],
         )
         return {
@@ -1866,8 +1847,8 @@ class EthSafeTxBuilder(_ChainUtil):
             ledger_api=self.ledger_api,
             contract_address=safe_address,
         )
-        txd = instance.encodeABI(
-            fn_name="enableModule",
+        txd = instance.encode_abi(
+            abi_element_identifier="enableModule",
             args=[module_address],
         )
         return {
@@ -1948,8 +1929,8 @@ def get_reuse_multisig_from_safe_payload(  # pylint: disable=too-many-locals
                 "to": multisig_address,
                 "data": HexBytes(
                     bytes.fromhex(
-                        multisig_instance.encodeABI(
-                            fn_name="addOwnerWithThreshold",
+                        multisig_instance.encode_abi(
+                            abi_element_identifier="addOwnerWithThreshold",
                             args=[_owner, 1],
                         )[2:]
                     )
@@ -1964,8 +1945,8 @@ def get_reuse_multisig_from_safe_payload(  # pylint: disable=too-many-locals
             "to": multisig_address,
             "data": HexBytes(
                 bytes.fromhex(
-                    multisig_instance.encodeABI(
-                        fn_name="removeOwner",
+                    multisig_instance.encode_abi(
+                        abi_element_identifier="removeOwner",
                         args=[new_owners[0], master_safe, 1],
                     )[2:]
                 )
@@ -1980,8 +1961,8 @@ def get_reuse_multisig_from_safe_payload(  # pylint: disable=too-many-locals
             "to": multisig_address,
             "data": HexBytes(
                 bytes.fromhex(
-                    multisig_instance.encodeABI(
-                        fn_name="changeThreshold",
+                    multisig_instance.encode_abi(
+                        abi_element_identifier="changeThreshold",
                         args=[threshold],
                     )[2:]
                 )
@@ -2006,8 +1987,8 @@ def get_reuse_multisig_from_safe_payload(  # pylint: disable=too-many-locals
         data=multisend_tx["data"],
         operation=1,
     ).get("tx_hash")
-    approve_hash_data = multisig_instance.encodeABI(
-        fn_name="approveHash",
+    approve_hash_data = multisig_instance.encode_abi(
+        abi_element_identifier="approveHash",
         args=[
             safe_tx_hash,
         ],
@@ -2019,8 +2000,8 @@ def get_reuse_multisig_from_safe_payload(  # pylint: disable=too-many-locals
         "value": 0,
     }
 
-    safe_exec_data = multisig_instance.encodeABI(
-        fn_name="execTransaction",
+    safe_exec_data = multisig_instance.encode_abi(
+        abi_element_identifier="execTransaction",
         args=[
             multisend_address,  # to address
             multisend_tx["value"],  # value

operate/services/utils/mech.py

@@ -24,7 +24,7 @@ from typing import Tuple
 import requests
 from aea_ledger_ethereum import Web3
 
-from operate.constants import MECH_MARKETPLACE_JSON_URL
+from operate.constants import DEFAULT_TIMEOUT, MECH_MARKETPLACE_JSON_URL
 from operate.operate_types import Chain
 from operate.quickstart.utils import print_section
 from operate.services.protocol import EthSafeTxBuilder
@@ -57,7 +57,7 @@ def deploy_mech(sftxb: EthSafeTxBuilder, service: Service) -> Tuple[str, str]:
     # Get the mech type from service config
     mech_type = service.env_variables.get("MECH_TYPE", {}).get("value", "Native")
 
-    abi = requests.get(MECH_MARKETPLACE_JSON_URL).json()["abi"]
+    abi = requests.get(MECH_MARKETPLACE_JSON_URL, timeout=DEFAULT_TIMEOUT).json()["abi"]
     chain = Chain.from_string(service.home_chain)
     mech_marketplace_address = service.env_variables["MECH_MARKETPLACE_ADDRESS"][
         "value"
@@ -82,7 +82,7 @@ def deploy_mech(sftxb: EthSafeTxBuilder, service: Service) -> Tuple[str, str]:
     contract = sftxb.ledger_api.api.eth.contract(
         address=Web3.to_checksum_address(mech_marketplace_address), abi=abi
     )
-    data = contract.encodeABI(
+    data = contract.encode_abi(
         "create",
         args=[
             service.chain_configs[service.home_chain].chain_data.token,