astreum 0.1.6__tar.gz → 0.1.8__tar.gz

astreum-0.1.8/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.2
+Name: astreum
+Version: 0.1.8
+Summary: Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
+Author-email: "Roy R. O. Okello" <roy@stelar.xyz>
+Project-URL: Homepage, https://github.com/astreum/lib
+Project-URL: Issues, https://github.com/astreum/lib/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# lib
+
+Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
+
+[View on PyPI](https://pypi.org/project/astreum/)
+
+## Configuration
+
+When initializing an Astreum Node, you need to provide a configuration dictionary. Below are the available configuration parameters:
+
+### Node Configuration
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `node_id` | bytes | Random 32 bytes | Unique identifier for the node |
+| `followed_chain_id` | bytes | None | ID of the blockchain that this node follows |
+| `storage_path` | str | "./storage" | Directory path where node data will be stored |
+
+### Network Configuration
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `use_ipv6` | bool | False | Whether to use IPv6 (True) or IPv4 (False) |
+| `incoming_port` | int | 7373 | Port to listen for incoming messages |
+| `max_message_size` | int | 65536 | Maximum size of UDP datagrams in bytes |
+| `num_workers` | int | 4 | Number of worker threads for message processing |
+
+### Route Configuration
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `peer_route` | bool | False | Whether to participate in the peer discovery route |
+| `validation_route` | bool | False | Whether to participate in the block validation route |
+| `bootstrap_peers` | list | [] | List of bootstrap peers in the format `[("hostname", port), ...]` |
+
+### Example Usage
+
+```python
+from astreum.node import Node
+
+# Configuration dictionary
+config = {
+    "node_id": b"my-unique-node-id-goes-here-exactly-32",  # 32 bytes
+    "followed_chain_id": b"main-chain-id-goes-here",
+    "storage_path": "./data/node1",
+    "incoming_port": 7373,
+    "use_ipv6": False,
+    "peer_route": True,
+    "validation_route": True,
+    "bootstrap_peers": [
+        ("bootstrap.astreum.org", 7373),
+        ("127.0.0.1", 7374)
+    ]
+}
+
+# Initialize the node with config
+node = Node(config)
+
+# Start the node
+node.start()
+
+# ... use the node ...
+
+# Stop the node when done
+node.stop()
+```
+
+## Testing
+
+python3 -m unittest discover -s tests

astreum-0.1.8/README.md

@@ -0,0 +1,70 @@
+# lib
+
+Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
+
+[View on PyPI](https://pypi.org/project/astreum/)
+
+## Configuration
+
+When initializing an Astreum Node, you need to provide a configuration dictionary. Below are the available configuration parameters:
+
+### Node Configuration
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `node_id` | bytes | Random 32 bytes | Unique identifier for the node |
+| `followed_chain_id` | bytes | None | ID of the blockchain that this node follows |
+| `storage_path` | str | "./storage" | Directory path where node data will be stored |
+
+### Network Configuration
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `use_ipv6` | bool | False | Whether to use IPv6 (True) or IPv4 (False) |
+| `incoming_port` | int | 7373 | Port to listen for incoming messages |
+| `max_message_size` | int | 65536 | Maximum size of UDP datagrams in bytes |
+| `num_workers` | int | 4 | Number of worker threads for message processing |
+
+### Route Configuration
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `peer_route` | bool | False | Whether to participate in the peer discovery route |
+| `validation_route` | bool | False | Whether to participate in the block validation route |
+| `bootstrap_peers` | list | [] | List of bootstrap peers in the format `[("hostname", port), ...]` |
+
+### Example Usage
+
+```python
+from astreum.node import Node
+
+# Configuration dictionary
+config = {
+    "node_id": b"my-unique-node-id-goes-here-exactly-32",  # 32 bytes
+    "followed_chain_id": b"main-chain-id-goes-here",
+    "storage_path": "./data/node1",
+    "incoming_port": 7373,
+    "use_ipv6": False,
+    "peer_route": True,
+    "validation_route": True,
+    "bootstrap_peers": [
+        ("bootstrap.astreum.org", 7373),
+        ("127.0.0.1", 7374)
+    ]
+}
+
+# Initialize the node with config
+node = Node(config)
+
+# Start the node
+node.start()
+
+# ... use the node ...
+
+# Stop the node when done
+node.stop()
+```
+
+## Testing
+
+python3 -m unittest discover -s tests

{astreum-0.1.6 → astreum-0.1.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "astreum"
-version = "0.1.6"
+version = "0.1.8"
 authors = [
   { name="Roy R. O. Okello", email="roy@stelar.xyz" },
 ]

astreum-0.1.8/src/astreum/lispeum/storage.py

@@ -0,0 +1,457 @@
+"""
+Storage utilities for Lispeum expressions.
+
+This module provides functions to convert Lispeum expressions to an
+object-based Merkle tree representation for storage and retrieval.
+"""
+
+import hashlib
+import struct
+from typing import Dict, Tuple, Any, List, Optional
+
+from astreum.lispeum.expression import Expr
+
+
+def expr_to_objects(expr: Any) -> Tuple[bytes, Dict[bytes, bytes]]:
+    """
+    Convert a Lispeum expression to a collection of objects in a Merkle tree structure.
+    
+    Args:
+        expr: The expression to convert
+        
+    Returns:
+        A tuple containing (root_hash, objects_dict) where:
+        - root_hash is the hash of the root object
+        - objects_dict is a dictionary mapping object hashes to their serialized representations
+    """
+    objects = {}
+    root_hash = _serialize_expr(expr, objects)
+    return root_hash, objects
+
+
+def objects_to_expr(root_hash: bytes, objects: Dict[bytes, bytes]) -> Any:
+    """
+    Convert a collection of objects back to a Lispeum expression.
+    
+    Args:
+        root_hash: The hash of the root object
+        objects: A dictionary mapping object hashes to their serialized representations
+        
+    Returns:
+        The reconstructed Lispeum expression
+    """
+    return _deserialize_expr(root_hash, objects)
+
+
+def _serialize_expr(expr: Any, objects: Dict[bytes, bytes]) -> bytes:
+    """
+    Serialize a Lispeum expression to bytes and add it to the objects dictionary.
+    
+    Args:
+        expr: The expression to serialize
+        objects: Dictionary to store serialized objects
+        
+    Returns:
+        The hash of the serialized expression
+    """
+    if expr is None:
+        # None type
+        type_bytes = b'N'  # N for None
+        type_hash = hashlib.sha256(type_bytes).digest()
+        objects[type_hash] = type_bytes
+        
+        # None values don't need a value leaf, just return the type hash
+        return type_hash
+        
+    elif isinstance(expr, Expr.ListExpr):
+        # Create type leaf
+        type_bytes = b'L'  # L for List
+        type_hash = hashlib.sha256(type_bytes).digest()
+        objects[type_hash] = type_bytes
+        
+        # Serialize each element and collect their hashes
+        element_hashes = []
+        for elem in expr.elements:
+            elem_hash = _serialize_expr(elem, objects)
+            element_hashes.append(elem_hash)
+            
+        # Create value leaf with all element hashes
+        value_bytes = b''.join(element_hashes)
+        value_hash = hashlib.sha256(value_bytes).digest()
+        objects[value_hash] = value_bytes
+        
+        # Create the tree node with type and value
+        tree_bytes = type_hash + value_hash
+        tree_hash = hashlib.sha256(tree_bytes).digest()
+        objects[tree_hash] = tree_bytes
+        
+        return tree_hash
+        
+    elif isinstance(expr, Expr.Symbol):
+        # Create type leaf
+        type_bytes = b'S'  # S for Symbol
+        type_hash = hashlib.sha256(type_bytes).digest()
+        objects[type_hash] = type_bytes
+        
+        # Create value leaf
+        value_bytes = expr.value.encode('utf-8')
+        value_hash = hashlib.sha256(value_bytes).digest()
+        objects[value_hash] = value_bytes
+        
+        # Create the tree node with type and value
+        tree_bytes = type_hash + value_hash
+        tree_hash = hashlib.sha256(tree_bytes).digest()
+        objects[tree_hash] = tree_bytes
+        
+        return tree_hash
+        
+    elif isinstance(expr, Expr.Integer):
+        # Create type leaf
+        type_bytes = b'I'  # I for Integer
+        type_hash = hashlib.sha256(type_bytes).digest()
+        objects[type_hash] = type_bytes
+        
+        # Create value leaf - use 2's complement little endian for integers
+        value_bytes = struct.pack("<q", expr.value)  # 8-byte little endian
+        value_hash = hashlib.sha256(value_bytes).digest()
+        objects[value_hash] = value_bytes
+        
+        # Create the tree node with type and value
+        tree_bytes = type_hash + value_hash
+        tree_hash = hashlib.sha256(tree_bytes).digest()
+        objects[tree_hash] = tree_bytes
+        
+        return tree_hash
+        
+    elif isinstance(expr, Expr.String):
+        # Create type leaf
+        type_bytes = b'T'  # T for Text/String
+        type_hash = hashlib.sha256(type_bytes).digest()
+        objects[type_hash] = type_bytes
+        
+        # Create value leaf
+        value_bytes = expr.value.encode('utf-8')
+        value_hash = hashlib.sha256(value_bytes).digest()
+        objects[value_hash] = value_bytes
+        
+        # Create the tree node with type and value
+        tree_bytes = type_hash + value_hash
+        tree_hash = hashlib.sha256(tree_bytes).digest()
+        objects[tree_hash] = tree_bytes
+        
+        return tree_hash
+        
+    elif isinstance(expr, Expr.Boolean):
+        # Create type leaf
+        type_bytes = b'B'  # B for Boolean
+        type_hash = hashlib.sha256(type_bytes).digest()
+        objects[type_hash] = type_bytes
+        
+        # Create value leaf
+        value_bytes = b'1' if expr.value else b'0'
+        value_hash = hashlib.sha256(value_bytes).digest()
+        objects[value_hash] = value_bytes
+        
+        # Create the tree node with type and value
+        tree_bytes = type_hash + value_hash
+        tree_hash = hashlib.sha256(tree_bytes).digest()
+        objects[tree_hash] = tree_bytes
+        
+        return tree_hash
+        
+    elif isinstance(expr, Expr.Function):
+        # Create type leaf
+        type_bytes = b'F'  # F for Function
+        type_hash = hashlib.sha256(type_bytes).digest()
+        objects[type_hash] = type_bytes
+        
+        # Serialize params
+        params_list = []
+        for param in expr.params:
+            params_list.append(param.encode('utf-8'))
+        params_bytes = b','.join(params_list)
+        params_hash = hashlib.sha256(params_bytes).digest()
+        objects[params_hash] = params_bytes
+        
+        # Serialize body recursively
+        body_hash = _serialize_expr(expr.body, objects)
+        
+        # Combine params and body hashes for the value
+        value_bytes = params_hash + body_hash
+        value_hash = hashlib.sha256(value_bytes).digest()
+        objects[value_hash] = value_bytes
+        
+        # Create the tree node with type and value
+        tree_bytes = type_hash + value_hash
+        tree_hash = hashlib.sha256(tree_bytes).digest()
+        objects[tree_hash] = tree_bytes
+        
+        return tree_hash
+        
+    elif isinstance(expr, Expr.Error):
+        # Create type leaf
+        type_bytes = b'E'  # E for Error
+        type_hash = hashlib.sha256(type_bytes).digest()
+        objects[type_hash] = type_bytes
+        
+        # Serialize error components
+        category_bytes = expr.category.encode('utf-8')
+        category_hash = hashlib.sha256(category_bytes).digest()
+        objects[category_hash] = category_bytes
+        
+        message_bytes = expr.message.encode('utf-8')
+        message_hash = hashlib.sha256(message_bytes).digest()
+        objects[message_hash] = message_bytes
+        
+        if expr.details:
+            details_bytes = expr.details.encode('utf-8')
+            details_hash = hashlib.sha256(details_bytes).digest()
+            objects[details_hash] = details_bytes
+            
+            # Combine all three components
+            value_bytes = category_hash + message_hash + details_hash
+        else:
+            # Just combine category and message
+            value_bytes = category_hash + message_hash
+            
+        value_hash = hashlib.sha256(value_bytes).digest()
+        objects[value_hash] = value_bytes
+        
+        # Create the tree node with type and value
+        tree_bytes = type_hash + value_hash
+        tree_hash = hashlib.sha256(tree_bytes).digest()
+        objects[tree_hash] = tree_bytes
+        
+        return tree_hash
+        
+    else:
+        # Unknown type - serialize as string
+        type_bytes = b'U'  # U for Unknown
+        type_hash = hashlib.sha256(type_bytes).digest()
+        objects[type_hash] = type_bytes
+        
+        # Create value leaf with string representation
+        value_bytes = str(expr).encode('utf-8')
+        value_hash = hashlib.sha256(value_bytes).digest()
+        objects[value_hash] = value_bytes
+        
+        # Create the tree node with type and value
+        tree_bytes = type_hash + value_hash
+        tree_hash = hashlib.sha256(tree_bytes).digest()
+        objects[tree_hash] = tree_bytes
+        
+        return tree_hash
+
+
+def _deserialize_expr(obj_hash: bytes, objects: Dict[bytes, bytes]) -> Any:
+    """
+    Deserialize a Lispeum expression from its hash.
+    
+    Args:
+        obj_hash: The hash of the object to deserialize
+        objects: Dictionary containing serialized objects
+        
+    Returns:
+        The deserialized Lispeum expression
+    """
+    if obj_hash not in objects:
+        return None
+        
+    obj_data = objects[obj_hash]
+    
+    # Check if this is a type-only node (for None)
+    if len(obj_data) == 1:
+        if obj_data == b'N':
+            return None
+        return None  # Unrecognized single-byte type
+    
+    # For regular nodes, expect 64 bytes (two 32-byte hashes)
+    if len(obj_data) == 64:
+        type_hash = obj_data[:32]
+        value_hash = obj_data[32:]
+        
+        if type_hash not in objects or value_hash not in objects:
+            return None
+            
+        type_data = objects[type_hash]
+        value_data = objects[value_hash]
+        
+        # Switch based on the type marker
+        if type_data == b'L':  # List
+            elements = []
+            # Each hash is 32 bytes
+            hash_size = 32
+            for i in range(0, len(value_data), hash_size):
+                elem_hash = value_data[i:i+hash_size]
+                if elem_hash:
+                    elem = _deserialize_expr(elem_hash, objects)
+                    elements.append(elem)
+            return Expr.ListExpr(elements)
+            
+        elif type_data == b'S':  # Symbol
+            return Expr.Symbol(value_data.decode('utf-8'))
+            
+        elif type_data == b'I':  # Integer
+            int_value = struct.unpack("<q", value_data)[0]
+            return Expr.Integer(int_value)
+            
+        elif type_data == b'T':  # String (Text)
+            return Expr.String(value_data.decode('utf-8'))
+            
+        elif type_data == b'B':  # Boolean
+            return Expr.Boolean(value_data == b'1')
+            
+        elif type_data == b'F':  # Function
+            # Value contains params_hash and body_hash
+            params_hash = value_data[:32]
+            body_hash = value_data[32:]
+            
+            if params_hash not in objects:
+                return None
+                
+            params_data = objects[params_hash]
+            params = [p.decode('utf-8') for p in params_data.split(b',') if p]
+            
+            body = _deserialize_expr(body_hash, objects)
+            return Expr.Function(params, body)
+            
+        elif type_data == b'E':  # Error
+            # Check if we have details or just category and message
+            if len(value_data) == 64:  # No details
+                category_hash = value_data[:32]
+                message_hash = value_data[32:]
+                details_hash = None
+            elif len(value_data) == 96:  # With details
+                category_hash = value_data[:32]
+                message_hash = value_data[32:64]
+                details_hash = value_data[64:]
+            else:
+                return None
+                
+            if category_hash not in objects or message_hash not in objects:
+                return None
+                
+            category = objects[category_hash].decode('utf-8')
+            message = objects[message_hash].decode('utf-8')
+            
+            details = None
+            if details_hash and details_hash in objects:
+                details = objects[details_hash].decode('utf-8')
+                
+            return Expr.Error(category, message, details)
+            
+        elif type_data == b'U':  # Unknown
+            return Expr.String(value_data.decode('utf-8'))
+            
+    return None  # Unrecognized format
+
+
+def store_expr(expr: Any, storage) -> bytes:
+    """
+    Store a Lispeum expression in the provided storage.
+    
+    Args:
+        expr: The expression to store
+        storage: Storage interface with put(key, value) method
+        
+    Returns:
+        The hash of the root object
+    """
+    root_hash, objects = expr_to_objects(expr)
+    
+    # Store all objects in the storage
+    for obj_hash, obj_data in objects.items():
+        storage.put(obj_hash, obj_data)
+        
+    return root_hash
+
+
+def get_expr_from_storage(root_hash: bytes, storage) -> Any:
+    """
+    Load a Lispeum expression from storage.
+    
+    Args:
+        root_hash: The hash of the root object
+        storage: Storage interface with get(key) method
+        
+    Returns:
+        The loaded Lispeum expression, or None if not found
+    """
+    if not root_hash:
+        return None
+        
+    # Build the objects dictionary from storage
+    objects = {}
+    queue = [root_hash]
+    visited = set()
+    
+    while queue:
+        current_hash = queue.pop(0)
+        if current_hash in visited:
+            continue
+            
+        visited.add(current_hash)
+        obj_data = storage.get(current_hash)
+        
+        if not obj_data:
+            # Can't find an object, return None
+            return None
+            
+        objects[current_hash] = obj_data
+        
+        # For single-byte nodes (e.g., None), no further processing needed
+        if len(obj_data) == 1:
+            continue
+            
+        # For regular tree nodes (type + value)
+        if len(obj_data) == 64:
+            # Add both hashes to the queue
+            type_hash = obj_data[:32]
+            value_hash = obj_data[32:]
+            
+            if type_hash not in visited:
+                queue.append(type_hash)
+                
+            if value_hash not in visited:
+                queue.append(value_hash)
+                
+            # For function and error types, we need to check the value fields
+            # which might contain additional hashes
+            if type_hash in objects:
+                type_data = objects[type_hash]
+                
+                # For Function type, the value contains params_hash + body_hash
+                if type_data == b'F' and value_hash in objects:
+                    value_data = objects[value_hash]
+                    if len(value_data) == 64:
+                        params_hash = value_data[:32]
+                        body_hash = value_data[32:]
+                        
+                        if params_hash not in visited:
+                            queue.append(params_hash)
+                            
+                        if body_hash not in visited:
+                            queue.append(body_hash)
+                
+                # For Error type, the value contains category_hash + message_hash + [details_hash]
+                elif type_data == b'E' and value_hash in objects:
+                    value_data = objects[value_hash]
+                    hash_size = 32
+                    
+                    for i in range(0, len(value_data), hash_size):
+                        component_hash = value_data[i:i+hash_size]
+                        if component_hash and component_hash not in visited:
+                            queue.append(component_hash)
+                
+                # For List type, the value contains all element hashes
+                elif type_data == b'L' and value_hash in objects:
+                    value_data = objects[value_hash]
+                    hash_size = 32
+                    
+                    for i in range(0, len(value_data), hash_size):
+                        elem_hash = value_data[i:i+hash_size]
+                        if elem_hash and elem_hash not in visited:
+                            queue.append(elem_hash)
+    
+    # Reconstruct the expression from objects
+    return objects_to_expr(root_hash, objects)

{astreum-0.1.6 → astreum-0.1.8}/src/astreum/node/__init__.py

@@ -10,6 +10,7 @@ from .route_table import RouteTable
 from .machine import AstreumMachine
 from .utils import encode, decode
 from .models import Block, Transaction
+from astreum.lispeum.storage import store_expr, get_expr_from_storage
 
 class Node:
     def __init__(self, config: dict):
@@ -17,8 +18,6 @@ class Node:
         self.node_id = config.get('node_id', os.urandom(32))  # Default to random ID if not provided
         self.relay = Relay(config)
         self.storage = Storage(config)
-        self.machine = AstreumMachine(config)
-        self.route_table = RouteTable(config, self.node_id)
         
         # Latest block of the chain this node is following
         self.latest_block = None
@@ -27,12 +26,19 @@ class Node:
         # Candidate chains that might be adopted
         self.candidate_chains = {}  # chain_id -> {'latest_block': block, 'timestamp': time.time()}
         
+        # Initialize route table with our node ID
+        self.route_table = RouteTable(config, self.node_id)
+        
+        # Initialize machine after storage so it can use it
+        # Pass self to machine so it can access the storage
+        self.machine = AstreumMachine(node=self)
+        
         # Register message handlers
         self._register_message_handlers()
         
         # Initialize latest block from storage if available
         self._initialize_latest_block()
-
+        
     def _register_message_handlers(self):
         """Register handlers for different message topics."""
         self.relay.register_message_handler(Topic.PING, self._handle_ping)
@@ -413,4 +419,43 @@ class Node:
         verify the chain and potentially switch to it if it's valid and better.
         """
         # TODO: Implement chain evaluation logic
-        pass
+        pass
+    
+    def post_global_storage(self, name: str, value):
+        """
+        Store a global variable in node storage.
+        
+        Args:
+            name: Name of the variable
+            value: Value to store
+        """
+        # Store the expression directly in node storage using DAG representation
+        root_hash = store_expr(value, self.storage)
+        
+        # Create a key for this variable name (without special prefixes)
+        key = hashlib.sha256(name.encode()).digest()
+        
+        # Store the root hash reference
+        self.storage.put(key, root_hash)
+        
+    def query_global_storage(self, name: str):
+        """
+        Retrieve a global variable from node storage.
+        
+        Args:
+            name: Name of the variable to retrieve
+            
+        Returns:
+            The stored expression, or None if not found
+        """
+        # Create the key for this variable name
+        key = hashlib.sha256(name.encode()).digest()
+        
+        # Try to retrieve the root hash
+        root_hash = self.storage.get(key)
+        
+        if root_hash:
+            # Load the expression using its root hash
+            return get_expr_from_storage(root_hash, self.storage)
+        
+        return None

astreum-0.1.8/src/astreum.egg-info/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.2
+Name: astreum
+Version: 0.1.8
+Summary: Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
+Author-email: "Roy R. O. Okello" <roy@stelar.xyz>
+Project-URL: Homepage, https://github.com/astreum/lib
+Project-URL: Issues, https://github.com/astreum/lib/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# lib
+
+Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
+
+[View on PyPI](https://pypi.org/project/astreum/)
+
+## Configuration
+
+When initializing an Astreum Node, you need to provide a configuration dictionary. Below are the available configuration parameters:
+
+### Node Configuration
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `node_id` | bytes | Random 32 bytes | Unique identifier for the node |
+| `followed_chain_id` | bytes | None | ID of the blockchain that this node follows |
+| `storage_path` | str | "./storage" | Directory path where node data will be stored |
+
+### Network Configuration
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `use_ipv6` | bool | False | Whether to use IPv6 (True) or IPv4 (False) |
+| `incoming_port` | int | 7373 | Port to listen for incoming messages |
+| `max_message_size` | int | 65536 | Maximum size of UDP datagrams in bytes |
+| `num_workers` | int | 4 | Number of worker threads for message processing |
+
+### Route Configuration
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `peer_route` | bool | False | Whether to participate in the peer discovery route |
+| `validation_route` | bool | False | Whether to participate in the block validation route |
+| `bootstrap_peers` | list | [] | List of bootstrap peers in the format `[("hostname", port), ...]` |
+
+### Example Usage
+
+```python
+from astreum.node import Node
+
+# Configuration dictionary
+config = {
+    "node_id": b"my-unique-node-id-goes-here-exactly-32",  # 32 bytes
+    "followed_chain_id": b"main-chain-id-goes-here",
+    "storage_path": "./data/node1",
+    "incoming_port": 7373,
+    "use_ipv6": False,
+    "peer_route": True,
+    "validation_route": True,
+    "bootstrap_peers": [
+        ("bootstrap.astreum.org", 7373),
+        ("127.0.0.1", 7374)
+    ]
+}
+
+# Initialize the node with config
+node = Node(config)
+
+# Start the node
+node.start()
+
+# ... use the node ...
+
+# Stop the node when done
+node.stop()
+```
+
+## Testing
+
+python3 -m unittest discover -s tests

{astreum-0.1.6 → astreum-0.1.8}/src/astreum.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ src/astreum.egg-info/top_level.txt
 src/astreum/lispeum/__init__.py
 src/astreum/lispeum/expression.py
 src/astreum/lispeum/parser.py
+src/astreum/lispeum/storage.py
 src/astreum/lispeum/tokenizer.py
 src/astreum/lispeum/special/__init__.py
 src/astreum/lispeum/special/definition.py

astreum-0.1.6/PKG-INFO

@@ -1,24 +0,0 @@
-Metadata-Version: 2.2
-Name: astreum
-Version: 0.1.6
-Summary: Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
-Author-email: "Roy R. O. Okello" <roy@stelar.xyz>
-Project-URL: Homepage, https://github.com/astreum/lib
-Project-URL: Issues, https://github.com/astreum/lib/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# lib
-
-Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
-
-[View on PyPI](https://pypi.org/project/astreum/)
-
-## Testing
-
-python3 -m unittest discover -s tests
-

astreum-0.1.6/README.md

@@ -1,10 +0,0 @@
-# lib
-
-Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
-
-[View on PyPI](https://pypi.org/project/astreum/)
-
-## Testing
-
-python3 -m unittest discover -s tests
-

astreum-0.1.6/src/astreum.egg-info/PKG-INFO

@@ -1,24 +0,0 @@
-Metadata-Version: 2.2
-Name: astreum
-Version: 0.1.6
-Summary: Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
-Author-email: "Roy R. O. Okello" <roy@stelar.xyz>
-Project-URL: Homepage, https://github.com/astreum/lib
-Project-URL: Issues, https://github.com/astreum/lib/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# lib
-
-Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
-
-[View on PyPI](https://pypi.org/project/astreum/)
-
-## Testing
-
-python3 -m unittest discover -s tests
-