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

operate/services/service.py

@@ -35,6 +35,7 @@ from json import JSONDecodeError
 from pathlib import Path
 from traceback import print_exc
 
+import requests
 from aea.configurations.constants import (
     DEFAULT_LEDGER,
     LEDGER,
@@ -42,6 +43,7 @@ from aea.configurations.constants import (
     PRIVATE_KEY_PATH_SCHEMA,
     SKILL,
 )
+from aea.helpers.logging import setup_logger
 from aea.helpers.yaml_utils import yaml_dump, yaml_load, yaml_load_all
 from aea_cli_ipfs.ipfs_utils import IPFSTool
 from autonomy.cli.helpers.deployment import run_deployment, stop_deployment
@@ -64,16 +66,21 @@ from autonomy.deploy.generators.kubernetes.base import KubernetesGenerator
 from docker import from_env
 
 from operate.constants import (
+    AGENT_FUNDS_STATUS_URL,
     AGENT_PERSISTENT_STORAGE_ENV_VAR,
     CONFIG_JSON,
     DEPLOYMENT_DIR,
     DEPLOYMENT_JSON,
     HEALTHCHECK_JSON,
+    SERVICE_SAFE_PLACEHOLDER,
+    ZERO_ADDRESS,
 )
 from operate.keys import KeysManager
+from operate.ledger import get_default_rpc
 from operate.operate_http.exceptions import NotAllowed
 from operate.operate_types import (
     Chain,
+    ChainAmounts,
     ChainConfig,
     ChainConfigs,
     DeployedNodes,
@@ -106,6 +113,8 @@ NON_EXISTENT_TOKEN = -1
 
 AGENT_TYPE_IDS = {"mech": 37, "optimus": 40, "modius": 40, "trader": 25}
 
+logger = setup_logger("operate.services.service")
+
 
 def mkdirs(build_dir: Path) -> None:
     """Build necessary directories."""
@@ -825,11 +834,12 @@ class Service(LocalResource):
             )
         )
 
-        ledger_configs = ServiceHelper(path=package_absolute_path).ledger_configs()
-
         chain_configs = {}
-        for chain, config in service_template["configurations"].items():
-            ledger_config = ledger_configs[chain]
+        for chain_str, config in service_template["configurations"].items():
+            chain = Chain(chain_str)
+            ledger_config = LedgerConfig(
+                rpc=get_default_rpc(Chain(chain_str)), chain=chain
+            )
             ledger_config.rpc = config["rpc"]
 
             chain_data = OnChainData(
@@ -839,7 +849,7 @@ class Service(LocalResource):
                 user_params=OnChainUserParams.from_json(config),  # type: ignore
             )
 
