colibri-stateless 0.7.2__cp38-cp38-win_amd64.whl → 0.7.4__cp38-cp38-win_amd64.whl

colibri/__init__.py

@@ -6,8 +6,8 @@ Python bindings for the Colibri stateless Ethereum proof library.
 
 import atexit
 from .storage import ColibriStorage, DefaultStorage, MemoryStorage  
-from .types import MethodType, ColibriError
-from .testing import MockStorage, MockRequestHandler
+from .types import MethodType, ColibriError, RPCError
+from .testing import MockStorage, MockRequestHandler, MockProofData, TestHelper
 
 # Try to import native module
 try:
@@ -24,21 +24,20 @@ _global_storage = None
 _storage_registered = False
 
 def _register_global_storage(storage: ColibriStorage = None):
-    """Register global storage once for the entire module"""
+    """Register global storage (can be changed, but affects all Colibri instances)"""
     global _global_storage, _storage_registered
     
-    if _storage_registered:
-        # Already registered - check if it's the same type
-        if storage is not None and type(storage) != type(_global_storage):
-            import warnings
-            warnings.warn(
-                f"Storage already registered as {type(_global_storage).__name__}, "
-                f"ignoring {type(storage).__name__}. C storage is global across all instances.",
-                RuntimeWarning
-            )
-        return _global_storage
+    # Allow storage re-registration for testing
+    # Note: This affects ALL Colibri instances as C storage is global
+    if _storage_registered and storage is not None:
+        if type(storage) != type(_global_storage):
+            # Storage type is changing - re-register
+            _storage_registered = False
         
     if storage is None:
+        if _storage_registered:
+            # Return existing storage
+            return _global_storage
         storage = DefaultStorage()
     
     _global_storage = storage
@@ -79,6 +78,9 @@ __all__ = [
     "MemoryStorage",
     "MethodType",
     "ColibriError",
+    "RPCError",
     "MockStorage",
     "MockRequestHandler",
+    "MockProofData",
+    "TestHelper",
 ]

colibri/client.py

@@ -154,7 +154,7 @@ class Colibri:
                 type_int = native.get_method_support(self.chain_id, method)
                 return MethodType(type_int)
             except (ValueError, TypeError):
