genlayer-test 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

gltest/contracts/contract.py

@@ -0,0 +1,205 @@
+import types
+from eth_account.signers.local import LocalAccount
+from dataclasses import dataclass
+from gltest.clients import get_gl_client
+from gltest.types import (
+    CalldataEncodable,
+    GenLayerTransaction,
+    TransactionStatus,
+    TransactionHashVariant,
+)
+from typing import List, Any, Optional, Dict, Callable
+from gltest_cli.config.general import get_general_config
+from .contract_functions import ContractFunction
+from .stats_collector import StatsCollector, SimulationConfig
+
+
+def read_contract_wrapper(
+    self,
+    method_name: str,
+    args: Optional[List[CalldataEncodable]] = None,
+) -> Any:
+    """
+    Wrapper to the contract read method.
+    """
+
+    def call_method(
+        transaction_hash_variant: TransactionHashVariant = TransactionHashVariant.LATEST_NONFINAL,
+    ):
+        client = get_gl_client()
+        return client.read_contract(
+            address=self.address,
+            function_name=method_name,
+            account=self.account,
+            args=args,
+            transaction_hash_variant=transaction_hash_variant,
+        )
+
+    return ContractFunction(
+        method_name=method_name,
+        read_only=True,
+        call_method=call_method,
+    )
+
+
+def write_contract_wrapper(
+    self,
+    method_name: str,
+    args: Optional[List[CalldataEncodable]] = None,
+) -> GenLayerTransaction:
+    """
+    Wrapper to the contract write method.
+    """
+
+    def transact_method(
+        value: int = 0,
+        consensus_max_rotations: Optional[int] = None,
+        wait_transaction_status: TransactionStatus = TransactionStatus.ACCEPTED,
+        wait_interval: Optional[int] = None,
+        wait_retries: Optional[int] = None,
+        wait_triggered_transactions: bool = False,
+        wait_triggered_transactions_status: TransactionStatus = TransactionStatus.ACCEPTED,
+    ):
+        """
+        Transact the contract method.
+        """
+        general_config = get_general_config()
+        actual_wait_interval = (
+            wait_interval
+            if wait_interval is not None
+            else general_config.get_default_wait_interval()
+        )
+        actual_wait_retries = (
+            wait_retries
+            if wait_retries is not None
+            else general_config.get_default_wait_retries()
+        )
+        leader_only = (
+            general_config.get_leader_only()
+            if general_config.check_studio_based_rpc()
+            else False
+        )
+        client = get_gl_client()
+        tx_hash = client.write_contract(
+            address=self.address,
+            function_name=method_name,
+            account=self.account,
+            value=value,
+            consensus_max_rotations=consensus_max_rotations,
+            leader_only=leader_only,
+            args=args,
+        )
+        receipt = client.wait_for_transaction_receipt(
+            transaction_hash=tx_hash,
+            status=wait_transaction_status,
+            interval=actual_wait_interval,
+            retries=actual_wait_retries,
+        )
+        if wait_triggered_transactions:
+            triggered_transactions = receipt["triggered_transactions"]
+            for triggered_transaction in triggered_transactions:
+                client.wait_for_transaction_receipt(
+                    transaction_hash=triggered_transaction,
+                    status=wait_triggered_transactions_status,
+                    interval=actual_wait_interval,
+                    retries=actual_wait_retries,
+                )
+        return receipt
+
+    def analyze_method(
+        provider: str,
+        model: str,
+        config: Optional[Dict[str, Any]] = None,
+        plugin: Optional[str] = None,
+        plugin_config: Optional[Dict[str, Any]] = None,
+        runs: int = 100,
+    ):
+        """
+        Analyze the contract method using StatsCollector.
+        """
+        collector = StatsCollector(
+            contract_address=self.address,
+            method_name=method_name,
+            account=self.account,
+            args=args,
+        )
+        sim_config = SimulationConfig(
+            provider=provider,
+            model=model,
+            config=config,
+            plugin=plugin,
+            plugin_config=plugin_config,
+        )
+        sim_results = collector.run_simulations(sim_config, runs)
+        return collector.analyze_results(sim_results, runs, sim_config)
+
+    return ContractFunction(
+        method_name=method_name,
+        read_only=False,
+        transact_method=transact_method,
+        analyze_method=analyze_method,
+    )
+
+
+def contract_function_factory(method_name: str, read_only: bool) -> Callable:
+    """
+    Create a function that interacts with a specific contract method.
+    """
+    if read_only:
+        return lambda self, args=None: read_contract_wrapper(self, method_name, args)
+    return lambda self, args=None: write_contract_wrapper(self, method_name, args)
+
+
+@dataclass
+class Contract:
+    """
+    Class to interact with a contract, its methods
+    are implemented dynamically at build time.
+    """
+
+    address: str
+    account: Optional[LocalAccount] = None
+    _schema: Optional[Dict[str, Any]] = None
+
+    @classmethod
+    def new(
+        cls,
+        address: str,
+        schema: Dict[str, Any],
+        account: Optional[LocalAccount] = None,
+    ) -> "Contract":
+        """
+        Build the methods from the schema.
+        """
+        if not isinstance(schema, dict) or "methods" not in schema:
+            raise ValueError("Invalid schema: must contain 'methods' field")
+        instance = cls(address=address, _schema=schema, account=account)
+        instance._build_methods_from_schema()
+        return instance
+
+    def _build_methods_from_schema(self):
+        """
+        Build the methods from the schema.
+        """
+        if self._schema is None:
+            raise ValueError("No schema provided")
+        for method_name, method_info in self._schema["methods"].items():
+            if not isinstance(method_info, dict) or "readonly" not in method_info:
+                raise ValueError(
+                    f"Invalid method info for '{method_name}': must contain 'readonly' field"
+                )
+            method_func = contract_function_factory(
+                method_name, method_info["readonly"]
+            )
+            bound_method = types.MethodType(method_func, self)
+            setattr(self, method_name, bound_method)
+
+    def connect(self, account: LocalAccount) -> "Contract":
+        """
+        Create a new instance of the contract with the same methods and a different account.
+        """
+        new_contract = self.__class__(
+            address=self.address, account=account, _schema=self._schema
+        )
+        new_contract._build_methods_from_schema()
+        return new_contract