-            chain_configs[chain] = ChainConfig(
+            chain_configs[chain_str] = ChainConfig(
                 ledger_config=ledger_config,
                 chain_data=chain_data,
             )
@@ -1118,3 +1128,69 @@ class Service(LocalResource):
 
         if updated:
             self.store()
+
+    def get_initial_funding_amounts(self) -> ChainAmounts:
+        """Get funding amounts as a dict structure."""
+        amounts = ChainAmounts()
+
+        for chain_str, chain_config in self.chain_configs.items():
+            fund_requirements = chain_config.chain_data.user_params.fund_requirements
+            service_safe = chain_config.chain_data.multisig
+
+            if service_safe is None or service_safe == ZERO_ADDRESS:
+                service_safe = SERVICE_SAFE_PLACEHOLDER
+
+            chain_amounts = amounts.setdefault(chain_str, {})
+            for asset, req in fund_requirements.items():
+                chain_amounts.setdefault(service_safe, {})[asset] = req.safe
+                for agent_address in self.agent_addresses:
+                    chain_amounts.setdefault(agent_address, {})[asset] = req.agent
+
+        return amounts
+
+    def get_funding_requests(self) -> ChainAmounts:
+        """Get funding amounts requested by the agent."""
+        agent_response = {}
+        funding_requests = ChainAmounts()
+
+        if self.deployment.status != DeploymentStatus.DEPLOYED:
+            return funding_requests
+
+        try:
+            resp = requests.get(AGENT_FUNDS_STATUS_URL, timeout=10)
+            resp.raise_for_status()
+            agent_response = resp.json()
+        except Exception as e:  # pylint: disable=broad-except
+            logger.warning(
+                f"[FUNDING MANAGER] Cannot read url {AGENT_FUNDS_STATUS_URL}: {e}"
+            )
+
+        for chain_str, addresses in agent_response.items():
+            for address, assets in addresses.items():
+                if chain_str not in self.chain_configs:
+                    raise ValueError(
+                        f"Service {self.service_config_id} asked funding for an unknown chain {chain_str}."
+                    )
+
+                if (
+                    address not in self.agent_addresses
+                    and address != self.chain_configs[chain_str].chain_data.multisig
+                ):
+                    raise ValueError(
+                        f"Service {self.service_config_id} asked funding for an unknown address {address} on chain {chain_str}."
+                    )
+
+                funding_requests.setdefault(chain_str, {})
+                funding_requests[chain_str].setdefault(address, {})
+                for asset, amounts in assets.items():
+                    try:
+                        funding_requests[chain_str][address][asset] = int(
+                            amounts["deficit"]
+                        )
+                    except (ValueError, TypeError):
+                        logger.warning(
+                            f"[FUNDING MANAGER] Invalid funding amount {amounts['deficit']} for asset {asset} on chain {chain_str} for address {address}. Setting to 0."
+                        )
+                        funding_requests[chain_str][address][asset] = 0
+
+        return funding_requests

operate/settings.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------------------------
+#
+#   Copyright 2024 Valory AG
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+# ------------------------------------------------------------------------------
+"""Settings for operate."""
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from operate.constants import SETTINGS_JSON
+from operate.ledger.profiles import DEFAULT_EOA_TOPUPS
+from operate.operate_types import ChainAmounts
+from operate.resource import LocalResource
+
+
+SETTINGS_JSON_VERSION = 1
+DEFAULT_SETTINGS = {
+    "version": SETTINGS_JSON_VERSION,
+    "eoa_topups": DEFAULT_EOA_TOPUPS,
+}
+
+
+class Settings(LocalResource):
+    """Settings for operate."""
+
+    _file = SETTINGS_JSON
+
+    version: int
+    eoa_topups: Dict[str, Dict[str, int]]
+
+    def __init__(self, path: Optional[Path] = None, **kwargs: Any) -> None:
+        """Initialize settings."""
+        super().__init__(path=path)
+        if path is not None and (path / self._file).exists():
+            self.load(path)
+
+        for key, default_value in DEFAULT_SETTINGS.items():
+            value = kwargs.get(key, default_value)
+            if not hasattr(self, key):
+                setattr(self, key, value)
+
+        if self.version != SETTINGS_JSON_VERSION:
+            raise ValueError(
+                f"Settings version {self.version} is not supported. Expected version {SETTINGS_JSON_VERSION}."
+            )
+
+    def get_eoa_topups(self, with_safe: bool = False) -> ChainAmounts:
+        """Get the EOA topups."""
+        return (
+            self.eoa_topups
+            if with_safe
+            else {
+                chain: {asset: amount * 2 for asset, amount in asset_amount.items()}
+                for chain, asset_amount in self.eoa_topups.items()
+            }
+        )

operate/utils/__init__.py

@@ -19,7 +19,6 @@
 
 """Helper utilities."""
 
-import functools
 import shutil
 import time
 import typing as t
@@ -32,34 +31,6 @@ class SingletonMeta(type):
 
     _instances: t.Dict[t.Type, t.Any] = {}
     _lock: Lock = Lock()
-    _class_locks: t.Dict[t.Type, Lock] = {}
-
-    def __new__(
-        cls, name: str, bases: t.Tuple[type, ...], dct: t.Dict[str, t.Any]
-    ) -> t.Type:
-        """Create a new class with thread-safe methods."""
-        # Wrap all callable methods (except special methods) with thread safety
-        for key, value in list(dct.items()):
-            if callable(value) and not key.startswith("__"):
-                dct[key] = cls._make_thread_safe(value)
-
-        new_class = super().__new__(cls, name, bases, dct)
-        cls._class_locks[new_class] = Lock()
-        return new_class
-
-    @staticmethod
-    def _make_thread_safe(func: t.Callable) -> t.Callable:
-        """Wrap a function to make it thread-safe."""
-
-        @functools.wraps(func)
-        def wrapper(self: t.Any, *args: t.Any, **kwargs: t.Any) -> t.Any:
-            class_lock = SingletonMeta._class_locks.get(type(self))
-            if class_lock:
-                with class_lock:
-                    return func(self, *args, **kwargs)
-            return func(self, *args, **kwargs)
-
-        return wrapper
 
     def __call__(cls, *args: t.Any, **kwargs: t.Any) -> t.Any:
         """Override the __call__ method to control instance creation."""

operate/utils/gnosis.py

@@ -22,6 +22,7 @@
 import binascii
 import itertools
 import secrets
+import time
 import typing as t
 from enum import Enum
 
@@ -39,6 +40,7 @@ from operate.constants import (
     ON_CHAIN_INTERACT_TIMEOUT,
     ZERO_ADDRESS,
 )
+from operate.ledger import get_default_ledger_api
 from operate.operate_types import Chain
 
 
@@ -174,11 +176,7 @@ def create_safe(
         tx = registry_contracts.gnosis_safe.get_deploy_transaction(
             ledger_api=ledger_api,
             deployer_address=crypto.address,
-            owners=(
-                [crypto.address]
-                if backup_owner is None
-                else [crypto.address, backup_owner]
-            ),
+            owners=([crypto.address]),
             threshold=1,
             salt_nonce=salt_nonce,
         )
@@ -209,7 +207,31 @@ def create_safe(
         contract_address="0xa6b71e26c5e0845f74c812102ca7114b6a896ab2",
     )
     (event,) = instance.events.ProxyCreation().process_receipt(receipt)
-    return event["args"]["proxy"], salt_nonce, tx_hash
+    safe_address = event["args"]["proxy"]
+
+    if backup_owner is not None:
+        retry_delays = [0, 60, 120, 180, 240]
+        for attempt in range(1, len(retry_delays) + 1):
+            try:
+                add_owner(
+                    ledger_api=ledger_api,
+                    crypto=crypto,
+                    safe=safe_address,
+                    owner=backup_owner,
+                )
+                break  # success
+            except Exception as e:  # pylint: disable=broad-except
+                if attempt == len(retry_delays):
+                    raise RuntimeError(
+                        f"Failed to add backup owner {backup_owner} after {len(retry_delays)} attempts: {e}"
+                    ) from e
+                next_delay = retry_delays[attempt]
+                logger.error(
+                    f"Retry add owner {attempt}/{len(retry_delays)} in {next_delay} seconds due to error: {e}"
+                )
+                time.sleep(next_delay)
+
+    return safe_address, salt_nonce, tx_hash
 
 
 def get_owners(ledger_api: LedgerApi, safe: str) -> t.List[str]:
@@ -274,6 +296,9 @@ def send_safe_txs(
         chain_type=Chain.from_id(
             ledger_api._chain_id  # pylint: disable=protected-access
         ),
+        timeout=ON_CHAIN_INTERACT_TIMEOUT,
+        retries=ON_CHAIN_INTERACT_RETRIES,
+        sleep=ON_CHAIN_INTERACT_SLEEP,
     )
     setattr(tx_settler, "build", _build_tx)  # noqa: B010
     tx_receipt = tx_settler.transact(
@@ -443,6 +468,9 @@ def transfer(
         chain_type=Chain.from_id(
             ledger_api._chain_id  # pylint: disable=protected-access
         ),
+        timeout=ON_CHAIN_INTERACT_TIMEOUT,
+        retries=ON_CHAIN_INTERACT_RETRIES,
+        sleep=ON_CHAIN_INTERACT_SLEEP,
     )
     setattr(tx_settler, "build", _build_tx)  # noqa: B010
     tx_receipt = tx_settler.transact(
@@ -485,6 +513,33 @@ def transfer_erc20_from_safe(
     )
 
 
+def estimate_transfer_tx_fee(chain: Chain, sender_address: str, to: str) -> int:
+    """Estimate transfer transaction fee."""
+    ledger_api = get_default_ledger_api(chain)
+    tx = ledger_api.get_transfer_transaction(
+        sender_address=sender_address,
+        destination_address=to,
+        amount=0,
+        tx_fee=0,
+        tx_nonce="0x",
+        chain_id=chain.id,
+        raise_on_try=True,
+    )
+    tx = ledger_api.update_with_gas_estimate(
+        transaction=tx,
+        raise_on_try=False,
+    )
+    chain_fee = tx["gas"] * tx["maxFeePerGas"]
+    if chain in (
+        Chain.ARBITRUM_ONE,
+        Chain.BASE,
+        Chain.OPTIMISM,
+        Chain.MODE,
+    ):
+        chain_fee += ledger_api.get_l1_data_fee(tx)
+    return chain_fee
+
+
 def drain_eoa(
     ledger_api: LedgerApi,
     crypto: Crypto,
@@ -505,34 +560,34 @@ def drain_eoa(
         *args: t.Any, **kwargs: t.Any
     ) -> t.Dict:
         """Build transaction"""
+        chain_fee = estimate_transfer_tx_fee(
+            chain=Chain.from_id(chain_id),
+            sender_address=crypto.address,
+            to=withdrawal_address,
+        )
+
+        amount = ledger_api.get_balance(crypto.address) - chain_fee
+        if amount <= 0:
+            raise ChainInteractionError(
+                f"No balance to drain from wallet: {crypto.address}"
+            )
+
         tx = ledger_api.get_transfer_transaction(
             sender_address=crypto.address,
             destination_address=withdrawal_address,
-            amount=0,
+            amount=amount,
             tx_fee=0,
             tx_nonce="0x",
             chain_id=chain_id,
             raise_on_try=True,
         )
-        tx = ledger_api.update_with_gas_estimate(
-            transaction=tx,
+        empty_tx = tx.copy()
+        empty_tx["value"] = 0
+        empty_tx = ledger_api.update_with_gas_estimate(
+            transaction=empty_tx,
             raise_on_try=False,
         )
-
-        chain_fee = tx["gas"] * tx["maxFeePerGas"]
-        if Chain.from_id(chain_id) in (
-            Chain.ARBITRUM_ONE,
-            Chain.BASE,
-            Chain.OPTIMISM,
-            Chain.MODE,
-        ):
-            chain_fee += ledger_api.get_l1_data_fee(tx)
-
-        tx["value"] = ledger_api.get_balance(crypto.address) - chain_fee
-        if tx["value"] <= 0:
-            raise ChainInteractionError(
-                f"No balance to drain from wallet: {crypto.address}"
-            )
+        tx["gas"] = empty_tx["gas"]
 
         logger.info(
             f"Draining {tx['value']} native units from wallet: {crypto.address}"

operate/utils/single_instance.py

@@ -0,0 +1,226 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------------------------
+#
+#   Copyright 2025 Valory AG
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+# ------------------------------------------------------------------------------
+
+"""Utility module for enforcing single-instance application behavior and monitoring parent process."""
+
+import asyncio
+import logging
+import os
+import socket
+import time
+from contextlib import suppress
+from typing import Callable, Optional
+
+import psutil
+import requests
+
+
+class AppSingleInstance:
+    """Ensure that only one instance of an application is running."""
+
+    host = "127.0.0.1"
+    after_kill_sleep_time = 1
+    proc_kill_wait_timeout = 10
+    proc_terminate_wait_timeout = 10
+    http_request_timeout = 3
+
+    def __init__(self, port_number: int, shutdown_endpoint: str = "/shutdown") -> None:
+        """Initialize the AppSingleInstance manager."""
+        self.port_number = port_number
+        self.shutdown_endpoint = shutdown_endpoint
+        self.logger = logging.getLogger("app_single_instance")
+        self.logger.setLevel(logging.DEBUG)
+
+    @staticmethod
+    def is_port_in_use(port: int) -> bool:
+        """Return True if a given TCP port is currently in use."""
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            return s.connect_ex(("127.0.0.1", port)) == 0
+
+    def shutdown_previous_instance(self) -> None:
+        """Attempt to stop a previously running instance of the application."""
+        if not self.is_port_in_use(self.port_number):
+            self.logger.info(f"Port {self.port_number} is free. All good.")
+            return
+
+        self.logger.warning(f"Port {self.port_number} is in use. Trying to free it!")
+        self.logger.warning(
+            f"Trying to stop previous instance via shutdown endpoint: {self.shutdown_endpoint}"
+        )
+        self.try_shutdown_with_endpoint()
+
+        if not self.is_port_in_use(self.port_number):
+            self.logger.info(f"Port {self.port_number} is free. All good.")
+            return
+
+        self.logger.warning(
+            f"Trying to stop previous instance by killing process using port {self.port_number}"
+        )
+        self.try_kill_proc_using_port()
+
+        if not self.is_port_in_use(self.port_number):
+            self.logger.info(f"Port {self.port_number} is free. All good.")
+            return
+
+        self.logger.error(f"Port {self.port_number} still in use. Cannot continue.")
+        raise RuntimeError(f"Port {self.port_number} is in use, cannot continue!")
+
+    def try_shutdown_with_endpoint(self) -> None:
+        """Attempt to gracefully shut down the previous instance via HTTP or HTTPS."""
+        try:
+            self.logger.warning(
+                "Attempting to stop previous instance via HTTPS shutdown endpoint."
+            )
+            requests.get(
+                f"https://{self.host}:{self.port_number}{self.shutdown_endpoint}",
+                timeout=self.http_request_timeout,
+                verify=False,  # nosec
+            )
+            time.sleep(self.after_kill_sleep_time)
+        except requests.exceptions.SSLError:
+            self.logger.warning("HTTPS shutdown failed, retrying without SSL.")
+            try:
+                requests.get(
+                    f"http://{self.host}:{self.port_number}{self.shutdown_endpoint}",
+                    timeout=self.http_request_timeout,
+                )
+                time.sleep(self.after_kill_sleep_time)
+            except Exception as e:  # pylint: disable=broad-except
+                self.logger.error(
+                    f"Failed to stop previous instance (HTTP). Error: {e}"
+                )
+        except Exception as e:  # pylint: disable=broad-except
+            self.logger.error(f"Failed to stop previous instance (HTTPS). Error: {e}")
+
+    def try_kill_proc_using_port(self) -> None:
+        """Attempt to forcibly terminate the process occupying the target port."""
+        for conn in psutil.net_connections(kind="tcp"):
+            if (
+                conn.laddr.port == self.port_number
+                and conn.status == psutil.CONN_LISTEN
+            ):
+                if conn.pid is None:
+                    self.logger.info(
+                        f"Process using port {self.port_number} found but PID is None. Cannot continue."
+                    )
+                    return
+                self.logger.info(
+                    f"Process using port {self.port_number} found (PID={conn.pid}). Terminating..."
+                )
+                try:
+                    self.kill_process_tree(conn.pid)
+                    time.sleep(self.after_kill_sleep_time)
+                    return
+                except Exception as e:  # pylint: disable=broad-except
+                    self.logger.error(f"Error stopping process {conn.pid}: {e}")
+        self.logger.info(f"No process found using port {self.port_number}.")
+
+    def kill_process_tree(self, pid: int) -> None:
+        """Terminate a process and all its child processes."""
+        try:
+            parent = psutil.Process(pid)
+            children = parent.children(recursive=True)
+
+            for child in children:
+                with suppress(psutil.NoSuchProcess):
+                    child.terminate()
+
+            _, still_alive = psutil.wait_procs(
+                children, timeout=self.proc_terminate_wait_timeout
+            )
+
+            for child in still_alive:
+                with suppress(psutil.NoSuchProcess):
+                    child.kill()
+
+            parent.terminate()
+            try:
+                parent.wait(timeout=self.proc_terminate_wait_timeout)
+            except psutil.TimeoutExpired:
+                parent.kill()
+                parent.wait(timeout=self.proc_kill_wait_timeout)
+
+        except psutil.NoSuchProcess:
+            self.logger.info(f"Process {pid} already terminated.")
+        except Exception as e:  # pylint: disable=broad-except
+            self.logger.error(f"Error killing process {pid}: {e}")
+
+
+logger = logging.getLogger("parent_watchdog")
+
+
+class ParentWatchdog:
+    """Monitor the parent process and trigger a shutdown when it exits."""
+
+    def __init__(
+        self, on_parent_exit: Callable[[], asyncio.Future], check_interval: int = 3
+    ) -> None:
+        """Initialize the ParentWatchdog."""
+        self.on_parent_exit = on_parent_exit
+        self.check_interval = check_interval
+        self._task: Optional[asyncio.Task] = None
+        self._stopping = False
+
+    async def _watch_loop(self) -> None:
+        """Continuously monitor the parent process and invoke the shutdown callback when it exits."""
+        try:
+            own_pid = os.getpid()
+            logger.info(f"ParentWatchdog started (pid={own_pid}, ppid={os.getppid()})")
+
+            while not self._stopping:
+                try:
+                    parent = psutil.Process(os.getppid())
+                    if not parent.is_running() or os.getppid() == 1:
+                        logger.warning(
+                            "Parent process no longer alive, initiating shutdown."
+                        )
+                        await self.on_parent_exit()
+                        break
+                except psutil.NoSuchProcess:
+                    logger.warning("Parent process not found, initiating shutdown.")
+                    await self.on_parent_exit()
+                    break
+                except Exception:  # pylint: disable=broad-except
+                    logger.exception("Parent check iteration failed.")
+                await asyncio.sleep(self.check_interval)
+
+        except asyncio.CancelledError:
+            logger.info("ParentWatchdog task cancelled.")
+        except Exception:  # pylint: disable=broad-except
+            logger.exception("ParentWatchdog crashed unexpectedly.")
+        finally:
+            logger.info("ParentWatchdog stopped.")
+
+    def start(self, loop: Optional[asyncio.AbstractEventLoop] = None) -> asyncio.Task:
+        """Start monitoring the parent process."""
+        if self._task:
+            logger.warning("ParentWatchdog already running.")
+            return self._task
+        loop = loop or asyncio.get_running_loop()
+        self._task = loop.create_task(self._watch_loop())
+        return self._task
+
+    async def stop(self) -> None:
+        """Stop the parent process watchdog."""
+        self._stopping = True
+        if self._task:
+            with suppress(Exception):
+                self._task.cancel()
+                await self._task
+            self._task = None