-                return MethodType.UNKNOWN
+                return MethodType.UNDEFINED
         
         # Fallback implementation for testing
         proofable_methods = {
@@ -173,7 +173,7 @@ class Colibri:
         elif method.startswith("eth_"):
             return MethodType.UNPROOFABLE
         else:
-            return MethodType.NOT_SUPPORTED
+            return MethodType.UNDEFINED
 
     async def create_proof(self, method: str, params: List[Any]) -> bytes:
         """
@@ -281,27 +281,12 @@ class Colibri:
                     if not status_json:
                         raise VerificationError("Verification execution returned null")
                     
-                    # Debug: Print the raw JSON response from C
-                    # DEBUG: Raw C JSON response available for debugging
-                    
+                    # Parse JSON response from C library
                     try:
                         status = json.loads(status_json)
                     except json.JSONDecodeError as e:
-                        # Workaround: Try to fix trailing comma issue from C
-                        if "," in status_json and status_json.rstrip().endswith(",}"):
-                            # Workaround: Fix trailing comma in C JSON
-                            fixed_json = status_json.replace(",}", "}")
-                            print(f"   Fixed JSON: {repr(fixed_json)}")
-                            try:
-                                status = json.loads(fixed_json)
-                                # JSON parsing successful after fix
-                            except json.JSONDecodeError as e2:
-                                print(f"Still invalid after fix: {e2}")
-                                raise VerificationError(f"Invalid JSON in verification response: {e2}")
-                        else:
-                            # JSON parse error occurred
-                            print(f"   Raw response: {status_json}")
-                            raise VerificationError(f"Invalid JSON in verification response: {e}")
+                        # JSON parsing failed - this indicates a bug in the C library
+                        raise VerificationError(f"Invalid JSON from C library: {e}") from e
                     
                     if status["status"] == "success":
                         return status.get("result")
@@ -358,7 +343,7 @@ class Colibri:
             # Local methods use empty proof
             return await self.verify_proof(b"", method, params)
             
-        elif method_type == MethodType.NOT_SUPPORTED:
+        elif method_type == MethodType.NOT_SUPPORTED or method_type == MethodType.UNDEFINED:
             raise ColibriError(f"Method {method} is not supported")
             
         else:

colibri/testing.py

@@ -2,6 +2,8 @@
 Testing utilities and mock implementations for Colibri Python bindings
 """
 
+from __future__ import annotations
+
 import json
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
@@ -11,6 +13,115 @@ from .storage import ColibriStorage
 from .types import DataRequest, ColibriError
 
 
+class MockProofData:
+    """Utility class for creating mock proof data for testing"""
+    
+    @staticmethod
+    def create_proof(method: str, params: List[Any], result: Any) -> bytes:
+        """
+        Create mock proof data for a given method, params, and result.
+        
+        @param method The RPC method name
+        @param params The RPC method parameters
+        @param result The expected result
+        @return Mock proof data as bytes
+        """
+        proof_dict = {
+            "method": method,
+            "params": params,
+            "result": result,
+            "mock": True
+        }
+        return json.dumps(proof_dict).encode('utf-8')
+    
+    @staticmethod
+    def create_empty_proof() -> bytes:
+        """
+        Create an empty proof (used for LOCAL methods).
+        
+        @return Empty bytes
+        """
+        return b""
+
+
+class TestHelper:
+    """Helper utilities for setting up test scenarios"""
+    
+    @staticmethod
+    def setup_eth_get_balance_mock(
+        handler: 'MockRequestHandler',
+        address: str,
+        block: str,
+        balance: str
+    ) -> None:
+        """
+        Setup a mock response for eth_getBalance.
+        
+        @param handler The mock request handler
+        @param address The Ethereum address
+        @param block The block number or tag
+        @param balance The balance to return (hex string)
+        """
+        response = {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "result": balance
+        }
+        handler.add_response("eth_getBalance", [address, block], response)
+    
+    @staticmethod
+    def setup_eth_get_block_mock(
+        handler: 'MockRequestHandler',
+        block_hash: str,
+        block_data: Dict[str, Any]
+    ) -> None:
+        """
+        Setup a mock response for eth_getBlockByHash.
+        
+        @param handler The mock request handler
+        @param block_hash The block hash
+        @param block_data The block data to return
+        """
+        response = {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "result": block_data
+        }
+        handler.add_response("eth_getBlockByHash", [block_hash, False], response)
+    
+    @staticmethod
+    def setup_proof_mock(
+        handler: 'MockRequestHandler',
+        method: str,
+        params: List[Any],
+        proof_data: Optional[bytes] = None
+    ) -> None:
+        """
+        Setup a mock proof response for a method.
+        
+        @param handler The mock request handler
+        @param method The RPC method name
+        @param params The RPC method parameters
+        @param proof_data Optional custom proof data (generates default if None)
+        """
+        if proof_data is None:
+            proof_data = MockProofData.create_proof(method, params, "mock_result")
+        handler.add_response(method, params, proof_data)
+    
+    @staticmethod
+    def create_mock_storage_with_data(preset_data: Dict[str, bytes]) -> MockStorage:
+        """
+        Create a MockStorage instance with preset data.
+        
+        @param preset_data Dictionary of key-value pairs to preset in storage
+        @return MockStorage instance with preset data
+        """
+        storage = MockStorage()
+        for key, value in preset_data.items():
+            storage.set(key, value)
+        return storage
+
+
 class MockStorage(ColibriStorage):
     """Mock storage implementation for testing"""
 
@@ -32,18 +143,139 @@ class MockStorage(ColibriStorage):
         self.delete_calls.append(key)
         self._data.pop(key, None)
 
+    def size(self) -> int:
+        """Return the number of items in storage"""
+        return len(self._data)
+
+    def preset_data(self, data: Dict[str, bytes]) -> None:
+        """
+        Preset storage with initial data without tracking calls.
+        
+        @param data Dictionary of key-value pairs to preset
+        """
+        self._data.update(data)
+
+    def clear_data(self) -> None:
+        """Clear all data from storage without tracking calls"""
+        self._data.clear()
+
+    def clear_calls(self) -> None:
+        """Clear the history of tracked calls"""
+        self.get_calls.clear()
+        self.set_calls.clear()
+        self.delete_calls.clear()
+
 
 class MockRequestHandler:
     """Mock HTTP request handler for testing"""
 
     def __init__(self):
         self._responses: Dict[str, Union[bytes, Dict[str, Any]]] = {}
+        self._method_responses: Dict[str, Union[bytes, Dict[str, Any]]] = {}
+        self._default_response: Optional[bytes] = None
         self.request_calls: List[DataRequest] = []
 
+    def _make_key(self, method: str, params: List[Any]) -> str:
+        """Create a unique key for method + params combination"""
+        return f"{method}:{json.dumps(params, sort_keys=True)}"
+
+    def add_response(
+        self, 
+        method: str, 
+        params: List[Any], 
+        response: Union[bytes, Dict[str, Any], str]
+    ) -> None:
+        """
+        Add a mock response for a specific method and params combination.
+        
+        @param method The RPC method name
+        @param params The RPC method parameters
+        @param response The response to return (can be bytes, dict, or string)
+        """
+        key = self._make_key(method, params)
+        self._responses[key] = response
+
+    def add_method_response(
+        self,
+        method: str,
+        response: Union[bytes, Dict[str, Any], str]
+    ) -> None:
+        """
+        Add a mock response for any call to a method (ignoring params).
+        
+        @param method The RPC method name
+        @param response The response to return
+        """
+        self._method_responses[method] = response
+
+    def set_default_response(self, response: bytes) -> None:
+        """
+        Set a default response for any unmatched requests.
+        
+        @param response The default response to return
+        """
+        self._default_response = response
+
+    def clear_responses(self) -> None:
+        """Clear all configured responses"""
+        self._responses.clear()
+        self._method_responses.clear()
+        self._default_response = None
+
+    def clear_calls(self) -> None:
+        """Clear the history of request calls"""
+        self.request_calls.clear()
+
+    def get_calls_for_method(self, method: str) -> List[DataRequest]:
+        """
+        Get all request calls for a specific method.
+        
+        @param method The RPC method name
+        @return List of matching requests
+        """
+        return [
+            req for req in self.request_calls
+            if req.payload and req.payload.get("method") == method
+        ]
+
     async def handle_request(self, request: DataRequest) -> bytes:
-        """Handle a mock HTTP request"""
+        """
+        Handle a mock HTTP request.
+        
+        @param request The data request to handle
+        @return Mock response data
+        """
         self.request_calls.append(request)
-        return b'{"result": "mock_response"}'
+        
+        # Try to find a matching response
+        if request.payload and "method" in request.payload:
+            method = request.payload["method"]
+            params = request.payload.get("params", [])
+            
+            # First try exact match (method + params)
+            key = self._make_key(method, params)
+            if key in self._responses:
+                response = self._responses[key]
+                if isinstance(response, bytes):
+                    return response
+                return json.dumps(response).encode('utf-8')
+            
+            # Then try method-only match
+            if method in self._method_responses:
+                response = self._method_responses[method]
+                if isinstance(response, bytes):
+                    return response
+                return json.dumps(response).encode('utf-8')
+        
+        # Use default response if available
+        if self._default_response is not None:
+            return self._default_response
+        
+        # No response configured
+        raise ColibriError(
+            f"No mock response configured for request: "
+            f"method={request.payload.get('method') if request.payload else 'unknown'}"
+        )
 
 
 class FileBasedMockStorage(ColibriStorage):
@@ -54,6 +286,46 @@ class FileBasedMockStorage(ColibriStorage):
         self._cache: Dict[str, Optional[bytes]] = {}
         self._access_count: Dict[str, int] = {}
         self._max_access_per_key = 5  # Prevent infinite loops
+    
+    def _find_file_with_truncation(self, filename: str) -> Optional[Path]:
+        """
+        Find a file, handling filesystem truncation (macOS has 255 char limit).
+        
+        @param filename The full filename to search for
+        @return The path to the file if found, None otherwise
+        """
+        file_path = self.test_data_dir / filename
+        
+        # Try exact match first
+        if file_path.exists():
+            return file_path
+        
+        # If not found and filename is long, try to find truncated versions
+        if len(filename) > 200:
+            # Get the extension
+            parts = filename.rsplit('.', 1)
+            if len(parts) == 2:
+                base_name, extension = parts
+                
+                # Search for files that start with the same prefix and have same extension
+                for prefix_len in [250, 240, 230, 220, 200, 150, 100]:
+                    if len(base_name) > prefix_len:
+                        prefix = base_name[:prefix_len]
+                        pattern = f"{prefix}*.{extension}"
+                        matching_files = list(self.test_data_dir.glob(pattern))
+                        if matching_files:
+                            return matching_files[0]
+            else:
+                # No extension, just search by prefix
+                for prefix_len in [250, 240, 230, 220, 200, 150, 100]:
+                    if len(filename) > prefix_len:
+                        prefix = filename[:prefix_len]
+                        pattern = f"{prefix}*"
+                        matching_files = list(self.test_data_dir.glob(pattern))
+                        if matching_files:
+                            return matching_files[0]
+        
+        return None
         
     def get(self, key: str) -> Optional[bytes]:
         # CRITICAL: Return None immediately to break infinite loops
@@ -70,9 +342,9 @@ class FileBasedMockStorage(ColibriStorage):
             # Return cached value
             return self._cache[key]
         
-        # Load from file
-        file_path = self.test_data_dir / key
-        if file_path.exists():
+        # Load from file (with truncation handling)
+        file_path = self._find_file_with_truncation(key)
+        if file_path:
             data = file_path.read_bytes()
             # Load file from storage
             self._cache[key] = data
@@ -99,6 +371,40 @@ class FileBasedMockRequestHandler:
         self._request_count = 0
         self._max_requests = 50  # Prevent infinite request loops
     
+    def _find_file_with_truncation(self, filename: str) -> Optional[Path]:
+        """
+        Find a file, handling filesystem truncation (macOS has 255 char limit).
+        
+        @param filename The full filename to search for
+        @return The path to the file if found, None otherwise
+        """
+        file_path = self.test_data_dir / filename
+        
+        # Try exact match first
+        if file_path.exists():
+            return file_path
+        
+        # If not found and filename is long, try to find truncated versions
+        # macOS typically truncates at 255 characters
+        if len(filename) > 200:  # If it's potentially truncated
+            # Get the extension
+            parts = filename.rsplit('.', 1)
+            if len(parts) == 2:
+                base_name, extension = parts
+                
+                # Search for files that start with the same prefix and have same extension
+                # Use progressively shorter prefixes to find the truncated file
+                for prefix_len in [250, 240, 230, 220, 200, 150, 100]:
+                    if len(base_name) > prefix_len:
+                        prefix = base_name[:prefix_len]
+                        pattern = f"{prefix}*.{extension}"
+                        matching_files = list(self.test_data_dir.glob(pattern))
+                        if matching_files:
+                            # Return the first match
+                            return matching_files[0]
+        
+        return None
+    
     async def handle_request(self, request: DataRequest) -> bytes:
         """Handle mock HTTP request by loading from file"""
         
@@ -106,20 +412,39 @@ class FileBasedMockRequestHandler:
         if self._request_count > self._max_requests:
             raise Exception(f"Too many requests ({self._request_count}) - possible infinite loop")
         
-        # Convert request to filename (simplified)
+        # Convert request to filename base (without extension) - matching C implementation
         if request.url:
-            filename = request.url.replace('/', '_').replace('?', '_').replace('=', '_').replace('&', '_')
-            filename = filename + '.' + request.encoding
+            # Sanitize URL to create filename base
+            base_name = request.url
+            # Replace problematic characters with underscore (matching C implementation)
+            for char in ['/', '.', ',', ' ', ':', '=', '?', '"', '&', '[', ']', '{', '}']:
+                base_name = base_name.replace(char, '_')
         elif request.payload and 'method' in request.payload:
-            method = request.payload['method']
-            filename = method + '.' + request.encoding
+            # For RPC requests, use method name and parameters
+            import json
+            method = request.payload.get('method', '')
+            params = request.payload.get('params', [])
+            base_name = method
+            for param in params:
+                param_str = param if isinstance(param, str) else json.dumps(param)
+                base_name += '_' + param_str
+            # Sanitize the base name
+            for char in ['/', '.', ',', ' ', ':', '=', '?', '"', '&', '[', ']', '{', '}']:
+                base_name = base_name.replace(char, '_')
         else:
-            filename = 'unknown.' + request.encoding
+            base_name = 'unknown'
         
-        # Look for mock response file
+        # CRITICAL: Truncate to maximum length BEFORE adding extension (matching C: C4_MAX_MOCKNAME_LEN = 100)
+        MAX_MOCKNAME_LEN = 100
+        if len(base_name) > MAX_MOCKNAME_LEN:
+            base_name = base_name[:MAX_MOCKNAME_LEN]
         
-        file_path = self.test_data_dir / filename
-        if file_path.exists():
+        # Add file extension based on encoding type
+        filename = base_name + '.' + request.encoding
+        
+        # Look for mock response file (with truncation handling)
+        file_path = self._find_file_with_truncation(filename)
+        if file_path:
             data = file_path.read_bytes()
             # Found mock response file
             return data

colibri/types.py

@@ -8,7 +8,7 @@ from typing import Any, Dict, List, Optional
 
 class MethodType(IntEnum):
     """Enum for RPC method support types"""
-    UNKNOWN = 0
+    UNDEFINED = 0      # Method is not defined/recognized
     PROOFABLE = 1
     UNPROOFABLE = 2  
     NOT_SUPPORTED = 3
@@ -21,7 +21,7 @@ class MethodType(IntEnum):
     def description(self) -> str:
         """Human-readable description of the method type"""
         descriptions = {
-            MethodType.UNKNOWN: "Unknown method type",
+            MethodType.UNDEFINED: "Method not defined/recognized",
             MethodType.PROOFABLE: "Method supports proof generation",
             MethodType.UNPROOFABLE: "Method doesn't support proofs, direct RPC call",
             MethodType.NOT_SUPPORTED: "Method not supported",

{colibri_stateless-0.7.2.dist-info → colibri_stateless-0.7.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: colibri-stateless
-Version: 0.7.2
+Version: 0.7.4
 Summary: Python bindings for Colibri stateless Ethereum proof library
 Home-page: https://github.com/corpus-core/colibri-stateless
 Author: corpus.core
@@ -54,7 +54,7 @@ The colibri client is a stateless and trustless ethereum client, which is optimi
 ### Installation
 
 ```bash
-pip install colibri-stateless
+python3 -m pip install colibri-stateless
 ```
 
 ### Basic Usage
@@ -113,11 +113,39 @@ cd colibri-stateless/bindings/python
 # Build native extension
 ./build.sh
 
-# Install in development mode
+# Option 1: Use virtual environment (recommended)
+python3 -m venv venv
+source venv/bin/activate
 pip install -e .
+pip install -r requirements-dev.txt
 
 # Run tests
-python -m pytest tests/
+pytest tests/ -v
+
+# Deactivate when done
+deactivate
+```
+
+**Alternative without virtual environment:**
+
+```bash
+# Install test dependencies with --user flag
+python3 -m pip install --user pytest pytest-asyncio aiohttp
+
+# Run tests directly with PYTHONPATH
+PYTHONPATH=src python3 -m pytest tests/ -v
+```
+
+### Quick Debug Build
+
+For faster iteration during development:
+
+```bash
+# Build in debug mode
+./build_debug.sh
+
+# Run tests without installation
+PYTHONPATH=src python3 -m pytest tests/ -v
 ```
 
 ### Integration Tests

colibri_stateless-0.7.4.dist-info/RECORD

@@ -0,0 +1,11 @@
+colibri/__init__.py,sha256=99QBzNVvVAO8P3Bd40ud_R8WJ82dkSPEMyTKhPSzKWo,2506
+colibri/_native.cp38-win_amd64.pyd,sha256=k1AUyslZSsuhT6VAp0jvosUrux-eLbAOmAe9XUw0vKQ,887808
+colibri/client.py,sha256=kgwSwY9kbqxln8yinXsYMRZnc2HPwldB02AQjbZE2wo,20955
+colibri/py.typed,sha256=fDUY3AqEcQHC01aGMGdCqP2qwZXb9ILFNzjSSBBwh1U,61
+colibri/storage.py,sha256=evl2zA4kbZd7sQFpvr2pfI4dNH0c94AvFvQw1VEy5do,4579
+colibri/testing.py,sha256=ti2FwuMGQ6TxKrSAB_rZ2ralpmLAxQX8r8OB5vzJtAg,22148
+colibri/types.py,sha256=QNwehmdN9xdJi3R_4QMwBklw4l1rPQ6LxpheNnGw8lQ,4049
+colibri_stateless-0.7.4.dist-info/METADATA,sha256=p_1BRsXeBCqEW0bHAjOrbIUGh79hOO0_eAEqMiPtrnE,6217
+colibri_stateless-0.7.4.dist-info/WHEEL,sha256=2M046GvC9RLU1f1TWyM-2sB7cRKLhAC7ucAFK8l8f24,99
+colibri_stateless-0.7.4.dist-info/top_level.txt,sha256=7YrQNaIHaKEkVXyESwWV8heheMQY94YJfVoepEYjWRk,8
+colibri_stateless-0.7.4.dist-info/RECORD,,

colibri_stateless-0.7.2.dist-info/RECORD

@@ -1,11 +0,0 @@
-colibri/__init__.py,sha256=5r_j9C9M-XUEojWhTSSmn0A85UZN5ztazAdc2MSM6Nk,2442
-colibri/_native.cp38-win_amd64.pyd,sha256=vdvW7CRqZUDBzz-gV8nNYgtH-AME3usu8jF5GwaAL_o,887808
-colibri/client.py,sha256=8ERKG2-QM-ZImqFUvpcnQxlmiqUmNX61auQPACNuOco,21893
-colibri/py.typed,sha256=fDUY3AqEcQHC01aGMGdCqP2qwZXb9ILFNzjSSBBwh1U,61
-colibri/storage.py,sha256=evl2zA4kbZd7sQFpvr2pfI4dNH0c94AvFvQw1VEy5do,4579
-colibri/testing.py,sha256=nCvlOSD1ydzv-lv7bLd8UJNtvnlRCPhKKF7KHtZrf5o,10016
-colibri/types.py,sha256=9gwXeUkcCPUwKaMFRyCO0vEtoJLyw8ZKNvouCnrtpTQ,3995
-colibri_stateless-0.7.2.dist-info/METADATA,sha256=3p_KPydAmdUZkDWzMbf6_bvQfnqqa5MU7uYdgxcevWI,5609
-colibri_stateless-0.7.2.dist-info/WHEEL,sha256=2M046GvC9RLU1f1TWyM-2sB7cRKLhAC7ucAFK8l8f24,99
-colibri_stateless-0.7.2.dist-info/top_level.txt,sha256=7YrQNaIHaKEkVXyESwWV8heheMQY94YJfVoepEYjWRk,8
-colibri_stateless-0.7.2.dist-info/RECORD,,