genlayer-test 0.10.1__py3-none-any.whl → 0.12.0__py3-none-any.whl

gltest/direct/loader.py

@@ -0,0 +1,288 @@
+"""
+Contract loader for direct test runner.
+
+Handles:
+- SDK version setup based on contract headers
+- Message context injection via stdin
+- WASI mock installation
+- Contract class discovery and instantiation
+"""
+
+from __future__ import annotations
+
+import sys
+import hashlib
+import importlib.util
+from pathlib import Path
+from typing import Any, Optional, Type, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .vm import VMContext
+
+
+def load_contract_class(
+    contract_path: Path,
+    vm: "VMContext",
+    sdk_version: Optional[str] = None,
+) -> Type[Any]:
+    """
+    Load a contract class from file.
+
+    Sets up SDK paths, WASI mock, and message context.
+    """
+    contract_path = Path(contract_path).resolve()
+
+    if not contract_path.exists():
+        raise FileNotFoundError(f"Contract not found: {contract_path}")
+
+    # 1. Setup WASI mock FIRST (before genlayer is imported)
+    from . import wasi_mock
+    wasi_mock.set_vm(vm)
+    sys.modules['_genlayer_wasi'] = wasi_mock
+
+    # 2. Setup SDK paths (this adds genlayer to sys.path)
+    from .sdk_loader import setup_sdk_paths
+    setup_sdk_paths(contract_path, sdk_version)
+
+    # 3. Inject message context into fd 0 BEFORE importing contract
+    #    (genlayer reads message from fd 0 at import time)
+    _inject_message_to_fd0(vm)
+
+    # 4. Load the contract module
+    module = _load_module(contract_path)
+
+    contract_cls = _find_contract_class(module)
+
+    if contract_cls is None:
+        raise ValueError(f"No contract class found in {contract_path}")
+
+    return contract_cls
+
+
+def deploy_contract(
+    contract_path: Path,
+    vm: "VMContext",
+    *args: Any,
+    sdk_version: Optional[str] = None,
+    **kwargs: Any,
+) -> Any:
+    """Deploy a contract and return an instance."""
+    contract_path = Path(contract_path).resolve()
+
+    if vm._contract_address is None:
+        addr_hash = hashlib.sha256(str(contract_path).encode()).digest()[:20]
+        vm._contract_address = addr_hash
+
+    contract_cls = load_contract_class(contract_path, vm, sdk_version)
+
+    instance = _allocate_contract(contract_cls, vm, *args, **kwargs)
+
+    return instance
+
+
+def _inject_message_to_fd0(vm: "VMContext") -> None:
+    """Inject message context by replacing stdin (fd 0) with encoded message."""
+    import os
+    import tempfile
+
+    try:
+        from genlayer.py import calldata
+        from genlayer.py.types import Address
+    except ImportError:
+        return
+
+    # Convert addresses to Address type
+    sender_addr = vm.sender
+    if isinstance(sender_addr, bytes):
+        sender_addr = Address(sender_addr)
+
+    contract_addr = vm._contract_address
+    if isinstance(contract_addr, bytes):
+        contract_addr = Address(contract_addr)
+
+    origin_addr = vm.origin
+    if isinstance(origin_addr, bytes):
+        origin_addr = Address(origin_addr)
+
+    # Build message dict
+    message_data = {
+        'contract_address': contract_addr,
+        'sender_address': sender_addr,
+        'origin_address': origin_addr,
+        'stack': [],
+        'value': vm._value,
+        'datetime': vm._datetime,
+        'is_init': False,
+        'chain_id': vm._chain_id,
+        'entry_kind': 0,
+        'entry_data': b'',
+        'entry_stage_data': None,
+    }
+
+    # Encode the message
+    encoded = calldata.encode(message_data)
+
+    # Create a temp file with the encoded message
+    fd, path = tempfile.mkstemp()
+    try:
+        os.write(fd, encoded)
+        os.lseek(fd, 0, os.SEEK_SET)  # Reset to beginning
+
+        # Save original stdin fd
+        original_stdin = os.dup(0)
+        vm._original_stdin_fd = original_stdin
+
+        # Replace stdin with our temp file
+        os.dup2(fd, 0)
+    finally:
+        os.close(fd)
+        os.unlink(path)
+
+
+def _load_module(contract_path: Path) -> Any:
+    """Load a Python module from file path."""
+    module_name = f"_contract_{contract_path.stem}"
+
+    if module_name in sys.modules:
+        del sys.modules[module_name]
+
+    spec = importlib.util.spec_from_file_location(module_name, contract_path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"Cannot load module from {contract_path}")
+
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[module_name] = module
+
+    try:
+        spec.loader.exec_module(module)
+    except Exception as e:
+        if module_name in sys.modules:
+            del sys.modules[module_name]
+        raise ImportError(f"Failed to load contract: {e}") from e
+
+    return module
+
+
+def _find_contract_class(module: Any) -> Optional[Type[Any]]:
+    """Find the contract class in a module."""
+    import dataclasses
+
+    candidates = []
+
+    for name in dir(module):
+        if name.startswith('_'):
+            continue
+
+        obj = getattr(module, name)
+
+        if not isinstance(obj, type):
+            continue
+
+        # Skip dataclasses - they're storage types, not contracts
+        if dataclasses.is_dataclass(obj):
+            continue
+
+        # Highest priority: explicit __gl_contract__ marker
+        if getattr(obj, '__gl_contract__', False):
+            return obj
+
+        # Second priority: inherits from Contract
+        for base in obj.__mro__:
+            if base.__name__ in ('Contract', 'gl.Contract'):
+                return obj
+
+        # Third priority: has storage-like annotations
+        # Collect as candidates but don't return immediately
+        if hasattr(obj, '__annotations__'):
+            annotations = obj.__annotations__
+            storage_types = ('TreeMap', 'DynArray', 'Array', 'u256', 'Address')
+            for ann in annotations.values():
+                ann_str = str(ann)
+                if any(st in ann_str for st in storage_types):
+                    candidates.append(obj)
+                    break
+
+    # Return first candidate if no explicit contract found
+    if candidates:
+        return candidates[0]
+
+    return None
+
+
+def _allocate_contract(
+    contract_cls: Type[Any],
+    vm: "VMContext",
+    *args: Any,
+    **kwargs: Any,
+) -> Any:
+    """Allocate and initialize a contract instance."""
+    try:
+        from genlayer.py.storage import Root, ROOT_SLOT_ID
+        from genlayer.py.storage._internal.generate import (
+            ORIGINAL_INIT_ATTR,
+            _storage_build,
+            Lit,
+        )
+
+        # Build the storage type descriptor
+        td = _storage_build(contract_cls, {})
+        assert not isinstance(td, Lit)
+
+        # Use the VM's storage manager
+        slot = vm._storage.get_store_slot(ROOT_SLOT_ID)
+        instance = td.get(slot, 0)
+
+        # Find and call the original __init__
+        init = getattr(td, 'cls', None)
+        if init is None:
+            init = getattr(contract_cls, '__init__', None)
+        else:
+            init = getattr(init, '__init__', None)
+        if init is not None:
+            if hasattr(init, ORIGINAL_INIT_ATTR):
+                init = getattr(init, ORIGINAL_INIT_ATTR)
+            init(instance, *args, **kwargs)
+
+        return instance
+
+    except ImportError:
+        pass
+
+    try:
+        from genlayer.py.storage import Root
+
+        Root.MANAGER = vm._storage
+
+        root_slot = vm._storage.get_store_slot(b'\x00' * 32)
+
+        instance = contract_cls.__new__(contract_cls)
+
+        if hasattr(instance, '_storage_slot'):
+            instance._storage_slot = root_slot.indirect(0)
+            instance._off = 0
+
+        if args or kwargs:
+            instance.__init__(*args, **kwargs)
+
+        return instance
+
+    except ImportError:
+        pass
+
+    return contract_cls(*args, **kwargs)
+
+
+def create_address(seed: str) -> Any:
+    """Create a deterministic address from seed string."""
+    addr_bytes = hashlib.sha256(seed.encode()).digest()[:20]
+
+    try:
+        from genlayer.py.types import Address
+        return Address(addr_bytes)
+    except ImportError:
+        return addr_bytes
+
+
+def create_test_addresses(count: int = 10) -> list:
+    """Create a list of test addresses."""
+    return [create_address(f"test_address_{i}") for i in range(count)]

