zexus 1.6.2 → 1.6.4

package/src/zexus/parser/strategy_context.py

@@ -1533,9 +1533,40 @@ class ContextStackParser:
                                     default_val = BooleanLiteral(True)
                                 elif val_token.type == FALSE:
                                     default_val = BooleanLiteral(False)
+                                elif val_token.type == LBRACE:
+                                    # Map literal: {}
+                                    # Find matching RBRACE
+                                    map_start = current_idx
+                                    depth = 1
+                                    current_idx += 1
+                                    while current_idx < brace_end and depth > 0:
+                                        if tokens[current_idx].type == LBRACE:
+                                            depth += 1
+                                        elif tokens[current_idx].type == RBRACE:
+                                            depth -= 1
+                                        current_idx += 1
+                                    # Parse the map literal
+                                    map_tokens = tokens[map_start:current_idx]
+                                    default_val = self._parse_map_literal(map_tokens)
+                                elif val_token.type == LBRACKET:
+                                    # List literal: []
+                                    # Find matching RBRACKET
+                                    list_start = current_idx
+                                    depth = 1
+                                    current_idx += 1
+                                    while current_idx < brace_end and depth > 0:
+                                        if tokens[current_idx].type == LBRACKET:
+                                            depth += 1
+                                        elif tokens[current_idx].type == RBRACKET:
+                                            depth -= 1
+                                        current_idx += 1
+                                    # Parse the list literal
+                                    list_tokens = tokens[list_start:current_idx]
+                                    default_val = self._parse_list_literal(list_tokens)
                                 elif val_token.type == IDENT:
                                     default_val = Identifier(val_token.literal)
