genlayer-test 0.11.0__tar.gz → 0.12.0__tar.gz

{genlayer_test-0.11.0 → genlayer_test-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: genlayer-test
-Version: 0.11.0
+Version: 0.12.0
 Summary: GenLayer Testing Suite
 Author: GenLayer
 License-Expression: MIT
@@ -312,6 +312,72 @@ The chain type determines various behaviors including RPC endpoints, consensus m
 - **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.
 - **Custom Transaction Context** – Set custom validators with specific LLM providers and models, and configure GenVM datetime for deterministic testing scenarios.
+- **Direct Execution Mode** – Run contracts directly in Python for ultra-fast unit testing (~ms vs minutes).
+
+## ⚡ Direct vs Simulator Mode
+
+The testing suite provides two execution modes:
+
+| Mode | How it works | Speed | Use case |
+|------|--------------|-------|----------|
+| **Simulator** | Deploy to GenLayer simulator, interact via RPC | ~minutes | Integration tests, consensus validation |
+| **Direct** | Run Python code directly in-memory | ~milliseconds | Unit tests, rapid development |
+
+### Quick Start with Direct Mode
+
+```python
+def test_token_transfer(direct_vm, direct_deploy):
+    # Deploy contract directly in Python (no simulator)
+    token = direct_deploy("contracts/Token.py", initial_supply=1000)
+
+    # Create test addresses
+    from gltest.direct import create_address
+    alice = create_address("alice")
+    bob = create_address("bob")
+
+    # Set sender and interact
+    direct_vm.sender = alice
+    token.mint(alice, 500)
+    token.transfer(bob, 100)
+
+    assert token.balances[bob] == 100
+```
+
+### Available Fixtures
+
+| Fixture | Description |
+|---------|-------------|
+| `direct_vm` | VM context with cheatcodes |
+| `direct_deploy` | Deploy contracts directly |
+| `direct_alice`, `direct_bob`, `direct_charlie` | Test addresses |
+| `direct_owner` | Default sender address |
+| `direct_accounts` | List of 10 test addresses |
+
+### Cheatcodes
+
+```python
+# Change sender
+direct_vm.sender = alice
+
+# Prank (temporary sender change)
+with direct_vm.prank(bob):
+    contract.method()  # Called as bob
+
+# Snapshots
+snap_id = direct_vm.snapshot()
+contract.modify_state()
+direct_vm.revert(snap_id)  # State restored
+
+# Expect revert
+with direct_vm.expect_revert("Insufficient balance"):
+    contract.transfer(bob, 1000000)
+
+# Mock web/LLM (for nondet operations)
+direct_vm.mock_web(r"api\.example\.com", {"status": 200, "body": "{}"})
+direct_vm.mock_llm(r"analyze.*", "positive sentiment")
+```
+
+📖 **[Full Direct Mode Documentation](docs/direct-runner.md)**
 
 ## 📚 Examples
 

{genlayer_test-0.11.0 → genlayer_test-0.12.0}/README.md

@@ -289,6 +289,72 @@ The chain type determines various behaviors including RPC endpoints, consensus m
 - **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.
 - **Custom Transaction Context** – Set custom validators with specific LLM providers and models, and configure GenVM datetime for deterministic testing scenarios.
+- **Direct Execution Mode** – Run contracts directly in Python for ultra-fast unit testing (~ms vs minutes).
+
+## ⚡ Direct vs Simulator Mode
+
+The testing suite provides two execution modes:
+
+| Mode | How it works | Speed | Use case |
+|------|--------------|-------|----------|
+| **Simulator** | Deploy to GenLayer simulator, interact via RPC | ~minutes | Integration tests, consensus validation |
+| **Direct** | Run Python code directly in-memory | ~milliseconds | Unit tests, rapid development |
+
+### Quick Start with Direct Mode
+
+```python
+def test_token_transfer(direct_vm, direct_deploy):
+    # Deploy contract directly in Python (no simulator)
+    token = direct_deploy("contracts/Token.py", initial_supply=1000)
+
+    # Create test addresses
+    from gltest.direct import create_address
+    alice = create_address("alice")
+    bob = create_address("bob")
+
+    # Set sender and interact
+    direct_vm.sender = alice
+    token.mint(alice, 500)
+    token.transfer(bob, 100)
+
+    assert token.balances[bob] == 100
+```
+
+### Available Fixtures
+
+| Fixture | Description |
+|---------|-------------|
+| `direct_vm` | VM context with cheatcodes |
+| `direct_deploy` | Deploy contracts directly |
+| `direct_alice`, `direct_bob`, `direct_charlie` | Test addresses |
+| `direct_owner` | Default sender address |
+| `direct_accounts` | List of 10 test addresses |
+
+### Cheatcodes
+
+```python
+# Change sender
+direct_vm.sender = alice
+
+# Prank (temporary sender change)
+with direct_vm.prank(bob):
+    contract.method()  # Called as bob
+
+# Snapshots
+snap_id = direct_vm.snapshot()
+contract.modify_state()
+direct_vm.revert(snap_id)  # State restored
+
+# Expect revert
+with direct_vm.expect_revert("Insufficient balance"):
+    contract.transfer(bob, 1000000)
+
+# Mock web/LLM (for nondet operations)
+direct_vm.mock_web(r"api\.example\.com", {"status": 200, "body": "{}"})
+direct_vm.mock_llm(r"analyze.*", "positive sentiment")
+```
+
+📖 **[Full Direct Mode Documentation](docs/direct-runner.md)**
 
 ## 📚 Examples
 

{genlayer_test-0.11.0 → genlayer_test-0.12.0}/genlayer_test.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: genlayer-test
-Version: 0.11.0
+Version: 0.12.0
 Summary: GenLayer Testing Suite
 Author: GenLayer
 License-Expression: MIT
@@ -312,6 +312,72 @@ The chain type determines various behaviors including RPC endpoints, consensus m
 - **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.
 - **Custom Transaction Context** – Set custom validators with specific LLM providers and models, and configure GenVM datetime for deterministic testing scenarios.
+- **Direct Execution Mode** – Run contracts directly in Python for ultra-fast unit testing (~ms vs minutes).
+
+## ⚡ Direct vs Simulator Mode
+
+The testing suite provides two execution modes:
+
+| Mode | How it works | Speed | Use case |
+|------|--------------|-------|----------|
+| **Simulator** | Deploy to GenLayer simulator, interact via RPC | ~minutes | Integration tests, consensus validation |
+| **Direct** | Run Python code directly in-memory | ~milliseconds | Unit tests, rapid development |
+
+### Quick Start with Direct Mode
+
+```python
+def test_token_transfer(direct_vm, direct_deploy):
+    # Deploy contract directly in Python (no simulator)
+    token = direct_deploy("contracts/Token.py", initial_supply=1000)
+
+    # Create test addresses
+    from gltest.direct import create_address
+    alice = create_address("alice")
+    bob = create_address("bob")
+
+    # Set sender and interact
+    direct_vm.sender = alice
+    token.mint(alice, 500)
+    token.transfer(bob, 100)
+
+    assert token.balances[bob] == 100
+```
+
+### Available Fixtures
+
+| Fixture | Description |
+|---------|-------------|
+| `direct_vm` | VM context with cheatcodes |
+| `direct_deploy` | Deploy contracts directly |
+| `direct_alice`, `direct_bob`, `direct_charlie` | Test addresses |
+| `direct_owner` | Default sender address |
+| `direct_accounts` | List of 10 test addresses |
+
+### Cheatcodes
+
+```python
+# Change sender
+direct_vm.sender = alice
+
+# Prank (temporary sender change)
+with direct_vm.prank(bob):
+    contract.method()  # Called as bob
+
+# Snapshots
+snap_id = direct_vm.snapshot()
+contract.modify_state()
+direct_vm.revert(snap_id)  # State restored
+
+# Expect revert
+with direct_vm.expect_revert("Insufficient balance"):
+    contract.transfer(bob, 1000000)
+
+# Mock web/LLM (for nondet operations)
+direct_vm.mock_web(r"api\.example\.com", {"status": 200, "body": "{}"})
+direct_vm.mock_llm(r"analyze.*", "positive sentiment")
+```
+
+📖 **[Full Direct Mode Documentation](docs/direct-runner.md)**
 
 ## 📚 Examples
 

{genlayer_test-0.11.0 → genlayer_test-0.12.0}/genlayer_test.egg-info/SOURCES.txt

@@ -25,6 +25,13 @@ gltest/contracts/contract_functions.py
 gltest/contracts/method_stats.py
 gltest/contracts/stats_collector.py
 gltest/contracts/utils.py
+gltest/direct/__init__.py
+gltest/direct/loader.py
+gltest/direct/pytest_plugin.py
+gltest/direct/sdk_loader.py
+gltest/direct/types.py
+gltest/direct/vm.py
+gltest/direct/wasi_mock.py
 gltest/helpers/__init__.py
 gltest/helpers/fixture_snapshot.py
 gltest/helpers/take_snapshot.py

{genlayer_test-0.11.0 → genlayer_test-0.12.0}/genlayer_test.egg-info/entry_points.txt

@@ -3,3 +3,4 @@ gltest = gltest_cli.main:main
 
 [pytest11]
 gltest = gltest_cli.config.plugin
+gltest_direct = gltest.direct.pytest_plugin

{genlayer_test-0.11.0 → genlayer_test-0.12.0}/genlayer_test.egg-info/top_level.txt

@@ -1,3 +1,4 @@
 dist
+docs
 gltest
 gltest_cli

genlayer_test-0.12.0/gltest/direct/__init__.py

@@ -0,0 +1,31 @@
+"""
+Native Python test runner for GenLayer intelligent contracts.
+
+Runs contracts directly in Python without WASM/simulator, providing
+Foundry-style cheatcodes and fast test execution.
+
+Usage:
+    from gltest.direct import VMContext, deploy_contract
+
+    def test_transfer():
+        vm = VMContext()
+        with vm.activate():
+            token = deploy_contract("path/to/Token.py", vm, owner)
+            vm.sender = alice
+            token.transfer(bob, 100)
+            assert token.balances[bob] == 100
+"""
+
+from .vm import VMContext
+from .loader import deploy_contract, load_contract_class, create_address, create_test_addresses
+from .wasi_mock import ContractRollback, MockNotFoundError
+
+__all__ = [
+    "VMContext",
+    "deploy_contract",
+    "load_contract_class",
+    "create_address",
+    "create_test_addresses",
+    "ContractRollback",
+    "MockNotFoundError",
+]

genlayer_test-0.12.0/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)]

genlayer_test-0.12.0/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)