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

gltest/glchain/client.py

@@ -0,0 +1,23 @@
+from genlayer_py.chains import localnet
+from genlayer_py import create_client
+from .account import default_account
+from functools import lru_cache
+from gltest.plugin_config import get_rpc_url
+
+
+@lru_cache(maxsize=1)
+def get_gl_client():
+    """
+    Get the GenLayer client instance.
+    """
+    return create_client(
+        chain=localnet, account=default_account, endpoint=get_rpc_url()
+    )
+
+
+def get_gl_provider():
+    """
+    Get the GenLayer provider instance.
+    """
+    client = get_gl_client()
+    return client.provider

gltest/glchain/contract.py

@@ -0,0 +1,244 @@
+from eth_typing import (
+    Address,
+    ChecksumAddress,
+)
+from eth_account.signers.local import LocalAccount
+from typing import Union
+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 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
+
+
+@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.ACCEPTED,
+        ) -> GenLayerTransaction:
+            """
+            Wrapper to the contract write method.
+            """
+            if wait_interval is None:
+                wait_interval = get_default_wait_interval()
+            if wait_retries is None:
+                wait_retries = 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
+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 build_contract(
+        self,
+        contract_address: Union[Address, ChecksumAddress],
+        account: Optional[LocalAccount] = None,
+    ) -> Contract:
+        """
+        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:
+            raise ValueError(
+                f"Failed to build contract {self.contract_name}: {str(e)}"
+            ) from e
+
+    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,
+        wait_transaction_status: TransactionStatus = TransactionStatus.FINALIZED,
+    ) -> Contract:
+        """
+        Deploy the contract
+        """
+        if wait_interval is None:
+            wait_interval = get_default_wait_interval()
+        if wait_retries is None:
+            wait_retries = get_default_wait_retries()
+        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,
+            )
+            tx_receipt = client.wait_for_transaction_receipt(
+                transaction_hash=tx_hash,
+                status=wait_transaction_status,
+                interval=wait_interval,
+                retries=wait_retries,
+            )
+            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.new(
+                address=contract_address, schema=schema, account=account
+            )
+        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)

gltest/helpers/__init__.py

@@ -0,0 +1,8 @@
+from .take_snapshot import take_snapshot
+from .fixture_snapshot import load_fixture, clear_snapshots
+
+__all__ = [
+    "take_snapshot",
+    "load_fixture",
+    "clear_snapshots",
+]

gltest/helpers/fixture_snapshot.py

@@ -0,0 +1,67 @@
+from typing import TypeVar, Callable, List, Any
+from dataclasses import dataclass
+from .take_snapshot import SnapshotRestorer, take_snapshot
+from gltest.exceptions import (
+    FixtureSnapshotError,
+    InvalidSnapshotError,
+    FixtureAnonymousFunctionError,
+)
+
+
+T = TypeVar("T")
+
+
+@dataclass
+class Snapshot:
+    """Represents a snapshot of the blockchain state."""
+
+    restorer: SnapshotRestorer
+    fixture: Callable[[], Any]
+    data: Any
+
+
+# Global storage for snapshots
+_snapshots: List[Snapshot] = []
+
+
+def load_fixture(fixture: Callable[[], T]) -> T:
+    """
+    Useful in tests for setting up the desired state of the network.
+    """
+    if fixture.__name__ == "<lambda>":
+        raise FixtureAnonymousFunctionError("Fixtures must be named functions")
+
+    # Find existing snapshot for this fixture
+    global _snapshots
+    snapshot = next((s for s in _snapshots if s.fixture == fixture), None)
+
+    if snapshot is not None:
+        try:
+            snapshot.restorer.restore()
+            # Remove snapshots that were taken after this one
+            
+            _snapshots = [
+                s
+                for s in _snapshots
+                if int(s.restorer.snapshot_id) <= int(snapshot.restorer.snapshot_id)
+            ]
+        except Exception as e:
+            if isinstance(e, InvalidSnapshotError):
+                raise FixtureSnapshotError(e) from e
+            raise e
+
+        return snapshot.data
+    else:
+        # Execute the fixture and take a snapshot
+        data = fixture()
+        restorer = take_snapshot()
+
+        _snapshots.append(Snapshot(restorer=restorer, fixture=fixture, data=data))
+
+        return data
+
+
+def clear_snapshots() -> None:
+    """Clears every existing snapshot."""
+    global _snapshots
+    _snapshots = []

gltest/helpers/take_snapshot.py

@@ -0,0 +1,41 @@
+from gltest.glchain import get_gl_provider
+from dataclasses import dataclass
+from typing import Callable
+from gltest.exceptions import HelperError, InvalidSnapshotError
+
+
+@dataclass
+class SnapshotRestorer:
+    """Class responsible for restoring blockchain state to a snapshot."""
+
+    restore: Callable[[], None]
+    snapshot_id: int
+
+
+def take_snapshot() -> SnapshotRestorer:
+    """
+    Take a snapshot of the current blockchain state and return a function to restore the state and the snapshot ID.
+    """
+    provider = get_gl_provider()
+    snapshot_id = provider.make_request(method="sim_createSnapshot", params=[])[
+        "result"
+    ]
+    if not isinstance(snapshot_id, int):
+        raise HelperError(
+            "Assertion error: the value returned by evm_snapshot should be a int"
+        )
+
+    def restore() -> None:
+        reverted = provider.make_request(
+            method="sim_restoreSnapshot", params=[snapshot_id]
+        )["result"]
+
+        if not isinstance(reverted, bool):
+            raise HelperError(
+                "Assertion error: the value returned by evm_revert should be a boolean"
+            )
+
+        if not reverted:
+            raise InvalidSnapshotError("")
+
+    return SnapshotRestorer(restore=restore, snapshot_id=snapshot_id)

gltest/plugin_config.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+
+_contracts_dir = None
+_rpc_url = None
+_default_wait_interval = None
+_default_wait_retries = None
+
+
+def set_contracts_dir(path: Path):
+    global _contracts_dir
+    _contracts_dir = path
+
+
+def get_contracts_dir() -> Path:
+    return Path(_contracts_dir)
+
+
+def set_rpc_url(rpc_url: str):
+    global _rpc_url
+    _rpc_url = rpc_url
+
+
+def get_rpc_url() -> str:
+    return _rpc_url
+
+
+def set_default_wait_interval(default_wait_interval: int):
+    global _default_wait_interval
+    _default_wait_interval = default_wait_interval
+
+
+def get_default_wait_interval() -> int:
+    return _default_wait_interval
+
+
+def set_default_wait_retries(default_wait_retries: int):
+    global _default_wait_retries
+    _default_wait_retries = default_wait_retries
+
+
+def get_default_wait_retries() -> int:
+    return _default_wait_retries

gltest/plugin_hooks.py

@@ -0,0 +1,51 @@
+from gltest.plugin_config import (
+    set_contracts_dir,
+    set_default_wait_interval,
+    set_default_wait_retries,
+    set_rpc_url,
+)
+from pathlib import Path
+from genlayer_py.chains.localnet import SIMULATOR_JSON_RPC_URL
+
+
+def pytest_addoption(parser):
+    group = parser.getgroup("gltest")
+    group.addoption(
+        "--contracts-dir",
+        action="store",
+        default="contracts",
+        help="Directory containing contract files",
+    )
+
+    group.addoption(
+        "--default-wait-interval",
+        action="store",
+        default=10000,
+        help="Default wait interval for waiting transaction receipts",
+    )
+
+    group.addoption(
+        "--default-wait-retries",
+        action="store",
+        default=15,
+        help="Default wait retries for waiting transaction receipts",
+    )
+
+    group.addoption(
+        "--rpc-url",
+        action="store",
+        default=SIMULATOR_JSON_RPC_URL,
+        help="RPC URL for the genlayer network",
+    )
+
+
+def pytest_configure(config):
+    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")
+
+    set_contracts_dir(Path(contracts_dir))
+    set_default_wait_interval(int(default_wait_interval))
+    set_default_wait_retries(int(default_wait_retries))
+    set_rpc_url(str(rpc_url))

gltest/types.py

@@ -0,0 +1,7 @@
+# Re-export genlayer-py types
+from genlayer_py.types import (
+    CalldataAddress,
+    GenLayerTransaction,
+    TransactionStatus,
+    CalldataEncodable,
+)

gltest_cli/main.py

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

tests/examples/tests/test_football_prediction_market.py

@@ -0,0 +1,19 @@
+from gltest import get_contract_factory
+from gltest.assertions import tx_execution_succeeded
+
+
+def test_football_prediction_market():
+    # Deploy Contract
+    factory = get_contract_factory("PredictionMarket")
+    contract = factory.deploy(args=["2024-06-26", "Georgia", "Portugal"])
+
+    # Resolve match
+    transaction_response_call_1 = contract.resolve(args=[])
+    assert tx_execution_succeeded(transaction_response_call_1)
+
+    # Get Updated State
+    contract_state_2 = contract.get_resolution_data(args=[])
+
+    assert contract_state_2["winner"] == 1
+    assert contract_state_2["score"] == "2:0"
+    assert contract_state_2["has_resolved"] == True

tests/examples/tests/test_intelligent_oracle_factory.py

@@ -0,0 +1,129 @@
+import time
+
+from gltest import get_contract_factory
+from gltest.assertions import tx_execution_succeeded
+
+
+def wait_for_contract_deployment(intelligent_oracle_contract, max_retries=10, delay=5):
+    """
+    Wait for intelligent oracle contract to be fully deployed by attempting to call a method.
+    This is used to check if the triggered deployment did deploy the contract.
+    """
+    for _ in range(max_retries):
+        try:
+            intelligent_oracle_contract.get_dict(args=[])
+            return True  # If successful, contract is deployed
+        except Exception:
+            time.sleep(delay)
+    return False
+
+
+def test_intelligent_oracle_factory_pattern():
+    # Get the intelligent oracle factory
+    intelligent_oracle_factory = get_contract_factory("IntelligentOracle")
+
+    # Deploy the Registry contract with the IntelligentOracle code
+    registry_factory = get_contract_factory("Registry")
+    registry_contract = registry_factory.deploy(
+        args=[intelligent_oracle_factory.contract_code]
+    )
+
+    markets_data = [
+        {
+            "prediction_market_id": "marathon2024",
+            "title": "Marathon Winner Prediction",
+            "description": "Predict the male winner of a major marathon event.",
+            "potential_outcomes": ["Bekele Fikre", "Tafa Mitku", "Chebii Douglas"],
+            "rules": [
+                "The outcome is based on the official race results announced by the marathon organizers."
+            ],
+            "data_source_domains": ["thepostrace.com"],
+            "resolution_urls": [],
+            "earliest_resolution_date": "2024-01-01T00:00:00+00:00",
+            "outcome": "Tafa Mitku",
+            "evidence_urls": "https://thepostrace.com/en/blog/marathon-de-madrid-2024-results-and-rankings/?srsltid=AfmBOor1uG6O3_4oJ447hkah_ilOYuy0XXMvl8j70EApe1Z7Bzd94XJl",
+        },
+        {
+            "prediction_market_id": "election2024",
+            "title": "Election Prediction",
+            "description": "Predict the winner of the 2024 US presidential election.",
+            "potential_outcomes": ["Kamala Harris", "Donald Trump"],
+            "rules": ["The outcome is based on official election results."],
+            "data_source_domains": ["bbc.com"],
+            "resolution_urls": [],
+            "earliest_resolution_date": "2024-01-01T00:00:00+00:00",
+            "outcome": "Donald Trump",
+            "evidence_urls": "https://www.bbc.com/news/election/2024/us/results",
+        },
+    ]
+    created_market_contracts = []
+
+    # Create markets through factory
+    for market_data in markets_data:
+        create_result = registry_contract.create_new_prediction_market(
+            args=[
+                market_data["prediction_market_id"],
+                market_data["title"],
+                market_data["description"],
+                market_data["potential_outcomes"],
+                market_data["rules"],
+                market_data["data_source_domains"],
+                market_data["resolution_urls"],
+                market_data["earliest_resolution_date"],
+            ],
+        )
+        assert tx_execution_succeeded(create_result)
+
+        # Get the latest contract address from factory
+        registered_addresses = registry_contract.get_contract_addresses(args=[])
+        new_market_address = registered_addresses[-1]
+
+        # Build a contract object
+        market_contract = intelligent_oracle_factory.build_contract(
+            new_market_address
+        )
+        created_market_contracts.append(market_contract)
+
+        # Wait for the new market contract to be deployed
+        assert wait_for_contract_deployment(
+            market_contract
+        ), f"Market contract deployment timeout for {market_data['prediction_market_id']}"
+
+    # Verify all markets were registered
+    assert len(registered_addresses) == len(markets_data)
+
+    # Verify each market's state
+    for i, market_contract in enumerate(created_market_contracts):
+        market_state = market_contract.get_dict(args=[])
+        expected_data = markets_data[i]
+
+        # Verify key market properties
+        assert market_state["title"] == expected_data["title"]
+        assert market_state["description"] == expected_data["description"]
+        assert market_state["potential_outcomes"] == expected_data["potential_outcomes"]
+        assert market_state["rules"] == expected_data["rules"]
+        assert (
+            market_state["data_source_domains"] == expected_data["data_source_domains"]
+        )
+        assert market_state["resolution_urls"] == expected_data["resolution_urls"]
+        assert market_state["status"] == "Active"
+        assert (
+            market_state["earliest_resolution_date"]
+            == expected_data["earliest_resolution_date"]
+        )
+        assert (
+            market_state["prediction_market_id"]
+            == expected_data["prediction_market_id"]
+        )
+
+    # Resolve markets
+    for i, market_contract in enumerate(created_market_contracts):
+        resolve_result = market_contract.resolve(
+            args=[markets_data[i]["evidence_urls"]],
+        )
+        assert tx_execution_succeeded(resolve_result)
+
+        # Verify market was resolved and has the correct outcome
+        market_state = market_contract.get_dict(args=[])
+        assert market_state["status"] == "Resolved"
+        assert market_state["outcome"] == markets_data[i]["outcome"]

tests/examples/tests/test_llm_erc20.py

@@ -0,0 +1,41 @@
+from gltest import get_contract_factory, default_account, create_account
+from gltest.assertions import tx_execution_succeeded
+
+TOKEN_TOTAL_SUPPLY = 1000
+TRANSFER_AMOUNT = 100
+
+
+def test_llm_erc20():
+    # Account Setup
+    from_account_a = default_account
+    from_account_b = create_account()
+
+    # Deploy Contract
+    factory = get_contract_factory("LlmErc20")
+    contract = factory.deploy(args=[TOKEN_TOTAL_SUPPLY])
+
+    # Get Initial State
+    contract_state_1 = contract.get_balances(args=[])
+    assert contract_state_1[from_account_a.address] == TOKEN_TOTAL_SUPPLY
+
+    # Transfer from User A to User B
+    transaction_response_call_1 = contract.transfer(
+        args=[TRANSFER_AMOUNT, from_account_b.address]
+    )
+    assert tx_execution_succeeded(transaction_response_call_1)
+
+    # Get Updated State
+    contract_state_2_1 = contract.get_balances(args=[])
+    assert (
+        contract_state_2_1[from_account_a.address]
+        == TOKEN_TOTAL_SUPPLY - TRANSFER_AMOUNT
+    )
+    assert contract_state_2_1[from_account_b.address] == TRANSFER_AMOUNT
+
+    # Get Updated State
+    contract_state_2_2 = contract.get_balance_of(args=[from_account_a.address])
+    assert contract_state_2_2 == TOKEN_TOTAL_SUPPLY - TRANSFER_AMOUNT
+
+    # Get Updated State
+    contract_state_2_3 = contract.get_balance_of(args=[from_account_b.address])
+    assert contract_state_2_3 == TRANSFER_AMOUNT