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

operate/operate_types.py

@@ -0,0 +1,544 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------------------------
+#
+#   Copyright 2023 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.
+#
+# ------------------------------------------------------------------------------
+
+"""Types module."""
+
+import base64
+import copy
+import enum
+import os
+import typing as t
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import argon2
+from aea_ledger_ethereum import cast
+from autonomy.chain.config import ChainType
+from autonomy.chain.constants import CHAIN_NAME_TO_CHAIN_ID
+from cryptography.fernet import Fernet
+from typing_extensions import TypedDict
+
+from operate.constants import FERNET_KEY_LENGTH, NO_STAKING_PROGRAM_ID
+from operate.resource import LocalResource
+
+
+CHAIN_NAME_TO_CHAIN_ID["solana"] = 900
+
+_CHAIN_ID_TO_CHAIN_NAME = {
+    chain_id: chain_name for chain_name, chain_id in CHAIN_NAME_TO_CHAIN_ID.items()
+}
+
+
+class LedgerType(str, enum.Enum):
+    """Ledger type enum."""
+
+    ETHEREUM = "ethereum"
+    SOLANA = "solana"
+
+    @property
+    def config_file(self) -> str:
+        """Config filename."""
+        return f"{self.name.lower()}.json"
+
+    @property
+    def key_file(self) -> str:
+        """Key filename."""
+        return f"{self.name.lower()}.txt"
+
+    @property
+    def mnemonic_file(self) -> str:
+        """Mnemonic filename."""
+        return f"{self.name.lower()}.mnemonic.json"
+
+    @classmethod
+    def from_id(cls, chain_id: int) -> "LedgerType":
+        """Load from chain ID."""
+        return Chain(_CHAIN_ID_TO_CHAIN_NAME[chain_id]).ledger_type
+
+
+# Dynamically create the Chain enum from the ChainType
+# TODO: Migrate this to open-autonomy and remove this modified version of Chain here and use the one from open-autonomy
+# This version of open-autonomy must support the LedgerType to support SOLANA in the future
+# If solana support is not fuly implemented, decide to keep this half-baked feature.
+#
+# TODO: Once the above issue is properly implemented in Open Autonomy, remove the following
+# lines from tox.ini:
+#
+#    exclude = ^(operate/operate_types\.py|scripts/setup_wallet\.py|operate/ledger/profiles\.py|operate/ledger/__init__\.py|operate/wallet/master\.py|operate/services/protocol\.py|operate/services/manage\.py|operate/cli\.py)$
+#
+#    [mypy-operate.*]
+#    follow_imports = skip  # noqa
+#
+# These lines were itroduced to resolve mypy issues with the temporary Chain/ChainType solution.
+Chain = enum.Enum(
+    "Chain",
+    [(member.name, member.value) for member in ChainType]
+    + [
+        ("SOLANA", "solana"),
+    ],
+)
+
+
+class ChainMixin:
+    """Mixin for some new functions in the ChainType class."""
+
+    @property
+    def id(self) -> t.Optional[int]:
+        """Chain ID"""
+        if self == Chain.CUSTOM:
+            chain_id = os.environ.get("CUSTOM_CHAIN_ID")
+            if chain_id is None:
+                return None
+            return int(chain_id)
+        return CHAIN_NAME_TO_CHAIN_ID[self.value]
+
+    @property
+    def ledger_type(self) -> LedgerType:
+        """Ledger type."""
+        if self in (Chain.SOLANA,):
+            return LedgerType.SOLANA
+        return LedgerType.ETHEREUM
+
+    @classmethod
+    def from_string(cls, chain: str) -> "Chain":
+        """Load from string."""
+        return Chain(chain.lower())
+
+    @classmethod
+    def from_id(cls, chain_id: int) -> "Chain":
+        """Load from chain ID."""
+        return Chain(_CHAIN_ID_TO_CHAIN_NAME[chain_id])
+
+
+# Add the ChainMixin methods to the Chain enum
+for name in dir(ChainMixin):
+    if not name.startswith("__"):
+        setattr(Chain, name, getattr(ChainMixin, name))
+
+
+class DeploymentStatus(enum.IntEnum):
+    """Status payload."""
+
+    CREATED = 0
+    BUILT = 1
+    DEPLOYING = 2
+    DEPLOYED = 3
+    STOPPING = 4
+    STOPPED = 5
+    DELETED = 6
+
+
+# TODO defined in aea.chain.base.OnChainState
+class OnChainState(enum.IntEnum):
+    """On-chain state."""
+
+    NON_EXISTENT = 0
+    PRE_REGISTRATION = 1
+    ACTIVE_REGISTRATION = 2
+    FINISHED_REGISTRATION = 3
+    DEPLOYED = 4
+    TERMINATED_BONDED = 5
+    UNBONDED = 6  # TODO this is not an on-chain state https://github.com/valory-xyz/autonolas-registries/blob/main/contracts/ServiceRegistryL2.sol
+
+
+class ContractAddresses(TypedDict):
+    """Contracts templates."""
+
+    service_manager: str
+    service_registry: str
+    service_registry_token_utility: str
+    gnosis_safe_proxy_factory: str
+    gnosis_safe_same_address_multisig: str
+    safe_multisig_with_recovery_module: str
+    recovery_module: str
+    multisend: str
+
+
+@dataclass
+class LedgerConfig(LocalResource):
+    """Ledger config."""
+
+    rpc: str
+    chain: Chain
+
+
+LedgerConfigs = t.Dict[str, LedgerConfig]
+
+
+class DeploymentConfig(TypedDict):
+    """Deployments template."""
+
+    volumes: t.Dict[str, str]
+
+
+class FundRequirementsTemplate(TypedDict):
+    """Fund requirement template."""
+
+    agent: int
+    safe: int
+
+
+class ConfigurationTemplate(TypedDict):
+    """Configuration template."""
+
+    staking_program_id: str
+    nft: str
+    rpc: str
+    agent_id: int
+    cost_of_bond: int
+    fund_requirements: t.Dict[str, FundRequirementsTemplate]
+    fallback_chain_params: t.Optional[t.Dict]
+
+
+class ServiceEnvProvisionType(str, enum.Enum):
+    """Service environment variable provision type."""
+
+    FIXED = "fixed"
+    USER = "user"
+    COMPUTED = "computed"
+
+
+class EnvVariableAttributes(TypedDict):
+    """Service environment variable template."""
+
+    name: str
+    description: str
+    value: str
+    provision_type: ServiceEnvProvisionType
+
+
+class AgentReleaseRepo(TypedDict):
+    """Agent release repo template."""
+
+    owner: str
+    name: str
+    version: str
+
+
+class AgentRelease(TypedDict):
+    """Agent release template."""
+
+    is_aea: bool
+    repository: AgentReleaseRepo
+
+
+ConfigurationTemplates = t.Dict[str, ConfigurationTemplate]
+EnvVariables = t.Dict[str, EnvVariableAttributes]
+
+
+class ServiceTemplate(TypedDict, total=False):
+    """Service template."""
+
+    name: str
+    hash: str
+    image: str
+    description: str
+    service_version: str
+    agent_release: AgentRelease
+    home_chain: str
+    configurations: ConfigurationTemplates
+    env_variables: EnvVariables
+
+
+@dataclass
+class DeployedNodes(LocalResource):
+    """Deployed nodes type."""
+
+    agent: t.List[str]
+    tendermint: t.List[str]
+
+
+@dataclass
+class OnChainFundRequirements(LocalResource):
+    """On-chain fund requirements."""
+
+    agent: float
+    safe: float
+
+
+OnChainTokenRequirements = t.Dict[str, OnChainFundRequirements]
+
+
+@dataclass
+class OnChainUserParams(LocalResource):
+    """On-chain user params."""
+
+    staking_program_id: str
+    nft: str
+    agent_id: int
+    cost_of_bond: int
+    fund_requirements: OnChainTokenRequirements
+
+    @property
+    def use_staking(self) -> bool:
+        """Check if staking is used."""
+        return (
+            self.staking_program_id is not None
+            and self.staking_program_id != NO_STAKING_PROGRAM_ID
+        )
+
+    @classmethod
+    def from_json(cls, obj: t.Dict) -> "OnChainUserParams":
+        """Load a service"""
+        return super().from_json(obj)  # type: ignore
+
+
+@dataclass
+class OnChainData(LocalResource):
+    """On-chain data"""
+
+    instances: t.List[str]  # Agent instances registered as safe owners
+    token: int
+    multisig: str
+    user_params: OnChainUserParams
+
+
+@dataclass
+class ChainConfig(LocalResource):
+    """Chain config."""
+
+    ledger_config: LedgerConfig
+    chain_data: OnChainData
+
+    @classmethod
+    def from_json(cls, obj: t.Dict) -> "ChainConfig":
+        """Load the chain config."""
+        return super().from_json(obj)  # type: ignore
+
+
+ChainConfigs = t.Dict[str, ChainConfig]
+
+
+class FundingConfig(TypedDict):
+    """Funding config."""
+
+    topup: int
+    threshold: int
+
+
+class AssetFundingValues(TypedDict):
+    """Asset Funding values."""
+
+    agent: FundingConfig
+    safe: FundingConfig
+
+
+FundingValues = t.Dict[str, AssetFundingValues]  # str is the asset address
+
+
+@dataclass
+class MechMarketplaceConfig:
+    """Mech Marketplace config."""
+
+    use_mech_marketplace: bool
+    mech_marketplace_address: str
+    priority_mech_address: str
+    priority_mech_service_id: int
+
+
+class Version:
+    """Version class."""
+
+    def __init__(self, version: str) -> None:
+        """Initialize the version."""
+        version = version.strip()
+        version_parts = version.split(".") if version else []
+        self.major = int(version_parts[0]) if len(version_parts) > 0 else 0
+        self.minor = int(version_parts[1]) if len(version_parts) > 1 else 0
+        self.patch = int(version_parts[2]) if len(version_parts) > 2 else 0
+
+    def __str__(self) -> str:
+        """String representation of the version."""
+        return f"{self.major}.{self.minor}.{self.patch}"
+
+    def __eq__(self, other: object) -> bool:
+        """Equality comparison."""
+        if not isinstance(other, Version):
+            return NotImplemented
+        return (
+            self.major == other.major
+            and self.minor == other.minor
+            and self.patch == other.patch
+        )
+
+    def __lt__(self, other: "Version") -> bool:
+        """Less than comparison."""
+        if self.major != other.major:
+            return self.major < other.major
+        if self.minor != other.minor:
+            return self.minor < other.minor
+        return self.patch < other.patch
+
+
+class ChainAmounts(dict[str, dict[str, dict[str, int]]]):
+    """
+    Class that represents chain amounts as a dictionary
+
+    The standard format follows the convention {chain: {address: {token: amount}}}
+    """
+
+    @classmethod
+    def shortfalls(
+        cls, requirements: "ChainAmounts", balances: "ChainAmounts"
+    ) -> "ChainAmounts":
+        """Return the shortfalls between requirements and balances."""
+        result: dict[str, dict[str, dict[str, int]]] = {}
+
+        for chain, addresses in requirements.items():
+            for address, assets in addresses.items():
+                for asset, required_amount in assets.items():
+                    available = balances.get(chain, {}).get(address, {}).get(asset, 0)
+                    shortfall = max(required_amount - available, 0)
+                    result.setdefault(chain, {}).setdefault(address, {})[
+                        asset
+                    ] = shortfall
+
+        return cls(result)
+
+    @classmethod
+    def add(cls, *chainamounts: "ChainAmounts") -> "ChainAmounts":
+        """Add multiple ChainAmounts"""
+        result: dict[str, dict[str, dict[str, int]]] = {}
+
+        for ca in chainamounts:
+            for chain, addresses in ca.items():
+                result_addresses = result.setdefault(chain, {})
+                for address, assets in addresses.items():
+                    result_assets = result_addresses.setdefault(address, {})
+                    for asset, amount in assets.items():
+                        result_assets[asset] = result_assets.get(asset, 0) + amount
+
+        return cls(result)
+
+    def __add__(self, other: "ChainAmounts") -> "ChainAmounts":
+        """Add two ChainAmounts"""
+        return ChainAmounts.add(self, other)
+
+    def __mul__(self, multiplier: float) -> "ChainAmounts":
+        """Multiply all amounts by the specified multiplier"""
+        output = copy.deepcopy(self)
+        for _, addresses in output.items():
+            for _, balances in addresses.items():
+                for asset, amount in balances.items():
+                    balances[asset] = int(amount * multiplier)
+        return output
+
+    def __sub__(self, other: "ChainAmounts") -> "ChainAmounts":
+        """Subtract two ChainAmounts"""
+        return self + (other * -1)
+
+    def __floordiv__(self, divisor: float) -> "ChainAmounts":
+        """Divide all amounts by the specified divisor"""
+        if divisor == 0:
+            raise ValueError("Cannot divide by zero")
+
+        output = copy.deepcopy(self)
+        for _, addresses in output.items():
+            for _, balances in addresses.items():
+                for asset, amount in balances.items():
+                    balances[asset] = int(amount // divisor)
+        return output
+
+    def __lt__(self, other: "ChainAmounts") -> bool:
+        """Return True if all amounts in self are strictly less than the corresponding amounts in other."""
+        for chain, addresses in self.items():
+            for address, assets in addresses.items():
+                for asset, amount in assets.items():
+                    if amount >= other.get(chain, {}).get(address, {}).get(asset, 0):
+                        return False
+        return True
+
+
+@dataclass
+class EncryptedData(LocalResource):
+    """EncryptedData type."""
+
+    path: Path
+    version: int
+    cipher: str
+    cipherparams: t.Dict[str, t.Union[int, str]] = field(repr=False)
+    ciphertext: str = field(repr=False)
+    kdf: str
+    kdfparams: t.Dict[str, t.Union[int, str]] = field(repr=False)
+
+    @classmethod
+    def new(cls, path: Path, password: str, plaintext_bytes: bytes) -> "EncryptedData":
+        """Creates a new EncryptedData"""
+        ph = argon2.PasswordHasher()
+        salt = os.urandom(ph.salt_len)
+        time_cost = ph.time_cost
+        memory_cost = ph.memory_cost
+        parallelism = ph.parallelism
+        hash_len = FERNET_KEY_LENGTH
+        argon2_type = argon2.Type.ID
+        key = argon2.low_level.hash_secret_raw(
+            secret=password.encode(),
+            salt=salt,
+            time_cost=time_cost,
+            memory_cost=memory_cost,
+            parallelism=parallelism,
+            hash_len=hash_len,
+            type=argon2_type,
+        )
+
+        fernet_key = base64.urlsafe_b64encode(key)
+        fernet = Fernet(fernet_key)
+        ciphertext_bytes = fernet.encrypt(plaintext_bytes)
+
+        return cls(
+            path=path,
+            version=1,
+            cipher=f"{fernet.__class__.__module__}.{fernet.__class__.__qualname__}",
+            cipherparams={  # Fernet token (ciphertext variable) already stores them
+                "version": ciphertext_bytes[0]
+            },
+            ciphertext=ciphertext_bytes.hex(),
+            kdf=f"{ph.__class__.__module__}.{ph.__class__.__qualname__}",
+            kdfparams={
+                "salt": salt.hex(),
+                "time_cost": time_cost,
+                "memory_cost": memory_cost,
+                "parallelism": parallelism,
+                "hash_len": hash_len,
+                "type": argon2_type.name,
+            },
+        )
+
+    def decrypt(self, password: str) -> bytes:
+        """Decrypts the EncryptedData"""
+        kdfparams = self.kdfparams
+        key = argon2.low_level.hash_secret_raw(
+            secret=password.encode(),
+            salt=bytes.fromhex(kdfparams["salt"]),
+            time_cost=kdfparams["time_cost"],
+            memory_cost=kdfparams["memory_cost"],
+            parallelism=kdfparams["parallelism"],
+            hash_len=kdfparams["hash_len"],
+            type=argon2.Type[kdfparams["type"]],
+        )
+        fernet_key = base64.urlsafe_b64encode(key)
+        fernet = Fernet(fernet_key)
+        ciphertext_bytes = bytes.fromhex(self.ciphertext)
+        plaintext_bytes = fernet.decrypt(ciphertext_bytes)
+        return plaintext_bytes
+
+    @classmethod
+    def load(cls, path: Path) -> "EncryptedData":
+        """Load EncryptedData."""
+        return cast(EncryptedData, super().load(path))

operate/pearl.py

@@ -18,10 +18,22 @@
 # ------------------------------------------------------------------------------
 
 """File used for pyinstaller to create a single executable file."""
-
 # pylint: disable=all
 # mypy: ignore-errors
 # flake8: noqa
+
+import os
+import sys
+from pathlib import Path
+
+import aea.configurations.validation as validation_module
+
+
+# patch for the _CUR_DIR value
+validation_module._CUR_DIR = Path(sys._MEIPASS) / validation_module._CUR_DIR
+validation_module._SCHEMAS_DIR = os.path.join(validation_module._CUR_DIR, "schemas")
+
+
 from aea.crypto.registries.base import *
 from aea.mail.base_pb2 import DESCRIPTOR
 from aea_ledger_cosmos.cosmos import *  # noqa

operate/quickstart/analyse_logs.py

@@ -0,0 +1,118 @@
+# ------------------------------------------------------------------------------
+#
+#   Copyright 2023-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.
+#
+# ------------------------------------------------------------------------------
+"""Quickstart script to run log analysis."""
+
+
+import json
+import os
+import subprocess  # nosec
+import sys
+from pathlib import Path
+from typing import List, TYPE_CHECKING, Union
+
+from operate.constants import DEPLOYMENT_DIR
+
+
+if TYPE_CHECKING:
+    from operate.cli import OperateApp
+
+
+def find_build_directory(config_file: Path, operate: "OperateApp") -> Path:
+    """Find the appropriate build directory of the configured service."""
+    with open(config_file, "r") as f:
+        config = json.load(f)
+        config_service_hash = config.get("hash")
+
+    services, _ = operate.service_manager().get_all_services()
+    for service in services:
+        if service.hash == config_service_hash:
+            build_dir = service.path / DEPLOYMENT_DIR
+            if not build_dir.exists():
+                print(f"{config.get('name')} not deployed.")
+                sys.exit(1)
+            return build_dir
+
+    print(f"{config.get('name')} not found.")
+    sys.exit(1)
+
+
+def run_analysis(logs_dir: Path, **kwargs: str) -> None:
+    """Run the log analysis command."""
+    command: List[Union[str, Path]] = [
+        "poetry",
+        "run",
+        "autonomy",
+        "analyse",
+        "logs",
+        "--from-dir",
+        logs_dir,
+    ]
+    if "agent" in kwargs and kwargs["agent"]:
+        command.extend(["--agent", kwargs["agent"]])
+    if "reset_db" in kwargs and kwargs["reset_db"]:
+        command.extend(["--reset-db"])
+    if "start_time" in kwargs and kwargs["start_time"]:
+        command.extend(["--start-time", kwargs["start_time"]])
+    if "end_time" in kwargs and kwargs["end_time"]:
+        command.extend(["--end-time", kwargs["end_time"]])
+    if "log_level" in kwargs and kwargs["log_level"]:
+        command.extend(["--log-level", kwargs["log_level"]])
+    if "period" in kwargs and kwargs["period"]:
+        command.extend(["--period", kwargs["period"]])
+    if "round" in kwargs and kwargs["round"]:
+        command.extend(["--round", kwargs["round"]])
+    if "behaviour" in kwargs and kwargs["behaviour"]:
+        command.extend(["--behaviour", kwargs["behaviour"]])
+    if "fsm" in kwargs and kwargs["fsm"]:
+        command.extend(["--fsm"])
+    if "include_regex" in kwargs and kwargs["include_regex"]:
+        command.extend(["--include-regex", kwargs["include_regex"]])
+    if "exclude_regex" in kwargs and kwargs["exclude_regex"]:
+        command.extend(["--exclude-regex", kwargs["exclude_regex"]])
+
+    try:
+        subprocess.run(command, check=True)  # nosec
+        print("Analysis completed successfully.")
+    except subprocess.CalledProcessError as e:
+        print(f"Command failed with exit code {e.returncode}")
+        sys.exit(e.returncode)
+    except FileNotFoundError:
+        print("Poetry or autonomy not found. Ensure they are installed and accessible.")
+        sys.exit(1)
+
+
+def analyse_logs(
+    operate: "OperateApp",
+    config_path: str,
+    **kwargs: str,
+) -> None:
+    """Run the log analysis command."""
+    config_file = Path(config_path)
+    if not config_file.exists():
+        print(f"Config file '{config_file}' not found.")
+        sys.exit(1)
+
+    # Auto-detect the logs directory
+    build_dir = find_build_directory(config_file, operate)
+    logs_dir = build_dir / "persistent_data" / "logs"
+    if not os.path.exists(logs_dir):
+        print(f"Logs directory '{logs_dir}' not found.")
+        sys.exit(1)
+
+    # Run the analysis
+    run_analysis(logs_dir, **kwargs)