olas-operate-middleware 0.1.0rc59__py3-none-any.whl → 0.13.2__py3-none-any.whl

operate/quickstart/stop_service.py

@@ -0,0 +1,72 @@
+# -*- 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.
+#
+# ------------------------------------------------------------------------------
+"""Quickstop script."""
+
+import json
+import warnings
+from typing import TYPE_CHECKING, cast
+
+from operate.quickstart.run_service import (
+    ask_password_if_needed,
+    configure_local_config,
+    get_service,
+    load_local_config,
+)
+from operate.quickstart.utils import print_section, print_title
+
+
+if TYPE_CHECKING:
+    from operate.cli import OperateApp
+
+warnings.filterwarnings("ignore", category=UserWarning)
+
+
+def stop_service(
+    operate: "OperateApp", config_path: str, use_binary: bool = False
+) -> None:
+    """Stop service."""
+
+    with open(config_path, "r") as config_file:
+        template = json.load(config_file)
+
+    print_title(f"Stop {template['name']} Quickstart")
+
+    # check if agent was started before
+    config = load_local_config(
+        operate=operate, service_name=cast(str, template["name"])
+    )
+    if not config.path.exists():
+        print("No previous agent setup found. Exiting.")
+        return
+
+    ask_password_if_needed(operate)
+    configure_local_config(template, operate)
+    manager = operate.service_manager()
+    service = get_service(manager, template)
+    if use_binary:
+        use_docker = False
+    else:
+        use_docker = True
+
+    manager.stop_service_locally(
+        service_config_id=service.service_config_id, use_docker=use_docker, force=True
+    )
+
+    print()
+    print_section(f"{template['name']} service stopped")

operate/quickstart/terminate_on_chain_service.py

@@ -0,0 +1,83 @@
+# ------------------------------------------------------------------------------
+#
+#   Copyright 2023-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.
+#
+# ------------------------------------------------------------------------------
+"""Terminate on-chain service."""
+
+import json
+from typing import TYPE_CHECKING, cast
+
+from operate.operate_types import OnChainState
+from operate.quickstart.run_service import (
+    ask_password_if_needed,
+    configure_local_config,
+    ensure_enough_funds,
+    get_service,
+    load_local_config,
+)
+from operate.quickstart.utils import ask_yes_or_no, print_section, print_title
+
+
+if TYPE_CHECKING:
+    from operate.cli import OperateApp
+
+
+def terminate_service(operate: "OperateApp", config_path: str) -> None:
+    """Terminate service."""
+
+    with open(config_path, "r") as config_file:
+        template = json.load(config_file)
+
+    print_title(f"Terminate {template['name']} on-chain service")
+
+    # check if agent was started before
+    config = load_local_config(
+        operate=operate, service_name=cast(str, template["name"])
+    )
+    if not config.path.exists():
+        print("No previous agent setup found. Exiting.")
+        return
+
+    if not ask_yes_or_no(
+        "Please, ensure that your service is stopped (./stop_service.sh) before proceeding. "
+        "Do you want to continue?"
+    ):
+        print("Cancelled.")
+        return
+
+    ask_password_if_needed(operate)
+    config = configure_local_config(template, operate)
+    manager = operate.service_manager()
+    service = get_service(manager, template)
+    ensure_enough_funds(operate, service)
+    manager.terminate_service_on_chain_from_safe(
+        service_config_id=service.service_config_id,
+        chain=config.principal_chain,
+    )
+
+    if (
+        manager._get_on_chain_state(service, config.principal_chain)
+        == OnChainState.PRE_REGISTRATION
+    ):
+        service_id = service.chain_configs[config.principal_chain].chain_data.token
+        print(
+            f"\nService {service_id} is now terminated and unbonded (i.e., it is on PRE-REGISTRATION state)."
+            f"You can check this on https://registry.olas.network/{config.principal_chain}/services/{service_id}."
+            "In order to deploy your on-chain service again, please run the service again'."
+        )
+
+    print()
+    print_section(f"{template['name']} service terminated")

operate/quickstart/utils.py