-                                current_idx += 1
+                                    current_idx += 1
+                                # Note: current_idx already advanced for LBRACE and LBRACKET cases
 
                         # Use AstNodeShim for compatibility with evaluator
                         storage_vars.append(AstNodeShim(
@@ -3234,9 +3265,10 @@ class ContextStackParser:
                 # Parse REQUIRE statement: require(condition, message) or require condition { tolerance_block }
                 j = i + 1
                 
-                # Collect tokens until semicolon OR until after tolerance block closes
+                # Collect tokens until semicolon OR until after tolerance block closes OR after closing paren
                 require_tokens = [token]
                 brace_nest = 0
+                paren_nest = 0
                 while j < len(tokens):
                     tj = tokens[j]
                     
@@ -3246,6 +3278,12 @@ class ContextStackParser:
                     elif tj.type == RBRACE:
                         brace_nest -= 1
                     
+                    # Track paren nesting for require(condition, message) form
+                    if tj.type == LPAREN:
+                        paren_nest += 1
+                    elif tj.type == RPAREN:
+                        paren_nest -= 1
+                    
                     require_tokens.append(tj)
                     j += 1
                     
@@ -3253,6 +3291,10 @@ class ContextStackParser:
                     if tj.type == SEMICOLON and brace_nest == 0:
                         break
                     
+                    # Stop after closing paren of require(...) form (when paren_nest returns to 0)
+                    if tj.type == RPAREN and paren_nest == 0 and brace_nest == 0:
+                        break
+                    
                     # Stop after tolerance block closes (if there was one)
                     if brace_nest == 0 and len(require_tokens) > 1 and require_tokens[-2].type == RBRACE:
                         break
@@ -3921,6 +3963,24 @@ class ContextStackParser:
                     if i < n and tokens[i].type == RPAREN:
                         i += 1  # Skip RPAREN
                     return CallExpression(Identifier(name), args, type_args=type_args)
+                
+                # Check for constructor call with map literal: Entity{field: value, ...}
+                elif i < n and tokens[i].type == LBRACE:
+                    # Parse the map literal as the single argument
+                    start = i
+                    depth = 1
+                    i += 1  # Skip LBRACE
+                    # Find matching RBRACE
+                    while i < n and depth > 0:
+                        if tokens[i].type == LBRACE:
+                            depth += 1
+                        elif tokens[i].type == RBRACE:
+                            depth -= 1
+                        i += 1
+                    # Parse the map literal tokens (including braces)
+                    map_literal = self._parse_map_literal(tokens[start:i])
+                    return CallExpression(Identifier(name), [map_literal], type_args=type_args)
+                
                 else:
                     return Identifier(name)
 
@@ -3986,7 +4046,8 @@ class ContextStackParser:
                     # Property access: expr.name
                     current_expr = PropertyAccessExpression(
                         object=current_expr,
-                        property=Identifier(name_token.literal)
+                        property=Identifier(name_token.literal),
+                        computed=False
                     )
                 continue
 
@@ -4041,7 +4102,8 @@ class ContextStackParser:
                 prop_expr = self._parse_expression(inner_tokens) if inner_tokens else Identifier('')
                 current_expr = PropertyAccessExpression(
                     object=current_expr,
-                    property=prop_expr
+                    property=prop_expr,
+                    computed=True
                 )
                 continue
 
@@ -4597,7 +4659,7 @@ class ContextStackParser:
         
         Returns a SanitizeStatement which can be evaluated as an expression.
         """
-        print("  🔧 [Sanitize Expression] Parsing sanitize expression")
+        # print("  🔧 [Sanitize Expression] Parsing sanitize expression")
         if not tokens or tokens[0].type != SANITIZE:
             return None
         
@@ -6155,8 +6217,22 @@ class ContextStackParser:
         
         # Check for parenthesized form: require(condition, message)
         if start_idx < len(tokens) and tokens[start_idx].type == LPAREN:
-            # Extract tokens between LPAREN and RPAREN
-            inner = tokens[start_idx+1:-1] if len(tokens) > start_idx+1 and tokens[-1].type == RPAREN else tokens[start_idx+1:]
+            # Find matching RPAREN
+            paren_depth = 1
+            end_idx = start_idx + 1
+            while end_idx < len(tokens) and paren_depth > 0:
+                if tokens[end_idx].type == LPAREN:
+                    paren_depth += 1
+                elif tokens[end_idx].type == RPAREN:
+                    paren_depth -= 1
+                end_idx += 1
+            
+            if paren_depth != 0:
+                parser_debug("  ❌ Unmatched parentheses in require")
+                return None
+            
+            # Extract tokens between LPAREN and matching RPAREN
+            inner = tokens[start_idx+1:end_idx-1]
             
             # Split by comma to get condition and optional message
             args = self._parse_argument_list(inner)

package/src/zexus/parser/strategy_structural.py

@@ -609,7 +609,14 @@ class StructuralAnalyzer:
                                         elif tokens[k].type in {LBRACE, COLON}:
                                             # Found statement form indicators
                                             break
-                                if not (in_assignment and (allow_in_assignment or allow_debug_call or allow_if_then_else)):
+                                
+                                # FIX #4: After seeing SANITIZE in assignment, also check if previous token was SANITIZE
+                                # This allows collecting the sanitize expression arguments
+                                prev_was_sanitize = False
+                                if j > 0 and tokens[j - 1].type == SANITIZE:
+                                    prev_was_sanitize = True
+                                
+                                if not (in_assignment and (allow_in_assignment or allow_debug_call or allow_if_then_else or prev_was_sanitize)):
                                     break
                     
                     # CRITICAL FIX: Also break on modifier tokens at nesting 0 when followed by statement keywords
@@ -647,9 +654,10 @@ class StructuralAnalyzer:
                     stmt_tokens.append(tj)
                     j += 1
                     
-                    # MODIFIED: For RETURN, CONTINUE, and PRINT, stop after closing parens at nesting 0
-                    # PRINT can have multiple comma-separated arguments inside the parens
-                    if t.type in {RETURN, CONTINUE, PRINT} and nesting == 0 and tj.type == RPAREN:
+                    # MODIFIED: For RETURN, CONTINUE, PRINT, and REQUIRE, stop after closing parens at nesting 0
+                    # These can have multiple comma-separated arguments inside the parens
+                    # NOTE: 't' is the statement starter token (first token), 'tj' is the just-collected token
+                    if t.type in {RETURN, CONTINUE, PRINT, REQUIRE} and nesting == 0 and tj.type == RPAREN:
                         break
                     
                     # If we just closed a brace block and are back at nesting 0, stop

package/src/zexus/persistence.py

@@ -128,15 +128,35 @@ def disable_memory_tracking():
 # PERSISTENT STORAGE BACKEND
 # ===============================================
 
+class StorageLimitError(Exception):
+    """Raised when persistent storage limits are exceeded"""
+    pass
+
+
 class PersistentStorage:
-    """Persistent storage for variables using SQLite"""
+    """Persistent storage for variables using SQLite with size limits"""
     
-    def __init__(self, scope_id: str, storage_dir: str = PERSISTENCE_DIR):
+    # Default limits (configurable)
+    DEFAULT_MAX_ITEMS = 10000  # Maximum number of stored variables
+    DEFAULT_MAX_SIZE_MB = 100  # Maximum storage size in MB
+    
+    def __init__(self, scope_id: str, storage_dir: str = PERSISTENCE_DIR,
+                 max_items: int = None, max_size_mb: int = None):
         self.scope_id = scope_id
         self.db_path = os.path.join(storage_dir, f"{scope_id}.sqlite")
         self.conn = None
         self.lock = Lock()
+        
+        # Storage limits
+        self.max_items = max_items if max_items is not None else self.DEFAULT_MAX_ITEMS
+        self.max_size_bytes = (max_size_mb if max_size_mb is not None else self.DEFAULT_MAX_SIZE_MB) * 1024 * 1024
+        
+        # Usage tracking
+        self.current_item_count = 0
+        self.current_size_bytes = 0
+        
         self._init_db()
+        self._update_usage_stats()
     
     def _init_db(self):
         """Initialize SQLite database"""
@@ -147,6 +167,7 @@ class PersistentStorage:
                 name TEXT PRIMARY KEY,
                 type TEXT NOT NULL,
                 value TEXT NOT NULL,
+                size_bytes INTEGER DEFAULT 0,
                 is_const INTEGER DEFAULT 0,
                 created_at REAL NOT NULL,
                 updated_at REAL NOT NULL
@@ -157,24 +178,96 @@ class PersistentStorage:
         ''')
         self.conn.commit()
     
+    def _update_usage_stats(self):
+        """Update current usage statistics"""
+        with self.lock:
+            cursor = self.conn.cursor()
+            
+            # Count items
+            cursor.execute('SELECT COUNT(*) FROM variables')
+            self.current_item_count = cursor.fetchone()[0]
+            
+            # Calculate total size
+            cursor.execute('SELECT SUM(size_bytes) FROM variables')
+            result = cursor.fetchone()[0]
+            self.current_size_bytes = result if result else 0
+    
+    def _calculate_size(self, serialized: Dict[str, str]) -> int:
+        """Calculate size of serialized data in bytes"""
+        # Approximate size: length of type + value strings
+        size = len(serialized['type']) + len(serialized['value'])
+        return size
+    
+    def _check_limits(self, name: str, new_size: int) -> None:
+        """Check if adding/updating a variable would exceed limits"""
+        # Get current size of existing variable if it exists
+        cursor = self.conn.cursor()
+        cursor.execute('SELECT size_bytes FROM variables WHERE name = ?', (name,))
+        row = cursor.fetchone()
+        existing_size = row[0] if row else 0
+        is_update = row is not None
+        
+        # Calculate new totals
+        new_item_count = self.current_item_count if is_update else self.current_item_count + 1
+        new_total_size = self.current_size_bytes - existing_size + new_size
+        
+        # Check item limit
+        if new_item_count > self.max_items:
+            raise StorageLimitError(
+                f"Persistent storage item limit exceeded: {new_item_count} > {self.max_items}. "
+                f"Cannot store variable '{name}'. "
+                f"Consider increasing max_items or cleaning up old variables."
+            )
+        
+        # Check size limit
+        if new_total_size > self.max_size_bytes:
+            size_mb = new_total_size / (1024 * 1024)
+            limit_mb = self.max_size_bytes / (1024 * 1024)
+            raise StorageLimitError(
+                f"Persistent storage size limit exceeded: {size_mb:.2f}MB > {limit_mb:.2f}MB. "
+                f"Cannot store variable '{name}' ({new_size} bytes). "
+                f"Consider increasing max_size_mb or cleaning up old data."
+            )
+    
+    def get_usage_stats(self) -> Dict[str, Any]:
+        """Get current storage usage statistics"""
+        return {
+            'item_count': self.current_item_count,
+            'max_items': self.max_items,
+            'items_remaining': self.max_items - self.current_item_count,
+            'size_bytes': self.current_size_bytes,
+            'size_mb': self.current_size_bytes / (1024 * 1024),
+            'max_size_mb': self.max_size_bytes / (1024 * 1024),
+            'size_remaining_mb': (self.max_size_bytes - self.current_size_bytes) / (1024 * 1024),
+            'usage_percent': (self.current_size_bytes / self.max_size_bytes * 100) if self.max_size_bytes > 0 else 0
+        }
+    
     def set(self, name: str, value: Object, is_const: bool = False):
-        """Persist a variable"""
+        """Persist a variable with size limit checks"""
         with self.lock:
             serialized = self._serialize(value)
+            size_bytes = self._calculate_size(serialized)
+            
+            # Check limits before storing
+            self._check_limits(name, size_bytes)
+            
             cursor = self.conn.cursor()
             
             import time
             timestamp = time.time()
             
             cursor.execute('''
-                INSERT OR REPLACE INTO variables (name, type, value, is_const, created_at, updated_at)
-                VALUES (?, ?, ?, ?, 
+                INSERT OR REPLACE INTO variables (name, type, value, size_bytes, is_const, created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?, 
                     COALESCE((SELECT created_at FROM variables WHERE name = ?), ?),
                     ?)
-            ''', (name, serialized['type'], serialized['value'], 1 if is_const else 0, 
+            ''', (name, serialized['type'], serialized['value'], size_bytes, 1 if is_const else 0, 
                   name, timestamp, timestamp))
             
             self.conn.commit()
+            
+            # Update usage stats
+            self._update_usage_stats()
     
     def get(self, name: str) -> Optional[Object]:
         """Retrieve a persisted variable"""
@@ -186,6 +279,9 @@ class PersistentStorage:
             if row is None:
                 return None
             
+            
+            # Update usage stats
+            self._update_usage_stats()
             return self._deserialize({'type': row[0], 'value': row[1]})
     
     def delete(self, name: str):
@@ -213,6 +309,9 @@ class PersistentStorage:
     def clear(self):
         """Clear all persisted variables"""
         with self.lock:
+            
+            # Update usage stats
+            self._update_usage_stats()
             cursor = self.conn.cursor()
             cursor.execute('DELETE FROM variables')
             self.conn.commit()

package/src/zexus/security.py

@@ -734,8 +734,10 @@ class StorageBackend:
 class InMemoryBackend(StorageBackend):
     def __init__(self):
         self.data = {}
-    def set(self, key, value): self.data[key] = value
-    def get(self, key): return self.data.get(key)
+    def set(self, key, value):
+        self.data[key] = value
+    def get(self, key):
+        return self.data.get(key)
     def delete(self, key): 
         if key in self.data: del self.data[key]
 
@@ -954,8 +956,24 @@ class SmartContract:
         
         print(f"   🔗 Contract Address: {new_address}")
 
-        # Deploy the instance (initialize storage)
-        instance.deploy()
+        # Copy initial storage values from the template contract
+        # This ensures instances get the evaluated initial values
+        initial_storage = {}
+        for var_node in self.storage_vars:
+            var_name = None
+            if hasattr(var_node, 'name'):
+                var_name = var_node.name.value if hasattr(var_node.name, 'value') else var_node.name
+            elif isinstance(var_node, dict):
+                var_name = var_node.get("name")
+            
+            if var_name:
+                # Get the initial value from the template contract's storage
+                value = self.storage.get(var_name)
+                if value is not None:
+                    initial_storage[var_name] = value
+        
+        # Deploy the instance with the copied initial values
+        instance.deploy(evaluated_storage_values=initial_storage)
         instance.parent_contract = self
         
         print(f"   Available actions: {list(self.actions.keys())}")
@@ -964,32 +982,32 @@ class SmartContract:
     def __call__(self, *args):
         return self.instantiate(args)
 
-    def deploy(self):
-        """Deploy the contract and initialize persistent storage"""
+    def deploy(self, evaluated_storage_values=None):
+        """Deploy the contract and initialize persistent storage
+        
+        Args:
+            evaluated_storage_values: Optional dict of evaluated initial values
+        """
         # Checks if we should reset storage or strictly load existing
         # For simplicity in this VM, subsequent runs act like "loading" if DB exists
         self.is_deployed = True
         
-        # Initialize storage only if key doesn't exist (preserve persistence)
-        for var_node in self.storage_vars:
-            var_name = None
-            default_value = None
-
-            if hasattr(var_node, 'initial_value'):
-                var_name = var_node.name.value if hasattr(var_node.name, 'value') else var_node.name
-                default_value = var_node.initial_value
-            elif isinstance(var_node, dict) and "initial_value" in var_node:
-                var_name = var_node.get("name")
-                default_value = var_node["initial_value"]
-
-            if var_name:
-                # ONLY set if not already in DB (Persistence Logic)
+        # If evaluated values are provided, use them (from evaluator)
+        if evaluated_storage_values:
+            for var_name, value in evaluated_storage_values.items():
                 if self.storage.get(var_name) is None:
-                    if default_value is not None:
-                        self.storage.set(var_name, default_value)
-                    else:
-                        # Set reasonable defaults for types if null
-                        self.storage.set(var_name, Null)
+                    self.storage.set(var_name, value)
+        else:
+            # Fallback: Initialize storage with NULL for declared variables
+            for var_node in self.storage_vars:
+                var_name = None
+                if hasattr(var_node, 'name'):
+                    var_name = var_node.name.value if hasattr(var_node.name, 'value') else var_node.name
+                elif isinstance(var_node, dict):
+                    var_name = var_node.get("name")
+                
+                if var_name and self.storage.get(var_name) is None:
+                    self.storage.set(var_name, Null)
 
     def call_method(self, action_name, args):
         """Call a contract action - similar to EntityInstance.call_method"""