gltest/{glchain/contract.py → contracts/contract_factory.py}

@@ -1,145 +1,26 @@
+from dataclasses import dataclass
+from typing import Type, Union, Optional, List, Any
+from pathlib import Path
 from eth_typing import (
     Address,
     ChecksumAddress,
 )
 from eth_account.signers.local import LocalAccount
-from typing import Union
-from pathlib import Path
-from dataclasses import dataclass
 from gltest.artifacts import (
     find_contract_definition_from_name,
     find_contract_definition_from_path,
 )
+from gltest.clients import (
+    get_gl_client,
+    get_gl_hosted_studio_client,
+    get_local_client,
+)
+from .contract import Contract
+from gltest.logging import logger
+from gltest.types import TransactionStatus
 from gltest.assertions import tx_execution_failed
 from gltest.exceptions import DeploymentError
-from .client import get_gl_client, get_gl_hosted_studio_client, get_local_client
-from gltest.types import CalldataEncodable, GenLayerTransaction, TransactionStatus
-from typing import List, Any, Type, Optional, Dict, Callable
-import types
 from gltest_cli.config.general import get_general_config
-from gltest.logging import logger
-
-
-@dataclass
-class Contract:
-    """
-    Class to interact with a contract, its methods
-    are implemented dynamically at build time.
-    """
-
-    address: str
-    account: Optional[LocalAccount] = None
-    _schema: Optional[Dict[str, Any]] = None
-
-    @classmethod
-    def new(
-        cls,
-        address: str,
-        schema: Dict[str, Any],
-        account: Optional[LocalAccount] = None,
-    ) -> "Contract":
-        """
-        Build the methods from the schema.
-        """
-        if not isinstance(schema, dict) or "methods" not in schema:
-            raise ValueError("Invalid schema: must contain 'methods' field")
-        instance = cls(address=address, _schema=schema, account=account)
-        instance._build_methods_from_schema()
-        return instance
-
-    def _build_methods_from_schema(self):
-        if self._schema is None:
-            raise ValueError("No schema provided")
-        for method_name, method_info in self._schema["methods"].items():
-            if not isinstance(method_info, dict) or "readonly" not in method_info:
-                raise ValueError(
-                    f"Invalid method info for '{method_name}': must contain 'readonly' field"
-                )
-            method_func = self.contract_method_factory(
-                method_name, method_info["readonly"]
-            )
-            bound_method = types.MethodType(method_func, self)
-            setattr(self, method_name, bound_method)
-
-    def connect(self, account: LocalAccount) -> "Contract":
-        """
-        Create a new instance of the contract with the same methods and a different account.
-        """
-        new_contract = self.__class__(
-            address=self.address, account=account, _schema=self._schema
-        )
-        new_contract._build_methods_from_schema()
-        return new_contract
-
-    @staticmethod
-    def contract_method_factory(method_name: str, read_only: bool) -> Callable:
-        """
-        Create a function that interacts with a specific contract method.
-        """
-
-        def read_contract_wrapper(
-            self,
-            args: Optional[List[CalldataEncodable]] = None,
-        ) -> Any:
-            """
-            Wrapper to the contract read method.
-            """
-            client = get_gl_client()
-            return client.read_contract(
-                address=self.address,
-                function_name=method_name,
-                account=self.account,
-                args=args,
-            )
-
-        def write_contract_wrapper(
-            self,
-            args: Optional[List[CalldataEncodable]] = None,
-            value: int = 0,
-            consensus_max_rotations: Optional[int] = None,
-            leader_only: bool = False,
-            wait_transaction_status: TransactionStatus = TransactionStatus.FINALIZED,
-            wait_interval: Optional[int] = None,
-            wait_retries: Optional[int] = None,
-            wait_triggered_transactions: bool = True,
-            wait_triggered_transactions_status: TransactionStatus = TransactionStatus.FINALIZED,
-        ) -> GenLayerTransaction:
-            """
-            Wrapper to the contract write method.
-            """
-            general_config = get_general_config()
-            if wait_interval is None:
-                wait_interval = general_config.get_default_wait_interval()
-            if wait_retries is None:
-                wait_retries = general_config.get_default_wait_retries()
-            client = get_gl_client()
-            tx_hash = client.write_contract(
-                address=self.address,
-                function_name=method_name,
-                account=self.account,
-                value=value,
-                consensus_max_rotations=consensus_max_rotations,
-                leader_only=leader_only,
-                args=args,
-            )
-            receipt = client.wait_for_transaction_receipt(
-                transaction_hash=tx_hash,
-                status=wait_transaction_status,
-                interval=wait_interval,
-                retries=wait_retries,
-            )
-            if wait_triggered_transactions:
-                triggered_transactions = receipt["triggered_transactions"]
-                for triggered_transaction in triggered_transactions:
-                    client.wait_for_transaction_receipt(
-                        transaction_hash=triggered_transaction,
-                        status=wait_triggered_transactions_status,
-                        interval=wait_interval,
-                        retries=wait_retries,
-                    )
-            return receipt
-
-        return read_contract_wrapper if read_only else write_contract_wrapper
 
 
 @dataclass