@@ -0,0 +1,298 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------------------------
+#
+#   Copyright 2023-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.
+#
+# ------------------------------------------------------------------------------
+"""Common utilities."""
+
+
+import getpass
+import os
+from dataclasses import dataclass
+from decimal import Decimal, ROUND_UP
+from pathlib import Path
+from typing import Dict, Optional, Union, get_args, get_origin
+
+import requests
+from halo import Halo  # type: ignore[import]  # pylint: disable=import-error
+
+from operate.constants import ZERO_ADDRESS
+from operate.ledger.profiles import OLAS, USDC
+from operate.operate_types import Chain
+from operate.resource import LocalResource, deserialize
+
+
+def print_box(text: str, margin: int = 1, character: str = "=") -> None:
+    """Print text centered within a box."""
+
+    lines = text.split("\n")
+    text_length = max(len(line) for line in lines)
+    length = text_length + 2 * margin
+
+    border = character * length
+    margin_str = " " * margin
+
+    print()
+    print(border)
+    print(f"{margin_str}{text}{margin_str}")
+    print(border)
+    print()
+
+
+def print_title(text: str) -> None:
+    """Print title."""
+    print_box(text, 4, "=")
+
+
+def print_section(text: str) -> None:
+    """Print section."""
+    print_box(text, 1, "-")
+
+
+def unit_to_wei(unit: float) -> int:
+    """Convert unit to Wei."""
+    return int(unit * 1e18)
+
+
+CHAIN_TO_METADATA = {
+    "gnosis": {
+        "name": "Gnosis",
+        "gasFundReq": unit_to_wei(0.5),  # fund for master EOA
+        "staking_bonding_token": OLAS[Chain.GNOSIS],
+        "token_data": {
+            ZERO_ADDRESS: {
+                "symbol": "xDAI",
+                "decimals": 18,
+            },
+            USDC[Chain.GNOSIS]: {
+                "symbol": "USDC",
+                "decimals": 6,
+            },
+            OLAS[Chain.GNOSIS]: {
+                "symbol": "OLAS",
+                "decimals": 18,
+            },
+        },
+        "gasParams": {
+            # this means default values will be used
+            "MAX_PRIORITY_FEE_PER_GAS": "",
+            "MAX_FEE_PER_GAS": "",
+        },
+    },
+    "mode": {
+        "name": "Mode",
+        "gasFundReq": unit_to_wei(0.005),  # fund for master EOA
+        "staking_bonding_token": OLAS[Chain.MODE],
+        "token_data": {
+            ZERO_ADDRESS: {
+                "symbol": "ETH",
+                "decimals": 18,
+            },
+            USDC[Chain.MODE]: {
+                "symbol": "USDC",
+                "decimals": 6,
+            },
+            OLAS[Chain.MODE]: {
+                "symbol": "OLAS",
+                "decimals": 18,
+            },
+        },
+        "gasParams": {
+            # this means default values will be used
+            "MAX_PRIORITY_FEE_PER_GAS": "",
+            "MAX_FEE_PER_GAS": "",
+        },
+    },
+    "optimism": {
+        "name": "Optimism",
+        "gasFundReq": unit_to_wei(0.005),  # fund for master EOA
+        "staking_bonding_token": OLAS[Chain.OPTIMISM],
+        "token_data": {
+            ZERO_ADDRESS: {
+                "symbol": "ETH",
+                "decimals": 18,
+            },
+            USDC[Chain.OPTIMISM]: {
+                "symbol": "USDC",
+                "decimals": 6,
+            },
+            OLAS[Chain.OPTIMISM]: {
+                "symbol": "OLAS",
+                "decimals": 18,
+            },
+        },
+        "gasParams": {
+            # this means default values will be used
+            "MAX_PRIORITY_FEE_PER_GAS": "",
+            "MAX_FEE_PER_GAS": "",
+        },
+    },
+    "base": {
+        "name": "Base",
+        "gasFundReq": unit_to_wei(0.005),  # fund for master EOA
+        "staking_bonding_token": OLAS[Chain.BASE],
+        "token_data": {
+            ZERO_ADDRESS: {
+                "symbol": "ETH",
+                "decimals": 18,
+            },
+            USDC[Chain.BASE]: {
+                "symbol": "USDC",
+                "decimals": 6,
+            },
+            OLAS[Chain.BASE]: {
+                "symbol": "OLAS",
+                "decimals": 18,
+            },
+        },
+        "gasParams": {
+            # this means default values will be used
+            "MAX_PRIORITY_FEE_PER_GAS": "",
+            "MAX_FEE_PER_GAS": "",
+        },
+    },
+}
+
+
+def wei_to_unit(wei: int, chain: str, token_address: str = ZERO_ADDRESS) -> Decimal:
+    """Convert Wei to unit."""
+    unit: Decimal = (
+        Decimal(str(wei))
+        / 10 ** CHAIN_TO_METADATA[chain]["token_data"][token_address]["decimals"]
+    )
+    return unit.quantize(Decimal("0.000001"), rounding=ROUND_UP)
+
+
+def wei_to_token(wei: int, chain: str, token_address: str = ZERO_ADDRESS) -> str:
+    """Convert Wei to token."""
+    return f"{wei_to_unit(wei, chain, token_address)} {CHAIN_TO_METADATA[chain]['token_data'][token_address]['symbol']}"
+
+
+def ask_yes_or_no(question: str) -> bool:
+    """Ask a yes/no question."""
+    if os.environ.get("ATTENDED", "true").lower() != "true":
+        return True
+    while True:
+        response = input(f"{question} (yes/no): ").strip().lower()
+        if response.lower() in ("yes", "y"):
+            return True
+        if response.lower() in ("no", "n"):
+            return False
+
+
+def ask_or_get_from_env(
+    prompt: str, is_pass: bool, env_var_name: str, raise_if_missing: bool = True
+) -> str:
+    """Get user input either interactively or from environment variables."""
+    if os.getenv("ATTENDED", "true").lower() == "true":
+        if is_pass:
+            return getpass.getpass(prompt).strip()
+        return input(prompt).strip()
+    if env_var_name in os.environ:
+        return os.environ[env_var_name].strip()
+    if raise_if_missing:
+        raise ValueError(f"{env_var_name} env var required in unattended mode")
+    return ""
+
+
+def check_rpc(chain: str, rpc_url: Optional[str] = None) -> bool:
+    """Check RPC."""
+    if rpc_url is None:
+        return False
+
+    spinner = Halo(text=f"[{chain}] Checking RPC...", spinner="dots")
+    spinner.start()
+
+    rpc_data = {
+        "jsonrpc": "2.0",
+        "method": "eth_newFilter",
+        "params": ["invalid"],
+        "id": 1,
+    }
+
+    try:
+        response = requests.post(
+            rpc_url, json=rpc_data, headers={"Content-Type": "application/json"}
+        )
+        response.raise_for_status()
+        rpc_response = response.json()
+    except (requests.exceptions.RequestException, ValueError, TypeError) as e:
+        spinner.fail(f"Error: Failed to send {chain} RPC request: {e}")
+        return False
+
+    rpc_error_message = (
+        rpc_response.get("error", {})
+        .get("message", "exception processing rpc response")
+        .lower()
+    )
+
+    if rpc_error_message == "exception processing rpc response":
+        print(
+            "Error: The received rpc response is malformed. Please verify the RPC address and/or rpc behavior."
+        )
+        print("  Received response:")
+        print("  ", rpc_response)
+        print("")
+        spinner.fail(f"[{chain}] Terminating script.")
+    elif rpc_error_message == "out of requests":
+        print("Error: The provided rpc is out of requests.")
+        spinner.fail(f"[{chain}] Terminating script.")
+    elif (
+        rpc_error_message == "the method eth_newfilter does not exist/is not available"
+    ):
+        print("Error: The provided RPC does not support 'eth_newFilter'.")
+        spinner.fail(f"[{chain}] Terminating script.")
+    elif "invalid" in rpc_error_message or "params" in rpc_error_message:
+        spinner.succeed(f"[{chain}] RPC checks passed.")
+        return True
+    else:
+        print("Error: Unknown rpc error.")
+        print("  Received response:")
+        print("  ", rpc_response)
+        print("")
+        spinner.fail(f"[{chain}] Terminating script.")
+
+    return False
+
+
+@dataclass
+class QuickstartConfig(LocalResource):
+    """Local configuration."""
+
+    path: Path
+    rpc: Optional[Dict[str, str]] = None
+    staking_program_id: Optional[str] = None
+    principal_chain: Optional[str] = None
+    user_provided_args: Optional[Dict[str, str]] = None
+
+    @classmethod
+    def from_json(cls, obj: Dict) -> "LocalResource":
+        """Load LocalResource from json."""
+        kwargs = {}
+        for pname, ptype in cls.__annotations__.items():
+            if pname.startswith("_"):
+                continue
+
+            # allow for optional types
+            is_optional_type = get_origin(ptype) is Union and type(None) in get_args(
+                ptype
+            )
+            value = obj.get(pname, None)
+            if is_optional_type and value is None:
+                continue
+
+            kwargs[pname] = deserialize(obj=obj[pname], otype=ptype)
+        return cls(**kwargs)

