genlayer-test 0.1.3__py3-none-any.whl → 0.3.0__py3-none-any.whl

gltest/glchain/contract.py

@@ -4,15 +4,20 @@ from eth_typing import (
 )
 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 gltest.artifacts import (
+    find_contract_definition_from_name,
+    find_contract_definition_from_path,
+)
 from gltest.assertions import tx_execution_failed
 from gltest.exceptions import DeploymentError
-from .client import get_gl_client
+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.plugin_config import get_default_wait_interval, get_default_wait_retries
+from gltest_cli.config.general import get_general_config
+from gltest_cli.logging import logger
 
 
 @dataclass
@@ -97,15 +102,16 @@ class Contract:
             wait_interval: Optional[int] = None,
             wait_retries: Optional[int] = None,
             wait_triggered_transactions: bool = True,
-            wait_triggered_transactions_status: TransactionStatus = TransactionStatus.ACCEPTED,
+            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 = get_default_wait_interval()
+                wait_interval = general_config.get_default_wait_interval()
             if wait_retries is None:
-                wait_retries = get_default_wait_retries()
+                wait_retries = general_config.get_default_wait_retries()
             client = get_gl_client()
             tx_hash = client.write_contract(
                 address=self.address,
@@ -146,13 +152,13 @@ class ContractFactory:
     contract_code: str
 
     @classmethod
-    def from_artifact(
+    def from_name(
         cls: Type["ContractFactory"], contract_name: str
     ) -> "ContractFactory":
         """
         Create a ContractFactory instance given the contract name.
         """
-        contract_info = find_contract_definition(contract_name)
+        contract_info = find_contract_definition_from_name(contract_name)
         if contract_info is None:
             raise ValueError(
                 f"Contract {contract_name} not found in the contracts directory"
@@ -161,6 +167,44 @@ class ContractFactory:
             contract_name=contract_name, contract_code=contract_info.contract_code
         )
 
+    @classmethod
+    def from_file_path(
+        cls: Type["ContractFactory"], contract_file_path: Union[str, Path]
+    ) -> "ContractFactory":
+        """
+        Create a ContractFactory instance given the contract file path.
+        """
+        contract_info = find_contract_definition_from_path(contract_file_path)
+        return cls(
+            contract_name=contract_info.contract_name,
+            contract_code=contract_info.contract_code,
+        )
+
+    def _get_schema_with_fallback(self):
+        """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
+
+        Returns:
+            Optional[Dict[str, Any]]: The contract schema if successful, None if all attempts fail.
+        """
+        clients = (
+            ("hosted studio", get_gl_hosted_studio_client()),
+            ("local", get_local_client()),
+            ("default", get_gl_client()),
+        )
+        for label, client in clients:
+            try:
+                return client.get_contract_schema_for_code(
+                    contract_code=self.contract_code
+                )
+            except Exception as e:
+                logger.warning("Schema fetch via %s client failed: %s", label, e)
+        return None
+
     def build_contract(
         self,
         contract_address: Union[Address, ChecksumAddress],
@@ -169,16 +213,13 @@ class ContractFactory:
         """
         Build contract from address
         """
-        client = get_gl_client()
-        try:
-            schema = client.get_contract_schema(address=contract_address)
-            return Contract.new(
-                address=contract_address, schema=schema, account=account
-            )
-        except Exception as e:
+        schema = self._get_schema_with_fallback()
+        if schema is None:
             raise ValueError(
-                f"Failed to build contract {self.contract_name}: {str(e)}"
-            ) from e
+                "Failed to get schema from all clients (hosted studio, local, and regular)"
+            )
+
+        return Contract.new(address=contract_address, schema=schema, account=account)
 
     def deploy(
         self,
@@ -193,10 +234,12 @@ class ContractFactory:
         """
         Deploy the contract
         """
+        general_config = get_general_config()
         if wait_interval is None:
-            wait_interval = get_default_wait_interval()
+            wait_interval = general_config.get_default_wait_interval()
         if wait_retries is None:
-            wait_retries = get_default_wait_retries()
+            wait_retries = general_config.get_default_wait_retries()
+
         client = get_gl_client()
         try:
             tx_hash = client.deploy_contract(
@@ -212,22 +255,27 @@ class ContractFactory:
                 interval=wait_interval,
                 retries=wait_retries,
             )
-            if (
-                not tx_receipt
-                or "data" not in tx_receipt
-                or "contract_address" not in tx_receipt["data"]
-            ):
+            if tx_execution_failed(tx_receipt):
                 raise ValueError(
-                    "Invalid transaction receipt: missing contract address"
+                    f"Deployment transaction finalized with error: {tx_receipt}"
                 )
 
-            if tx_execution_failed(tx_receipt):
+            if (
+                "tx_data_decoded" in tx_receipt
+                and "contract_address" in tx_receipt["tx_data_decoded"]
+            ):
+                contract_address = tx_receipt["tx_data_decoded"]["contract_address"]
+            elif "data" in tx_receipt and "contract_address" in tx_receipt["data"]:
+                contract_address = tx_receipt["data"]["contract_address"]
+            else:
+                raise ValueError("Transaction receipt missing contract address")
+
+            schema = self._get_schema_with_fallback()
+            if schema is None:
                 raise ValueError(
-                    f"Deployment transaction finalized with error: {tx_receipt}"
+                    "Failed to get schema from all clients (hosted studio, local, and regular)"
                 )
 
-            contract_address = tx_receipt["data"]["contract_address"]
-            schema = client.get_contract_schema(address=contract_address)
             return Contract.new(
                 address=contract_address, schema=schema, account=account
             )
@@ -237,8 +285,27 @@ class ContractFactory:
             ) from e
 
 
-def get_contract_factory(contract_name: str) -> ContractFactory:
+def get_contract_factory(
+    contract_name: Optional[str] = None,
+    contract_file_path: Optional[Union[str, Path]] = None,
+) -> ContractFactory:
     """
     Get a ContractFactory instance for a contract.
+
+    Args:
+        contract_name: Name of the contract to load from artifacts
+        contract_file_path: Path to the contract file to load directly
+
+    Note: Exactly one of contract_name or contract_file_path must be provided.
     """
-    return ContractFactory.from_artifact(contract_name)
+    if contract_name is not None and contract_file_path is not None:
+        raise ValueError(
+            "Only one of contract_name or contract_file_path should be provided"
+        )
+
+    if contract_name is None and contract_file_path is None:
+        raise ValueError("Either contract_name or contract_file_path must be provided")
+
+    if contract_name is not None:
+        return ContractFactory.from_name(contract_name)
+    return ContractFactory.from_file_path(contract_file_path)

gltest/helpers/fixture_snapshot.py

@@ -7,7 +7,7 @@ from gltest.exceptions import (
     InvalidSnapshotError,
     FixtureAnonymousFunctionError,
 )
-from gltest.plugin_config import get_rpc_url
+from gltest_cli.config.general import get_general_config
 
 SUPPORTED_RPC_DOMAINS = ["localhost", "127.0.0.1"]
 
@@ -34,7 +34,8 @@ def load_fixture(fixture: Callable[[], T]) -> T:
     if fixture.__name__ == "<lambda>":
         raise FixtureAnonymousFunctionError("Fixtures must be named functions")
 
-    rpc_url = get_rpc_url()
+    general_config = get_general_config()
+    rpc_url = general_config.get_rpc_url()
     domain = urlparse(rpc_url).netloc.split(":")[0]  # Extract domain without port
     if domain not in SUPPORTED_RPC_DOMAINS:
         return fixture()

gltest_cli/config/constants.py

@@ -0,0 +1,10 @@
+from genlayer_py.chains.localnet import SIMULATOR_JSON_RPC_URL
+from pathlib import Path
+
+
+GLTEST_CONFIG_FILE = "gltest.config.yaml"
+DEFAULT_NETWORK = "localnet"
+DEFAULT_RPC_URL = SIMULATOR_JSON_RPC_URL
+DEFAULT_ENVIRONMENT = ".env"
+DEFAULT_CONTRACTS_DIR = Path("contracts")
+DEFAULT_NETWORK_ID = 61999

gltest_cli/config/general.py

@@ -0,0 +1,10 @@
+from gltest_cli.config.types import GeneralConfig
+
+
+_general_config = GeneralConfig()
+
+
+def get_general_config() -> GeneralConfig:
+    global _general_config
+
+    return _general_config

gltest_cli/config/plugin.py

@@ -0,0 +1,102 @@
+from pathlib import Path
+from gltest_cli.logging import logger
+from gltest_cli.config.user import (
+    user_config_exists,
+    load_user_config,
+    get_default_user_config,
+)
+from gltest_cli.config.general import (
+    get_general_config,
+)
+from gltest_cli.config.types import PluginConfig
+
+
+def pytest_addoption(parser):
+    group = parser.getgroup("gltest")
+    group.addoption(
+        "--contracts-dir",
+        action="store",
+        default=None,
+        help="Path to directory containing contract files",
+    )
+
+    group.addoption(
+        "--default-wait-interval",
+        action="store",
+        default=10000,
+        help="Default interval (ms) between transaction receipt checks",
+    )
+
+    group.addoption(
+        "--default-wait-retries",
+        action="store",
+        default=15,
+        help="Default number of retries for transaction receipt checks",
+    )
+
+    group.addoption(
+        "--rpc-url",
+        action="store",
+        default=None,
+        help="RPC endpoint URL for the GenLayer network",
+    )
+
+    group.addoption(
+        "--network",
+        action="store",
+        default=None,
+        help="Target network (defaults to 'localnet' if no config file)",
+    )
+
+
+def pytest_configure(config):
+    general_config = get_general_config()
+
+    # Handle user config from gltest.config.yaml
+    if not user_config_exists():
+        logger.warning(
+            "File `gltest.config.yaml` not found in the current directory, using default config"
+        )
+        logger.info("Create a `gltest.config.yaml` file to manage multiple networks")
+        user_config = get_default_user_config()
+    else:
+        logger.info(
+            "File `gltest.config.yaml` found in the current directory, using it"
+        )
+        user_config = load_user_config("gltest.config.yaml")
+
+    general_config.user_config = user_config
+
+    # Handle plugin config from command line
+    contracts_dir = config.getoption("--contracts-dir")
+    default_wait_interval = config.getoption("--default-wait-interval")
+    default_wait_retries = config.getoption("--default-wait-retries")
+    rpc_url = config.getoption("--rpc-url")
+    network = config.getoption("--network")
+
+    plugin_config = PluginConfig()
+    plugin_config.contracts_dir = (
+        Path(contracts_dir) if contracts_dir is not None else None
+    )
+    plugin_config.default_wait_interval = int(default_wait_interval)
+    plugin_config.default_wait_retries = int(default_wait_retries)
+    plugin_config.rpc_url = rpc_url
+    plugin_config.network_name = network
+
+    general_config.plugin_config = plugin_config
+
+
+def pytest_sessionstart(session):
+    general_config = get_general_config()
+    logger.info("Using the following configuration:")
+    logger.info(f"  RPC URL: {general_config.get_rpc_url()}")
+    logger.info(f"  Selected Network: {general_config.get_network_name()}")
+    logger.info(
+        f"  Available networks: {list(general_config.user_config.networks.keys())}"
+    )
+    logger.info(f"  Contracts directory: {general_config.get_contracts_dir()}")
+    logger.info(f"  Environment: {general_config.user_config.environment}")
+    logger.info(
+        f"  Default wait interval: {general_config.get_default_wait_interval()} ms"
+    )
+    logger.info(f"  Default wait retries: {general_config.get_default_wait_retries()}")

gltest_cli/config/types.py

@@ -0,0 +1,137 @@
+from enum import Enum
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional
+from genlayer_py.chains import localnet, testnet_asimov
+from genlayer_py.types import GenLayerChain
+
+
+class NetworkConfig(str, Enum):
+    LOCALNET = "localnet"
+    TESTNET_ASIMOV = "testnet_asimov"
+
+
+@dataclass
+class PluginConfig:
+    contracts_dir: Optional[Path] = None
+    rpc_url: Optional[str] = None
+    default_wait_interval: Optional[int] = None
+    default_wait_retries: Optional[int] = None
+    network_name: Optional[str] = None
+
+
+@dataclass
+class NetworkConfigData:
+    id: Optional[int] = None
+    url: Optional[str] = None
+    accounts: Optional[List[str]] = None
+    from_account: Optional[str] = None
+
+    def __post_init__(self):
+        if self.id is not None and not isinstance(self.id, int):
+            raise ValueError("id must be an integer")
+        if self.url is not None and not isinstance(self.url, str):
+            raise ValueError("url must be a string")
+        if self.accounts is not None:
+            if not isinstance(self.accounts, list):
+                raise ValueError("accounts must be a list")
+            if not all(isinstance(acc, str) for acc in self.accounts):
+                raise ValueError("accounts must be strings")
+        if self.from_account is not None and not isinstance(self.from_account, str):
+            raise ValueError("from_account must be a string")
+
+
+@dataclass
+class PathConfig:
+    contracts: Optional[Path] = None
+
+    def __post_init__(self):
+        if self.contracts is not None and not isinstance(self.contracts, (str, Path)):
+            raise ValueError("contracts must be a string or Path")
+
+
+@dataclass
+class UserConfig:
+    networks: Dict[str, NetworkConfigData] = field(default_factory=dict)
+    paths: PathConfig = field(default_factory=PathConfig)
+    environment: Optional[str] = None
+    default_network: Optional[str] = None
+
+    def __post_init__(self):
+        if not isinstance(self.networks, dict):
+            raise ValueError("networks must be a dictionary")
+
+        if not isinstance(self.paths, PathConfig):
+            raise ValueError("paths must be a PathConfig instance")
+
+        if self.environment is not None and not isinstance(self.environment, str):
+            raise ValueError("environment must be a string")
+
+        if self.default_network is not None and not isinstance(
+            self.default_network, str
+        ):
+            raise ValueError("default_network must be a string")
+
+        # Validate network configurations
+        for name, network_config in self.networks.items():
+            if not isinstance(network_config, NetworkConfigData):
+                raise ValueError(f"network {name} must be a NetworkConfigData instance")
+
+
+@dataclass
+class GeneralConfig:
+    user_config: UserConfig = field(default_factory=UserConfig)
+    plugin_config: PluginConfig = field(default_factory=PluginConfig)
+
+    def get_contracts_dir(self) -> Path:
+        if self.plugin_config.contracts_dir is not None:
+            return self.plugin_config.contracts_dir
+        return self.user_config.paths.contracts
+
+    def set_contracts_dir(self, contracts_dir: Path):
+        self.plugin_config.contracts_dir = contracts_dir
+
+    def get_rpc_url(self) -> str:
+        if self.plugin_config.rpc_url is not None:
+            return self.plugin_config.rpc_url
+        network_name = self.get_network_name()
+        return self.user_config.networks[network_name].url
+
+    def get_default_account_key(self, network_name: Optional[str] = None) -> str:
+        if network_name is not None:
+            return self.user_config.networks[network_name].from_account
+        return self.user_config.networks[self.user_config.default_network].from_account
+
+    def get_accounts_keys(self, network_name: Optional[str] = None) -> List[str]:
+        if network_name is not None:
+            return self.user_config.networks[network_name].accounts
+        return self.user_config.networks[self.user_config.default_network].accounts
+
+    def get_chain(self) -> GenLayerChain:
+        chain_map_by_id = {
+            61999: localnet,
+            4221: testnet_asimov,
+        }
+        network_name = self.get_network_name()
+        network_id = self.user_config.networks[network_name].id
+        if network_id not in chain_map_by_id:
+            known = ", ".join(map(str, chain_map_by_id.keys()))
+            raise ValueError(
+                f"Unknown network: {network_name}, possible values: {known}"
+            )
+        return chain_map_by_id[network_id]
+
+    def get_default_wait_interval(self) -> int:
+        if self.plugin_config.default_wait_interval is not None:
+            return self.plugin_config.default_wait_interval
+        raise ValueError("default_wait_interval is not set")
+
+    def get_default_wait_retries(self) -> int:
+        if self.plugin_config.default_wait_retries is not None:
+            return self.plugin_config.default_wait_retries
+        raise ValueError("default_wait_retries is not set")
+
+    def get_network_name(self) -> str:
+        if self.plugin_config.network_name is not None:
+            return self.plugin_config.network_name
+        return self.user_config.default_network