@@ -184,17 +65,17 @@ class ContractFactory:
         """Attempts to get the contract schema using multiple clients in a fallback pattern.
 
         This method tries to get the contract schema in the following order:
-        1. Hosted studio client
-        2. Local client
-        3. Regular client
+        1. Default client
+        2. Hosted studio client
+        3. Local client
 
         Returns:
             Optional[Dict[str, Any]]: The contract schema if successful, None if all attempts fail.
         """
         clients = (
+            ("default", get_gl_client()),
             ("hosted studio", get_gl_hosted_studio_client()),
             ("local", get_local_client()),
-            ("default", get_gl_client()),
         )
         for label, client in clients:
             try:
@@ -216,7 +97,7 @@ class ContractFactory:
         schema = self._get_schema_with_fallback()
         if schema is None:
             raise ValueError(
-                "Failed to get schema from all clients (hosted studio, local, and regular)"
+                "Failed to get schema from all clients (default, hosted studio, and local)"
             )
 
         return Contract.new(address=contract_address, schema=schema, account=account)
@@ -226,19 +107,31 @@ class ContractFactory:
         args: List[Any] = [],
         account: Optional[LocalAccount] = None,
         consensus_max_rotations: Optional[int] = None,
-        leader_only: bool = False,
         wait_interval: Optional[int] = None,
         wait_retries: Optional[int] = None,
-        wait_transaction_status: TransactionStatus = TransactionStatus.FINALIZED,
+        wait_transaction_status: TransactionStatus = TransactionStatus.ACCEPTED,
+        wait_triggered_transactions: bool = False,
+        wait_triggered_transactions_status: TransactionStatus = TransactionStatus.ACCEPTED,
     ) -> Contract:
         """
         Deploy the contract
         """
         general_config = get_general_config()
