genlayer-test 0.0.1__py3-none-any.whl → 0.1.0b1__py3-none-any.whl

genlayer_test-0.1.0b1.dist-info/METADATA

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: genlayer-test
+Version: 0.1.0b1
+Summary: GenLayer Testing Suite
+Author: GenLayer
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pytest
+Requires-Dist: genlayer-py==0.1.0b1
+
+# GenLayer Testing Suite
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/license/mit/)
+[![Discord](https://dcbadge.vercel.app/api/server/8Jm4v89VAu?compact=true&style=flat)](https://discord.gg/VpfmXEMN66)
+[![Twitter](https://img.shields.io/twitter/url/https/twitter.com/yeagerai.svg?style=social&label=Follow%20%40GenLayer)](https://x.com/GenLayer)
+
+
+## About
+
+The GenLayer Testing Suite is a powerful testing framework designed to streamline the development and validation of intelligent contracts within the GenLayer ecosystem. Built on top of [pytest](https://docs.pytest.org/en/stable/), this suite provides developers with a comprehensive set of tools for deploying, interacting with, and testing intelligent contracts efficiently in a simulated GenLayer environment.
+
+
+## Prerequisites
+
+Before installing GenLayer Testing Suite, ensure you have the following prerequisites installed:
+
+- Python (>=3.8)
+- GenLayer Studio (Docker deployment)
+- pip (Python package installer)
+
+## 🛠️ Installation and Usage
+
+### Installation Options
+
+1. Install from PyPI (recommended):
+```bash
+$ pip install genlayer-test
+```
+
+2. Install from source:
+```bash
+$ git clone https://github.com/yeagerai/genlayer-testing-suite
+$ cd genlayer-testing-suite
+$ pip install -e .
+```
+
+
+### Running Tests
+
+1. Run all tests:
+```bash
+$ gltest
+```
+
+2. Run specific test file:
+```bash
+$ gltest tests/test_mycontract.py
+```
+
+3. Run tests with specific markers:
+```bash
+$ gltest -m "integration"
+```
+
+4. Run tests with verbose output:
+```bash
+$ gltest -v
+```
+
+For more detailed information and advanced usage, please refer to our [documentation](https://docs.genlayer.com/api-references/genlayer-testing-suite).
+
+## 🚀 Key Features
+- **Pytest Integration** – Extends pytest to support intelligent contract testing, making it familiar and easy to adopt.
+
+- **Account & Transaction Management** – Create, fund, and track accounts and transactions within the GenLayer Simulator.
+
+- **Contract Deployment & Interaction** – Deploy contracts, call methods, and monitor events seamlessly.
+
+- **CLI Compatibility** – Run tests directly from the command line, ensuring smooth integration with the GenLayer CLI.
+
+- **State Injection & Consensus Simulation** – Modify contract states dynamically and simulate consensus scenarios for advanced testing.
+
+- **Prompt Testing & Statistical Analysis** – Evaluate and statistically test prompts for AI-driven contract execution.
+
+- **Scalability to Security & Audit Tools** – Designed to extend into security testing and smart contract auditing.
+
+
+By leveraging the GenLayer Testing Suite, developers can ensure their contracts perform reliably and securely before deployment on the live network. 

genlayer_test-0.1.0b1.dist-info/RECORD

@@ -0,0 +1,15 @@
+gltest/__init__.py,sha256=AK_YfRvwlhrOheOelUG8qIRG17on0-nFCF747dopg2w,332
+gltest/assertions.py,sha256=wrT5R8yLAxm0B1EzmdZjOK5gBriugIrdtOIt9Qi0G-k,591
+gltest/cli.py,sha256=Ti2-0Ev1x5_cM0D1UKqdgaDt80CDHEQGtdRne2qLm4M,53
+gltest/exceptions.py,sha256=g7IF0qA8L0PdonXHTsbFnWx05U3jEYWOL3EFTW21IL4,95
+gltest/artifacts/__init__.py,sha256=QCsQI8BSOHQwGWFxZVDRL-HA0Dyae3Re24E-yAZrflA,86
+gltest/artifacts/contract.py,sha256=tOXv5rOGkoEeBndEp2wB9YnaTNvBRqACkGMkzC_tt4E,1761
+gltest/glchain/__init__.py,sha256=wD2Hzdz_wKpu-mCAX5iBINZDCNdKezLVI2lywkSkjvw,400
+gltest/glchain/account.py,sha256=vOXxcR09NkT6iFw_m49DW1nVC7kP8wf23555iPPXRkw,402
+gltest/glchain/client.py,sha256=U_JJJQ0V8oLPLeIbGpFcHOtnCVPJIoN9DMlvHSD1C0I,355
+gltest/glchain/contract.py,sha256=pt-LdF8k8jWCmWhU2-LI72w-vdVyi2g9Ux59MR8W3Es,6469
+genlayer_test-0.1.0b1.dist-info/METADATA,sha256=2nkEPJTInKomnfv-DnvCJoDTkyWrImvUsWyctCqu8mo,3409
+genlayer_test-0.1.0b1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+genlayer_test-0.1.0b1.dist-info/entry_points.txt,sha256=JfU-i_s5OciWVqtb0Ye5Pu_A1jJkDkitwLn4esJPZz4,43
+genlayer_test-0.1.0b1.dist-info/top_level.txt,sha256=xTaZGUzUZ0S1U6_lp5SwNMQWZJKFaXI1Yg8gGKFKFJg,7
+genlayer_test-0.1.0b1.dist-info/RECORD,,

genlayer_test-0.1.0b1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gltest = gltest.cli:main

genlayer_test-0.1.0b1.dist-info/top_level.txt

@@ -0,0 +1 @@
+gltest

gltest/__init__.py

@@ -0,0 +1,18 @@
+from gltest.glchain import (
+    create_account,
+    create_accounts,
+    get_contract_factory,
+    get_gl_client,
+    default_account,
+    accounts,
+)
+
+__all__ = [
+    "find_contract_definition",
+    "create_account",
+    "create_accounts",
+    "get_contract_factory",
+    "get_gl_client",
+    "default_account",
+    "accounts",
+]

gltest/artifacts/__init__.py

@@ -0,0 +1,3 @@
+from .contract import find_contract_definition
+
+__all__ = ["find_contract_definition"]

gltest/artifacts/contract.py

@@ -0,0 +1,52 @@
+import ast
+from pathlib import Path
+from typing import Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class ContractDefinition:
+    """Class that represents a contract definition from a .gpy file."""
+
+    contract_name: str
+    contract_code: str
+    source_file: str
+    ast_node: ast.ClassDef
+
+
+def find_contract_definition(
+    contract_name: str, relative_contracts_dir: str = "contracts"
+) -> Optional[ContractDefinition]:
+    """
+    Search in the contracts directory for a contract definition.
+    TODO: Make this more robust to handle imports and other files.
+    """
+    # Use provided directory or default to 'contracts' in current working directory
+    contracts_dir = Path.cwd() / relative_contracts_dir
+
+    if not contracts_dir.exists():
+        raise FileNotFoundError(f"Contracts directory not found at: {contracts_dir}")
+
+    # Search through all .gpy files in the contracts directory
+    for file_path in contracts_dir.glob("*.gpy"):
+        try:
+            # Read the file content
+            with open(file_path, "r") as f:
+                content = f.read()
+
+            # Parse the content into an AST
+            tree = ast.parse(content)
+
+            # Search for class definitions
+            for node in ast.walk(tree):
+                if isinstance(node, ast.ClassDef) and node.name == contract_name:
+                    # Found the contract class
+                    return ContractDefinition(
+                        contract_name=contract_name,
+                        source_file=str(file_path),
+                        contract_code=content,
+                        ast_node=node,
+                    )
+        except Exception as e:
+            raise ValueError(f"Error reading file {file_path}: {e}")
+    return None

gltest/assertions.py

@@ -0,0 +1,17 @@
+from genlayer_py.types import GenLayerTransaction
+
+
+def tx_execution_succeeded(result: GenLayerTransaction) -> bool:
+    if "consensus_data" not in result:
+        return False
+    if "leader_receipt" not in result["consensus_data"]:
+        return False
+    if "execution_result" not in result["consensus_data"]["leader_receipt"]:
+        return False
+    execution_result = result["consensus_data"]["leader_receipt"]["execution_result"]
+    return execution_result == "SUCCESS"
+
+
+def tx_execution_failed(result: GenLayerTransaction) -> bool:
+    return not tx_execution_succeeded(result)
+

gltest/cli.py

@@ -0,0 +1,5 @@
+import pytest
+
+
+def main():
+    return pytest.main()

gltest/exceptions.py

@@ -0,0 +1,4 @@
+class DeploymentError(Exception):
+    """Raised when a contract deployment fails."""
+
+    pass

gltest/glchain/__init__.py

@@ -0,0 +1,16 @@
+from .contract import Contract, ContractFactory, get_contract_factory
+from .client import gl_client, get_gl_client
+from .account import create_accounts, create_account, accounts, default_account
+
+
+__all__ = [
+    "Contract",
+    "ContractFactory",
+    "get_contract_factory",
+    "gl_client",
+    "create_account",
+    "default_account",
+    "accounts",
+    "create_accounts",
+    "get_gl_client",
+]

gltest/glchain/account.py

@@ -0,0 +1,17 @@
+from genlayer_py import create_account
+
+
+def create_accounts(n_accounts: int):
+    """
+    Create a list of accounts
+    """
+    accounts = []
+    for _ in range(n_accounts):
+        accounts.append(create_account())
+    return accounts
+
+# Accounts for testing
+accounts = create_accounts(n_accounts=10)
+
+# Default account to use for transaction handling, if not specified
+default_account = accounts[0]

gltest/glchain/client.py

@@ -0,0 +1,15 @@
+from genlayer_py.chains import localnet
+from genlayer_py import create_client
+from .account import default_account
+from functools import lru_cache
+
+# Create the client
+gl_client = create_client(chain=localnet, account=default_account)
+
+
+@lru_cache(maxsize=1)
+def get_gl_client():
+    """
+    Get the GenLayer client instance.
+    """
+    return gl_client

gltest/glchain/contract.py

@@ -0,0 +1,192 @@
+from dataclasses import dataclass
+from gltest.artifacts import find_contract_definition
+from gltest.assertions import tx_execution_failed
+from gltest.exceptions import DeploymentError
+from .client import get_gl_client
+from genlayer_py.types import CalldataEncodable, GenLayerTransaction
+from eth_account.signers.local import LocalAccount
+from typing import List, Any, Type, Optional, Dict, Callable
+import types
+
+
+@dataclass
+class Contract:
+    """
+    Class to interact with a contract, its methods
+    are implemented dynamically at build time.
+    """
+
+    address: str
+    account: Optional[LocalAccount] = None
+
+    @classmethod
+    def from_address_and_schema(
+        cls, address: str, schema: Dict[str, Any]
+    ) -> "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)
+        for method_name, method_info in 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"
+                )
+            setattr(
+                instance,
+                method_name,
+                types.MethodType(
+                    cls.contract_method_factory(method_name, method_info["readonly"]),
+                    instance,
+                ),
+            )
+        return instance
+
+    def connect(self, account: LocalAccount) -> "Contract":
+        self.account = account
+        return self
+
+    @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_interval: Optional[int] = None,
+            wait_retries: Optional[int] = None,
+        ) -> GenLayerTransaction:
+            """
+            Wrapper to the contract write method.
+            """
+            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,
+            )
+            extra_args = {}
+            if wait_interval is not None:
+                extra_args["interval"] = wait_interval
+            if wait_retries is not None:
+                extra_args["retries"] = wait_retries
+            receipt = client.wait_for_transaction_receipt(
+                transaction_hash=tx_hash, status="FINALIZED", **extra_args
+            )
+            return receipt
+
+        return read_contract_wrapper if read_only else write_contract_wrapper
+
+
+@dataclass
+class ContractFactory:
+    """
+    A factory for deploying contracts.
+    """
+
+    contract_name: str
+    contract_code: str
+
+    @classmethod
+    def from_artifact(
+        cls: Type["ContractFactory"], contract_name: str
+    ) -> "ContractFactory":
+        """
+        Create a ContractFactory instance given the contract name.
+        """
+        contract_info = find_contract_definition(contract_name)
+        if contract_info is None:
+            raise ValueError(
+                f"Contract {contract_name} not found in the contracts directory"
+            )
+        return cls(
+            contract_name=contract_name, contract_code=contract_info.contract_code
+        )
+
+    def deploy(
+        self,
+        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,
+    ) -> Contract:
+        """
+        Deploy the contract
+        """
+        client = get_gl_client()
+        try:
+            tx_hash = client.deploy_contract(
+                code=self.contract_code,
+                args=args,
+                account=account,
+                consensus_max_rotations=consensus_max_rotations,
+                leader_only=leader_only,
+            )
+            extra_args = {}
+            if wait_interval is not None:
+                extra_args["interval"] = wait_interval
+            if wait_retries is not None:
+                extra_args["retries"] = wait_retries
+            tx_receipt = client.wait_for_transaction_receipt(
+                transaction_hash=tx_hash, status="FINALIZED", **extra_args
+            )
+
+            if (
+                not tx_receipt
+                or "data" not in tx_receipt
+                or "contract_address" not in tx_receipt["data"]
+            ):
+                raise ValueError(
+                    "Invalid transaction receipt: missing contract address"
+                )
+
+            if tx_execution_failed(tx_receipt):
+                raise ValueError(
+                    f"Deployment transaction finalized with error: {tx_receipt}"
+                )
+
+            contract_address = tx_receipt["data"]["contract_address"]
+            schema = client.get_contract_schema(address=contract_address)
+            return Contract.from_address_and_schema(
+                address=contract_address, schema=schema
+            )
+        except Exception as e:
+            raise DeploymentError(
+                f"Failed to deploy contract {self.contract_name}: {str(e)}"
+            ) from e
+
+
+def get_contract_factory(contract_name: str) -> ContractFactory:
+    """
+    Get a ContractFactory instance for a contract.
+    """
+    return ContractFactory.from_artifact(contract_name)

genlayer_test-0.0.1.dist-info/METADATA

@@ -1,17 +0,0 @@
-Metadata-Version: 2.4
-Name: genlayer-test
-Version: 0.0.1
-Summary: A minimal empty PyPI package for genlayer-test
-Author-email: GenLayer Labs Corp <tech@genlayer.com>
-License: MIT
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-
-# GenLayer Test
-
-This is a minimal empty Python package for genlayer-test.
-
-## Installation
-```bash
-pip install genlayer-test
-```

genlayer_test-0.0.1.dist-info/RECORD

@@ -1,4 +0,0 @@
-genlayer_test-0.0.1.dist-info/METADATA,sha256=s6JVDtHiKhzy8c3UKBLYxGJLhzgitAsegT_XClxJVWM,373
-genlayer_test-0.0.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-genlayer_test-0.0.1.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-genlayer_test-0.0.1.dist-info/RECORD,,

genlayer_test-0.0.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-