genlayer-test 0.11.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

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",
+]

gltest/direct/vm.py

@@ -0,0 +1,432 @@
+"""
+VMContext - Foundry-style test VM for GenLayer contracts.
+
+Provides cheatcodes for:
+- Setting sender/value (vm.sender, vm.value)
+- Snapshots and reverts (vm.snapshot(), vm.revert())
+- Mocking nondet operations (vm.mock_web(), vm.mock_llm())
+- Expecting reverts (vm.expect_revert())
+- Pranking (vm.prank(), vm.startPrank(), vm.stopPrank())
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+import hashlib
+from contextlib import contextmanager, ExitStack
+from dataclasses import dataclass, field
+from typing import Any, Optional, Pattern, List, Tuple, Dict
+from unittest.mock import patch
+
+from ..types import MockedWebResponseData
+
+
+@dataclass
+class Snapshot:
+    """Storage snapshot for revert functionality."""
+    id: int
+    storage_data: Dict[bytes, bytes]
+    balances: Dict[bytes, int]
+
+
+class InmemManager:
+    """
+    In-memory storage manager compatible with genlayer.py.storage.
+    """
+
+    def __init__(self):
+        self._parts: Dict[bytes, Tuple["Slot", bytearray]] = {}
+
+    def get_store_slot(self, slot_id: bytes) -> "Slot":
+        res = self._parts.get(slot_id)
+        if res is None:
+            slot = Slot(slot_id, self)
+            self._parts[slot_id] = (slot, bytearray())
+            return slot
+        return res[0]
+
+    def do_read(self, slot_id: bytes, off: int, length: int) -> bytes:
+        res = self._parts.get(slot_id)
+        if res is None:
+            slot = Slot(slot_id, self)
+            mem = bytearray()
+            self._parts[slot_id] = (slot, mem)
+        else:
+            _, mem = res
+
+        needed = off + length
+        if len(mem) < needed:
+            mem.extend(b'\x00' * (needed - len(mem)))
+
+        return bytes(memoryview(mem)[off:off + length])
+
+    def do_write(self, slot_id: bytes, off: int, what: bytes) -> None:
+        res = self._parts.get(slot_id)
+        if res is None:
+            slot = Slot(slot_id, self)
+            mem = bytearray()
+            self._parts[slot_id] = (slot, mem)
+        else:
+            _, mem = res
+
+        what_view = memoryview(what)
+        length = len(what_view)
+
+        needed = off + length
+        if len(mem) < needed:
+            mem.extend(b'\x00' * (needed - len(mem)))
+
+        memoryview(mem)[off:off + length] = what_view
+
+    def snapshot(self) -> Dict[bytes, bytes]:
+        return {
+            slot_id: bytes(mem)
+            for slot_id, (_, mem) in self._parts.items()
+        }
+
+    def restore(self, data: Dict[bytes, bytes]) -> None:
+        self._parts.clear()
+        for slot_id, mem_data in data.items():
+            slot = Slot(slot_id, self)
+            self._parts[slot_id] = (slot, bytearray(mem_data))
+
+
+class Slot:
+    """Storage slot compatible with genlayer.py.storage."""
+
+    __slots__ = ('id', 'manager', '_indir_cache')
+
+    def __init__(self, slot_id: bytes, manager: InmemManager):
+        self.id = slot_id
+        self.manager = manager
+        self._indir_cache = hashlib.sha3_256(slot_id)
+
+    def read(self, off: int, length: int) -> bytes:
+        return self.manager.do_read(self.id, off, length)
+
+    def write(self, off: int, what: bytes) -> None:
+        self.manager.do_write(self.id, off, what)
+
+    def indirect(self, off: int) -> "Slot":
+        hasher = self._indir_cache.copy()
+        hasher.update(off.to_bytes(4, 'little'))
+        return self.manager.get_store_slot(hasher.digest())
+
+
+ROOT_SLOT_ID = b'\x00' * 32
+
+
+@dataclass
+class VMContext:
+    """
+    Test VM context providing Foundry-style cheatcodes.
+
+    Usage:
+        vm = VMContext()
+        vm.sender = Address("0x" + "a" * 40)
+        vm.mock_web("api.example.com", {"status": 200, "body": "{}"})
+
+        with vm.activate():
+            contract = deploy_contract("Token.py", vm, owner)
+            contract.transfer(bob, 100)
+    """
+
+    # Message context
+    _sender: Optional[Any] = None
+    _origin: Optional[Any] = None
+    _contract_address: Optional[Any] = None
+    _value: int = 0
+    _chain_id: int = 1
+    _datetime: str = "2024-01-01T00:00:00Z"
+
+    # Storage
+    _storage: InmemManager = field(default_factory=InmemManager)
+    _balances: Dict[bytes, int] = field(default_factory=dict)
+
+    # Snapshots
+    _snapshots: Dict[int, Snapshot] = field(default_factory=dict)
+    _snapshot_counter: int = 0
+
+    # Mocks
+    _web_mocks: List[Tuple[Pattern, MockedWebResponseData]] = field(default_factory=list)
+    _llm_mocks: List[Tuple[Pattern, str]] = field(default_factory=list)
+
+    # Expect revert
+    _expect_revert: Optional[str] = None
+    _expect_revert_any: bool = False
+
+    # Prank stack
+    _prank_stack: List[Any] = field(default_factory=list)
+
+    # Return value capture
+    _return_value: Any = None
+    _returned: bool = False
+
+    # Debug tracing
+    _traces: List[str] = field(default_factory=list)
+    _trace_enabled: bool = True
+
+    @property
+    def sender(self) -> Any:
+        if self._prank_stack:
+            return self._prank_stack[-1]
+        return self._sender
+
+    @sender.setter
+    def sender(self, addr: Any) -> None:
+        self._sender = addr
+        self._refresh_gl_message()
+
+    @property
+    def value(self) -> int:
+        return self._value
+
+    @value.setter
+    def value(self, val: int) -> None:
+        self._value = val
+
+    @property
+    def origin(self) -> Any:
+        return self._origin or self._sender
+
+    @origin.setter
+    def origin(self, addr: Any) -> None:
+        self._origin = addr
+
+    def warp(self, timestamp: str) -> None:
+        """Set block timestamp (ISO format)."""
+        self._datetime = timestamp
+
+    def deal(self, address: Any, amount: int) -> None:
+        """Set balance for an address."""
+        addr_bytes = self._to_bytes(address)
+        self._balances[addr_bytes] = amount
+
+    def snapshot(self) -> int:
+        """Take a snapshot of current state. Returns snapshot ID."""
+        snap_id = self._snapshot_counter
+        self._snapshot_counter += 1
+
+        self._snapshots[snap_id] = Snapshot(
+            id=snap_id,
+            storage_data=self._storage.snapshot(),
+            balances=dict(self._balances),
+        )
+
+        return snap_id
+
+    def revert(self, snapshot_id: int) -> None:
+        """Revert to a previous snapshot."""
+        if snapshot_id not in self._snapshots:
+            raise ValueError(f"Snapshot {snapshot_id} not found")
+
+        snap = self._snapshots[snapshot_id]
+        self._storage.restore(snap.storage_data)
+        self._balances = dict(snap.balances)
+
+        self._snapshots = {
+            k: v for k, v in self._snapshots.items()
+            if k <= snapshot_id
+        }
+
+    def mock_web(
+        self,
+        url_pattern: str,
+        response: MockedWebResponseData,
+    ) -> None:
+        """Mock web requests matching URL pattern."""
+        pattern = re.compile(url_pattern)
+        self._web_mocks.append((pattern, response))
+
+    def mock_llm(self, prompt_pattern: str, response: str) -> None:
+        """Mock LLM prompts matching pattern."""
+        pattern = re.compile(prompt_pattern)
+        self._llm_mocks.append((pattern, response))
+
+    def clear_mocks(self) -> None:
+        """Clear all registered mocks."""
+        self._web_mocks.clear()
+        self._llm_mocks.clear()
+
+    @contextmanager
+    def expect_revert(self, message: Optional[str] = None):
+        """Context manager expecting the next call to revert."""
+        self._expect_revert = message
+        self._expect_revert_any = message is None
+
+        try:
+            yield
+            raise AssertionError(
+                f"Expected revert{f' with message: {message}' if message else ''}, but call succeeded"
+            )
+        except Exception as e:
+            from .wasi_mock import ContractRollback
+
+            if isinstance(e, ContractRollback):
+                if message is not None and message not in e.message:
+                    raise AssertionError(
+                        f"Expected revert with message '{message}', got '{e.message}'"
+                    )
+            elif isinstance(e, AssertionError):
+                raise
+            else:
+                if message is not None and message not in str(e):
+                    raise
+        finally:
+            self._expect_revert = None
+            self._expect_revert_any = False
+
+    @contextmanager
+    def prank(self, address: Any):
+        """Context manager to temporarily change sender."""
+        self._prank_stack.append(address)
+        self._refresh_gl_message()
+        try:
+            yield
+        finally:
+            self._prank_stack.pop()
+            self._refresh_gl_message()
+
+    def startPrank(self, address: Any) -> None:
+        """Start pranking as address (persists until stopPrank)."""
+        self._prank_stack.append(address)
+        self._refresh_gl_message()
+
+    def stopPrank(self) -> None:
+        """Stop the current prank."""
+        if self._prank_stack:
+            self._prank_stack.pop()
+            self._refresh_gl_message()
+        else:
+            raise RuntimeError("No active prank to stop")
+
+    @contextmanager
+    def activate(self):
+        """
+        Activate this VM context for contract execution.
+        Uses proper cleanup via ExitStack for resource management.
+        """
+        from . import wasi_mock
+
+        with ExitStack() as stack:
+            wasi_mock.set_vm(self)
+            sys.modules['_genlayer_wasi'] = wasi_mock
+
+            stack.enter_context(
+                patch('os.fdopen', wasi_mock.patched_fdopen)
+            )
+            stack.callback(self._cleanup_after_deactivate)
+
+            try:
+                yield self
+            finally:
+                if '_genlayer_wasi' in sys.modules:
+                    del sys.modules['_genlayer_wasi']
+                wasi_mock.clear_vm()
+
+    def _cleanup_after_deactivate(self) -> None:
+        """Clean up resources after VM deactivation."""
+        modules_to_remove = [
+            key for key in sys.modules.keys()
+            if key.startswith('genlayer') or key.startswith('_contract_')
+        ]
+        for mod in modules_to_remove:
+            del sys.modules[mod]
+
+    def _match_web_mock(self, url: str, method: str = "GET") -> Optional[MockedWebResponseData]:
+        for pattern, response in self._web_mocks:
+            if pattern.search(url):
+                if response.get("method", "GET") == method:
+                    return response
+        return None
+
+    def _match_llm_mock(self, prompt: str) -> Optional[str]:
+        for pattern, response in self._llm_mocks:
+            if pattern.search(prompt):
+                return response
+        return None
+
+    def _trace(self, message: str) -> None:
+        if self._trace_enabled:
+            self._traces.append(message)
+
+    def _to_bytes(self, addr: Any) -> bytes:
+        if isinstance(addr, bytes):
+            return addr
+        if hasattr(addr, 'as_bytes'):
+            return addr.as_bytes
+        if hasattr(addr, '__bytes__'):
+            return bytes(addr)
+        if isinstance(addr, str):
+            if addr.startswith("0x"):
+                return bytes.fromhex(addr[2:])
+            return bytes.fromhex(addr)
+        raise ValueError(f"Cannot convert {type(addr)} to bytes")
+
+    def _refresh_gl_message(self) -> None:
+        """
+        Refresh gl.message and gl.message_raw to reflect current sender.
+
+        GenLayer SDK caches gl.message at import time. This method updates
+        the cached values so contracts see the current vm.sender.
+
+        Only updates if genlayer.gl is already imported - we must not trigger
+        a fresh import as that would read from stdin before message is injected.
+        """
+        # Only proceed if genlayer.gl is already loaded
+        if 'genlayer.gl' not in sys.modules:
+            return
+
+        try:
+            gl = sys.modules['genlayer.gl']
+            from genlayer.py.types import Address, u256
+
+            # Convert sender to Address if needed
+            sender = self.sender
+            if sender is not None and not isinstance(sender, Address):
+                if isinstance(sender, bytes):
+                    sender = Address(sender)
+                elif hasattr(sender, 'as_bytes'):
+                    sender = Address(sender.as_bytes)
+
+            origin = self.origin
+            if origin is not None and not isinstance(origin, Address):
+                if isinstance(origin, bytes):
+                    origin = Address(origin)
+                elif hasattr(origin, 'as_bytes'):
+                    origin = Address(origin.as_bytes)
+
+            # Update message_raw dict (mutable)
+            if hasattr(gl, 'message_raw') and gl.message_raw is not None:
+                gl.message_raw['sender_address'] = sender
+                gl.message_raw['origin_address'] = origin
+
+            # Replace gl.message with new NamedTuple (immutable, must recreate)
+            if hasattr(gl, 'message') and gl.message is not None:
+                gl.message = gl.MessageType(
+                    contract_address=gl.message.contract_address,
+                    sender_address=sender,
+                    origin_address=origin,
+                    value=u256(self._value),
+                    chain_id=u256(self._chain_id),
+                )
+        except ImportError:
+            # genlayer not loaded yet, nothing to update
+            pass
+
+    def get_message_raw(self) -> Dict[str, Any]:
+        """Get MessageRawType dict for stdin injection."""
+        return {
+            "contract_address": self._contract_address,
+            "sender_address": self.sender,
+            "origin_address": self.origin,
+            "stack": [],
+            "value": self._value,
+            "datetime": self._datetime,
+            "is_init": False,
+            "chain_id": self._chain_id,
+            "entry_kind": 0,
+            "entry_data": b"",
+            "entry_stage_data": None,
+        }