-        if wait_interval is None:
-            wait_interval = general_config.get_default_wait_interval()
-        if wait_retries is None:
-            wait_retries = general_config.get_default_wait_retries()
+        actual_wait_interval = (
+            wait_interval
+            if wait_interval is not None
+            else general_config.get_default_wait_interval()
+        )
+        actual_wait_retries = (
+            wait_retries
+            if wait_retries is not None
+            else general_config.get_default_wait_retries()
+        )
+        leader_only = (
+            general_config.get_leader_only()
+            if general_config.check_studio_based_rpc()
+            else False
+        )
 
         client = get_gl_client()
         try:
@@ -252,14 +145,24 @@ class ContractFactory:
             tx_receipt = client.wait_for_transaction_receipt(
                 transaction_hash=tx_hash,
                 status=wait_transaction_status,
-                interval=wait_interval,
-                retries=wait_retries,
+                interval=actual_wait_interval,
+                retries=actual_wait_retries,
             )
             if tx_execution_failed(tx_receipt):
                 raise ValueError(
                     f"Deployment transaction finalized with error: {tx_receipt}"
                 )
 
+            if wait_triggered_transactions:
+                triggered_transactions = tx_receipt["triggered_transactions"]
+                for triggered_transaction in triggered_transactions:
+                    client.wait_for_transaction_receipt(
+                        transaction_hash=triggered_transaction,
+                        status=wait_triggered_transactions_status,
+                        interval=actual_wait_interval,
+                        retries=actual_wait_retries,
+                    )
+
             if (
                 "tx_data_decoded" in tx_receipt
                 and "contract_address" in tx_receipt["tx_data_decoded"]
@@ -273,7 +176,7 @@ class ContractFactory:
             schema = self._get_schema_with_fallback()
             if schema is None:
                 raise ValueError(
-                    "Failed to get schema from all clients (hosted studio, local, and regular)"
+                    "Failed to get schema from all clients (default, hosted studio, and local)"
                 )
 
             return Contract.new(

gltest/contracts/contract_functions.py

@@ -0,0 +1,62 @@
+from dataclasses import dataclass
+from typing import Callable, Optional, Dict, Any
+from gltest.types import TransactionStatus, TransactionHashVariant
+
+
+@dataclass
+class ContractFunction:
+    method_name: str
+    read_only: bool
+    call_method: Optional[Callable] = None
+    analyze_method: Optional[Callable] = None
+    transact_method: Optional[Callable] = None
+
+    def call(
+        self,
+        transaction_hash_variant: TransactionHashVariant = TransactionHashVariant.LATEST_NONFINAL,
+    ):
+        if not self.read_only:
+            raise ValueError("call() not implemented for non-readonly method")
+        return self.call_method(transaction_hash_variant=transaction_hash_variant)
+
+    def transact(
+        self,
+        value: int = 0,
+        consensus_max_rotations: Optional[int] = None,
+        wait_transaction_status: TransactionStatus = TransactionStatus.ACCEPTED,
+        wait_interval: Optional[int] = None,
+        wait_retries: Optional[int] = None,
+        wait_triggered_transactions: bool = False,
+        wait_triggered_transactions_status: TransactionStatus = TransactionStatus.ACCEPTED,
+    ):
+        if self.read_only:
+            raise ValueError("Cannot transact read-only method")
+        return self.transact_method(
+            value=value,
+            consensus_max_rotations=consensus_max_rotations,
+            wait_transaction_status=wait_transaction_status,
+            wait_interval=wait_interval,
+            wait_retries=wait_retries,
+            wait_triggered_transactions=wait_triggered_transactions,
+            wait_triggered_transactions_status=wait_triggered_transactions_status,
+        )
+
+    def analyze(
+        self,
+        provider: str,
+        model: str,
+        config: Optional[Dict[str, Any]] = None,
+        plugin: Optional[str] = None,
+        plugin_config: Optional[Dict[str, Any]] = None,
+        runs: int = 100,
+    ):
+        if self.read_only:
+            raise ValueError("Cannot analyze read-only method")
+        return self.analyze_method(
+            provider=provider,
+            model=model,
+            config=config,
+            plugin=plugin,
+            plugin_config=plugin_config,
+            runs=runs,
+        )

gltest/contracts/method_stats.py

@@ -0,0 +1,163 @@
+from dataclasses import dataclass
+from typing import List, Any, Optional, Dict
+import json
+from pathlib import Path
+from .utils import safe_filename
+
+
+@dataclass
+class MethodStatsSummary:
+    """Statistical analysis results for a contract method execution."""
+
+    method: str
+    args: List[Any]
+    total_runs: int
+    executed_runs: int
+    server_error_runs: int
+    failed_runs: int
+    successful_runs: int
+    unique_states: int
+    most_common_state_count: int
+    reliability_score: float
+    execution_time: float
+    provider: str
+    model: str
+
+    @property
+    def success_rate(self) -> float:
+        """Calculate success rate as percentage."""
+        if self.total_runs == 0:
+            return 0.0
+        return (self.successful_runs / self.total_runs) * 100
+
+    def __str__(self) -> str:
+        """Format the statistical analysis results."""
+        return f"""Method analysis summary
+---------------------------
+Method: {self.method}
+Args: {self.args}
+Provider: {self.provider}
+Model: {self.model}
+Total runs: {self.total_runs}
+Server error runs: {self.server_error_runs}
+Method executed runs: {self.executed_runs}
+Method successful runs: {self.successful_runs}
+Method failed runs: {self.failed_runs}
+Unique states: {self.unique_states}
+Reliability score: {self.reliability_score:.2f}% ({self.most_common_state_count}/{self.executed_runs} consistent)
+Execution time: {self.execution_time:.1f}s"""
+
+
+@dataclass
+class StateGroup:
+    """Represents a group of runs with the same contract state."""
+
+    count: int
+    state_hash: str
+
+
+@dataclass
+class FailedRun:
+    """Represents a failed run with error details."""
+
+    run: int
+    error: str
+    error_type: str  # "server" or "simulation"
+    genvm_result: Optional[Dict[str, str]]
+
+
+@dataclass
+class MethodStatsDetailed:
+    """Detailed statistical analysis results for a contract method execution."""
+
+    method: str
+    params: List[Any]
+    timestamp: str
+    configuration: Dict[str, Any]
+    execution_time: float
+    executed_runs: int
+    failed_runs: int
+    successful_runs: int
+    server_error_runs: int
+    most_common_state_count: int
+    reliability_score: float
+    sim_results: List[Any]
+    unique_states: int
+    state_groups: List[StateGroup]
+    failed_runs_results: List[FailedRun]
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary format."""
+        return {
+            "method": self.method,
+            "params": self.params,
+            "timestamp": self.timestamp,
+            "configuration": self.configuration,
+            "execution_time": self.execution_time,
+            "method_executed_runs": self.executed_runs,
+            "method_failed_runs": self.failed_runs,
+            "method_successful_runs": self.successful_runs,
+            "server_error_runs": self.server_error_runs,
+            "most_common_state_count": self.most_common_state_count,
+            "reliability_score": self.reliability_score,
+            "unique_states": self.unique_states,
+            "state_groups": [
+                {"count": sg.count, "state_hash": sg.state_hash}
+                for sg in self.state_groups
+            ],
+            "failed_runs": [
+                {
+                    "run": fr.run,
+                    "error": fr.error,
+                    "error_type": fr.error_type,
+                    "genvm_result": fr.genvm_result,
+                }
+                for fr in self.failed_runs_results
+            ],
+            "simulation_results": self.filter_sim_results(),
+        }
+
+    def filter_sim_results(self) -> List[Any]:
+        """Filter the simulation results to only include specific fields."""
+        filtered_results = []
+        allowed_fields = [
+            "calldata",
+            "contract_state",
+            "eq_outputs",
+            "execution_result",
+            "genvm_result",
+            "node_config",
+            "pending_transactions",
+            "result",
+        ]
+
+        for result in self.sim_results:
+            filtered_result = {
+                key: result.get(key) for key in allowed_fields if key in result
+            }
+            filtered_results.append(filtered_result)
+
+        return filtered_results
+
+    def save_to_directory(self, directory: str, filename: Optional[str] = None) -> str:
+        """
+        Save the detailed stats to a JSON file in the specified directory.
+
+        Raises:
+            OSError: If directory creation or file writing fails.
+        """
+        directory_path = Path(directory)
+        directory_path.mkdir(parents=True, exist_ok=True)
+        if filename is None:
+            safe_method = safe_filename(self.method)
+            safe_timestamp = safe_filename(self.timestamp)
+            filename = f"{safe_method}_{safe_timestamp}.json"
+        if not filename.endswith(".json"):
+            filename += ".json"
+        filepath = directory_path / filename
+        try:
+            with open(filepath, "w") as f:
+                json.dump(self.to_dict(), f, indent=2)
+        except (OSError, TypeError) as e:
+            raise OSError(f"Failed to save stats to {filepath}: {e}") from e
+        return str(filepath)