gltest/direct/pytest_plugin.py

@@ -0,0 +1,117 @@
+"""
+Pytest plugin for direct GenLayer contract testing.
+
+Provides fixtures:
+- direct_vm: VMContext for Foundry-style cheatcodes
+- direct_deploy: Factory for deploying contracts
+
+Usage:
+    def test_transfer(direct_vm, direct_deploy):
+        token = direct_deploy("contracts/Token.py")
+        direct_vm.sender = alice
+        token.transfer(bob, 100)
+        assert token.balances[bob] == 100
+"""
+
+from __future__ import annotations
+
+import pytest
+from pathlib import Path
+from typing import Any, Optional, Callable
+
+from .vm import VMContext
+from .loader import deploy_contract, create_address, create_test_addresses
+
+
+@pytest.fixture
+def direct_vm() -> VMContext:
+    """
+    Provides a fresh VMContext for each test.
+    The VM is automatically activated for the test scope.
+    """
+    ctx = VMContext()
+    ctx.sender = create_address("default_sender")
+
+    with ctx.activate():
+        yield ctx
+
+
+@pytest.fixture
+def direct_deploy(direct_vm: VMContext) -> Callable[..., Any]:
+    """
+    Factory fixture for deploying contracts directly.
+
+    Usage:
+        def test_example(direct_deploy):
+            token = direct_deploy("path/to/Token.py", initial_supply=1000)
+    """
+    def _deploy(
+        contract_path: str,
+        *args: Any,
+        sdk_version: Optional[str] = None,
+        **kwargs: Any,
+    ) -> Any:
+        path = Path(contract_path)
+
+        if not path.is_absolute():
+            if path.exists():
+                path = path.resolve()
+            else:
+                for base in [
+                    Path.cwd(),
+                    Path.cwd() / "contracts",
+                    Path.cwd() / "intelligent-contracts",
+                ]:
+                    candidate = base / contract_path
+                    if candidate.exists():
+                        path = candidate.resolve()
+                        break
+
+        return deploy_contract(path, direct_vm, *args, sdk_version=sdk_version, **kwargs)
+
+    return _deploy
+
+
+@pytest.fixture
+def direct_alice() -> Any:
+    """Test address: Alice."""
+    return create_address("alice")
+
+
+@pytest.fixture
+def direct_bob() -> Any:
+    """Test address: Bob."""
+    return create_address("bob")
+
+
+@pytest.fixture
+def direct_charlie() -> Any:
+    """Test address: Charlie."""
+    return create_address("charlie")
+
+
+@pytest.fixture
+def direct_owner() -> Any:
+    """Test address: Owner (default sender)."""
+    return create_address("default_sender")
+
+
+@pytest.fixture
+def direct_accounts() -> list:
+    """List of 10 test addresses."""
+    return create_test_addresses(10)
+
+
+def pytest_configure(config):
+    """Register markers for direct tests."""
+    config.addinivalue_line(
+        "markers",
+        "direct: mark test as using direct contract execution (no simulator)",
+    )
+
+
+def pytest_collection_modifyitems(config, items):
+    """Auto-mark tests using direct fixtures."""
+    for item in items:
+        if 'direct_vm' in item.fixturenames or 'direct_deploy' in item.fixturenames:
+            item.add_marker(pytest.mark.direct)