operate/resource.py

@@ -21,31 +21,56 @@
 
 import enum
 import json
+import os
+import platform
+import shutil
+import types
 import typing as t
 from dataclasses import asdict, is_dataclass
 from pathlib import Path
 
+from operate.utils import safe_file_operation
+
 
 # pylint: disable=too-many-return-statements,no-member
 
 
+N_BACKUPS = 5
+
+
 def serialize(obj: t.Any) -> t.Any:
     """Serialize object."""
     if is_dataclass(obj):
-        return asdict(obj)
+        return serialize(asdict(obj))
     if isinstance(obj, Path):
         return str(obj)
     if isinstance(obj, dict):
-        return {key: serialize(obj=value) for key, value in obj.items()}
+        return {serialize(key): serialize(obj=value) for key, value in obj.items()}
     if isinstance(obj, list):
         return [serialize(obj=value) for value in obj]
     if isinstance(obj, enum.Enum):
         return obj.value
+    if isinstance(obj, bytes):
+        return obj.hex()
     return obj
 
 
 def deserialize(obj: t.Any, otype: t.Any) -> t.Any:
     """Desrialize a json object."""
+
+    origin = getattr(otype, "__origin__", None)
+
+    # Handle Union and Optional
+    if origin is t.Union or isinstance(otype, types.UnionType):
+        for arg in t.get_args(otype):
+            if arg is type(None):  # noqa: E721
+                continue
+            try:
+                return deserialize(obj, arg)
+            except Exception:  # pylint: disable=broad-except  # nosec
+                continue
+        return None
+
     base = getattr(otype, "__class__")  # noqa: B009
     if base.__name__ == "_GenericAlias":  # type: ignore
         args = otype.__args__  # type: ignore
