zexus 1.6.8 → 1.7.2

package/src/zexus/security.py

@@ -13,6 +13,8 @@ import uuid
 import sqlite3
 import time
 import hashlib
+import threading
+from zexus.config import config as zexus_config
 
 # Try importing advanced database drivers
 try:
@@ -27,16 +29,49 @@ try:
 except ImportError:
     _ROCKSDB_AVAILABLE = False
 
-from .object import (
+from zexus.object import (
     Environment, Map, String, Integer, Float, Boolean as BooleanObj,
     Builtin, List, Null, EvaluationError as ObjectEvaluationError, NULL
 )
 
 try:
-    from .object import ContractReference
+    from zexus.object import ContractReference
 except ImportError:  # Fallback if optional type missing
     ContractReference = None
 
+# =============================================
+# Shared Evaluator Cache for Performance
+# =============================================
+# Creating a new Evaluator() for every contract method call is expensive
+# This cache provides thread-local evaluators that can be reused
+
+_evaluator_cache = threading.local()
+_vm_action_context = threading.local()
+
+def _get_vm_action_context() -> bool:
+    return bool(getattr(_vm_action_context, 'disable_vm', False))
+
+def _set_vm_action_context(flag: bool) -> None:
+    _vm_action_context.disable_vm = bool(flag)
+
+def _get_cached_evaluator():
+    """Get a cached evaluator instance for the current thread.
+    
+    This significantly improves performance for contract method calls
+    by avoiding repeated Evaluator() initialization overhead.
+    """
+    if not hasattr(_evaluator_cache, 'evaluator'):
+        from zexus.evaluator.core import Evaluator
+        _evaluator_cache.evaluator = Evaluator()
+    return _evaluator_cache.evaluator
+
+def _clear_evaluator_cache():
+    """Clear the evaluator cache (useful for testing)."""
+    if hasattr(_evaluator_cache, 'evaluator'):
+        del _evaluator_cache.evaluator
+
+# =============================================
+
 # Ensure storage directory exists
 STORAGE_DIR = "chain_data"
 if not os.path.exists(STORAGE_DIR):
@@ -664,10 +699,8 @@ class EntityInstance:
                         param_name = str(param)
                     method_env.set(param_name, args[i])
         
-        # Import evaluator to execute the method body
-        # Avoid circular import by importing here
-        from zexus.evaluator.core import Evaluator
-        evaluator = Evaluator()
+        # Use cached evaluator for performance (avoids repeated Evaluator() initialization)
+        evaluator = _get_cached_evaluator()
         
         # Execute the method body with stack trace
         result = evaluator.eval_node(method.body, method_env, stack_trace=[])
@@ -881,6 +914,66 @@ class RocksDBBackend(StorageBackend):
 # CONTRACT SYSTEM - Blockchain State & Logic
 # ===============================================
 
+class TrackingList(list):
+    def __init__(self, owner, iterable=None):
+        super().__init__(iterable or [])
+        self.owner = owner
+        
+    def __setitem__(self, key, value):
+        super().__setitem__(key, value)
+        self.owner.mark_dirty(key)
+        
+    def append(self, item):
+        idx = len(self)
+        super().append(item)
+        self.owner.mark_dirty(idx)
+        
+    def extend(self, iterable):
+        start_idx = len(self)
+        super().extend(iterable)
+        end_idx = len(self)
+        for i in range(start_idx, end_idx):
+            self.owner.mark_dirty(i)
+
+class StorageList(List):
+    """List wrapper for persistent storage"""
+    __slots__ = ('_dirty_indices', '_var_name', '_orig_elements')
+    
+    def __init__(self, elements, var_name):
+        # We wrap elements in TrackingList
+        tracked = TrackingList(self, elements)
+        super().__init__(tracked)
+        self._dirty_indices = set()
+        self._var_name = var_name
+        
+    def mark_dirty(self, index):
+        self._dirty_indices.add(index)
+        
+    def mark_all_dirty(self):
+        # Mark all current indices as dirty
+        self._dirty_indices = set(range(len(self.elements)))
+        
+    def mark_clean(self):
+        self._dirty_indices.clear()
+        
+    @property
+    def dirty_indices(self):
+        return self._dirty_indices
+
+    def set(self, index, value):
+        """Set value at index, mirroring list item assignment."""
+        try:
+            idx = index.value if hasattr(index, 'value') else int(index)
+        except Exception:
+            raise ObjectEvaluationError(f"Invalid index for assignment: {index}")
+
+        if idx < 0 or idx >= len(self.elements):
+            raise ObjectEvaluationError(f"Index out of range: {idx}")
+
+        self.elements[idx] = value
+        self.mark_dirty(idx)
+        return value
+
 class StorageMap(Map):
     """Map wrapper that tracks dirty entries for persistent storage"""
 
@@ -924,25 +1017,39 @@ class StorageMap(Map):
         return self._var_name
 
 class ContractStorage:
-    """Persistent storage for contract state with DB selection"""
+    """Persistent storage for contract state with DB selection
+    
+    Storage Engine Priority:
+    1. Explicit db_type parameter
+    2. ZEXUS_STORAGE_ENGINE environment variable
+    3. Default: 'memory' for maximum performance
+    
+    Set ZEXUS_STORAGE_ENGINE=sqlite for persistence in production.
+    """
 
-    def __init__(self, contract_id, db_type="sqlite"):
+    def __init__(self, contract_id, db_type=None):
         self.transaction_log = []
+        
+        # Determine storage type: explicit > env var > default (memory)
+        if db_type is None:
+            db_type = os.environ.get("ZEXUS_STORAGE_ENGINE", "memory")
         self.db_type = db_type
         self._map_meta_cache = {}
         
         # Determine strict path
         base_path = os.path.join(STORAGE_DIR, f"{contract_id}")
         
-        # Initialize Backend
-        if db_type == "leveldb" and _LEVELDB_AVAILABLE:
+        # Initialize Backend - memory is now first for performance
+        if db_type == "memory":
+            self.backend = InMemoryBackend()
+        elif db_type == "leveldb" and _LEVELDB_AVAILABLE:
             self.backend = LevelDBBackend(base_path)
         elif db_type == "rocksdb" and _ROCKSDB_AVAILABLE:
             self.backend = RocksDBBackend(f"{base_path}.rdb")
         elif db_type == "sqlite":
             self.backend = SQLiteBackend(f"{base_path}.sqlite")
         else:
-            print(f"   ⚠️ Storage Warning: '{db_type}' unavailable or unknown. Falling back to In-Memory.")
+            # Unknown type, fall back to memory
             self.backend = InMemoryBackend()
 
         self._cache_enabled = False
@@ -983,6 +1090,36 @@ class ContractStorage:
                     self._action_cache[key] = storage_map
                 self._persistent_cache[key] = storage_map
                 return storage_map
+
+            if isinstance(meta, dict) and meta.get("__kind") == "list":
+                entries = self.backend.scan(self._list_entry_prefix(key))
+                items = {}
+                max_idx = -1
+                prefix_len = len(self._list_entry_prefix(key))
+                
+                for entry_key, payload in entries:
+                    idx_str = entry_key[prefix_len:]
+                    try:
+                        idx = int(idx_str)
+                        val = self._deserialize_recursive(json.loads(payload))
+                        items[idx] = val
+                        if idx > max_idx: max_idx = idx
+                    except ValueError:
+                        continue
+                
+                length = meta.get("length", max_idx + 1)
+                final_list = []
+                for i in range(length):
+                    # We use NULL for missing items (should not happen in valid state)
+                    final_list.append(items.get(i, NULL))
+                
+                storage_list = StorageList(final_list, key)
+                storage_list.mark_clean()
+                
+                if self._cache_enabled and self._action_cache is not None:
+                    self._action_cache[key] = storage_list
+                self._persistent_cache[key] = storage_list
+                return storage_list
         except json.JSONDecodeError:
             pass
 
@@ -1011,6 +1148,19 @@ class ContractStorage:
             self._store_map(key, storage_map)
             return
 
+        if isinstance(value, List):
+            if isinstance(value, StorageList):
+                storage_list = value
+            else:
+                storage_list = StorageList(value.elements, key)
+                storage_list.mark_all_dirty()
+            
+            if self._cache_enabled and self._action_cache is not None:
+                self._action_cache[key] = storage_list
+            self._persistent_cache[key] = storage_list
+            self._store_list(key, storage_list)
+            return
+
         serialized = self._serialize(value)
         self.backend.set(key, serialized)
         if self._cache_enabled and self._action_cache is not None:
@@ -1102,6 +1252,39 @@ class ContractStorage:
         if isinstance(map_obj, StorageMap):
             map_obj.mark_clean()
 
+    def _list_entry_prefix(self, storage_key):
+        return f"{storage_key}:L:"
+        
+    def _list_entry_key(self, storage_key, index):
+        return f"{self._list_entry_prefix(storage_key)}{index}"
+        
+    def _store_list(self, storage_key, list_obj):
+        meta = {"__kind": "list", "version": 1, "length": len(list_obj.elements)}
+        self.backend.set(storage_key, json.dumps(meta))
+        
+        is_storage_list = isinstance(list_obj, StorageList)
+        
+        if is_storage_list:
+            indices_to_write = list_obj.dirty_indices
+        else:
+            # Full rewrite
+            self._delete_list_entries(storage_key)
+            indices_to_write = range(len(list_obj.elements))
+            
+        for i in indices_to_write:
+            if i < len(list_obj.elements):
+                val = list_obj.elements[i]
+                entry_payload = json.dumps(self._serialize_val_recursive(val))
+                entry_key = self._list_entry_key(storage_key, i)
+                self.backend.set(entry_key, entry_payload)
+            
+        if is_storage_list:
+            list_obj.mark_clean()
+
+    def _delete_list_entries(self, storage_key):
+        for entry_key, _ in self.backend.scan(self._list_entry_prefix(storage_key)):
+            self.backend.delete(entry_key)
+
         summary = {
             "dirty": len(dirty_keys),
             "deleted": len(deleted_keys)
@@ -1112,6 +1295,19 @@ class ContractStorage:
         for entry_key, _ in self.backend.scan(self._map_entry_prefix(storage_key)):
             self.backend.delete(entry_key)
 
+    def _key_to_str(self, key):
+        """Convert a Zexus object key to a Python string for JSON serialization."""
+        if key.__class__ is String:
+            return key.value
+        if key.__class__ is Integer:
+            return str(key.value)
+        if key.__class__ is Float:
+            return str(key.value)
+        if key.__class__ is BooleanObj:
+            return str(key.value)
+        # Fallback for other types
+        return str(key)
+
     def _serialize(self, obj):
         """Convert Zexus Object -> JSON String"""
         cls = obj.__class__
@@ -1134,7 +1330,8 @@ class ContractStorage:
             serialized_list = [self._serialize_val_recursive(e) for e in obj.elements]
             return json.dumps({"type": "list", "val": serialized_list})
         if cls is Map or cls is StorageMap:
-            serialized_map = {k: self._serialize_val_recursive(v) for k, v in obj.pairs.items()}
+            # Convert Zexus String keys to Python strings for JSON compatibility
+            serialized_map = {self._key_to_str(k): self._serialize_val_recursive(v) for k, v in obj.pairs.items()}
             return json.dumps({"type": "map", "val": serialized_map})
 
         if obj is NULL or obj is None:
@@ -1161,7 +1358,8 @@ class ContractStorage:
         if cls is List:
             return {"type": "list", "val": [self._serialize_val_recursive(e) for e in obj.elements]}
         if cls is Map or cls is StorageMap:
-            return {"type": "map", "val": {k: self._serialize_val_recursive(v) for k, v in obj.pairs.items()}}
+            # Convert Zexus String keys to Python strings for JSON compatibility
+            return {"type": "map", "val": {self._key_to_str(k): self._serialize_val_recursive(v) for k, v in obj.pairs.items()}}
         if obj is NULL:
             return {"type": "null", "val": None}
 
@@ -1253,6 +1451,66 @@ def lookup_contract(address):
 class SmartContract:
     """Represents a smart contract with persistent storage"""
 
+    @staticmethod
+    def _clone_storage_value(value, var_name=None):
+        """Deep clone storage values to keep instances isolated."""
+        from zexus.object import (
+            Integer as ZInteger,
+            Float as ZFloat,
+            Boolean as ZBoolean,
+            String as ZString,
+            List as ZList,
+            Map as ZMap,
+        )
+
+        if isinstance(value, StorageList):
+            target_name = var_name or getattr(value, "_var_name", "")
+            cloned_elements = [SmartContract._clone_storage_value(item) for item in value.elements]
+            cloned_list = StorageList(cloned_elements, target_name)
+            cloned_list.mark_clean()
+            return cloned_list
+
+        if isinstance(value, ZList):
+            return ZList([SmartContract._clone_storage_value(item) for item in value.elements])
+
+        if isinstance(value, StorageMap):
+            target_name = var_name or getattr(value, "_var_name", "")
+            cloned_pairs = {}
+            for key, stored_val in value.pairs.items():
+                cloned_pairs[key] = SmartContract._clone_storage_value(stored_val)
+            cloned_map = StorageMap(cloned_pairs, target_name)
+            cloned_map.mark_clean()
+            return cloned_map
+
+        if isinstance(value, ZMap):
+            cloned_pairs = {}
+            for key, stored_val in value.pairs.items():
+                cloned_pairs[key] = SmartContract._clone_storage_value(stored_val)
+            return ZMap(cloned_pairs)
+
+        if isinstance(value, ZString):
+            return ZString(value.value, sanitized_for=value.sanitized_for, is_trusted=value.is_trusted)
+
+        if isinstance(value, ZInteger):
+            return ZInteger(value.value)
+
+        if isinstance(value, ZFloat):
+            return ZFloat(value.value)
+
+        if isinstance(value, ZBoolean):
+            return ZBoolean(value.value)
+
+        if isinstance(value, list):
+            return [SmartContract._clone_storage_value(item) for item in value]
+
+        if isinstance(value, tuple):
+            return tuple(SmartContract._clone_storage_value(item) for item in value)
+
+        if isinstance(value, dict):
+            return {key: SmartContract._clone_storage_value(val) for key, val in value.items()}
+
+        return value
+
     def __init__(self, name, storage_vars, actions, blockchain_config=None, address=None):
         self.name = name
         self.storage_vars = storage_vars or []
@@ -1262,8 +1520,10 @@ class SmartContract:
         # Generate a unique address/ID for this specific instance if not provided
         self.address = address or str(uuid.uuid4())[:8]
         
-        # Default to SQLite, can be configured via blockchain_config
-        db_pref = (blockchain_config or {}).get("storage_engine", "sqlite")
+        # Storage engine priority: blockchain_config > env var > default (memory)
+        db_pref = (blockchain_config or {}).get("storage_engine")
+        if db_pref is None:
+            db_pref = os.environ.get("ZEXUS_STORAGE_ENGINE", "memory")
         
         # Initialize storage linked to unique address
         # The unique ID ensures multiple "ZiverWallet()" calls don't overwrite each other
@@ -1287,7 +1547,8 @@ class SmartContract:
 
     def instantiate(self, args=None):
         """Create a new instance of this contract when called like ZiverWallet()."""
-        print(f"📄 SmartContract.instantiate() called for: {self.name}")
+        if zexus_config.should_log('debug'):
+            print(f"📄 SmartContract.instantiate() called for: {self.name}")
         
         # Generate new unique address for the instance
         new_address = str(uuid.uuid4())[:16]
@@ -1301,7 +1562,8 @@ class SmartContract:
             address=new_address
         )
         
-        print(f"   🔗 Contract Address: {new_address}")
+        if zexus_config.should_log('debug'):
+            print(f"   🔗 Contract Address: {new_address}")
 
         # Copy initial storage values from the template contract
         # This ensures instances get the evaluated initial values
@@ -1317,13 +1579,12 @@ class SmartContract:
                 # 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
+                    initial_storage[var_name] = self._clone_storage_value(value, var_name=var_name)
         
         # 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())}")
         return instance
 
     def __call__(self, *args):
@@ -1343,7 +1604,8 @@ class SmartContract:
         if evaluated_storage_values:
             for var_name, value in evaluated_storage_values.items():
                 if self.storage.get(var_name) is None:
-                    self.storage.set(var_name, value)
+                    cloned_value = self._clone_storage_value(value, var_name=var_name)
+                    self.storage.set(var_name, cloned_value)
         else:
             # Fallback: Initialize storage with NULL for declared variables
             for var_node in self.storage_vars:
@@ -1366,24 +1628,50 @@ class SmartContract:
             from zexus.object import EvaluationError
             return EvaluationError(f"Action '{action_name}' not found in contract {self.name}")
 
+        trace_calls = os.environ.get("ZEXUS_VM_TRACE_CALLS")
+        if trace_calls:
+            try:
+                interval = int(trace_calls) if trace_calls.isdigit() else 1000
+            except Exception:
+                interval = 1000
+            count = getattr(self, "_trace_call_count", 0) + 1
+            self._trace_call_count = count
+            if interval > 0 and count % interval == 0:
+                print(f"[VM TRACE] CONTRACT action={action_name} total={count}")
+
         # Get the action (Action object)
         action = self.actions[action_name]
         
-        # Create a new environment for the action execution
+        # FAST PATH: Cache environments per action for reuse (big perf win)
+        if not hasattr(self, '_action_env_cache'):
+            self._action_env_cache = {}
+        
         from zexus.environment import Environment
-        action_env = Environment(outer=action.env if hasattr(action, 'env') else None)
+        cached_env = self._action_env_cache.get(action_name)
+        if cached_env is not None:
+            action_env = cached_env
+            # Clear only local store, keep outer linkage intact
+            action_env.store.clear()
+        else:
+            action_env = Environment(outer=action.env if hasattr(action, 'env') else None)
+            self._action_env_cache[action_name] = action_env
+
         
         # Bind 'this' to the current contract instance in the action environment
         action_env.set('this', self)
         
-        # Add msg.sender context - default to contract deployer if not in transaction context
-        # In a real blockchain, this would be the transaction sender's address
+        # FAST PATH: Reuse msg object
         msg_sender = getattr(self, '_current_sender', self.deployer if hasattr(self, 'deployer') else "0x0000000000000000")
+        cached_msg = getattr(self, '_cached_msg_obj', None)
         from zexus.object import String as ZexusString, Map as ZexusMap
-        # msg is a Map with sender property for better compatibility
-        msg_obj = ZexusMap({
-            ZexusString("sender"): ZexusString(msg_sender)
-        })
+        if cached_msg is not None and getattr(self, '_cached_msg_sender', None) == msg_sender:
+            msg_obj = cached_msg
+        else:
+            msg_obj = ZexusMap({
+                ZexusString("sender"): ZexusString(msg_sender)
+            })
+            self._cached_msg_obj = msg_obj
+            self._cached_msg_sender = msg_sender
         action_env.set('msg', msg_obj)
         
         # Make contract storage accessible in the action environment
@@ -1401,6 +1689,9 @@ class SmartContract:
                 stored_value = self.storage.get(var_name)
                 if stored_value is not None:
                     action_env.set(var_name, stored_value)
+                else:
+                    # Ensure state variables always exist in the action env
+                    action_env.set(var_name, Null)
         
         # Bind action parameters to arguments
         if hasattr(action, 'parameters'):
@@ -1421,16 +1712,105 @@ class SmartContract:
                     from zexus.object import Null
                     action_env.set(param_name, Null)
         
-        # Execute the action body
-        from zexus.evaluator.core import Evaluator
-        evaluator = Evaluator()
+        # Execute the action body - use cached evaluator for performance
+        evaluator = _get_cached_evaluator()
+        disable_vm = _get_vm_action_context()
+        saved_use_vm = None
+        saved_vm_enabled = None
+        if disable_vm:
+            saved_use_vm = evaluator.use_vm
+            evaluator.use_vm = False
+            if evaluator.unified_executor is not None:
+                saved_vm_enabled = evaluator.unified_executor.vm_enabled
+                evaluator.unified_executor.vm_enabled = False
+
+        # Optional: VM cached action execution for performance mode
+        vm_result = None
+        use_vm_actions = False
+        try:
+            if evaluator.unified_executor and evaluator.unified_executor.vm_enabled:
+                if evaluator.unified_executor.vm_config.get("vm_action_cache", False):
+                    use_vm_actions = True
+                else:
+                    perf_mode_flag = action_env.get("performance_mode")
+                    perf_mode = getattr(perf_mode_flag, "value", perf_mode_flag)
+                    config_obj = action_env.get("config")
+                    perf_use_vm_actions = None
+                    if isinstance(config_obj, Map):
+                        key = String("perf_use_vm_actions")
+                        if key in config_obj.pairs:
+                            perf_use_vm_actions = config_obj.pairs.get(key)
+                        elif "perf_use_vm_actions" in config_obj.pairs:
+                            perf_use_vm_actions = config_obj.pairs.get("perf_use_vm_actions")
+                    if isinstance(perf_use_vm_actions, BooleanObj):
+                        perf_use_vm_actions = perf_use_vm_actions.value
+                    if perf_use_vm_actions is True and perf_mode is True:
+                        use_vm_actions = True
+        except Exception:
+            use_vm_actions = False
+
+        if disable_vm:
+            use_vm_actions = False
         
         # Start batching storage writes for performance
         self.storage.begin_batch()
         self.storage.enable_action_cache()
         
         try:
-            result = evaluator.eval_node(action.body, action_env, stack_trace=[])
+            if use_vm_actions:
+                try:
+                    from zexus.evaluator.bytecode_compiler import EvaluatorBytecodeCompiler, should_use_vm_for_node
+                    from zexus.evaluator.utils import is_error
+
+                    if should_use_vm_for_node(action.body):
+                        cache = getattr(self, "_vm_action_cache", None)
+                        if cache is None:
+                            cache = {}
+                            self._vm_action_cache = cache
+
+                        bytecode = cache.get(action_name)
+                        if bytecode is None:
+                            compiler = EvaluatorBytecodeCompiler(use_cache=True)
+                            bytecode = compiler.compile(action.body, optimize=True)
+                            if bytecode and not compiler.errors:
+                                cache[action_name] = bytecode
+                                sync_cache = getattr(self, "_vm_action_sync_keys", None)
+                                if sync_cache is None:
+                                    sync_cache = {}
+                                    self._vm_action_sync_keys = sync_cache
+                                try:
+                                    sync_cache[action_name] = evaluator.unified_executor._collect_assigned_names(action.body)
+                                except Exception:
+                                    sync_cache[action_name] = None
+
+                        if bytecode is not None:
+                            instr_count = 0
+                            try:
+                                instr_count = len(getattr(bytecode, "instructions", []) or [])
+                            except Exception:
+                                instr_count = 0
+                            min_instr = 32
+                            try:
+                                min_instr = int(evaluator.unified_executor.vm_config.get("vm_action_min_instructions", 32))
+                            except Exception:
+                                min_instr = 32
+
+                            if instr_count >= min_instr:
+                                sync_keys = None
+                                try:
+                                    sync_keys = self._vm_action_sync_keys.get(action_name)
+                                except Exception:
+                                    sync_keys = None
+                                vm_result = evaluator.unified_executor.execute_action_bytecode(bytecode, action_env, sync_keys=sync_keys)
+                                if is_error(vm_result):
+                                    vm_result = None
+                except Exception:
+                    vm_result = None
+
+            if vm_result is not None:
+                result = vm_result
+            else:
+                result = evaluator.eval_node(action.body, action_env, stack_trace=[])
             
             # Save any modified state variables back to storage
             # SKIP variables that were set via this.property (direct storage updates)
@@ -1450,6 +1830,13 @@ class SmartContract:
                         continue
                     
                     current_value = action_env.get(var_name)
+                    if var_name == 'chain' and zexus_config.should_log('debug'):
+                        size = None
+                        try:
+                            size = len(current_value.elements)
+                        except Exception:
+                            size = 'n/a'
+                        print(f"DEBUG storage sync chain -> {current_value} (len={size})")
                     if current_value is not None:
                         self.storage.set(var_name, current_value)
             
@@ -1467,6 +1854,11 @@ class SmartContract:
         finally:
             self.storage.disable_action_cache()
 
+            if disable_vm:
+                evaluator.use_vm = saved_use_vm
+                if evaluator.unified_executor is not None and saved_vm_enabled is not None:
+                    evaluator.unified_executor.vm_enabled = saved_vm_enabled
+
         
         return result
 
@@ -1502,12 +1894,10 @@ class SmartContract:
             attr = getattr(self, property_name)
             # Wrap primitive Python types
             if isinstance(attr, str):
-                from ..object import String
                 return String(attr)
             return attr
         
         # Return NULL if not found
-        from ..object import NULL
         return NULL
     
     def set(self, property_name, value):