gltest/direct/sdk_loader.py

@@ -0,0 +1,260 @@
+"""
+SDK version loader for direct test runner.
+
+Handles downloading and extracting the correct genlayer-py-std version
+based on contract header dependencies, similar to genvm-linter.
+"""
+
+import os
+import re
+import sys
+import json
+import tarfile
+import tempfile
+import urllib.request
+from pathlib import Path
+from typing import Optional, Dict, List
+
+CACHE_DIR = Path.home() / ".cache" / "gltest-direct"
+GITHUB_RELEASES_URL = "https://github.com/genlayerlabs/genvm/releases"
+
+RUNNER_TYPE = "py-genlayer"
+STD_LIB_TYPE = "py-lib-genlayer-std"
+EMBEDDINGS_TYPE = "py-lib-genlayer-embeddings"
+PROTOBUF_TYPE = "py-lib-protobuf"
+
+
+def parse_contract_header(contract_path: Path) -> Dict[str, str]:
+    """
+    Parse contract file header to extract dependency hashes.
+
+    Returns dict mapping dependency name to hash.
+    """
+    deps = {}
+    with open(contract_path, "r") as f:
+        content = f.read(2000)
+
+    pattern = r'"Depends":\s*"([^:]+):([^"]+)"'
+    for match in re.finditer(pattern, content):
+        name, hash_val = match.groups()
+        deps[name] = hash_val
+
+    return deps
+
+
+def get_latest_version() -> str:
+    """Get latest genvm release version from GitHub."""
+    try:
+        req = urllib.request.Request(
+            f"{GITHUB_RELEASES_URL}/latest",
+            method="HEAD",
+        )
+        req.add_header("User-Agent", "gltest-direct")
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            final_url = resp.url
+            version = final_url.split("/")[-1]
+            return version
+    except Exception:
+        return "v0.2.12"
+
+
+def list_cached_versions() -> List[str]:
+    """List all cached genvm versions."""
+    if not CACHE_DIR.exists():
+        return []
+
+    versions = []
+    for f in CACHE_DIR.glob("genvm-universal-*.tar.xz"):
+        match = re.search(r"genvm-universal-(.+)\.tar\.xz", f.name)
+        if match:
+            versions.append(match.group(1))
+    return sorted(versions, reverse=True)
+
+
+def download_artifacts(version: str) -> Path:
+    """Download genvm release tarball if not cached."""
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+    tarball_name = f"genvm-universal-{version}.tar.xz"
+    tarball_path = CACHE_DIR / tarball_name
+
+    if tarball_path.exists():
+        return tarball_path
+
+    url = f"{GITHUB_RELEASES_URL}/download/{version}/genvm-universal.tar.xz"
+    print(f"Downloading {url}...")
+
+    req = urllib.request.Request(url)
+    req.add_header("User-Agent", "gltest-direct")
+
+    with urllib.request.urlopen(req, timeout=300) as resp:
+        total = int(resp.headers.get("Content-Length", 0))
+        downloaded = 0
+
+        with tempfile.NamedTemporaryFile(delete=False, dir=CACHE_DIR) as tmp:
+            while True:
+                chunk = resp.read(1024 * 1024)
+                if not chunk:
+                    break
+                tmp.write(chunk)
+                downloaded += len(chunk)
+                if total:
+                    pct = downloaded * 100 // total
+                    print(f"\r  {pct}% ({downloaded // 1024 // 1024}MB)", end="", flush=True)
+
+            tmp_path = tmp.name
+
+    print()
+    os.rename(tmp_path, tarball_path)
+    return tarball_path
+
+
+def extract_runner(
+    tarball_path: Path,
+    runner_type: str,
+    runner_hash: Optional[str] = None,
+    version: Optional[str] = None,
+) -> Path:
+    """Extract a runner from the tarball."""
+    if version is None:
+        match = re.search(r"genvm-universal-(.+)\.tar\.xz", tarball_path.name)
+        version = match.group(1) if match else "unknown"
+
+    extract_base = CACHE_DIR / "extracted" / version / runner_type
+
+    # Fast path: if hash specified and already extracted, skip tarball entirely
+    if runner_hash and runner_hash.lower() != "latest":
+        extract_dir = extract_base / runner_hash
+        if extract_dir.exists():
+            return extract_dir
+
+    # Check if any version already extracted (for "latest" case)
+    if extract_base.exists():
+        existing = sorted(extract_base.iterdir(), reverse=True)
+        if existing and (not runner_hash or runner_hash.lower() == "latest"):
+            return existing[0]
+
+    # Need to open tarball - this is slow (~13s for xz)
+    with tarfile.open(tarball_path, "r:xz") as outer_tar:
+        prefix = f"runners/{runner_type}/"
+        runner_tars = [
+            m.name for m in outer_tar.getmembers()
+            if m.name.startswith(prefix) and m.name.endswith(".tar")
+        ]
+
+        if not runner_tars:
+            raise ValueError(f"No {runner_type} runners found in tarball")
+
+        # Treat "latest" as no specific hash
+        if runner_hash and runner_hash.lower() != "latest":
+            target = f"runners/{runner_type}/{runner_hash[:2]}/{runner_hash[2:]}.tar"
+            if target not in runner_tars:
+                raise ValueError(f"Runner hash {runner_hash} not found")
+            runner_tar_name = target
+            extract_dir = extract_base / runner_hash
+        else:
+            runner_tar_name = sorted(runner_tars)[-1]
+            parts = runner_tar_name.split("/")
+            runner_hash = parts[-2] + parts[-1].replace(".tar", "")
+            extract_dir = extract_base / runner_hash
+
+        if extract_dir.exists():
+            return extract_dir
+
+        inner_tar_file = outer_tar.extractfile(runner_tar_name)
+        if inner_tar_file is None:
+            raise ValueError(f"Failed to read {runner_tar_name}")
+
+        extract_dir.mkdir(parents=True, exist_ok=True)
+
+        with tarfile.open(fileobj=inner_tar_file, mode="r:") as inner_tar:
+            inner_tar.extractall(extract_dir)
+
+        return extract_dir
+
+
+def parse_runner_manifest(runner_dir: Path) -> Dict[str, str]:
+    """Parse runner.json to get transitive dependencies."""
+    manifest_path = runner_dir / "runner.json"
+    if not manifest_path.exists():
+        return {}
+
+    with open(manifest_path) as f:
+        manifest = json.load(f)
+
+    deps = {}
+    seq = manifest.get("Seq", [])
+    for item in seq:
+        if "Depends" in item:
+            dep = item["Depends"]
+            if ":" in dep:
+                name, hash_val = dep.split(":", 1)
+                deps[name] = hash_val
+
+    return deps
+
+
+def setup_sdk_paths(
+    contract_path: Optional[Path] = None,
+    version: Optional[str] = None,
+) -> List[Path]:
+    """
+    Setup sys.path with correct SDK versions for a contract.
+
+    Returns list of paths added to sys.path.
+    """
+    contract_deps = {}
+    if contract_path and contract_path.exists():
+        contract_deps = parse_contract_header(contract_path)
+
+    if version is None:
+        cached = list_cached_versions()
+        version = cached[0] if cached else get_latest_version()
+
+    tarball = download_artifacts(version)
+
+    runner_hash = contract_deps.get(RUNNER_TYPE)
+    runner_dir = extract_runner(tarball, RUNNER_TYPE, runner_hash, version)
+
+    runner_deps = parse_runner_manifest(runner_dir)
+
+    std_hash = runner_deps.get(STD_LIB_TYPE)
+    std_dir: Optional[Path] = None
+    if std_hash:
+        std_dir = extract_runner(tarball, STD_LIB_TYPE, std_hash, version)
+
+    embeddings_hash = contract_deps.get(EMBEDDINGS_TYPE)
+    embeddings_dir: Optional[Path] = None
+    proto_dir: Optional[Path] = None
+    if embeddings_hash:
+        embeddings_dir = extract_runner(tarball, EMBEDDINGS_TYPE, embeddings_hash, version)
+        proto_hash = runner_deps.get(PROTOBUF_TYPE)
+        if proto_hash:
+            proto_dir = extract_runner(tarball, PROTOBUF_TYPE, proto_hash, version)
+
+    added_paths = []
+
+    # Helper to add path - tries both 'src' subdirectory and direct directory
+    def add_sdk_path(sdk_dir: Path) -> None:
+        src_path = sdk_dir / "src"
+        if src_path.exists():
+            path_to_add = src_path
+        else:
+            path_to_add = sdk_dir
+
+        if str(path_to_add) not in sys.path:
+            sys.path.insert(0, str(path_to_add))
+            added_paths.append(path_to_add)
+
+    add_sdk_path(runner_dir)
+
+    if std_dir:
+        add_sdk_path(std_dir)
+
+    if embeddings_dir:
+        add_sdk_path(embeddings_dir)
+
+    if proto_dir:
+        add_sdk_path(proto_dir)
+
+    return added_paths

gltest/direct/types.py

@@ -0,0 +1,18 @@
+"""
+Type definitions for direct test runner.
+
+Reuses MockedLLMResponse and MockedWebResponse from gltest.types.
+"""
+
+# Re-export from parent package for convenience
+from ..types import (
+    MockedLLMResponse,
+    MockedWebResponse,
+    MockedWebResponseData,
+)
+
+__all__ = [
+    "MockedLLMResponse",
+    "MockedWebResponse",
+    "MockedWebResponseData",
+]