@@ -65,6 +90,8 @@ def deserialize(obj: t.Any, otype: t.Any) -> t.Any:
         return Path(obj)
     if is_dataclass(otype):
         return otype.from_json(obj)
+    if otype is bytes:
+        return bytes.fromhex(obj)
     return obj
 
 
@@ -117,10 +144,42 @@ class LocalResource:
         if self._file is not None:
             path = path / self._file
 
-        path.write_text(
+        bak0 = path.with_name(f"{path.name}.0.bak")
+
+        if path.exists() and not bak0.exists():
+            safe_file_operation(shutil.copy2, path, bak0)
+
+        tmp_path = path.parent / f".{path.name}.tmp"
+
+        # Clean up any existing tmp file
+        if tmp_path.exists():
+            safe_file_operation(tmp_path.unlink)
+
+        tmp_path.write_text(
             json.dumps(
                 self.json,
                 indent=2,
             ),
             encoding="utf-8",
         )
+
+        # Atomic replace to avoid corruption
+        try:
+            safe_file_operation(os.replace, tmp_path, path)
+        except (PermissionError, FileNotFoundError):
+            # On Windows, if the replace fails, clean up and skip
+            if platform.system() == "Windows":
+                safe_file_operation(tmp_path.unlink)
+
+        self.load(self.path)  # Validate before making backup
+
+        # Rotate backup files
+        for i in reversed(range(N_BACKUPS - 1)):
+            newer = path.with_name(f"{path.name}.{i}.bak")
+            older = path.with_name(f"{path.name}.{i + 1}.bak")
+            if newer.exists():
+                if older.exists():
+                    safe_file_operation(older.unlink)
+                safe_file_operation(newer.rename, older)
+
+        safe_file_operation(shutil.copy2, path, bak0)